[MOVED FROM BAD 01/57] Adds a first draft of an FLV demuxer.

Original commit message from CVS:
2007-07-19  Julien MOUTTE  <julien@moutte.net>

* configure.ac:
* gst/flv/Makefile.am:
* gst/flv/gstflvdemux.c: (gst_flv_demux_flush),
(gst_flv_demux_cleanup), (gst_flv_demux_chain),
(gst_flv_demux_pull_tag), (gst_flv_demux_pull_header),
(gst_flv_demux_seek_to_prev_keyframe), (gst_flv_demux_loop),
(gst_flv_demux_sink_activate),
(gst_flv_demux_sink_activate_push),
(gst_flv_demux_sink_activate_pull), (gst_flv_demux_sink_event),
(gst_flv_demux_change_state), (gst_flv_demux_dispose),
(gst_flv_demux_base_init), (gst_flv_demux_class_init),
(gst_flv_demux_init), (plugin_init):
* gst/flv/gstflvdemux.h:
* gst/flv/gstflvparse.c: (FLV_GET_BEUI24), (FLV_GET_STRING),
(gst_flv_demux_query_types), (gst_flv_demux_query),
(gst_flv_parse_metadata_item), (gst_flv_parse_tag_script),
(gst_flv_parse_tag_audio), (gst_flv_parse_tag_video),
(gst_flv_parse_tag_type), (gst_flv_parse_header):
* gst/flv/gstflvparse.h: Adds a first draft of an FLV demuxer.
It does not do seeking yet, it supports pull and push mode so
YES
you can use it to play youtube videos directly from an HTTP uri.
Not so much testing done yet but it parses metadata, reply to
duration queries, etc...

5 files changed, 1633 insertions, 0 deletions

diff --git a/gst/flv/Makefile.am b/gst/flv/Makefile.am
new file mode 100644
index 00000000..7850e7ee
--- /dev/null
+++ b/gst/flv/Makefile.am
@@ -0,0 +1,9 @@
+
+plugin_LTLIBRARIES = libgstflvdemux.la
+
+libgstflvdemux_la_CFLAGS = ${GST_CFLAGS}
+libgstflvdemux_la_LIBADD = $(GST_BASE_LIBS)
+libgstflvdemux_la_LDFLAGS = ${GST_PLUGIN_LDFLAGS} 
+libgstflvdemux_la_SOURCES = gstflvdemux.c gstflvparse.c
+
+noinst_HEADERS = gstflvdemux.h gstflvparse.h
diff --git a/gst/flv/gstflvdemux.c b/gst/flv/gstflvdemux.c
new file mode 100644
index 00000000..f91763db
--- /dev/null
+++ b/gst/flv/gstflvdemux.c
@@ -0,0 +1,675 @@
+/* GStreamer
+ * Copyright (C) <2007> Julien Moutte <julien@moutte.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstflvdemux.h"
+#include "gstflvparse.h"
+
+#include <string.h>
+
+static GstStaticPadTemplate flv_sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/x-flv")
+    );
+
+static GstStaticPadTemplate audio_src_template =
+GST_STATIC_PAD_TEMPLATE ("audio",
+    GST_PAD_SRC,
+    GST_PAD_SOMETIMES,
+    GST_STATIC_CAPS_ANY);
+
+static GstStaticPadTemplate video_src_template =
+GST_STATIC_PAD_TEMPLATE ("video",
+    GST_PAD_SRC,
+    GST_PAD_SOMETIMES,
+    GST_STATIC_CAPS_ANY);
+
+static GstElementDetails flv_demux_details = {
+  "FLV Demuxer",
+  "Codec/Demuxer",
+  "Demux FLV feeds into digital streams",
+  "Julien Moutte <julien@moutte.net>"
+};
+
+GST_DEBUG_CATEGORY (flvdemux_debug);
+#define GST_CAT_DEFAULT flvdemux_debug
+
+GST_BOILERPLATE (GstFLVDemux, gst_flv_demux, GstElement, GST_TYPE_ELEMENT);
+
+#define FLV_HEADER_SIZE 13
+#define FLV_TAG_TYPE_SIZE 4
+
+static void
+gst_flv_demux_flush (GstFLVDemux * demux, gboolean discont)
+{
+  GST_DEBUG_OBJECT (demux, "flushing queued data in the FLV demuxer");
+
+  gst_adapter_clear (demux->adapter);
+
+  demux->audio_need_discont = TRUE;
+  demux->video_need_discont = TRUE;
+}
+
+static void
+gst_flv_demux_cleanup (GstFLVDemux * demux)
+{
+  GST_DEBUG_OBJECT (demux, "cleaning up FLV demuxer");
+}
+
+static GstFlowReturn
+gst_flv_demux_chain (GstPad * pad, GstBuffer * buffer)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstFLVDemux *demux = NULL;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (pad));
+
+  gst_adapter_push (demux->adapter, buffer);
+
+parse:
+  switch (demux->state) {
+    case FLV_STATE_HEADER:
+    {
+      if (gst_adapter_available (demux->adapter) >= FLV_HEADER_SIZE) {
+        const guint8 *data;
+
+        data = gst_adapter_peek (demux->adapter, FLV_HEADER_SIZE);
+
+        ret = gst_flv_parse_header (demux, data, FLV_HEADER_SIZE);
+
+        gst_adapter_flush (demux->adapter, FLV_HEADER_SIZE);
+
+        demux->state = FLV_STATE_TAG_TYPE;
+        goto parse;
+      } else {
+        goto beach;
+      }
+    }
+    case FLV_STATE_TAG_TYPE:
+    {
+      if (gst_adapter_available (demux->adapter) >= FLV_TAG_TYPE_SIZE) {
+        const guint8 *data;
+
+        data = gst_adapter_peek (demux->adapter, FLV_TAG_TYPE_SIZE);
+
+        ret = gst_flv_parse_tag_type (demux, data, FLV_TAG_TYPE_SIZE);
+
+        gst_adapter_flush (demux->adapter, FLV_TAG_TYPE_SIZE);
+
+        goto parse;
+      } else {
+        goto beach;
+      }
+    }
+    case FLV_STATE_TAG_VIDEO:
+    {
+      if (gst_adapter_available (demux->adapter) >= demux->tag_size) {
+        const guint8 *data;
+
+        data = gst_adapter_peek (demux->adapter, demux->tag_size);
+
+        ret = gst_flv_parse_tag_video (demux, data, demux->tag_size);
+
+        gst_adapter_flush (demux->adapter, demux->tag_size);
+
+        demux->state = FLV_STATE_TAG_TYPE;
+        goto parse;
+      } else {
+        goto beach;
+      }
+    }
+    case FLV_STATE_TAG_AUDIO:
+    {
+      if (gst_adapter_available (demux->adapter) >= demux->tag_size) {
+        const guint8 *data;
+
+        data = gst_adapter_peek (demux->adapter, demux->tag_size);
+
+        ret = gst_flv_parse_tag_audio (demux, data, demux->tag_size);
+
+        gst_adapter_flush (demux->adapter, demux->tag_size);
+
+        demux->state = FLV_STATE_TAG_TYPE;
+        goto parse;
+      } else {
+        goto beach;
+      }
+    }
+    case FLV_STATE_TAG_SCRIPT:
+    {
+      if (gst_adapter_available (demux->adapter) >= demux->tag_size) {
+        const guint8 *data;
+
+        data = gst_adapter_peek (demux->adapter, demux->tag_size);
+
+        ret = gst_flv_parse_tag_script (demux, data, demux->tag_size);
+
+        gst_adapter_flush (demux->adapter, demux->tag_size);
+
+        demux->state = FLV_STATE_TAG_TYPE;
+        goto parse;
+      } else {
+        goto beach;
+      }
+    }
+    default:
+      GST_DEBUG_OBJECT (demux, "unexpected demuxer state");
+  }
+
+beach:
+  gst_object_unref (demux);
+
+  return ret;
+}
+
+static GstFlowReturn
+gst_flv_demux_pull_tag (GstPad * pad, GstFLVDemux * demux)
+{
+  GstBuffer *buffer = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  /* Get the first 4 bytes to identify tag type and size */
+  ret = gst_pad_pull_range (pad, demux->offset, FLV_TAG_TYPE_SIZE, &buffer);
+  if (G_UNLIKELY (ret != GST_FLOW_OK)) {
+    GST_WARNING_OBJECT (demux, "failed when pulling %d bytes",
+        FLV_TAG_TYPE_SIZE);
+    goto beach;
+  }
+
+  if (G_UNLIKELY (buffer && GST_BUFFER_SIZE (buffer) != FLV_TAG_TYPE_SIZE)) {
+    GST_WARNING_OBJECT (demux, "partial pull got %d when expecting %d",
+        GST_BUFFER_SIZE (buffer), FLV_TAG_TYPE_SIZE);
+    gst_buffer_unref (buffer);
+    ret = GST_FLOW_UNEXPECTED;
+    goto beach;
+  }
+
+  /* Identify tag type */
+  ret = gst_flv_parse_tag_type (demux, GST_BUFFER_DATA (buffer),
+      GST_BUFFER_SIZE (buffer));
+
+  gst_buffer_unref (buffer);
+
+  /* Jump over tag type + size */
+  demux->offset += FLV_TAG_TYPE_SIZE;
+
+  /* Pull the whole tag */
+  ret = gst_pad_pull_range (pad, demux->offset, demux->tag_size, &buffer);
+  if (G_UNLIKELY (ret != GST_FLOW_OK)) {
+    GST_WARNING_OBJECT (demux, "failed when pulling %d bytes", demux->tag_size);
+    goto beach;
+  }
+
+  if (G_UNLIKELY (buffer && GST_BUFFER_SIZE (buffer) != demux->tag_size)) {
+    GST_WARNING_OBJECT (demux, "partial pull got %d when expecting %d",
+        GST_BUFFER_SIZE (buffer), demux->tag_size);
+    gst_buffer_unref (buffer);
+    ret = GST_FLOW_UNEXPECTED;
+    goto beach;
+  }
+
+  switch (demux->state) {
+    case FLV_STATE_TAG_VIDEO:
+      ret = gst_flv_parse_tag_video (demux, GST_BUFFER_DATA (buffer),
+          GST_BUFFER_SIZE (buffer));
+      break;
+    case FLV_STATE_TAG_AUDIO:
+      ret = gst_flv_parse_tag_audio (demux, GST_BUFFER_DATA (buffer),
+          GST_BUFFER_SIZE (buffer));
+      break;
+    case FLV_STATE_TAG_SCRIPT:
+      ret = gst_flv_parse_tag_script (demux, GST_BUFFER_DATA (buffer),
+          GST_BUFFER_SIZE (buffer));
+      break;
+    default:
+      GST_WARNING_OBJECT (demux, "unexpected state %d", demux->state);
+  }
+
+  gst_buffer_unref (buffer);
+
+  /* Jump over that part we've just parsed */
+  demux->offset += demux->tag_size;
+
+  /* Make sure we reinitialize the tag size */
+  demux->tag_size = 0;
+
+  /* Ready for the next tag */
+  demux->state = FLV_STATE_TAG_TYPE;
+
+beach:
+  return ret;
+}
+
+static GstFlowReturn
+gst_flv_demux_pull_header (GstPad * pad, GstFLVDemux * demux)
+{
+  GstBuffer *buffer = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  /* Get the first 9 bytes */
+  ret = gst_pad_pull_range (pad, demux->offset, FLV_HEADER_SIZE, &buffer);
+  if (G_UNLIKELY (ret != GST_FLOW_OK)) {
+    GST_WARNING_OBJECT (demux, "failed when pulling %d bytes", FLV_HEADER_SIZE);
+    goto beach;
+  }
+
+  if (G_UNLIKELY (buffer && GST_BUFFER_SIZE (buffer) != FLV_HEADER_SIZE)) {
+    GST_WARNING_OBJECT (demux, "partial pull got %d when expecting %d",
+        GST_BUFFER_SIZE (buffer), FLV_HEADER_SIZE);
+    gst_buffer_unref (buffer);
+    ret = GST_FLOW_UNEXPECTED;
+    goto beach;
+  }
+
+  ret = gst_flv_parse_header (demux, GST_BUFFER_DATA (buffer),
+      GST_BUFFER_SIZE (buffer));
+
+  /* Jump over the header now */
+  demux->offset += FLV_HEADER_SIZE;
+  demux->state = FLV_STATE_TAG_TYPE;
+
+beach:
+  return ret;
+}
+
+static GstFlowReturn
+gst_flv_demux_seek_to_prev_keyframe (GstFLVDemux * demux)
+{
+  return GST_FLOW_OK;
+}
+
+static void
+gst_flv_demux_loop (GstPad * pad)
+{
+  GstFLVDemux *demux = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (pad));
+
+  if (demux->segment->rate >= 0) {
+    /* pull in data */
+    switch (demux->state) {
+      case FLV_STATE_TAG_TYPE:
+        ret = gst_flv_demux_pull_tag (pad, demux);
+        break;
+      case FLV_STATE_DONE:
+        ret = GST_FLOW_UNEXPECTED;
+        break;
+      default:
+        ret = gst_flv_demux_pull_header (pad, demux);
+    }
+
+    /* pause if something went wrong */
+    if (G_UNLIKELY (ret != GST_FLOW_OK))
+      goto pause;
+
+    /* check EOS condition */
+    if ((demux->segment->flags & GST_SEEK_FLAG_SEGMENT) &&
+        (demux->segment->stop != -1) &&
+        (demux->segment->last_stop >= demux->segment->stop)) {
+      ret = GST_FLOW_UNEXPECTED;
+      goto pause;
+    }
+  } else {                      /* Reverse playback */
+    /* pull in data */
+    switch (demux->state) {
+      case FLV_STATE_TAG_TYPE:
+        ret = gst_flv_demux_pull_tag (pad, demux);
+        /* When packet parsing returns UNEXPECTED that means we ve reached the
+           point where we want to go to the previous keyframe. This is either
+           the last FLV tag or the keyframe we used last time */
+        if (ret == GST_FLOW_UNEXPECTED) {
+          ret = gst_flv_demux_seek_to_prev_keyframe (demux);
+          demux->state = FLV_STATE_TAG_TYPE;
+        }
+        break;
+      default:
+        ret = gst_flv_demux_pull_header (pad, demux);
+    }
+
+    /* pause if something went wrong */
+    if (G_UNLIKELY (ret != GST_FLOW_OK))
+      goto pause;
+
+    /* check EOS condition */
+    if (demux->segment->last_stop <= demux->segment->start) {
+      ret = GST_FLOW_UNEXPECTED;
+      goto pause;
+    }
+  }
+
+  gst_object_unref (demux);
+
+  return;
+
+pause:
+  {
+    const gchar *reason = gst_flow_get_name (ret);
+
+    GST_LOG_OBJECT (demux, "pausing task, reason %s", reason);
+    gst_pad_pause_task (pad);
+
+    if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
+      if (ret == GST_FLOW_UNEXPECTED) {
+        /* perform EOS logic */
+        gst_element_no_more_pads (GST_ELEMENT_CAST (demux));
+        if (demux->segment->flags & GST_SEEK_FLAG_SEGMENT) {
+          gint64 stop;
+
+          /* for segment playback we need to post when (in stream time)
+           * we stopped, this is either stop (when set) or the duration. */
+          if ((stop = demux->segment->stop) == -1)
+            stop = demux->segment->duration;
+
+          if (demux->segment->rate >= 0) {
+            GST_LOG_OBJECT (demux, "Sending segment done, at end of segment");
+            gst_element_post_message (GST_ELEMENT_CAST (demux),
+                gst_message_new_segment_done (GST_OBJECT_CAST (demux),
+                    GST_FORMAT_TIME, stop));
+          } else {              /* Reverse playback */
+            GST_LOG_OBJECT (demux, "Sending segment done, at beginning of "
+                "segment");
+            gst_element_post_message (GST_ELEMENT_CAST (demux),
+                gst_message_new_segment_done (GST_OBJECT_CAST (demux),
+                    GST_FORMAT_TIME, demux->segment->start));
+          }
+        } else {
+          /* normal playback, send EOS to all linked pads */
+          gst_element_no_more_pads (GST_ELEMENT (demux));
+          GST_LOG_OBJECT (demux, "Sending EOS, at end of stream");
+          if (!gst_pad_event_default (demux->sinkpad, gst_event_new_eos ())) {
+            GST_WARNING_OBJECT (demux, "failed pushing EOS on streams");
+            GST_ELEMENT_ERROR (demux, STREAM, FAILED,
+                ("Internal data stream error."),
+                ("Can't push EOS downstream (empty/invalid file "
+                    "with no streams/tags ?)"));
+          }
+        }
+      } else {
+        GST_ELEMENT_ERROR (demux, STREAM, FAILED,
+            ("Internal data stream error."),
+            ("stream stopped, reason %s", reason));
+        gst_pad_event_default (demux->sinkpad, gst_event_new_eos ());
+      }
+    }
+    gst_object_unref (demux);
+    return;
+  }
+}
+
+/* If we can pull that's prefered */
+static gboolean
+gst_flv_demux_sink_activate (GstPad * sinkpad)
+{
+  if (gst_pad_check_pull_range (sinkpad)) {
+    return gst_pad_activate_pull (sinkpad, TRUE);
+  } else {
+    return gst_pad_activate_push (sinkpad, TRUE);
+  }
+}
+
+/* This function gets called when we activate ourselves in push mode.
+ * We cannot seek (ourselves) in the stream */
+static gboolean
+gst_flv_demux_sink_activate_push (GstPad * sinkpad, gboolean active)
+{
+  GstFLVDemux *demux;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (sinkpad));
+
+  demux->random_access = FALSE;
+
+  gst_object_unref (demux);
+
+  return TRUE;
+}
+
+/* this function gets called when we activate ourselves in pull mode.
+ * We can perform  random access to the resource and we start a task
+ * to start reading */
+static gboolean
+gst_flv_demux_sink_activate_pull (GstPad * sinkpad, gboolean active)
+{
+  GstFLVDemux *demux;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (sinkpad));
+
+  if (active) {
+    demux->random_access = TRUE;
+    gst_object_unref (demux);
+    return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_flv_demux_loop,
+        sinkpad);
+  } else {
+    demux->random_access = FALSE;
+    gst_object_unref (demux);
+    return gst_pad_stop_task (sinkpad);
+  }
+}
+
+static gboolean
+gst_flv_demux_sink_event (GstPad * pad, GstEvent * event)
+{
+  GstFLVDemux *demux;
+  gboolean ret = FALSE;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (pad));
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_FLUSH_STOP:
+      GST_DEBUG_OBJECT (demux, "flushing FLV demuxer");
+      gst_flv_demux_flush (demux, TRUE);
+      gst_adapter_clear (demux->adapter);
+      gst_segment_init (demux->segment, GST_FORMAT_TIME);
+      ret = gst_pad_event_default (demux->sinkpad, event);
+      break;
+    case GST_EVENT_EOS:
+      GST_DEBUG_OBJECT (demux, "received EOS");
+      gst_element_no_more_pads (GST_ELEMENT (demux));
+      if (!gst_pad_event_default (demux->sinkpad, event)) {
+        GST_WARNING_OBJECT (demux, "failed pushing EOS on streams");
+        GST_ELEMENT_ERROR (demux, STREAM, FAILED,
+            ("Internal data stream error."),
+            ("Can't push EOS downstream (empty/invalid file "
+                "with no streams/tags ?)"));
+      }
+      ret = TRUE;
+      break;
+    case GST_EVENT_NEWSEGMENT:
+    {
+      GstFormat format;
+      gdouble rate;
+      gint64 start, stop, time;
+      gboolean update;
+
+      GST_DEBUG_OBJECT (demux, "received new segment");
+
+      gst_event_parse_new_segment (event, &update, &rate, &format, &start,
+          &stop, &time);
+
+      if (format == GST_FORMAT_TIME) {
+        /* time segment, this is perfect, copy over the values. */
+        gst_segment_set_newsegment (demux->segment, update, rate, format, start,
+            stop, time);
+
+#ifdef POST_10_10
+        GST_DEBUG_OBJECT (demux, "NEWSEGMENT: %" GST_SEGMENT_FORMAT,
+            demux->segment);
+#endif
+
+        /* and forward */
+        ret = gst_pad_event_default (demux->sinkpad, event);
+      } else {
+        /* non-time format */
+        demux->audio_need_segment = TRUE;
+        demux->video_need_segment = TRUE;
+        ret = TRUE;
+        gst_event_unref (event);
+      }
+      break;
+    }
+    default:
+      ret = gst_pad_event_default (demux->sinkpad, event);
+      break;
+  }
+
+  gst_object_unref (demux);
+
+  return ret;
+}
+
+static GstStateChangeReturn
+gst_flv_demux_change_state (GstElement * element, GstStateChange transition)
+{
+  GstFLVDemux *demux;
+  GstStateChangeReturn ret;
+
+  demux = GST_FLV_DEMUX (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      demux->state = FLV_STATE_HEADER;
+      demux->need_header = TRUE;
+      demux->audio_need_discont = TRUE;
+      demux->video_need_discont = TRUE;
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+  if (ret == GST_STATE_CHANGE_FAILURE)
+    return ret;
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_flv_demux_cleanup (demux);
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+static void
+gst_flv_demux_dispose (GObject * object)
+{
+  GstFLVDemux *demux = GST_FLV_DEMUX (object);
+
+  GST_DEBUG_OBJECT (demux, "disposing FLV demuxer");
+
+  if (demux->adapter) {
+    gst_adapter_clear (demux->adapter);
+    g_object_unref (demux->adapter);
+    demux->adapter = NULL;
+  }
+
+  if (demux->segment) {
+    gst_segment_free (demux->segment);
+    demux->segment = NULL;
+  }
+
+  if (demux->taglist) {
+    gst_tag_list_free (demux->taglist);
+    demux->taglist = NULL;
+  }
+
+  if (demux->new_seg_event) {
+    gst_event_unref (demux->new_seg_event);
+    demux->new_seg_event = NULL;
+  }
+
+  GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
+}
+
+static void
+gst_flv_demux_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&flv_sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&audio_src_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&video_src_template));
+  gst_element_class_set_details (element_class, &flv_demux_details);
+}
+
+static void
+gst_flv_demux_class_init (GstFLVDemuxClass * klass)
+{
+  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_flv_demux_dispose);
+
+  gstelement_class->change_state =
+      GST_DEBUG_FUNCPTR (gst_flv_demux_change_state);
+}
+
+static void
+gst_flv_demux_init (GstFLVDemux * demux, GstFLVDemuxClass * g_class)
+{
+  demux->sinkpad =
+      gst_pad_new_from_static_template (&flv_sink_template, "sink");
+
+  gst_pad_set_event_function (demux->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_flv_demux_sink_event));
+  gst_pad_set_chain_function (demux->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_flv_demux_chain));
+  gst_pad_set_activate_function (demux->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_flv_demux_sink_activate));
+  gst_pad_set_activatepull_function (demux->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_flv_demux_sink_activate_pull));
+  gst_pad_set_activatepush_function (demux->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_flv_demux_sink_activate_push));
+
+  gst_element_add_pad (GST_ELEMENT (demux), demux->sinkpad);
+
+  demux->adapter = gst_adapter_new ();
+  demux->segment = gst_segment_new ();
+  demux->taglist = gst_tag_list_new ();
+  gst_segment_init (demux->segment, GST_FORMAT_TIME);
+
+  demux->offset = 0;
+
+  demux->strict = FALSE;
+  demux->push_tags = FALSE;
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  GST_DEBUG_CATEGORY_INIT (flvdemux_debug, "flvdemux", 0, "FLV demuxer");
+
+  if (!gst_element_register (plugin, "flvdemux", GST_RANK_PRIMARY,
+          gst_flv_demux_get_type ()))
+    return FALSE;
+
+  return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR,
+    "flvdemux", "Element demuxing FLV stream",
+    plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
diff --git a/gst/flv/gstflvdemux.h b/gst/flv/gstflvdemux.h
new file mode 100644
index 00000000..09de14fd
--- /dev/null
+++ b/gst/flv/gstflvdemux.h
@@ -0,0 +1,108 @@
+/* GStreamer
+ * Copyright (C) <2007> Julien Moutte <julien@moutte.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __FLV_DEMUX_H__
+#define __FLV_DEMUX_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstadapter.h>
+
+G_BEGIN_DECLS
+  
+#define GST_TYPE_FLV_DEMUX \
+  (gst_flv_demux_get_type())
+#define GST_FLV_DEMUX(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLV_DEMUX,GstFLVDemux))
+#define GST_FLV_DEMUX_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLV_DEMUX,GstFLVDemuxClass))
+#define GST_IS_FLV_DEMUX(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLV_DEMUX))
+#define GST_IS_FLV_DEMUX_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLV_DEMUX))
+
+typedef struct _GstFLVDemux GstFLVDemux;
+typedef struct _GstFLVDemuxClass GstFLVDemuxClass;
+
+typedef enum {
+  FLV_STATE_HEADER,
+  FLV_STATE_TAG_TYPE,
+  FLV_STATE_TAG_VIDEO,
+  FLV_STATE_TAG_AUDIO,
+  FLV_STATE_TAG_SCRIPT,
+  FLV_STATE_DONE,
+  FLV_STATE_NONE
+} GstFLVDemuxState;
+
+struct _GstFLVDemux {
+  GstElement element;
+
+  GstPad * sinkpad;
+  
+  GstPad * audio_pad;
+  GstPad * video_pad;
+  
+  GstAdapter * adapter;
+  
+  GstSegment * segment;
+  
+  GstEvent * new_seg_event;
+  
+  GstTagList * taglist;
+  
+  GstFLVDemuxState state;
+  
+  guint64 offset;
+  GstClockTime duration;
+  guint64 tag_size;
+  guint64 tag_data_size;
+  
+  /* Audio infos */
+  guint16 rate;
+  guint16 channels;
+  guint16 width;
+  guint16 audio_codec_tag;
+  guint64 audio_offset;
+  gboolean audio_need_discont;
+  gboolean audio_need_segment;
+  
+  /* Video infos */
+  guint32 w;
+  guint32 h;
+  guint16 video_codec_tag;
+  guint64 video_offset;
+  gboolean video_need_discont;
+  gboolean video_need_segment;
+  
+  gboolean random_access;
+  gboolean need_header;
+  gboolean has_audio;
+  gboolean has_video;
+  gboolean push_tags;
+  gboolean strict;
+};
+
+struct _GstFLVDemuxClass {
+  GstElementClass parent_class;
+};
+
+GType gst_flv_demux_get_type (void);
+
+G_END_DECLS
+
+#endif /* __FLV_DEMUX_H__ */
diff --git a/gst/flv/gstflvparse.c b/gst/flv/gstflvparse.c
new file mode 100644
index 00000000..023df66c
--- /dev/null
+++ b/gst/flv/gstflvparse.c
@@ -0,0 +1,797 @@
+/* GStreamer
+ * Copyright (C) <2007> Julien Moutte <julien@moutte.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "gstflvparse.h"
+
+#include <string.h>
+
+GST_DEBUG_CATEGORY_EXTERN (flvdemux_debug);
+#define GST_CAT_DEFAULT flvdemux_debug
+
+static guint32
+FLV_GET_BEUI24 (const guint8 * data, size_t data_size)
+{
+  guint32 ret = 0;
+
+  g_return_val_if_fail (data != NULL, 0);
+  g_return_val_if_fail (data_size >= 3, 0);
+
+  ret = GST_READ_UINT16_BE (data) << 8;
+  ret |= GST_READ_UINT8 (data + 2);
+
+  return ret;
+}
+
+static gchar *
+FLV_GET_STRING (const guint8 * data, size_t data_size)
+{
+  guint32 string_size = 0;
+  gchar *string = NULL;
+
+  g_return_val_if_fail (data != NULL, 0);
+  g_return_val_if_fail (data_size >= 3, 0);
+
+  string_size = GST_READ_UINT16_BE (data);
+
+  string = g_try_malloc0 (string_size + 1);
+  if (G_UNLIKELY (!string)) {
+    return NULL;
+  }
+
+  memcpy (string, data + 2, string_size);
+
+  return string;
+}
+
+static const GstQueryType *
+gst_flv_demux_query_types (GstPad * pad)
+{
+  static const GstQueryType query_types[] = {
+    GST_QUERY_DURATION,
+    0
+  };
+
+  return query_types;
+}
+
+static gboolean
+gst_flv_demux_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res = TRUE;
+  GstFLVDemux *demux;
+
+  demux = GST_FLV_DEMUX (gst_pad_get_parent (pad));
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_DURATION:
+    {
+      GstFormat format;
+
+      gst_query_parse_duration (query, &format, NULL);
+
+      /* duration is time only */
+      if (format != GST_FORMAT_TIME) {
+        GST_DEBUG_OBJECT (demux, "duration query only supported for time "
+            "format");
+        res = FALSE;
+        goto beach;
+      }
+
+      GST_DEBUG_OBJECT (pad, "duration query, replying %" GST_TIME_FORMAT,
+          GST_TIME_ARGS (demux->duration));
+
+      gst_query_set_duration (query, GST_FORMAT_TIME, demux->duration);
+
+      break;
+    }
+    case GST_QUERY_LATENCY:
+    {
+      GstPad *peer;
+
+      if ((peer = gst_pad_get_peer (demux->sinkpad))) {
+        /* query latency on peer pad */
+        res = gst_pad_query (peer, query);
+        gst_object_unref (peer);
+      } else {
+        /* no peer, we don't know */
+        res = FALSE;
+      }
+      break;
+    }
+    default:
+      res = FALSE;
+      break;
+  }
+
+beach:
+  gst_object_unref (demux);
+
+  return res;
+}
+
+static size_t
+gst_flv_parse_metadata_item (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  gchar *tag_name = NULL;
+  guint8 tag_type = 0;
+  size_t offset = 0;
+
+  /* Name of the tag */
+  tag_name = FLV_GET_STRING (data, data_size);
+
+  offset += strlen (tag_name) + 2;
+
+  /* What kind of object is that */
+  tag_type = GST_READ_UINT8 (data + offset);
+
+  offset++;
+
+  GST_DEBUG_OBJECT (demux, "tag name %s, tag type %d", tag_name, tag_type);
+
+  switch (tag_type) {
+    case 0:                    // Double
+    {                           /* Use a union to read the uint64 and then as a double */
+      union
+      {
+        guint64 value_uint64;
+        gdouble value_double;
+      } value_union;
+
+      value_union.value_uint64 = GST_READ_UINT64_BE (data + offset);
+
+      offset += 8;
+
+      GST_DEBUG_OBJECT (demux, "%s => (double) %f", tag_name,
+          value_union.value_double);
+
+      if (!strcmp (tag_name, "duration")) {
+        demux->duration = value_union.value_double * GST_SECOND;
+
+        gst_tag_list_add (demux->taglist, GST_TAG_MERGE_REPLACE,
+            GST_TAG_DURATION, demux->duration, NULL);
+      } else {
+        if (tag_name) {
+          if (!gst_tag_exists (tag_name)) {
+            gst_tag_register (tag_name, GST_TAG_FLAG_META, G_TYPE_DOUBLE,
+                tag_name, tag_name, gst_tag_merge_use_first);
+          }
+
+          if (gst_tag_get_type (tag_name) == G_TYPE_DOUBLE) {
+            gst_tag_list_add (demux->taglist, GST_TAG_MERGE_REPLACE,
+                tag_name, value_union.value_double, NULL);
+          } else {
+            GST_WARNING_OBJECT (demux, "tag %s already registered with a "
+                "different type", tag_name);
+          }
+        }
+      }
+
+      break;
+    }
+    case 1:                    // Boolean
+    {
+      gboolean value = GST_READ_UINT8 (data + offset);
+
+      offset++;
+
+      GST_DEBUG_OBJECT (demux, "%s => (boolean) %d", tag_name, value);
+
+      if (tag_name) {
+        if (!gst_tag_exists (tag_name)) {
+          gst_tag_register (tag_name, GST_TAG_FLAG_META, G_TYPE_BOOLEAN,
+              tag_name, tag_name, gst_tag_merge_use_first);
+        }
+
+        if (gst_tag_get_type (tag_name) == G_TYPE_BOOLEAN) {
+          gst_tag_list_add (demux->taglist, GST_TAG_MERGE_REPLACE,
+              tag_name, value, NULL);
+        } else {
+          GST_WARNING_OBJECT (demux, "tag %s already registered with a "
+              "different type", tag_name);
+        }
+      }
+
+      break;
+    }
+    case 2:                    // String
+    {
+      gchar *value = NULL;
+
+      value = FLV_GET_STRING (data + offset, data_size - offset);
+
+      offset += strlen (value) + 2;
+
+      GST_DEBUG_OBJECT (demux, "%s => (string) %s", tag_name, value);
+
+      if (tag_name) {
+        if (!gst_tag_exists (tag_name)) {
+          gst_tag_register (tag_name, GST_TAG_FLAG_META, G_TYPE_STRING,
+              tag_name, tag_name, gst_tag_merge_strings_with_comma);
+        }
+
+        if (gst_tag_get_type (tag_name) == G_TYPE_STRING) {
+          gst_tag_list_add (demux->taglist, GST_TAG_MERGE_REPLACE,
+              tag_name, value, NULL);
+        } else {
+          GST_WARNING_OBJECT (demux, "tag %s already registered with a "
+              "different type", tag_name);
+        }
+      }
+
+      g_free (value);
+
+      break;
+    }
+    default:
+      GST_WARNING_OBJECT (demux, "unsupported tag type %d", tag_type);
+  }
+
+  g_free (tag_name);
+
+  return offset;
+}
+
+GstFlowReturn
+gst_flv_parse_tag_script (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  size_t offset = 7;
+
+  GST_LOG_OBJECT (demux, "parsing a script tag");
+
+  if (GST_READ_UINT8 (data + offset++) == 2) {
+    gchar *function_name = FLV_GET_STRING (data + offset, data_size - offset);
+
+    GST_LOG_OBJECT (demux, "function name is %s", function_name);
+
+    if (!strcmp (function_name, "onMetaData")) {
+      guint32 nb_elems = 0;
+
+      GST_DEBUG_OBJECT (demux, "we have a metadata script object");
+
+      /* Jump over the onMetaData string and the array indicator */
+      offset += 13;
+
+      nb_elems = GST_READ_UINT32_BE (data + offset);
+
+      /* Jump over the number of elements */
+      offset += 4;
+
+      GST_DEBUG_OBJECT (demux, "there are %d elements in the array", nb_elems);
+
+      while (nb_elems--) {
+        offset += gst_flv_parse_metadata_item (demux, data + offset,
+            data_size - offset);
+      }
+
+      demux->push_tags = TRUE;
+    }
+
+    g_free (function_name);
+  }
+
+
+  return ret;
+}
+
+GstFlowReturn
+gst_flv_parse_tag_audio (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *buffer = NULL;
+  guint32 pts = 0, codec_tag = 0, rate = 0, width = 0, channels = 0;
+  guint32 codec_data = 0;
+  guint8 flags = 0;
+
+  GST_LOG_OBJECT (demux, "parsing an audio tag");
+
+  /* Grab information about audio tag */
+  pts = FLV_GET_BEUI24 (data, data_size);
+  flags = GST_READ_UINT8 (data + 7);
+
+  /* Channels */
+  if (flags & 0x01) {
+    channels = 2;
+  } else {
+    channels = 1;
+  }
+  /* Width */
+  if (flags & 0x02) {
+    width = 16;
+  } else {
+    width = 8;
+  }
+  /* Sampling rate */
+  if (flags & 0x0C) {
+    rate = 44100;
+  } else if (flags & 0x08) {
+    rate = 22050;
+  } else if (flags & 0x04) {
+    rate = 11025;
+  } else {
+    rate = 5512;
+  }
+  /* Codec tag */
+  if (flags & 0x10) {
+    codec_tag = 1;
+    codec_data = 1;
+  } else if (flags & 0x20) {
+    codec_tag = 2;
+    codec_data = 1;
+  } else if (flags & 0x30) {
+    codec_tag = 3;
+    codec_data = 1;
+  } else if (flags & 0x40) {
+    codec_tag = 4;
+    codec_data = 1;
+  } else if (flags & 0x50) {
+    codec_tag = 5;
+    codec_data = 1;
+  }
+
+  GST_LOG_OBJECT (demux, "audio tag with %d channels, %dHz sampling rate, "
+      "%d bits width, codec tag %d", channels, rate, width, codec_tag);
+
+  /* If we don't have our audio pad created, then create it. */
+  if (G_UNLIKELY (!demux->audio_pad)) {
+    GstCaps *caps = NULL;
+
+    demux->audio_pad = gst_pad_new ("audio", GST_PAD_SRC);
+    if (G_UNLIKELY (!demux->audio_pad)) {
+      GST_WARNING_OBJECT (demux, "failed creating audio pad");
+      ret = GST_FLOW_ERROR;
+      goto beach;
+    }
+
+    /* Make it active */
+    gst_pad_set_active (demux->audio_pad, TRUE);
+
+    switch (codec_tag) {
+      case 2:
+        caps = gst_caps_new_simple ("audio/mpeg",
+            "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
+        break;
+      case 0:
+      case 3:
+        caps = gst_caps_new_simple ("audio/x-raw-int", NULL);
+        break;
+      default:
+        GST_WARNING_OBJECT (demux, "unsupported audio codec tag", codec_tag);
+    }
+
+    if (G_UNLIKELY (!caps)) {
+      GST_WARNING_OBJECT (demux, "failed creating caps for audio pad");
+      ret = GST_FLOW_ERROR;
+      gst_object_unref (demux->audio_pad);
+      demux->audio_pad = NULL;
+      goto beach;
+    }
+
+    gst_caps_set_simple (caps,
+        "rate", G_TYPE_INT, rate,
+        "channels", G_TYPE_INT, channels, "width", G_TYPE_INT, width, NULL);
+
+    gst_pad_set_caps (demux->audio_pad, caps);
+
+    gst_caps_unref (caps);
+
+    /* Store the caps we have set */
+    demux->audio_codec_tag = codec_tag;
+    demux->rate = rate;
+    demux->channels = channels;
+    demux->width = width;
+
+    /* Set functions on the pad */
+    gst_pad_set_query_type_function (demux->audio_pad,
+        GST_DEBUG_FUNCPTR (gst_flv_demux_query_types));
+    gst_pad_set_query_function (demux->audio_pad,
+        GST_DEBUG_FUNCPTR (gst_flv_demux_query));
+
+    /* We need to set caps before adding */
+    gst_element_add_pad (GST_ELEMENT (demux), demux->audio_pad);
+  }
+
+  /* Check if caps have changed */
+  if (G_UNLIKELY (rate != demux->rate || channels != demux->channels ||
+          codec_tag != demux->audio_codec_tag || width != demux->width)) {
+    GstCaps *caps = NULL;
+
+    GST_DEBUG_OBJECT (demux, "audio settings have changed, changing caps");
+
+    switch (codec_tag) {
+      case 2:
+        caps = gst_caps_new_simple ("audio/mpeg",
+            "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
+        break;
+      case 0:
+      case 3:
+        caps = gst_caps_new_simple ("audio/x-raw-int", NULL);
+        break;
+      default:
+        GST_WARNING_OBJECT (demux, "unsupported audio codec tag", codec_tag);
+    }
+
+    if (G_UNLIKELY (!caps)) {
+      GST_WARNING_OBJECT (demux, "failed creating caps for audio pad");
+      ret = GST_FLOW_ERROR;
+      goto beach;
+    }
+
+    gst_caps_set_simple (caps,
+        "rate", G_TYPE_INT, rate,
+        "channels", G_TYPE_INT, channels, "width", G_TYPE_INT, width, NULL);
+
+    gst_pad_set_caps (demux->audio_pad, caps);
+
+    gst_caps_unref (caps);
+
+    /* Store the caps we have set */
+    demux->audio_codec_tag = codec_tag;
+    demux->rate = rate;
+    demux->channels = channels;
+    demux->width = width;
+  }
+
+  /* Push taglist if present */
+  if ((demux->has_audio & (demux->audio_pad != NULL)) &&
+      (demux->has_video & (demux->video_pad != NULL)) &&
+      demux->taglist && demux->push_tags) {
+    GST_DEBUG_OBJECT (demux, "pushing tags out");
+    gst_element_found_tags (GST_ELEMENT (demux), demux->taglist);
+    demux->taglist = gst_tag_list_new ();
+    demux->push_tags = FALSE;
+  }
+
+  /* Create buffer from pad */
+  ret = gst_pad_alloc_buffer (demux->audio_pad, GST_BUFFER_OFFSET_NONE,
+      demux->tag_data_size - codec_data, GST_PAD_CAPS (demux->audio_pad),
+      &buffer);
+  if (G_UNLIKELY (ret != GST_FLOW_OK)) {
+    GST_WARNING_OBJECT (demux, "failed allocating a %d bytes buffer",
+        demux->tag_data_size);
+    goto beach;
+  }
+
+  /* Fill buffer with data */
+  GST_BUFFER_TIMESTAMP (buffer) = pts * GST_MSECOND;
+  GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
+  GST_BUFFER_OFFSET (buffer) = demux->audio_offset++;
+  GST_BUFFER_OFFSET_END (buffer) = demux->audio_offset;
+
+  if (G_UNLIKELY (demux->audio_need_discont)) {
+    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+    demux->audio_need_discont = FALSE;
+  }
+
+  gst_segment_set_last_stop (demux->segment, GST_FORMAT_TIME,
+      GST_BUFFER_TIMESTAMP (buffer));
+
+  /* Do we need a newsegment event ? */
+  if (G_UNLIKELY (demux->audio_need_segment)) {
+    if (!demux->new_seg_event) {
+      GST_DEBUG_OBJECT (demux, "pushing newsegment from %"
+          GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
+          GST_TIME_ARGS (demux->segment->last_stop), GST_TIME_ARGS (-1));
+      demux->new_seg_event = gst_event_new_new_segment (FALSE,
+          demux->segment->rate, demux->segment->format,
+          demux->segment->last_stop, -1, demux->segment->last_stop);
+    }
+
+    gst_pad_push_event (demux->audio_pad, gst_event_ref (demux->new_seg_event));
+
+    demux->audio_need_segment = FALSE;
+  }
+
+  memcpy (GST_BUFFER_DATA (buffer), data + 7 + codec_data,
+      demux->tag_data_size - codec_data);
+
+  GST_LOG_OBJECT (demux, "pushing %d bytes buffer at pts %" GST_TIME_FORMAT
+      " with duration %" GST_TIME_FORMAT ", offset %" G_GUINT64_FORMAT,
+      GST_BUFFER_SIZE (buffer), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
+      GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)), GST_BUFFER_OFFSET (buffer));
+
+  /* Push downstream */
+  ret = gst_pad_push (demux->audio_pad, buffer);
+
+beach:
+  return ret;
+}
+
+GstFlowReturn
+gst_flv_parse_tag_video (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *buffer = NULL;
+  guint32 pts = 0, codec_tag = 0, codec_data = 0;
+  gboolean keyframe = FALSE;
+  guint8 flags = 0;
+
+  GST_LOG_OBJECT (demux, "parsing a video tag");
+
+  /* Grab information about audio tag */
+  pts = FLV_GET_BEUI24 (data, data_size);
+  flags = GST_READ_UINT8 (data + 7);
+
+  /* Keyframe */
+  if (flags & 0x10) {
+    keyframe = TRUE;
+  } else if (flags & 0x20) {
+    keyframe = FALSE;
+  }
+  /* Codec tag */
+  if (flags & 0x02) {           // H263
+    codec_tag = 2;
+    codec_data = 1;
+  } else if (flags & 0x03) {    // Sorenson Spark
+    codec_tag = 3;
+    codec_data = 1;
+  } else if (flags & 0x04) {    // VP6
+    codec_tag = 4;
+    codec_data = 2;
+  } else if (flags & 0x05) {    // VP6 Alpha
+    codec_tag = 5;
+    codec_data = 2;
+  }
+
+  GST_LOG_OBJECT (demux, "video tag with codec tag %d, keyframe (%d)",
+      codec_tag, keyframe);
+
+  /* If we don't have our video pad created, then create it. */
+  if (G_UNLIKELY (!demux->video_pad)) {
+    GstCaps *caps = NULL;
+
+    demux->video_pad = gst_pad_new ("video", GST_PAD_SRC);
+    if (G_UNLIKELY (!demux->video_pad)) {
+      GST_WARNING_OBJECT (demux, "failed creating video pad");
+      ret = GST_FLOW_ERROR;
+      goto beach;
+    }
+    /* Make it active */
+    gst_pad_set_active (demux->video_pad, TRUE);
+
+    /* Generate caps for that pad */
+    switch (codec_tag) {
+      case 2:
+        caps = gst_caps_new_simple ("video/x-flash-video", NULL);
+        break;
+      case 3:
+        caps = gst_caps_new_simple ("video/x-flash-video", NULL);
+        break;
+      case 4:
+        caps = gst_caps_new_simple ("video/x-vp6", NULL);
+        break;
+      case 5:
+        caps = gst_caps_new_simple ("video/x-vp6", NULL);
+        break;
+      default:
+        GST_WARNING_OBJECT (demux, "unsupported video codec tag %d", codec_tag);
+    }
+
+    if (G_UNLIKELY (!caps)) {
+      GST_WARNING_OBJECT (demux, "failed creating caps for video pad");
+      gst_object_unref (demux->video_pad);
+      demux->video_pad = NULL;
+      ret = GST_FLOW_ERROR;
+      goto beach;
+    }
+
+    gst_pad_set_caps (demux->video_pad, caps);
+
+    gst_caps_unref (caps);
+
+    /* Store the caps we have set */
+    demux->video_codec_tag = codec_tag;
+
+    /* Set functions on the pad */
+    gst_pad_set_query_type_function (demux->video_pad,
+        GST_DEBUG_FUNCPTR (gst_flv_demux_query_types));
+    gst_pad_set_query_function (demux->video_pad,
+        GST_DEBUG_FUNCPTR (gst_flv_demux_query));
+
+    /* We need to set caps before adding */
+    gst_element_add_pad (GST_ELEMENT (demux), demux->video_pad);
+  }
+
+  /* Check if caps have changed */
+  if (G_UNLIKELY (codec_tag != demux->video_codec_tag)) {
+    GstCaps *caps = NULL;
+
+    GST_DEBUG_OBJECT (demux, "video settings have changed, changing caps");
+
+    /* Generate caps for that pad */
+    switch (codec_tag) {
+      case 2:
+        caps = gst_caps_new_simple ("video/x-flash-video", NULL);
+        break;
+      case 3:
+        caps = gst_caps_new_simple ("video/x-flash-video", NULL);
+        break;
+      case 4:
+        caps = gst_caps_new_simple ("video/x-vp6", NULL);
+        break;
+      case 5:
+        caps = gst_caps_new_simple ("video/x-vp6", NULL);
+        break;
+      default:
+        GST_WARNING_OBJECT (demux, "unsupported video codec tag %d", codec_tag);
+    }
+
+    if (G_UNLIKELY (!caps)) {
+      GST_WARNING_OBJECT (demux, "failed creating caps for video pad");
+      ret = GST_FLOW_ERROR;
+      goto beach;
+    }
+
+    gst_pad_set_caps (demux->video_pad, caps);
+
+    gst_caps_unref (caps);
+
+    /* Store the caps we have set */
+    demux->video_codec_tag = codec_tag;
+  }
+
+  /* Push taglist if present */
+  if ((demux->has_audio & (demux->audio_pad != NULL)) &&
+      (demux->has_video & (demux->video_pad != NULL)) &&
+      demux->taglist && demux->push_tags) {
+    GST_DEBUG_OBJECT (demux, "pushing tags out");
+    gst_element_found_tags (GST_ELEMENT (demux), demux->taglist);
+    demux->taglist = gst_tag_list_new ();
+    demux->push_tags = FALSE;
+  }
+
+  /* Create buffer from pad */
+  ret = gst_pad_alloc_buffer (demux->video_pad, GST_BUFFER_OFFSET_NONE,
+      demux->tag_data_size - codec_data, GST_PAD_CAPS (demux->video_pad),
+      &buffer);
+  if (G_UNLIKELY (ret != GST_FLOW_OK)) {
+    GST_WARNING_OBJECT (demux, "failed allocating a %d bytes buffer",
+        demux->tag_data_size);
+    goto beach;
+  }
+
+  /* Fill buffer with data */
+  GST_BUFFER_TIMESTAMP (buffer) = pts * GST_MSECOND;
+  GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
+  GST_BUFFER_OFFSET (buffer) = demux->video_offset++;
+  GST_BUFFER_OFFSET_END (buffer) = demux->video_offset;
+
+  if (!keyframe) {
+    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
+  }
+
+  if (G_UNLIKELY (demux->video_need_discont)) {
+    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+    demux->video_need_discont = FALSE;
+  }
+
+  gst_segment_set_last_stop (demux->segment, GST_FORMAT_TIME,
+      GST_BUFFER_TIMESTAMP (buffer));
+
+  /* Do we need a newsegment event ? */
+  if (G_UNLIKELY (demux->video_need_segment)) {
+    if (!demux->new_seg_event) {
+      GST_DEBUG_OBJECT (demux, "pushing newsegment from %"
+          GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
+          GST_TIME_ARGS (demux->segment->last_stop), GST_TIME_ARGS (-1));
+      demux->new_seg_event = gst_event_new_new_segment (FALSE,
+          demux->segment->rate, demux->segment->format,
+          demux->segment->last_stop, -1, demux->segment->last_stop);
+    }
+
+    gst_pad_push_event (demux->video_pad, gst_event_ref (demux->new_seg_event));
+
+    demux->video_need_segment = FALSE;
+  }
+
+  /* FIXME: safety checks */
+  memcpy (GST_BUFFER_DATA (buffer), data + 7 + codec_data,
+      demux->tag_data_size - codec_data);
+
+  GST_LOG_OBJECT (demux, "pushing %d bytes buffer at pts %" GST_TIME_FORMAT
+      " with duration %" GST_TIME_FORMAT ", offset %" G_GUINT64_FORMAT
+      ", keyframe (%d)", GST_BUFFER_SIZE (buffer),
+      GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
+      GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)), GST_BUFFER_OFFSET (buffer),
+      keyframe);
+
+  /* Push downstream */
+  ret = gst_pad_push (demux->video_pad, buffer);
+
+beach:
+  return ret;
+}
+
+GstFlowReturn
+gst_flv_parse_tag_type (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+  guint8 tag_type = 0;
+
+  tag_type = data[0];
+
+  switch (tag_type) {
+    case 9:
+      demux->state = FLV_STATE_TAG_VIDEO;
+      break;
+    case 8:
+      demux->state = FLV_STATE_TAG_AUDIO;
+      break;
+    case 18:
+      demux->state = FLV_STATE_TAG_SCRIPT;
+      break;
+    default:
+      GST_WARNING_OBJECT (demux, "unsupported tag type %u", tag_type);
+  }
+
+  /* Tag size is 1 byte of type + 3 bytes of size + 7 bytes + tag data size +
+   * 4 bytes of previous tag size */
+  demux->tag_data_size = FLV_GET_BEUI24 (data + 1, data_size - 1);
+  demux->tag_size = demux->tag_data_size + 11;
+
+  GST_LOG_OBJECT (demux, "tag data size is %d", demux->tag_data_size);
+
+  return ret;
+}
+
+GstFlowReturn
+gst_flv_parse_header (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  /* Check for the FLV tag */
+  if (data[0] == 'F' && data[1] == 'L' && data[2] == 'V') {
+    GST_DEBUG_OBJECT (demux, "FLV header detected");
+  } else {
+    if (G_UNLIKELY (demux->strict)) {
+      GST_WARNING_OBJECT (demux, "invalid header tag detected");
+      ret = GST_FLOW_UNEXPECTED;
+      goto beach;
+    }
+  }
+
+  /* Jump over the 4 first bytes */
+  data += 4;
+
+  /* Now look at audio/video flags */
+  {
+    guint8 flags = data[0];
+
+    if (flags & 1) {
+      GST_DEBUG_OBJECT (demux, "there is a video stream");
+      demux->has_video = TRUE;
+    }
+    if (flags & 4) {
+      GST_DEBUG_OBJECT (demux, "there is an audio stream");
+      demux->has_audio = TRUE;
+    }
+  }
+
+  /* We don't care about the rest */
+  demux->need_header = FALSE;
+
+beach:
+  return ret;
+}
diff --git a/gst/flv/gstflvparse.h b/gst/flv/gstflvparse.h
new file mode 100644
index 00000000..027aaeda
--- /dev/null
+++ b/gst/flv/gstflvparse.h
@@ -0,0 +1,44 @@
+/* GStreamer
+ * Copyright (C) <2007> Julien Moutte <julien@moutte.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+ 
+#ifndef __FLV_PARSE_H__
+#define __FLV_PARSE_H__
+
+#include "gstflvdemux.h"
+
+G_BEGIN_DECLS
+
+GstFlowReturn gst_flv_parse_tag_script (GstFLVDemux * demux,
+    const guint8 * data, size_t data_size);
+
+GstFlowReturn gst_flv_parse_tag_audio (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size);
+
+GstFlowReturn gst_flv_parse_tag_video (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size);
+    
+GstFlowReturn gst_flv_parse_tag_type (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size);
+
+GstFlowReturn gst_flv_parse_header (GstFLVDemux * demux, const guint8 * data,
+    size_t data_size);
+
+G_END_DECLS
+
+#endif /* __FLV_PARSE_H__ */