Initial revision

Original commit message from CVS:
Initial revision

1 files changed, 757 insertions, 0 deletions

diff --git a/gst/avi/gstavidemux.c b/gst/avi/gstavidemux.c
new file mode 100644
index 00000000..1aca1ad2
--- /dev/null
+++ b/gst/avi/gstavidemux.c
@@ -0,0 +1,757 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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.
+ */
+
+
+//#define GST_DEBUG_ENABLED
+#include <string.h>
+
+#include "gstavidemux.h"
+
+
+/* elementfactory information */
+static GstElementDetails gst_avi_demux_details = {
+  ".avi parser",
+  "Parser/Video",
+  "Parse a .avi file into audio and video",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>\n"
+  "Wim Taymans <wim.taymans@tvd.be>",
+  "(C) 1999",
+};
+
+static GstCaps* avi_typefind (GstBuffer *buf, gpointer private);
+
+/* typefactory for 'avi' */
+static GstTypeDefinition avidefinition = {
+  "avidemux_video/avi",
+  "video/avi",
+  ".avi",
+  avi_typefind,
+};
+
+/* AviDemux signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_BITRATE,
+  ARG_MEDIA_TIME,
+  ARG_CURRENT_TIME,
+  /* FILL ME */
+};
+
+GST_PADTEMPLATE_FACTORY (sink_templ,
+  "sink",
+  GST_PAD_SINK,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "avidemux_sink",
+     "video/avi",
+     NULL
+  )
+)
+
+GST_PADTEMPLATE_FACTORY (src_video_templ,
+  "video_[00-32]",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "src_video",
+    "video/avi",
+      "format",  GST_PROPS_LIST (
+	           GST_PROPS_STRING ("strf_vids"),
+	           GST_PROPS_STRING ("strf_iavs")
+      		 )
+  )
+)
+
+GST_PADTEMPLATE_FACTORY (src_audio_templ,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "src_audio",
+    "video/avi",
+      "format", GST_PROPS_STRING ("strf_auds")
+  )
+)
+
+static void 	gst_avi_demux_class_init	(GstAviDemuxClass *klass);
+static void 	gst_avi_demux_init		(GstAviDemux *avi_demux);
+
+static void 	gst_avi_demux_loop 		(GstElement *element);
+
+static void     gst_avi_demux_get_property      (GObject *object, guint prop_id, 	
+						 GValue *value, GParamSpec *pspec);
+
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_avi_demux_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_avi_demux_get_type(void) 
+{
+  static GType avi_demux_type = 0;
+
+  if (!avi_demux_type) {
+    static const GTypeInfo avi_demux_info = {
+      sizeof(GstAviDemuxClass),      
+      NULL,
+      NULL,
+      (GClassInitFunc)gst_avi_demux_class_init,
+      NULL,
+      NULL,
+      sizeof(GstAviDemux),
+      0,
+      (GInstanceInitFunc)gst_avi_demux_init,
+    };
+    avi_demux_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAviDemux", &avi_demux_info, 0);
+  }
+  return avi_demux_type;
+}
+
+static void
+gst_avi_demux_class_init (GstAviDemuxClass *klass) 
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_BITRATE,
+    g_param_spec_long ("bitrate","bitrate","bitrate",
+                       G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
+  g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_MEDIA_TIME,
+    g_param_spec_long ("media_time","media_time","media_time",
+                       G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
+  g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_CURRENT_TIME,
+    g_param_spec_long ("current_time","current_time","current_time",
+                       G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
+
+  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+  
+  gobject_class->get_property = gst_avi_demux_get_property;
+}
+
+static void 
+gst_avi_demux_init (GstAviDemux *avi_demux) 
+{
+  guint i;
+
+  GST_FLAG_SET (avi_demux, GST_ELEMENT_EVENT_AWARE);
+				
+  avi_demux->sinkpad = gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (sink_templ), "sink");
+  gst_element_add_pad (GST_ELEMENT (avi_demux), avi_demux->sinkpad);
+
+  gst_element_set_loop_function (GST_ELEMENT (avi_demux), gst_avi_demux_loop);
+
+  avi_demux->state = GST_AVI_DEMUX_UNKNOWN;
+  avi_demux->num_audio_pads = 0;
+  avi_demux->num_video_pads = 0;
+  avi_demux->next_time = 0;
+  avi_demux->flags = 0;
+  avi_demux->index_entries = NULL;
+  avi_demux->index_size = 0;
+  avi_demux->resync_offset = 0;
+
+  //GST_FLAG_SET( GST_OBJECT (avi_demux), GST_ELEMENT_NO_SEEK);
+
+  for(i=0; i<GST_AVI_DEMUX_MAX_AUDIO_PADS; i++) 
+    avi_demux->audio_pad[i] = NULL;
+
+  for(i=0; i<GST_AVI_DEMUX_MAX_VIDEO_PADS; i++) 
+    avi_demux->video_pad[i] = NULL;
+
+}
+
+static GstCaps*
+avi_typefind (GstBuffer *buf,
+              gpointer private)
+{
+  gchar *data = GST_BUFFER_DATA (buf);
+  GstCaps *new;
+
+  GST_DEBUG (0,"avi_demux: typefind\n");
+
+  if (GUINT32_FROM_LE (((guint32 *)data)[0]) != GST_RIFF_TAG_RIFF)
+    return NULL;
+  if (GUINT32_FROM_LE (((guint32 *)data)[2]) != GST_RIFF_RIFF_AVI)
+    return NULL;
+
+  new = gst_caps_new ("avi_typefind","video/avi", NULL);
+
+  return new;
+}
+
+static gboolean
+gst_avi_demux_avih (GstAviDemux *avi_demux)
+{
+  gst_riff_avih *avih;
+  GstByteStream *bs = avi_demux->bs;
+
+  avih = (gst_riff_avih *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_avih));
+  if (avih) {
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux: avih tag found");
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  us_frame    %d", GUINT32_FROM_LE (avih->us_frame));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  max_bps     %d", GUINT32_FROM_LE (avih->max_bps));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  pad_gran    %d", GUINT32_FROM_LE (avih->pad_gran));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  flags       0x%08x", GUINT32_FROM_LE (avih->flags));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  tot_frames  %d", GUINT32_FROM_LE (avih->tot_frames));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  init_frames %d", GUINT32_FROM_LE (avih->init_frames));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  streams     %d", GUINT32_FROM_LE (avih->streams));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  bufsize     %d", GUINT32_FROM_LE (avih->bufsize));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  width       %d", GUINT32_FROM_LE (avih->width));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  height      %d", GUINT32_FROM_LE (avih->height));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  scale       %d", GUINT32_FROM_LE (avih->scale));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  rate        %d", GUINT32_FROM_LE (avih->rate));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  start       %d", GUINT32_FROM_LE (avih->start));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  length      %d", GUINT32_FROM_LE (avih->length));
+
+    avi_demux->time_interval = GUINT32_FROM_LE (avih->us_frame);
+    avi_demux->tot_frames = GUINT32_FROM_LE (avih->tot_frames);
+    avi_demux->flags = GUINT32_FROM_LE (avih->flags);
+
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static gboolean 
+gst_avi_demux_strh (GstAviDemux *avi_demux)
+{
+  gst_riff_strh *strh;
+  GstByteStream *bs = avi_demux->bs;
+
+  strh = (gst_riff_strh *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_strh));
+  if (strh) {
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux: strh tag found");
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  type        0x%08x (%s)", 
+  		  GUINT32_FROM_LE (strh->type), gst_riff_id_to_fourcc (strh->type));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  fcc_handler 0x%08x (%s)", 
+		  GUINT32_FROM_LE (strh->fcc_handler), gst_riff_id_to_fourcc (strh->fcc_handler));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  flags       0x%08x", GUINT32_FROM_LE (strh->flags));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  priority    %d", GUINT32_FROM_LE (strh->priority));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  init_frames %d", GUINT32_FROM_LE (strh->init_frames));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  scale       %d", GUINT32_FROM_LE (strh->scale));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  rate        %d", GUINT32_FROM_LE (strh->rate));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  start       %d", GUINT32_FROM_LE (strh->start));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  length      %d", GUINT32_FROM_LE (strh->length));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  bufsize     %d", GUINT32_FROM_LE (strh->bufsize));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  quality     %d", GUINT32_FROM_LE (strh->quality));
+    GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  samplesize  %d", GUINT32_FROM_LE (strh->samplesize));
+
+    avi_demux->fcc_type = GUINT32_FROM_LE (strh->type);
+
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static void 
+gst_avi_demux_strf_vids (GstAviDemux *avi_demux)
+{
+  gst_riff_strf_vids *strf;
+  GstPad *srcpad;
+  GstByteStream *bs = avi_demux->bs;
+
+  strf = (gst_riff_strf_vids *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_strf_vids));
+
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux: strf tag found in context vids");
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  size        %d", GUINT32_FROM_LE (strf->size));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  width       %d", GUINT32_FROM_LE (strf->width));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  height      %d", GUINT32_FROM_LE (strf->height));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  planes      %d", GUINT16_FROM_LE (strf->planes));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  bit_cnt     %d", GUINT16_FROM_LE (strf->bit_cnt));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  compression 0x%08x (%s)", 
+		  GUINT32_FROM_LE (strf->compression), gst_riff_id_to_fourcc (strf->compression));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  image_size  %d", GUINT32_FROM_LE (strf->image_size));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  xpels_meter %d", GUINT32_FROM_LE (strf->xpels_meter));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  ypels_meter %d", GUINT32_FROM_LE (strf->ypels_meter));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  num_colors  %d", GUINT32_FROM_LE (strf->num_colors));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  imp_colors  %d", GUINT32_FROM_LE (strf->imp_colors));
+
+  srcpad =  gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (src_video_templ), g_strdup_printf ("video_%02d", 
+			  avi_demux->num_video_pads));
+
+  gst_pad_set_caps (srcpad, gst_caps_new (
+			  "avidec_video_src",
+			  "video/avi",
+			  gst_props_new (
+			    "format",    	GST_PROPS_STRING ("strf_vids"),
+			      "size", 		GST_PROPS_INT (GUINT32_FROM_LE (strf->size)),
+			      "width", 		GST_PROPS_INT (GUINT32_FROM_LE (strf->width)),
+			      "height", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->height)),
+			      "planes", 	GST_PROPS_INT (GUINT16_FROM_LE (strf->planes)),
+			      "bit_cnt", 	GST_PROPS_INT (GUINT16_FROM_LE (strf->bit_cnt)),
+			      "compression", 	GST_PROPS_FOURCC (GUINT32_FROM_LE (strf->compression)),
+			      "image_size", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->image_size)),
+			      "xpels_meter", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->xpels_meter)),
+			      "ypels_meter", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->ypels_meter)),
+			      "num_colors", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->num_colors)),
+			      "imp_colors", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->imp_colors)),
+			      NULL)));
+
+  avi_demux->video_pad[avi_demux->num_video_pads++] = srcpad;
+  gst_element_add_pad (GST_ELEMENT (avi_demux), srcpad);
+}
+
+static void 
+gst_avi_demux_strf_auds (GstAviDemux *avi_demux)
+{
+  gst_riff_strf_auds *strf;
+  GstPad *srcpad;
+  GstByteStream *bs = avi_demux->bs;
+
+  strf = (gst_riff_strf_auds *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_strf_auds));
+
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux: strf tag found in context auds");
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  format      %d", GUINT16_FROM_LE (strf->format));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  channels    %d", GUINT16_FROM_LE (strf->channels));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  rate        %d", GUINT32_FROM_LE (strf->rate));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  av_bps      %d", GUINT32_FROM_LE (strf->av_bps));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  blockalign  %d", GUINT16_FROM_LE (strf->blockalign));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  size        %d", GUINT16_FROM_LE (strf->size));
+
+  srcpad =  gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (src_audio_templ), g_strdup_printf ("audio_%02d", 
+			  avi_demux->num_audio_pads));
+
+  gst_pad_set_caps (srcpad, gst_caps_new (
+			  "avidec_audio_src",
+			  "video/avi",
+			  gst_props_new (
+			    "format",    	GST_PROPS_STRING ("strf_auds"),
+			      "fmt", 		GST_PROPS_INT (GUINT16_FROM_LE (strf->format)),
+			      "channels", 	GST_PROPS_INT (GUINT16_FROM_LE (strf->channels)),
+			      "rate", 		GST_PROPS_INT (GUINT32_FROM_LE (strf->rate)),
+			      "av_bps",		GST_PROPS_INT (GUINT32_FROM_LE (strf->av_bps)),
+			      "blockalign",	GST_PROPS_INT (GUINT16_FROM_LE (strf->blockalign)),
+			      "size",		GST_PROPS_INT (GUINT16_FROM_LE (strf->size)),
+			      NULL)));
+
+  avi_demux->audio_pad[avi_demux->num_audio_pads++] = srcpad;
+  gst_element_add_pad (GST_ELEMENT (avi_demux), srcpad);
+}
+
+static void 
+gst_avi_demux_strf_iavs (GstAviDemux *avi_demux)
+{
+  gst_riff_strf_iavs *strf;
+  GstPad *srcpad;
+  GstByteStream *bs = avi_demux->bs;
+
+  strf = (gst_riff_strf_iavs *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_strf_iavs));
+
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux: strf tag found in context iavs");
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVAAuxSrc   %08x", GUINT32_FROM_LE (strf->DVAAuxSrc));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVAAuxCtl   %08x", GUINT32_FROM_LE (strf->DVAAuxCtl));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVAAuxSrc1  %08x", GUINT32_FROM_LE (strf->DVAAuxSrc1));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVAAuxCtl1  %08x", GUINT32_FROM_LE (strf->DVAAuxCtl1));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVVAuxSrc   %08x", GUINT32_FROM_LE (strf->DVVAuxSrc));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVVAuxCtl   %08x", GUINT32_FROM_LE (strf->DVVAuxCtl));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVReserved1 %08x", GUINT32_FROM_LE (strf->DVReserved1));
+  GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux:  DVReserved2 %08x", GUINT32_FROM_LE (strf->DVReserved2));
+
+  srcpad =  gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (src_video_templ), g_strdup_printf ("video_%02d", 
+			  avi_demux->num_video_pads));
+
+  gst_pad_set_caps (srcpad, gst_caps_new (
+			  "avidec_iav_src",
+			  "video/avi",
+			  gst_props_new (
+			    "format",    	GST_PROPS_STRING ("strf_iavs"),
+                              "DVAAuxSrc", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVAAuxSrc)),
+                              "DVAAuxCtl", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVAAuxCtl)),
+                              "DVAAuxSrc1", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVAAuxSrc1)),
+                              "DVAAuxCtl1", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVAAuxCtl1)),
+                              "DVVAuxSrc", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVVAuxSrc)),
+                              "DVVAuxCtl", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVVAuxCtl)),
+                              "DVReserved1", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVReserved1)),
+                              "DVReserved2", 	GST_PROPS_INT (GUINT32_FROM_LE (strf->DVReserved2)),
+			      NULL)));
+
+  avi_demux->video_pad[avi_demux->num_video_pads++] = srcpad;
+  gst_element_add_pad (GST_ELEMENT (avi_demux), srcpad);
+}
+
+static void
+gst_avidemux_parse_index (GstAviDemux *avi_demux,
+		            gulong offset)
+{
+  GstBuffer *buf;
+  gulong index_size;
+
+  buf = gst_pad_pullregion (avi_demux->sinkpad, GST_REGION_OFFSET_LEN, offset, 8);
+
+  if (!buf || GST_BUFFER_OFFSET (buf) != offset || GST_BUFFER_SIZE (buf) != 8) {
+    GST_INFO (GST_CAT_PLUGIN_INFO, "avidemux: could not get index");
+    return;
+  }
+
+  if (gst_riff_fourcc_to_id (GST_BUFFER_DATA (buf)) != GST_RIFF_TAG_idx1) {
+    GST_INFO (GST_CAT_PLUGIN_INFO, "avidemux: no index found");
+    return;
+  }
+
+  index_size = GUINT32_FROM_LE(*(guint32 *)(GST_BUFFER_DATA (buf) + 4));
+
+  buf = gst_pad_pullregion(avi_demux->sinkpad, GST_REGION_OFFSET_LEN, offset+8, index_size);
+
+  avi_demux->index_size = index_size/sizeof(gst_riff_index_entry);
+
+  GST_INFO (GST_CAT_PLUGIN_INFO, "avidemux: index size %lu", avi_demux->index_size);
+
+  avi_demux->index_entries = g_malloc (GST_BUFFER_SIZE (buf));
+  memcpy (avi_demux->index_entries, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
+
+  buf = gst_pad_pullregion(avi_demux->sinkpad, GST_REGION_OFFSET_LEN, avi_demux->index_offset, 0);
+}
+
+static inline gboolean 
+gst_avidemux_read_chunk (GstByteStream *bs, guint32 *id, guint32 *size)
+{
+  gst_riff_chunk *chunk;
+
+  chunk = (gst_riff_chunk *) gst_bytestream_peek_bytes (bs, sizeof (gst_riff_chunk));
+  if (chunk) {
+    *id =   GUINT32_FROM_LE (chunk->id);
+    *size = GUINT32_FROM_LE (chunk->size);
+
+    gst_bytestream_flush (bs, sizeof (gst_riff_chunk));
+
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static void
+gst_avidemux_forall_pads (GstAviDemux *avi_demux, GFunc func, gpointer user_data)
+{
+  gint i;
+  GstPad *pad;
+  
+  for(i=0; i<GST_AVI_DEMUX_MAX_AUDIO_PADS; i++) {
+    pad = avi_demux->audio_pad[i];
+    if (pad && GST_PAD_CONNECTED (pad)) {
+      (*func) (pad, user_data);
+    }
+  }
+
+  for(i=0; i<GST_AVI_DEMUX_MAX_VIDEO_PADS; i++) {
+    pad = avi_demux->video_pad[i];
+    if (pad && GST_PAD_CONNECTED (pad)) {
+      (*func) (pad, user_data);
+    }
+  }
+}
+
+static void
+gst_avidemux_queue_event_func (GstPad *pad, gpointer user_data)
+{
+  GstEventType type = GPOINTER_TO_INT (user_data);
+
+  gst_pad_push (pad, GST_BUFFER (gst_event_new (type)));
+}
+
+static gboolean
+gst_avidemux_handle_event (GstAviDemux *avi_demux)
+{
+  guint32 remaining;
+  GstEvent *event;
+  GstEventType type;
+  
+  gst_bytestream_get_status (avi_demux->bs, &remaining, &event);
+
+  type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
+
+  switch (type) {
+    case GST_EVENT_EOS:
+      gst_element_set_state (GST_ELEMENT (avi_demux), GST_STATE_PAUSED);
+      g_warning ("eos event\n");
+      gst_avidemux_forall_pads (avi_demux, (GFunc) gst_avidemux_queue_event_func, GINT_TO_POINTER (GST_EVENT_EOS));
+      break;
+    case GST_EVENT_SEEK:
+      g_warning ("seek event\n");
+      break;
+    case GST_EVENT_FLUSH:
+      g_warning ("flush event\n");
+      break;
+    case GST_EVENT_DISCONTINUOUS:
+      g_warning ("discont event\n");
+      break;
+    default:
+      g_warning ("unhandled event %d\n", type);
+      break;
+  }
+
+  return TRUE;
+}
+
+static gboolean
+gst_avidemux_process_chunk (GstAviDemux *avi_demux, guint64 filepos,
+			     guint32 desired_tag,
+			     gint rec_depth, guint32 *chunksize)
+{
+  guint32 chunkid;	
+  guint64 datapos;
+  GstByteStream *bs = avi_demux->bs;
+
+  if (!gst_avidemux_read_chunk (bs, &chunkid, chunksize)) {
+    printf ("  *****  Error reading chunk at filepos 0x%08llx\n", filepos);
+    return FALSE;
+  }
+  if (desired_tag) {		/* do we have to test identity? */
+    if (desired_tag != chunkid) {
+      printf ("\n\n *** Error: Expected chunk '%08x', found '%08x'\n",
+	      desired_tag, chunkid);
+      return FALSE;
+    }
+  }
+
+  GST_INFO (GST_CAT_PLUGIN_INFO, "chunkid %s, size %08x, filepos %08llx", 
+		  gst_riff_id_to_fourcc (chunkid), *chunksize, filepos);
+
+  datapos = filepos + sizeof (guint32) + sizeof (guint32);
+
+  switch (chunkid) {
+    case GST_RIFF_TAG_RIFF:
+    case GST_RIFF_TAG_LIST:
+    {
+      guint32 datashowed;
+      guint32 subchunksize;	/* size of a read subchunk             */
+
+      // flush the form type
+      if (!gst_bytestream_flush (bs, sizeof (guint32)))
+	return FALSE;
+
+      datashowed = sizeof (guint32);	/* we showed the form type      */
+      datapos += datashowed;	/* for the rest of the routine  */
+
+      while (datashowed < *chunksize) {	/* while not showed all: */
+
+	guint32 subchunklen;	/* complete size of a subchunk  */
+
+	/* recurse for subchunks of RIFF and LIST chunks: */
+	if (!gst_avidemux_process_chunk (avi_demux, datapos, 0,
+			   rec_depth + 1, &subchunksize))
+	  return FALSE;
+
+	subchunklen = sizeof (guint32) + sizeof (guint32) + ((subchunksize + 1) & ~1);
+
+	datashowed += subchunklen;
+	datapos += subchunklen;
+      }
+      *chunksize -= datashowed;
+      break;
+    }
+    case GST_RIFF_TAG_avih:
+      gst_avi_demux_avih (avi_demux);
+      break;
+    case GST_RIFF_TAG_strh:
+    {
+      gst_avi_demux_strh (avi_demux);
+      break;
+    }
+    case GST_RIFF_TAG_strf:
+      switch (avi_demux->fcc_type) {
+        case GST_RIFF_FCC_vids:
+          gst_avi_demux_strf_vids (avi_demux);
+	  break;
+        case GST_RIFF_FCC_auds:
+          gst_avi_demux_strf_auds (avi_demux);
+	  break;
+        case GST_RIFF_FCC_iavs:
+          gst_avi_demux_strf_iavs (avi_demux);
+	  break;
+	case GST_RIFF_FCC_pads:
+	case GST_RIFF_FCC_txts:
+	default:
+          GST_INFO (GST_CAT_PLUGIN_INFO, "gst_avi_demux_chain: strh type %s not supported", gst_riff_id_to_fourcc (avi_demux->fcc_type));
+	  break;
+      }
+      break;
+    case GST_RIFF_00dc:
+    case GST_RIFF_00db:
+    case GST_RIFF_00__:
+    {
+      GST_DEBUG (0,"gst_avi_demux_chain: tag found %08x size %08x\n",
+		    chunkid, *chunksize);
+
+      if (GST_PAD_CONNECTED (avi_demux->video_pad[0])) {
+	GstBuffer *buf;
+
+	if (*chunksize) {
+          buf = gst_bytestream_peek (bs, *chunksize);
+	}
+	else {
+          buf = gst_buffer_new ();
+	}
+        GST_BUFFER_TIMESTAMP (buf) = avi_demux->next_time;
+        avi_demux->next_time += avi_demux->time_interval;
+
+        if (avi_demux->video_need_flush[0]) {
+          avi_demux->video_need_flush[0] = FALSE;
+ 	  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
+        }
+
+        GST_DEBUG (0,"gst_avi_demux_chain: send video buffer %08x\n", *chunksize);
+        gst_pad_push(avi_demux->video_pad[0], buf);
+        GST_DEBUG (0,"gst_avi_demux_chain: sent video buffer %08x %p\n",
+	  	      *chunksize, &avi_demux->video_pad[0]);
+        avi_demux->current_frame++;
+      }
+      *chunksize = (*chunksize + 1) & ~1;
+      break;
+    }
+    case GST_RIFF_01wb:
+    {
+      GST_DEBUG (0,"gst_avi_demux_chain: tag found %08x size %08x\n",
+		    chunkid, *chunksize);
+
+      if (GST_PAD_CONNECTED (avi_demux->audio_pad[0])) {
+	GstBuffer *buf;
+
+	if (*chunksize) {
+          buf = gst_bytestream_peek (bs, *chunksize);
+	}
+	else {
+          buf = gst_buffer_new ();
+	}
+
+        if (avi_demux->audio_need_flush[0]) {
+  	  GST_DEBUG (0,"audio flush\n");
+          avi_demux->audio_need_flush[0] = FALSE;
+  	  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
+        }
+
+        GST_DEBUG (0,"gst_avi_demux_chain: send audio buffer %08x\n", *chunksize);
+        gst_pad_push (avi_demux->audio_pad[0], buf);
+        GST_DEBUG (0,"gst_avi_demux_chain: sent audio buffer %08x\n", *chunksize);
+      }
+      *chunksize = (*chunksize + 1) & ~1;
+      break;
+    }
+    default:
+      printf ("  *****  unknown chunkid %08x (%s)\n", chunkid, gst_riff_id_to_fourcc (chunkid));
+      break;
+  }
+  GST_INFO (GST_CAT_PLUGIN_INFO, "chunkid %s, flush %08x, filepos %08llx", 
+		  gst_riff_id_to_fourcc (chunkid), *chunksize, filepos);
+
+  if (!gst_bytestream_flush (bs, *chunksize)) {
+    return gst_avidemux_handle_event (avi_demux);
+  }
+
+  return TRUE;
+}
+
+static void
+gst_avi_demux_loop (GstElement *element)
+{
+  GstAviDemux *avi_demux;
+  guint32 chunksize;
+
+  g_return_if_fail (element != NULL);
+  g_return_if_fail (GST_IS_AVI_DEMUX (element));
+
+  avi_demux = GST_AVI_DEMUX (element);
+
+  avi_demux->bs = gst_bytestream_new (avi_demux->sinkpad);
+
+  do {
+    if (!gst_avidemux_process_chunk (avi_demux, 0, GST_RIFF_TAG_RIFF, 0, &chunksize)) {
+      GST_INFO (GST_CAT_PLUGIN_INFO, "sorry, isn't AVI");
+      break;
+    }
+  } while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
+
+  gst_bytestream_destroy (avi_demux->bs);
+}
+
+static void
+gst_avi_demux_get_property (GObject *object, guint prop_id, GValue *value,
+			    GParamSpec *pspec)
+{
+  GstAviDemux *src;
+
+  g_return_if_fail (GST_IS_AVI_DEMUX (object));
+
+  src = GST_AVI_DEMUX (object);
+
+  switch (prop_id) {
+    case ARG_BITRATE:
+      break;
+    case ARG_MEDIA_TIME:
+      g_value_set_long (value, (src->tot_frames * src->time_interval) / 1000000);
+      break;
+    case ARG_CURRENT_TIME:
+      g_value_set_long (value, (src->current_frame * src->time_interval) / 1000000);
+      break;
+    default:
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+  GstTypeFactory *type;
+
+  /* this filter needs the riff parser */
+  if (!gst_library_load ("gstbytestream")) {
+    gst_info("avidemux: could not load support library: 'gstbytestream'\n");
+    return FALSE;
+  }
+  if (!gst_library_load ("gstriff")) {
+    gst_info("avidemux: could not load support library: 'gstriff'\n");
+    return FALSE;
+  }
+
+  /* create an elementfactory for the avi_demux element */
+  factory = gst_elementfactory_new ("avidemux",GST_TYPE_AVI_DEMUX,
+                                    &gst_avi_demux_details);
+  g_return_val_if_fail (factory != NULL, FALSE);
+
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_audio_templ));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_video_templ));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (sink_templ));
+
+  type = gst_typefactory_new (&avidefinition);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "avidemux",
+  plugin_init
+};
+