gst-indent

Original commit message from CVS:
gst-indent

7 files changed, 1270 insertions, 1278 deletions

diff --git a/gst/avi/avi-ids.h b/gst/avi/avi-ids.h
index f9e2dd31..f7e773ec 100644
--- a/gst/avi/avi-ids.h
+++ b/gst/avi/avi-ids.h
@@ -22,21 +22,22 @@
 
 #include <gst/gst.h>
 
-typedef struct _gst_riff_avih {
-  guint32 us_frame;          /* microsec per frame */
-  guint32 max_bps;           /* byte/s overall */
-  guint32 pad_gran;          /* pad_granularity */
+typedef struct _gst_riff_avih
+{
+  guint32 us_frame;		/* microsec per frame */
+  guint32 max_bps;		/* byte/s overall */
+  guint32 pad_gran;		/* pad_granularity */
   guint32 flags;
 /* flags values */
-#define GST_RIFF_AVIH_HASINDEX       0x00000010 /* has idx1 chunk */
-#define GST_RIFF_AVIH_MUSTUSEINDEX   0x00000020 /* must use idx1 chunk to determine order */
-#define GST_RIFF_AVIH_ISINTERLEAVED  0x00000100 /* AVI file is interleaved */
-#define GST_RIFF_AVIH_WASCAPTUREFILE 0x00010000 /* specially allocated used for capturing real time video */
-#define GST_RIFF_AVIH_COPYRIGHTED    0x00020000 /* contains copyrighted data */
-  guint32 tot_frames;        /* # of frames (all) */
-  guint32 init_frames;       /* initial frames (???) */
+#define GST_RIFF_AVIH_HASINDEX       0x00000010	/* has idx1 chunk */
+#define GST_RIFF_AVIH_MUSTUSEINDEX   0x00000020	/* must use idx1 chunk to determine order */
+#define GST_RIFF_AVIH_ISINTERLEAVED  0x00000100	/* AVI file is interleaved */
+#define GST_RIFF_AVIH_WASCAPTUREFILE 0x00010000	/* specially allocated used for capturing real time video */
+#define GST_RIFF_AVIH_COPYRIGHTED    0x00020000	/* contains copyrighted data */
+  guint32 tot_frames;		/* # of frames (all) */
+  guint32 init_frames;		/* initial frames (???) */
   guint32 streams;
-  guint32 bufsize;           /* suggested buffer size */
+  guint32 bufsize;		/* suggested buffer size */
   guint32 width;
   guint32 height;
   guint32 scale;
diff --git a/gst/avi/gstavi.c b/gst/avi/gstavi.c
index fa17fa47..dbdc7859 100644
--- a/gst/avi/gstavi.c
+++ b/gst/avi/gstavi.c
@@ -29,7 +29,7 @@
 #include "gstavimux.h"
 
 static gboolean
-plugin_init (GstPlugin *plugin)
+plugin_init (GstPlugin * plugin)
 {
   if (!gst_library_load ("riff"))
     return FALSE;
@@ -40,21 +40,13 @@ plugin_init (GstPlugin *plugin)
 #endif /* ENABLE_NLS */
 
   return (gst_element_register (plugin, "avidemux",
-				GST_RANK_PRIMARY,
-				GST_TYPE_AVI_DEMUX) &&
-	  gst_element_register (plugin, "avimux",
-				GST_RANK_NONE,
-				GST_TYPE_AVIMUX));
+	  GST_RANK_PRIMARY,
+	  GST_TYPE_AVI_DEMUX) &&
+      gst_element_register (plugin, "avimux", GST_RANK_NONE, GST_TYPE_AVIMUX));
 }
 
-GST_PLUGIN_DEFINE (
-  GST_VERSION_MAJOR,
-  GST_VERSION_MINOR,
-  "avi",
-  "AVI stream handling",
-  plugin_init,
-  VERSION,
-  "LGPL",
-  GST_PACKAGE,
-  GST_ORIGIN
-)
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "avi",
+    "AVI stream handling",
+    plugin_init, VERSION, "LGPL", GST_PACKAGE, GST_ORIGIN)
diff --git a/gst/avi/gstavidecoder.c b/gst/avi/gstavidecoder.c
index 9f9a5968..d4cb493f 100644
--- a/gst/avi/gstavidecoder.c
+++ b/gst/avi/gstavidecoder.c
@@ -31,12 +31,11 @@ static GstElementDetails gst_avi_decoder_details = {
   "Decoder/Video",
   "Decodes a .avi file into audio and video",
   VERSION,
-  "Erik Walthinsen <omega@cse.ogi.edu>\n"
-  "Wim Taymans <wim.taymans@tvd.be>",
+  "Erik Walthinsen <omega@cse.ogi.edu>\n" "Wim Taymans <wim.taymans@tvd.be>",
   "(C) 1999",
 };
 
-static GstCaps* avi_typefind (GstBuffer *buf, gpointer private);
+static GstCaps *avi_typefind (GstBuffer * buf, gpointer private);
 
 /* typefactory for 'avi' */
 static GstTypeDefinition avidefinition = {
@@ -47,12 +46,14 @@ static GstTypeDefinition avidefinition = {
 };
 
 /* AviDecoder signals and args */
-enum {
+enum
+{
   /* FILL ME */
   LAST_SIGNAL
 };
 
-enum {
+enum
+{
   ARG_0,
   ARG_BITRATE,
   ARG_MEDIA_TIME,
@@ -61,118 +62,104 @@ enum {
 };
 
 GST_PADTEMPLATE_FACTORY (sink_templ,
-  "sink",
-  GST_PAD_SINK,
-  GST_PAD_ALWAYS,
-  GST_CAPS_NEW (
-    "avidecoder_sink",
-     "video/avi",
-       "RIFF",  GST_PROPS_STRING ("AVI")
-  )
-)
-
-GST_PADTEMPLATE_FACTORY (src_video_templ,
-  "video_src",
-  GST_PAD_SRC,
-  GST_PAD_ALWAYS,
-  GST_CAPS_NEW (
-    "wincodec_src",
-    "video/raw",
-      "format",         GST_PROPS_LIST (
-                          GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y','U','Y','2')),
-                          GST_PROPS_FOURCC (GST_MAKE_FOURCC ('I','4','2','0')),
-                          GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R','G','B',' '))
-                        ),
-      "width",          GST_PROPS_INT_RANGE (16, 4096),
-      "height",         GST_PROPS_INT_RANGE (16, 4096)
-  )
-)
-
-GST_PADTEMPLATE_FACTORY (src_audio_templ,
-  "audio_src",
-  GST_PAD_SRC,
-  GST_PAD_ALWAYS,
-  GST_CAPS_NEW (
-    "src_audio",
-    "audio/raw",
-      "format",           GST_PROPS_STRING ("int"),
-      "law",              GST_PROPS_INT (0),
-      "endianness",       GST_PROPS_INT (G_BYTE_ORDER),
-      "signed",           GST_PROPS_LIST (
-      			    GST_PROPS_BOOLEAN (TRUE),
-      			    GST_PROPS_BOOLEAN (FALSE)
-			  ),
-      "width",            GST_PROPS_LIST (
-	                    GST_PROPS_INT (8),
-	                    GST_PROPS_INT (16)
-			  ),
-      "depth",            GST_PROPS_LIST (
-	                    GST_PROPS_INT (8),
-	                    GST_PROPS_INT (16)
-			  ),
-      "rate",             GST_PROPS_INT_RANGE (11025, 48000),
-      "channels",         GST_PROPS_INT_RANGE (1, 2)
-  )
-)
-
-static void 	gst_avi_decoder_class_init	(GstAviDecoderClass *klass);
-static void 	gst_avi_decoder_init		(GstAviDecoder *avi_decoder);
-
-static void     gst_avi_decoder_get_property    (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
-
-
-
-static GstElementClass *parent_class = NULL;
+    "sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_CAPS_NEW ("avidecoder_sink",
+	"video/avi", "RIFF", GST_PROPS_STRING ("AVI")
+    )
+    )
+
+    GST_PADTEMPLATE_FACTORY (src_video_templ,
+    "video_src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_CAPS_NEW ("wincodec_src",
+	"video/raw",
+	"format", GST_PROPS_LIST (GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'U', 'Y',
+		    '2')), GST_PROPS_FOURCC (GST_MAKE_FOURCC ('I', '4', '2', '0')),
+	    GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
+	), "width", GST_PROPS_INT_RANGE (16, 4096), "height",
+	GST_PROPS_INT_RANGE (16, 4096)
+    )
+    )
+
+    GST_PADTEMPLATE_FACTORY (src_audio_templ,
+    "audio_src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_CAPS_NEW ("src_audio",
+	"audio/raw",
+	"format", GST_PROPS_STRING ("int"),
+	"law", GST_PROPS_INT (0),
+	"endianness", GST_PROPS_INT (G_BYTE_ORDER),
+	"signed", GST_PROPS_LIST (GST_PROPS_BOOLEAN (TRUE),
+	    GST_PROPS_BOOLEAN (FALSE)
+	), "width", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)
+	), "depth", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)
+	),
+	"rate", GST_PROPS_INT_RANGE (11025, 48000),
+	"channels", GST_PROPS_INT_RANGE (1, 2)
+    )
+    )
+
+     static void gst_avi_decoder_class_init (GstAviDecoderClass * klass);
+     static void gst_avi_decoder_init (GstAviDecoder * avi_decoder);
+
+     static void gst_avi_decoder_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
+
+
+
+     static GstElementClass *parent_class = NULL;
+
 /*static guint gst_avi_decoder_signals[LAST_SIGNAL] = { 0 }; */
 
 GType
-gst_avi_decoder_get_type(void) 
+gst_avi_decoder_get_type (void)
 {
   static GType avi_decoder_type = 0;
 
   if (!avi_decoder_type) {
     static const GTypeInfo avi_decoder_info = {
-      sizeof(GstAviDecoderClass),      
+      sizeof (GstAviDecoderClass),
       NULL,
       NULL,
-      (GClassInitFunc)gst_avi_decoder_class_init,
+      (GClassInitFunc) gst_avi_decoder_class_init,
       NULL,
       NULL,
-      sizeof(GstAviDecoder),
+      sizeof (GstAviDecoder),
       0,
-      (GInstanceInitFunc)gst_avi_decoder_init,
+      (GInstanceInitFunc) gst_avi_decoder_init,
     };
-    avi_decoder_type = g_type_register_static(GST_TYPE_BIN, "GstAviDecoder", &avi_decoder_info, 0);
+    avi_decoder_type =
+	g_type_register_static (GST_TYPE_BIN, "GstAviDecoder",
+	&avi_decoder_info, 0);
   }
   return avi_decoder_type;
 }
 
 static void
-gst_avi_decoder_class_init (GstAviDecoderClass *klass) 
+gst_avi_decoder_class_init (GstAviDecoderClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
 
-  gobject_class = (GObjectClass*)klass;
-  gstelement_class = (GstElementClass*)klass;
+  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 */
+  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_BIN);
-  
+
   gobject_class->get_property = gst_avi_decoder_get_property;
 }
 
-static void 
-gst_avi_decoder_new_pad (GstElement *element, GstPad *pad, GstAviDecoder *avi_decoder) 
+static void
+gst_avi_decoder_new_pad (GstElement * element, GstPad * pad,
+    GstAviDecoder * avi_decoder)
 {
   GstCaps *caps;
   GstCaps *targetcaps = NULL;
@@ -182,38 +169,40 @@ gst_avi_decoder_new_pad (GstElement *element, GstPad *pad, GstAviDecoder *avi_de
   GstElement *new_element = NULL;
   gchar *padname = NULL;
   gchar *gpadname = NULL;
+
 #define AVI_TYPE_VIDEO  1
 #define AVI_TYPE_AUDIO  2
   gint media_type = 0;
-  
-  GST_DEBUG (0, "avidecoder: new pad for element \"%s\"", gst_element_get_name (element));
+
+  GST_DEBUG (0, "avidecoder: new pad for element \"%s\"",
+      gst_element_get_name (element));
 
   caps = gst_pad_get_caps (pad);
   format = gst_caps_get_string (caps, "format");
 
-  if (!strcmp (format, "strf_vids")) { 
-    targetcaps = gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_video_templ));
+  if (!strcmp (format, "strf_vids")) {
+    targetcaps =
+	gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_video_templ));
     media_type = AVI_TYPE_VIDEO;
     gpadname = g_strdup_printf ("video_%02d", avi_decoder->video_count++);
-  }
-  else if (!strcmp (format, "strf_auds")) {
-    targetcaps = gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_audio_templ));
+  } else if (!strcmp (format, "strf_auds")) {
+    targetcaps =
+	gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_audio_templ));
     media_type = AVI_TYPE_AUDIO;
     gpadname = g_strdup_printf ("audio_%02d", avi_decoder->audio_count++);
-  }
-  else if (!strcmp (format, "strf_iavs")) {
-    targetcaps = gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_video_templ));
+  } else if (!strcmp (format, "strf_iavs")) {
+    targetcaps =
+	gst_padtemplate_get_caps (GST_PADTEMPLATE_GET (src_video_templ));
     media_type = AVI_TYPE_VIDEO;
     gpadname = g_strdup_printf ("video_%02d", avi_decoder->video_count++);
-  }
-  else {
+  } else {
     g_assert_not_reached ();
   }
 
   gst_element_set_state (GST_ELEMENT (avi_decoder), GST_STATE_PAUSED);
 
-  type = gst_elementfactory_make ("avitypes", 
-		  g_strdup_printf ("typeconvert%d", avi_decoder->count));
+  type = gst_elementfactory_make ("avitypes",
+      g_strdup_printf ("typeconvert%d", avi_decoder->count));
 
   /* brin the element to the READY state so it can do our caps negotiation */
   gst_element_set_state (type, GST_STATE_READY);
@@ -224,13 +213,13 @@ gst_avi_decoder_new_pad (GstElement *element, GstPad *pad, GstAviDecoder *avi_de
   if (type_found) {
 
     gst_bin_add (GST_BIN (avi_decoder), type);
-    
+
     pad = gst_element_get_pad (type, "src");
     caps = gst_pad_get_caps (pad);
 
     if (gst_caps_is_always_compatible (caps, targetcaps)) {
-      gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder), 
-	    gst_element_get_pad (type, "src"), gpadname);
+      gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder),
+	  gst_element_get_pad (type, "src"), gpadname);
 
       avi_decoder->count++;
       goto done;
@@ -238,7 +227,8 @@ gst_avi_decoder_new_pad (GstElement *element, GstPad *pad, GstAviDecoder *avi_de
 #ifndef GST_DISABLE_AUTOPLUG
     else {
       GstAutoplug *autoplug;
-      autoplug = gst_autoplugfactory_make("static");
+
+      autoplug = gst_autoplugfactory_make ("static");
 
       new_element = gst_autoplug_to_caps (autoplug, caps, targetcaps, NULL);
 
@@ -249,45 +239,43 @@ gst_avi_decoder_new_pad (GstElement *element, GstPad *pad, GstAviDecoder *avi_de
 
   if (!new_element && (media_type == AVI_TYPE_VIDEO)) {
     padname = "src";
-  }
-  else if (!new_element && (media_type == AVI_TYPE_AUDIO)) {
+  } else if (!new_element && (media_type == AVI_TYPE_AUDIO)) {
     /*FIXME */
     padname = "src";
   }
 
   if (new_element) {
     gst_pad_connect (pad, gst_element_get_pad (new_element, "sink"));
-    gst_element_set_name (new_element, g_strdup_printf ("element%d", avi_decoder->count));
+    gst_element_set_name (new_element, g_strdup_printf ("element%d",
+	    avi_decoder->count));
     gst_bin_add (GST_BIN (avi_decoder), new_element);
 
-    gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder), 
-	    gst_element_get_pad (new_element, padname), gpadname);
+    gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder),
+	gst_element_get_pad (new_element, padname), gpadname);
 
     avi_decoder->count++;
-  }
-  else {
+  } else {
     g_warning ("avidecoder: could not autoplug\n");
   }
 
-done: 
+done:
   gst_element_set_state (GST_ELEMENT (avi_decoder), GST_STATE_PLAYING);
 }
 
-static void 
-gst_avi_decoder_init (GstAviDecoder *avi_decoder) 
+static void
+gst_avi_decoder_init (GstAviDecoder * avi_decoder)
 {
   avi_decoder->demuxer = gst_elementfactory_make ("avidemux", "demux");
 
   if (avi_decoder->demuxer) {
     gst_bin_add (GST_BIN (avi_decoder), avi_decoder->demuxer);
 
-    gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder), 
-		    gst_element_get_pad (avi_decoder->demuxer, "sink"), "sink");
+    gst_element_add_ghost_pad (GST_ELEMENT (avi_decoder),
+	gst_element_get_pad (avi_decoder->demuxer, "sink"), "sink");
 
-    g_signal_connect (G_OBJECT (avi_decoder->demuxer),"new_pad", G_CALLBACK (gst_avi_decoder_new_pad),
-		    avi_decoder);
-  }
-  else {
+    g_signal_connect (G_OBJECT (avi_decoder->demuxer), "new_pad",
+	G_CALLBACK (gst_avi_decoder_new_pad), avi_decoder);
+  } else {
     g_warning ("wow!, no avi demuxer found. help me\n");
   }
 
@@ -296,26 +284,27 @@ gst_avi_decoder_init (GstAviDecoder *avi_decoder)
   avi_decoder->video_count = 0;
 }
 
-static GstCaps*
-avi_typefind (GstBuffer *buf,
-              gpointer private)
+static GstCaps *
+avi_typefind (GstBuffer * buf, gpointer private)
 {
   gchar *data = GST_BUFFER_DATA (buf);
   GstCaps *new;
 
-  GST_DEBUG (0,"avi_decoder: typefind");
-  if (strncmp (&data[0], "RIFF", 4)) return NULL;
-  if (strncmp (&data[8], "AVI ", 4)) return NULL;
+  GST_DEBUG (0, "avi_decoder: typefind");
+  if (strncmp (&data[0], "RIFF", 4))
+    return NULL;
+  if (strncmp (&data[8], "AVI ", 4))
+    return NULL;
 
   new = GST_CAPS_NEW ("avi_typefind",
-		      "video/avi", 
-		        "RIFF", GST_PROPS_STRING ("AVI"));
+      "video/avi", "RIFF", GST_PROPS_STRING ("AVI"));
 
   return new;
 }
 
 static void
-gst_avi_decoder_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+gst_avi_decoder_get_property (GObject * object, guint prop_id, GValue * value,
+    GParamSpec * pspec)
 {
   GstAviDecoder *src;
 
@@ -323,14 +312,16 @@ gst_avi_decoder_get_property (GObject *object, guint prop_id, GValue *value, GPa
 
   src = GST_AVI_DECODER (object);
 
-  switch(prop_id) {
+  switch (prop_id) {
     case ARG_BITRATE:
       break;
     case ARG_MEDIA_TIME:
-      g_value_set_long (value, gst_util_get_long_arg (G_OBJECT (src->demuxer), "media_time"));
+      g_value_set_long (value, gst_util_get_long_arg (G_OBJECT (src->demuxer),
+	      "media_time"));
       break;
     case ARG_CURRENT_TIME:
-      g_value_set_long (value, gst_util_get_long_arg (G_OBJECT (src->demuxer), "current_time"));
+      g_value_set_long (value, gst_util_get_long_arg (G_OBJECT (src->demuxer),
+	      "current_time"));
       break;
     default:
       break;
@@ -339,19 +330,22 @@ gst_avi_decoder_get_property (GObject *object, guint prop_id, GValue *value, GPa
 
 
 static gboolean
-plugin_init (GModule *module, GstPlugin *plugin)
+plugin_init (GModule * module, GstPlugin * plugin)
 {
   GstElementFactory *factory;
   GstTypeFactory *type;
 
   /* create an elementfactory for the avi_decoder element */
   factory = gst_elementfactory_new ("avidecoder", GST_TYPE_AVI_DECODER,
-                                    &gst_avi_decoder_details);
+      &gst_avi_decoder_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));
+  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));
@@ -367,4 +361,3 @@ GstPluginDesc plugin_desc = {
   "avidecoder",
   plugin_init
 };
-
diff --git a/gst/avi/gstavidemux.c b/gst/avi/gstavidemux.c
index 1b50b98e..03403488 100644
--- a/gst/avi/gstavidemux.c
+++ b/gst/avi/gstavidemux.c
@@ -32,72 +32,62 @@ GST_DEBUG_CATEGORY_STATIC (avidemux_debug);
 #define GST_CAT_DEFAULT avidemux_debug
 
 /* AviDemux signals and args */
-enum {
+enum
+{
   /* FILL ME */
   LAST_SIGNAL
 };
 
-enum {
+enum
+{
   ARG_0,
   ARG_STREAMINFO,
   /* FILL ME */
 };
 
-static GstStaticPadTemplate sink_templ =
-GST_STATIC_PAD_TEMPLATE (
-  "sink",
-  GST_PAD_SINK,
-  GST_PAD_ALWAYS,
-  GST_STATIC_CAPS ("video/x-msvideo")
-);
+static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/x-msvideo")
+    );
 
-static void 	gst_avi_demux_base_init	        (GstAviDemuxClass *klass);
-static void 	gst_avi_demux_class_init	(GstAviDemuxClass *klass);
-static void 	gst_avi_demux_init		(GstAviDemux *avi);
+static void gst_avi_demux_base_init (GstAviDemuxClass * klass);
+static void gst_avi_demux_class_init (GstAviDemuxClass * klass);
+static void gst_avi_demux_init (GstAviDemux * avi);
 
-static void	gst_avi_demux_reset		(GstAviDemux *avi);
-static void 	gst_avi_demux_loop 		(GstElement  *element);
+static void gst_avi_demux_reset (GstAviDemux * avi);
+static void gst_avi_demux_loop (GstElement * element);
 
-static gboolean gst_avi_demux_send_event 	(GstElement  *element,
-						 GstEvent    *event);
+static gboolean gst_avi_demux_send_event (GstElement * element,
+    GstEvent * event);
 
-static const GstEventMask *
-		gst_avi_demux_get_event_mask 	(GstPad      *pad);
-static gboolean gst_avi_demux_handle_src_event 	(GstPad      *pad,
-						 GstEvent    *event);
-static const GstFormat *
-		gst_avi_demux_get_src_formats 	(GstPad      *pad); 
-static const GstQueryType *
-		gst_avi_demux_get_src_query_types (GstPad    *pad);
-static gboolean gst_avi_demux_handle_src_query 	(GstPad      *pad,
-						 GstQueryType type, 
-						 GstFormat   *format,
-						 gint64      *value);
-static gboolean gst_avi_demux_src_convert 	(GstPad      *pad,
-						 GstFormat    src_format,
-						 gint64       src_value,
-	        	          		 GstFormat   *dest_format,
-						 gint64      *dest_value);
+static const GstEventMask *gst_avi_demux_get_event_mask (GstPad * pad);
+static gboolean gst_avi_demux_handle_src_event (GstPad * pad, GstEvent * event);
+static const GstFormat *gst_avi_demux_get_src_formats (GstPad * pad);
+static const GstQueryType *gst_avi_demux_get_src_query_types (GstPad * pad);
+static gboolean gst_avi_demux_handle_src_query (GstPad * pad,
+    GstQueryType type, GstFormat * format, gint64 * value);
+static gboolean gst_avi_demux_src_convert (GstPad * pad,
+    GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
 
-static GstElementStateReturn
-		gst_avi_demux_change_state 	(GstElement  *element);
+static GstElementStateReturn gst_avi_demux_change_state (GstElement * element);
 
-static void     gst_avi_demux_get_property      (GObject     *object,
-						 guint        prop_id, 	
-						 GValue      *value,
-						 GParamSpec  *pspec);
+static void gst_avi_demux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
 
 static GstRiffReadClass *parent_class = NULL;
+
 /*static guint gst_avi_demux_signals[LAST_SIGNAL] = { 0 }; */
 
 GType
-gst_avi_demux_get_type(void) 
+gst_avi_demux_get_type (void)
 {
   static GType avi_demux_type = 0;
 
   if (!avi_demux_type) {
     static const GTypeInfo avi_demux_info = {
-      sizeof (GstAviDemuxClass),      
+      sizeof (GstAviDemuxClass),
       (GBaseInitFunc) gst_avi_demux_base_init,
       NULL,
       (GClassInitFunc) gst_avi_demux_class_init,
@@ -110,40 +100,34 @@ gst_avi_demux_get_type(void)
 
     avi_demux_type =
 	g_type_register_static (GST_TYPE_RIFF_READ,
-				"GstAviDemux",
-				&avi_demux_info, 0);
+	"GstAviDemux", &avi_demux_info, 0);
   }
 
   return avi_demux_type;
 }
 
 static void
-gst_avi_demux_base_init (GstAviDemuxClass *klass)
+gst_avi_demux_base_init (GstAviDemuxClass * klass)
 {
-  static GstElementDetails gst_avi_demux_details = GST_ELEMENT_DETAILS (
-    "Avi demuxer",
-    "Codec/Demuxer",
-    "Demultiplex an avi file into audio and video",
-    "Erik Walthinsen <omega@cse.ogi.edu>\n"
-    "Wim Taymans <wim.taymans@chello.be>\n"
-    "Ronald Bultje <rbultje@ronald.bitfreak.net>"
-  );
+  static GstElementDetails gst_avi_demux_details =
+      GST_ELEMENT_DETAILS ("Avi demuxer",
+      "Codec/Demuxer",
+      "Demultiplex an avi file into audio and video",
+      "Erik Walthinsen <omega@cse.ogi.edu>\n"
+      "Wim Taymans <wim.taymans@chello.be>\n"
+      "Ronald Bultje <rbultje@ronald.bitfreak.net>");
   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
   GstPadTemplate *videosrctempl, *audiosrctempl;
   GstCaps *audcaps, *vidcaps;
 
   audcaps = gst_riff_create_audio_template_caps ();
   audiosrctempl = gst_pad_template_new ("audio_%02d",
-					GST_PAD_SRC,
-					GST_PAD_SOMETIMES,
-					audcaps);
+      GST_PAD_SRC, GST_PAD_SOMETIMES, audcaps);
 
   vidcaps = gst_riff_create_video_template_caps ();
   gst_caps_append (vidcaps, gst_riff_create_iavs_template_caps ());
   videosrctempl = gst_pad_template_new ("video_%02d",
-					GST_PAD_SRC,
-					GST_PAD_SOMETIMES,
-					vidcaps);
+      GST_PAD_SRC, GST_PAD_SOMETIMES, vidcaps);
 
   gst_element_class_add_pad_template (element_class, audiosrctempl);
   gst_element_class_add_pad_template (element_class, videosrctempl);
@@ -153,36 +137,37 @@ gst_avi_demux_base_init (GstAviDemuxClass *klass)
 }
 
 static void
-gst_avi_demux_class_init (GstAviDemuxClass *klass) 
+gst_avi_demux_class_init (GstAviDemuxClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
 
-  gobject_class = (GObjectClass*)klass;
-  gstelement_class = (GstElementClass*)klass;
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
 
   g_object_class_install_property (gobject_class, ARG_STREAMINFO,
-    g_param_spec_boxed ("streaminfo", "Streaminfo", "Streaminfo",
-                        GST_TYPE_CAPS, G_PARAM_READABLE));
+      g_param_spec_boxed ("streaminfo", "Streaminfo", "Streaminfo",
+	  GST_TYPE_CAPS, G_PARAM_READABLE));
 
   GST_DEBUG_CATEGORY_INIT (avidemux_debug, "avidemux",
-			   0, "Demuxer for AVI streams");
+      0, "Demuxer for AVI streams");
 
   parent_class = g_type_class_ref (GST_TYPE_RIFF_READ);
-  
+
   gobject_class->get_property = gst_avi_demux_get_property;
-  
+
   gstelement_class->change_state = gst_avi_demux_change_state;
   gstelement_class->send_event = gst_avi_demux_send_event;
 }
 
-static void 
-gst_avi_demux_init (GstAviDemux *avi) 
+static void
+gst_avi_demux_init (GstAviDemux * avi)
 {
   GST_FLAG_SET (avi, GST_ELEMENT_EVENT_AWARE);
 
-  avi->sinkpad = gst_pad_new_from_template (
-	gst_static_pad_template_get (&sink_templ), "sink");
+  avi->sinkpad =
+      gst_pad_new_from_template (gst_static_pad_template_get (&sink_templ),
+      "sink");
   gst_element_add_pad (GST_ELEMENT (avi), avi->sinkpad);
   GST_RIFF_READ (avi)->sinkpad = avi->sinkpad;
 
@@ -195,7 +180,7 @@ gst_avi_demux_init (GstAviDemux *avi)
 }
 
 static void
-gst_avi_demux_reset (GstAviDemux *avi)
+gst_avi_demux_reset (GstAviDemux * avi)
 {
   gint i;
 
@@ -221,27 +206,25 @@ gst_avi_demux_reset (GstAviDemux *avi)
   avi->num_frames = 0;
   avi->us_per_frame = 0;
 
-  avi->seek_offset = (guint64) -1;
+  avi->seek_offset = (guint64) - 1;
 
   gst_caps_replace (&avi->streaminfo, NULL);
 }
 
 static void
-gst_avi_demux_streaminfo (GstAviDemux *avi)
+gst_avi_demux_streaminfo (GstAviDemux * avi)
 {
   /* compression formats are added later - a bit hacky */
 
   gst_caps_replace (&avi->streaminfo,
       gst_caps_new_simple ("application/x-gst-streaminfo", NULL));
 
-  /*g_object_notify(G_OBJECT(avi), "streaminfo");*/
+  /*g_object_notify(G_OBJECT(avi), "streaminfo"); */
 }
 
 static gst_avi_index_entry *
-gst_avi_demux_index_next (GstAviDemux *avi,
-			  gint         stream_nr,
-			  gint         start,
-			  guint32      flags)
+gst_avi_demux_index_next (GstAviDemux * avi,
+    gint stream_nr, gint start, guint32 flags)
 {
   gint i;
   gst_avi_index_entry *entry = NULL;
@@ -258,10 +241,8 @@ gst_avi_demux_index_next (GstAviDemux *avi,
 }
 
 static gst_avi_index_entry *
-gst_avi_demux_index_entry_for_time (GstAviDemux *avi,
-				    gint         stream_nr,
-				    guint64      time,
-				    guint32      flags)
+gst_avi_demux_index_entry_for_time (GstAviDemux * avi,
+    gint stream_nr, guint64 time, guint32 flags)
 {
   gst_avi_index_entry *entry = NULL, *last_entry = NULL;
   gint i;
@@ -283,10 +264,8 @@ gst_avi_demux_index_entry_for_time (GstAviDemux *avi,
 }
 
 static gst_avi_index_entry *
-gst_avi_demux_index_entry_for_byte (GstAviDemux *avi,
-				    gint         stream_nr,
-				    guint64      byte,
-				    guint32      flags)
+gst_avi_demux_index_entry_for_byte (GstAviDemux * avi,
+    gint stream_nr, guint64 byte, guint32 flags)
 {
   gst_avi_index_entry *entry = NULL, *last_entry = NULL;
   gint i;
@@ -308,10 +287,8 @@ gst_avi_demux_index_entry_for_byte (GstAviDemux *avi,
 }
 
 static gst_avi_index_entry *
-gst_avi_demux_index_entry_for_frame (GstAviDemux *avi,
-				     gint         stream_nr,
-				     guint32      frame,
-				     guint32      flags)
+gst_avi_demux_index_entry_for_frame (GstAviDemux * avi,
+    gint stream_nr, guint32 frame, guint32 flags)
 {
   gst_avi_index_entry *entry = NULL, *last_entry = NULL;
   gint i;
@@ -333,7 +310,7 @@ gst_avi_demux_index_entry_for_frame (GstAviDemux *avi,
 }
 
 static const GstFormat *
-gst_avi_demux_get_src_formats (GstPad *pad) 
+gst_avi_demux_get_src_formats (GstPad * pad)
 {
   avi_stream_context *stream = gst_pad_get_element_private (pad);
 
@@ -350,36 +327,34 @@ gst_avi_demux_get_src_formats (GstPad *pad)
   };
 
   return (stream->strh->type == GST_RIFF_FCC_auds ?
-	  src_a_formats : src_v_formats);
+      src_a_formats : src_v_formats);
 }
 
 static gboolean
-gst_avi_demux_src_convert (GstPad    *pad,
-			   GstFormat  src_format,
-			   gint64     src_value,
-	                   GstFormat *dest_format,
-			   gint64    *dest_value)
+gst_avi_demux_src_convert (GstPad * pad,
+    GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value)
 {
   gboolean res = TRUE;
-  /*GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));*/
+
+  /*GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad)); */
   avi_stream_context *stream = gst_pad_get_element_private (pad);
 
-  if (stream->strh->type != GST_RIFF_FCC_auds && 
-      (src_format == GST_FORMAT_BYTES ||
-       *dest_format == GST_FORMAT_BYTES))
+  if (stream->strh->type != GST_RIFF_FCC_auds &&
+      (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))
     return FALSE;
 
   switch (src_format) {
     case GST_FORMAT_TIME:
       switch (*dest_format) {
 	case GST_FORMAT_BYTES:
-          *dest_value = src_value * stream->strh->rate /
-			(stream->strh->scale * GST_SECOND);
-          break;
-        case GST_FORMAT_DEFAULT:
-          *dest_value = src_value * stream->strh->rate /
-			(stream->strh->scale * GST_SECOND);
-          break;
+	  *dest_value = src_value * stream->strh->rate /
+	      (stream->strh->scale * GST_SECOND);
+	  break;
+	case GST_FORMAT_DEFAULT:
+	  *dest_value = src_value * stream->strh->rate /
+	      (stream->strh->scale * GST_SECOND);
+	  break;
 	default:
 	  res = FALSE;
 	  break;
@@ -388,7 +363,7 @@ gst_avi_demux_src_convert (GstPad    *pad,
     case GST_FORMAT_BYTES:
       switch (*dest_format) {
 	case GST_FORMAT_TIME:
-          *dest_value = ((gfloat) src_value) * GST_SECOND / stream->strh->rate;
+	  *dest_value = ((gfloat) src_value) * GST_SECOND / stream->strh->rate;
 	  break;
 	default:
 	  res = FALSE;
@@ -398,8 +373,8 @@ gst_avi_demux_src_convert (GstPad    *pad,
     case GST_FORMAT_DEFAULT:
       switch (*dest_format) {
 	case GST_FORMAT_TIME:
-          *dest_value = ((((gfloat) src_value) * stream->strh->scale)  /
-			stream->strh->rate) * GST_SECOND;
+	  *dest_value = ((((gfloat) src_value) * stream->strh->scale) /
+	      stream->strh->rate) * GST_SECOND;
 	  break;
 	default:
 	  res = FALSE;
@@ -414,7 +389,7 @@ gst_avi_demux_src_convert (GstPad    *pad,
 }
 
 static const GstQueryType *
-gst_avi_demux_get_src_query_types (GstPad *pad) 
+gst_avi_demux_get_src_query_types (GstPad * pad)
 {
   static const GstQueryType src_types[] = {
     GST_QUERY_TOTAL,
@@ -426,67 +401,64 @@ gst_avi_demux_get_src_query_types (GstPad *pad)
 }
 
 static gboolean
-gst_avi_demux_handle_src_query (GstPad      *pad,
-				GstQueryType type, 
-				GstFormat   *format,
-				gint64      *value)
+gst_avi_demux_handle_src_query (GstPad * pad,
+    GstQueryType type, GstFormat * format, gint64 * value)
 {
   gboolean res = TRUE;
-  /*GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));*/
+
+  /*GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad)); */
   avi_stream_context *stream = gst_pad_get_element_private (pad);
 
   switch (type) {
     case GST_QUERY_TOTAL:
       switch (*format) {
-        case GST_FORMAT_TIME:
-          *value = (((gfloat) stream->strh->scale) * stream->strh->length /
-			stream->strh->rate) * GST_SECOND;
+	case GST_FORMAT_TIME:
+	  *value = (((gfloat) stream->strh->scale) * stream->strh->length /
+	      stream->strh->rate) * GST_SECOND;
 	  break;
-        case GST_FORMAT_BYTES:
-          if (stream->strh->type == GST_RIFF_FCC_auds) {
-            *value = stream->total_bytes;
-	  }
-	  else
+	case GST_FORMAT_BYTES:
+	  if (stream->strh->type == GST_RIFF_FCC_auds) {
+	    *value = stream->total_bytes;
+	  } else
 	    res = FALSE;
 	  break;
-        case GST_FORMAT_DEFAULT:
-          if (stream->strh->type == GST_RIFF_FCC_auds)
-            *value = stream->strh->length * stream->strh->samplesize;
+	case GST_FORMAT_DEFAULT:
+	  if (stream->strh->type == GST_RIFF_FCC_auds)
+	    *value = stream->strh->length * stream->strh->samplesize;
 	  else if (stream->strh->type == GST_RIFF_FCC_vids)
-            *value = stream->strh->length;
+	    *value = stream->strh->length;
 	  else
 	    res = FALSE;
 	  break;
 	default:
-          res = FALSE;
+	  res = FALSE;
 	  break;
       }
       break;
     case GST_QUERY_POSITION:
       switch (*format) {
-        case GST_FORMAT_TIME:
-          if (stream->strh->samplesize &&
+	case GST_FORMAT_TIME:
+	  if (stream->strh->samplesize &&
 	      stream->strh->type == GST_RIFF_FCC_auds) {
-            *value = ((gfloat) stream->current_byte) * GST_SECOND /
-			stream->strh->rate;
-	  }
-	  else {
-            *value = (((gfloat) stream->current_frame) * stream->strh->scale /
-			stream->strh->rate) * GST_SECOND;
+	    *value = ((gfloat) stream->current_byte) * GST_SECOND /
+		stream->strh->rate;
+	  } else {
+	    *value = (((gfloat) stream->current_frame) * stream->strh->scale /
+		stream->strh->rate) * GST_SECOND;
 	  }
 	  break;
-        case GST_FORMAT_BYTES:
-          *value = stream->current_byte;
+	case GST_FORMAT_BYTES:
+	  *value = stream->current_byte;
 	  break;
-        case GST_FORMAT_DEFAULT:
-          if (stream->strh->samplesize &&
-	      stream->strh->type == GST_RIFF_FCC_auds) 
-            *value = stream->current_byte * stream->strh->samplesize;
-	  else 
-            *value = stream->current_frame;
+	case GST_FORMAT_DEFAULT:
+	  if (stream->strh->samplesize &&
+	      stream->strh->type == GST_RIFF_FCC_auds)
+	    *value = stream->current_byte * stream->strh->samplesize;
+	  else
+	    *value = stream->current_frame;
 	  break;
 	default:
-          res = FALSE;
+	  res = FALSE;
 	  break;
       }
       break;
@@ -499,7 +471,7 @@ gst_avi_demux_handle_src_query (GstPad      *pad,
 }
 
 static GstCaps *
-gst_avi_demux_src_getcaps (GstPad *pad)
+gst_avi_demux_src_getcaps (GstPad * pad)
 {
   avi_stream_context *stream = gst_pad_get_element_private (pad);
 
@@ -507,8 +479,7 @@ gst_avi_demux_src_getcaps (GstPad *pad)
 }
 
 static gint32
-gst_avi_demux_sync_streams (GstAviDemux *avi,
-			    guint64      time)
+gst_avi_demux_sync_streams (GstAviDemux * avi, guint64 time)
 {
   gint i;
   guint32 min_index = G_MAXUINT;
@@ -521,25 +492,25 @@ gst_avi_demux_sync_streams (GstAviDemux *avi,
     GST_DEBUG ("finding %d for time %" G_GINT64_FORMAT, i, time);
 
     entry = gst_avi_demux_index_entry_for_time (avi, stream->num, time,
-						GST_RIFF_IF_KEYFRAME);
+	GST_RIFF_IF_KEYFRAME);
     if (entry) {
       min_index = MIN (entry->index_nr, min_index);
     }
   }
   GST_DEBUG ("first index at %d", min_index);
-  
+
   /* now we know the entry we need to sync on. calculate number of frames to
    * skip fro there on and the stream stats */
   for (i = 0; i < avi->num_streams; i++) {
     gst_avi_index_entry *next_entry;
+
     stream = &avi->stream[i];
 
     /* next entry */
-    next_entry = gst_avi_demux_index_next (avi, stream->num,
-					   min_index, 0);
+    next_entry = gst_avi_demux_index_next (avi, stream->num, min_index, 0);
     /* next entry with keyframe */
     entry = gst_avi_demux_index_next (avi, stream->num, min_index,
-				      GST_RIFF_IF_KEYFRAME);
+	GST_RIFF_IF_KEYFRAME);
 
     stream->current_byte = next_entry->bytes_before;
     stream->current_frame = next_entry->frames_before;
@@ -554,14 +525,13 @@ gst_avi_demux_sync_streams (GstAviDemux *avi,
 }
 
 static gboolean
-gst_avi_demux_send_event (GstElement *element,
-			  GstEvent   *event)
+gst_avi_demux_send_event (GstElement * element, GstEvent * event)
 {
   const GList *pads;
 
   pads = gst_element_get_pad_list (element);
 
-  while (pads) { 
+  while (pads) {
     GstPad *pad = GST_PAD (pads->data);
 
     if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC) {
@@ -574,93 +544,88 @@ gst_avi_demux_send_event (GstElement *element,
 	return TRUE;
       }
     }
-    
+
     pads = g_list_next (pads);
   }
-  
+
   gst_event_unref (event);
 
   return FALSE;
 }
 
 static const GstEventMask *
-gst_avi_demux_get_event_mask (GstPad *pad)
+gst_avi_demux_get_event_mask (GstPad * pad)
 {
   static const GstEventMask masks[] = {
-    { GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_KEY_UNIT },
-    { 0, }
+    {GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_KEY_UNIT},
+    {0,}
   };
 
   return masks;
 }
-	
+
 static gboolean
-gst_avi_demux_handle_src_event (GstPad   *pad,
-				GstEvent *event)
+gst_avi_demux_handle_src_event (GstPad * pad, GstEvent * event)
 {
   gboolean res = TRUE;
   GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));
   avi_stream_context *stream;
-  
+
   stream = gst_pad_get_element_private (pad);
 
   switch (GST_EVENT_TYPE (event)) {
     case GST_EVENT_SEEK:
       GST_DEBUG ("seek format %d, %08x", GST_EVENT_SEEK_FORMAT (event),
-		 stream->strh->type);
+	  stream->strh->type);
 
       switch (GST_EVENT_SEEK_FORMAT (event)) {
 	case GST_FORMAT_BYTES:
 	case GST_FORMAT_DEFAULT:
-	case GST_FORMAT_TIME: {
+	case GST_FORMAT_TIME:{
 	  gst_avi_index_entry *seek_entry, *entry = NULL;
 	  gint64 desired_offset = GST_EVENT_SEEK_OFFSET (event);
 	  guint32 flags;
-          guint64 min_index;
+	  guint64 min_index;
 
 	  /* no seek on audio yet */
 	  if (stream->strh->type == GST_RIFF_FCC_auds) {
 	    res = FALSE;
 	    goto done;
 	  }
-          GST_DEBUG ("seeking to %" G_GINT64_FORMAT, desired_offset);
+	  GST_DEBUG ("seeking to %" G_GINT64_FORMAT, desired_offset);
 
-          flags = GST_RIFF_IF_KEYFRAME;
-          switch (GST_EVENT_SEEK_FORMAT (event)) {
+	  flags = GST_RIFF_IF_KEYFRAME;
+	  switch (GST_EVENT_SEEK_FORMAT (event)) {
 	    case GST_FORMAT_BYTES:
-              entry = gst_avi_demux_index_entry_for_byte (avi, stream->num,
-							  desired_offset,
-							  flags);
-              break;
+	      entry = gst_avi_demux_index_entry_for_byte (avi, stream->num,
+		  desired_offset, flags);
+	      break;
 	    case GST_FORMAT_DEFAULT:
-              entry = gst_avi_demux_index_entry_for_frame (avi, stream->num,
-							   desired_offset,
-							   flags);
-              break;
+	      entry = gst_avi_demux_index_entry_for_frame (avi, stream->num,
+		  desired_offset, flags);
+	      break;
 	    case GST_FORMAT_TIME:
-              entry = gst_avi_demux_index_entry_for_time (avi, stream->num,
-							  desired_offset,
-							  flags);
-              break;
-          }
+	      entry = gst_avi_demux_index_entry_for_time (avi, stream->num,
+		  desired_offset, flags);
+	      break;
+	  }
 
 	  if (entry) {
 	    min_index = gst_avi_demux_sync_streams (avi, entry->ts);
-            seek_entry = &avi->index_entries[min_index];
+	    seek_entry = &avi->index_entries[min_index];
 
 	    avi->seek_offset = seek_entry->offset + avi->index_offset;
-            avi->last_seek = entry->ts;
+	    avi->last_seek = entry->ts;
 	  } else {
-            GST_DEBUG ("no index entry found for format=%d value=%"
-		       G_GINT64_FORMAT, GST_EVENT_SEEK_FORMAT (event),
-		       desired_offset);
+	    GST_DEBUG ("no index entry found for format=%d value=%"
+		G_GINT64_FORMAT, GST_EVENT_SEEK_FORMAT (event), desired_offset);
 	    res = FALSE;
 	  }
 	  break;
 	}
 	default:
 	  res = FALSE;
-          break;
+	  break;
       }
       break;
     default:
@@ -679,7 +644,7 @@ done:
  */
 
 gboolean
-gst_avi_demux_stream_init (GstAviDemux *avi)
+gst_avi_demux_stream_init (GstAviDemux * avi)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint32 doctype;
@@ -699,9 +664,8 @@ gst_avi_demux_stream_init (GstAviDemux *avi)
  */
 
 gboolean
-gst_avi_demux_stream_avih (GstAviDemux *avi,
-			   guint32     *flags,
-			   guint32     *streams)
+gst_avi_demux_stream_avih (GstAviDemux * avi,
+    guint32 * flags, guint32 * streams)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint32 tag;
@@ -718,43 +682,43 @@ gst_avi_demux_stream_avih (GstAviDemux *avi,
   }
   if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_avih)) {
     g_warning ("Too small avih (%d available, %d needed)",
-	       GST_BUFFER_SIZE (buf), (int) sizeof (gst_riff_avih));
+	GST_BUFFER_SIZE (buf), (int) sizeof (gst_riff_avih));
     gst_buffer_unref (buf);
     return FALSE;
   }
 
   _avih = (gst_riff_avih *) GST_BUFFER_DATA (buf);
-  avih.us_frame    = GUINT32_FROM_LE (_avih->us_frame);
-  avih.max_bps     = GUINT32_FROM_LE (_avih->max_bps);
-  avih.pad_gran    = GUINT32_FROM_LE (_avih->pad_gran);
-  avih.flags       = GUINT32_FROM_LE (_avih->flags);
-  avih.tot_frames  = GUINT32_FROM_LE (_avih->tot_frames);
+  avih.us_frame = GUINT32_FROM_LE (_avih->us_frame);
+  avih.max_bps = GUINT32_FROM_LE (_avih->max_bps);
+  avih.pad_gran = GUINT32_FROM_LE (_avih->pad_gran);
+  avih.flags = GUINT32_FROM_LE (_avih->flags);
+  avih.tot_frames = GUINT32_FROM_LE (_avih->tot_frames);
   avih.init_frames = GUINT32_FROM_LE (_avih->init_frames);
-  avih.streams     = GUINT32_FROM_LE (_avih->streams);
-  avih.bufsize     = GUINT32_FROM_LE (_avih->bufsize);
-  avih.width       = GUINT32_FROM_LE (_avih->width);
-  avih.height      = GUINT32_FROM_LE (_avih->height);
-  avih.scale       = GUINT32_FROM_LE (_avih->scale);
-  avih.rate        = GUINT32_FROM_LE (_avih->rate);
-  avih.start       = GUINT32_FROM_LE (_avih->start);
-  avih.length      = GUINT32_FROM_LE (_avih->length);
+  avih.streams = GUINT32_FROM_LE (_avih->streams);
+  avih.bufsize = GUINT32_FROM_LE (_avih->bufsize);
+  avih.width = GUINT32_FROM_LE (_avih->width);
+  avih.height = GUINT32_FROM_LE (_avih->height);
+  avih.scale = GUINT32_FROM_LE (_avih->scale);
+  avih.rate = GUINT32_FROM_LE (_avih->rate);
+  avih.start = GUINT32_FROM_LE (_avih->start);
+  avih.length = GUINT32_FROM_LE (_avih->length);
 
   /* debug stuff */
   GST_INFO ("avih tag found:");
-  GST_INFO (" us_frame    %u",     avih.us_frame);
-  GST_INFO (" max_bps     %u",     avih.max_bps);
-  GST_INFO (" pad_gran    %u",     avih.pad_gran);
+  GST_INFO (" us_frame    %u", avih.us_frame);
+  GST_INFO (" max_bps     %u", avih.max_bps);
+  GST_INFO (" pad_gran    %u", avih.pad_gran);
   GST_INFO (" flags       0x%08x", avih.flags);
-  GST_INFO (" tot_frames  %u",     avih.tot_frames);
-  GST_INFO (" init_frames %u",     avih.init_frames);
-  GST_INFO (" streams     %u",     avih.streams);
-  GST_INFO (" bufsize     %u",     avih.bufsize);
-  GST_INFO (" width       %u",     avih.width);
-  GST_INFO (" height      %u",     avih.height);
-  GST_INFO (" scale       %u",     avih.scale);
-  GST_INFO (" rate        %u",     avih.rate);
-  GST_INFO (" start       %u",     avih.start);
-  GST_INFO (" length      %u",     avih.length);
+  GST_INFO (" tot_frames  %u", avih.tot_frames);
+  GST_INFO (" init_frames %u", avih.init_frames);
+  GST_INFO (" streams     %u", avih.streams);
+  GST_INFO (" bufsize     %u", avih.bufsize);
+  GST_INFO (" width       %u", avih.width);
+  GST_INFO (" height      %u", avih.height);
+  GST_INFO (" scale       %u", avih.scale);
+  GST_INFO (" rate        %u", avih.rate);
+  GST_INFO (" start       %u", avih.start);
+  GST_INFO (" length      %u", avih.length);
 
   avi->num_frames = avih.tot_frames;
   avi->us_per_frame = avih.us_frame;
@@ -771,7 +735,7 @@ gst_avi_demux_stream_avih (GstAviDemux *avi,
  */
 
 static gboolean
-gst_avi_demux_add_stream (GstAviDemux *avi)
+gst_avi_demux_add_stream (GstAviDemux * avi)
 {
   GstElementClass *klass = GST_ELEMENT_GET_CLASS (avi);
   GstRiffRead *riff = GST_RIFF_READ (avi);
@@ -782,7 +746,8 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
   GstPadTemplate *templ = NULL;
   GstPad *pad;
   avi_stream_context *stream;
-  union {
+  union
+  {
     gst_riff_strf_vids *vids;
     gst_riff_strf_auds *auds;
     gst_riff_strf_iavs *iavs;
@@ -803,25 +768,25 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
     return FALSE;
   if (tag != GST_RIFF_TAG_strf) {
     GST_ELEMENT_ERROR (avi, STREAM, DEMUX, (NULL),
-		       ("Invalid AVI header (no strf as second tag)"));
+	("Invalid AVI header (no strf as second tag)"));
     goto skip_stream;
   }
   switch (strh->type) {
     case GST_RIFF_FCC_vids:
       if (!gst_riff_read_strf_vids (riff, &strf.vids))
-        return FALSE;
+	return FALSE;
       break;
     case GST_RIFF_FCC_auds:
       if (!gst_riff_read_strf_auds (riff, &strf.auds))
-        return FALSE;
+	return FALSE;
       break;
     case GST_RIFF_FCC_iavs:
       if (!gst_riff_read_strf_iavs (riff, &strf.iavs))
-        return FALSE;
+	return FALSE;
       break;
     default:
       g_warning ("Unknown stream type " GST_FOURCC_FORMAT,
-		 GST_FOURCC_ARGS (strh->type));
+	  GST_FOURCC_ARGS (strh->type));
       goto skip_stream;
   }
 
@@ -836,22 +801,22 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
 
     switch (tag) {
       case GST_RIFF_TAG_strn:
-        if (name)
-          g_free (name);
-        if (!gst_riff_read_ascii (riff, &tag, &name))
-          return FALSE;
-        break;
+	if (name)
+	  g_free (name);
+	if (!gst_riff_read_ascii (riff, &tag, &name))
+	  return FALSE;
+	break;
 
       default:
-        GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
-		     GST_FOURCC_ARGS (tag));
-        /* fall-through */
+	GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
+	    GST_FOURCC_ARGS (tag));
+	/* fall-through */
 
-      case GST_RIFF_TAG_strd: /* what is this? */
+      case GST_RIFF_TAG_strd:	/* what is this? */
       case GST_RIFF_TAG_JUNK:
-        if (!gst_riff_read_skip (riff))
-          return FALSE;
-        break;
+	if (!gst_riff_read_skip (riff))
+	  return FALSE;
+	break;
     }
 
     if (avi->level_up) {
@@ -866,15 +831,17 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
     {
       char *codec_name = NULL;
       GstTagList *list = gst_tag_list_new ();
+
       padname = g_strdup_printf ("video_%02d", avi->num_v_streams);
       templ = gst_element_class_get_pad_template (klass, "video_%02d");
       caps = gst_riff_create_video_caps (strf.vids->compression, strh,
-                                         strf.vids, &codec_name);
+	  strf.vids, &codec_name);
       gst_tag_list_add (list, GST_TAG_MERGE_APPEND, GST_TAG_VIDEO_CODEC,
-                        codec_name, NULL);
+	  codec_name, NULL);
       gst_element_found_tags (GST_ELEMENT (avi), list);
       gst_tag_list_free (list);
-      if (codec_name) g_free (codec_name);
+      if (codec_name)
+	g_free (codec_name);
       g_free (strf.vids);
       avi->num_v_streams++;
       break;
@@ -883,15 +850,17 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
     {
       char *codec_name = NULL;
       GstTagList *list = gst_tag_list_new ();
+
       padname = g_strdup_printf ("audio_%02d", avi->num_a_streams);
       templ = gst_element_class_get_pad_template (klass, "audio_%02d");
       caps = gst_riff_create_audio_caps (strf.auds->format, strh, strf.auds,
-                                         &codec_name);
+	  &codec_name);
       gst_tag_list_add (list, GST_TAG_MERGE_APPEND, GST_TAG_AUDIO_CODEC,
-                        codec_name, NULL);
+	  codec_name, NULL);
       gst_element_found_tags (GST_ELEMENT (avi), list);
       gst_tag_list_free (list);
-      if (codec_name) g_free (codec_name);
+      if (codec_name)
+	g_free (codec_name);
       g_free (strf.auds);
       avi->num_a_streams++;
       break;
@@ -900,15 +869,17 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
     {
       char *codec_name = NULL;
       GstTagList *list = gst_tag_list_new ();
+
       padname = g_strdup_printf ("video_%02d", avi->num_v_streams);
       templ = gst_element_class_get_pad_template (klass, "video_%02d");
       caps = gst_riff_create_iavs_caps (strh->fcc_handler, strh, strf.iavs,
-                                        &codec_name);
+	  &codec_name);
       gst_tag_list_add (list, GST_TAG_MERGE_APPEND, GST_TAG_VIDEO_CODEC,
-                        codec_name, NULL);
+	  codec_name, NULL);
       gst_element_found_tags (GST_ELEMENT (avi), list);
       gst_tag_list_free (list);
-      if (codec_name) g_free (codec_name);
+      if (codec_name)
+	g_free (codec_name);
       g_free (strf.iavs);
       avi->num_v_streams++;
       break;
@@ -918,7 +889,7 @@ gst_avi_demux_add_stream (GstAviDemux *avi)
   }
 
   /* set proper settings and add it */
-  pad =  gst_pad_new_from_template (templ, padname);
+  pad = gst_pad_new_from_template (templ, padname);
   g_free (padname);
 
   gst_pad_set_formats_function (pad, gst_avi_demux_get_src_formats);
@@ -964,7 +935,7 @@ skip_stream:
   /* add a "NULL" stream */
   avi->num_streams++;
 
-  return TRUE; /* recoverable */
+  return TRUE;			/* recoverable */
 }
 
 /*
@@ -972,7 +943,7 @@ skip_stream:
  */
 
 static gboolean
-gst_avi_demux_stream_odml (GstAviDemux *avi)
+gst_avi_demux_stream_odml (GstAviDemux * avi)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint32 tag;
@@ -987,38 +958,38 @@ gst_avi_demux_stream_odml (GstAviDemux *avi)
     }
 
     switch (tag) {
-      case GST_RIFF_TAG_dmlh: {
-        gst_riff_dmlh dmlh, *_dmlh;
-        GstBuffer *buf;
-
-        if (!gst_riff_read_data (riff, &tag, &buf))
-          return FALSE;
-        if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_dmlh)) {
-          g_warning ("DMLH entry is too small (%d bytes, %d needed)",
-		     GST_BUFFER_SIZE (buf), (int) sizeof (gst_riff_dmlh));
-          gst_buffer_unref (buf);
-          break;
-        }
-        _dmlh = (gst_riff_dmlh *) GST_BUFFER_DATA (buf);
-        dmlh.totalframes = GUINT32_FROM_LE (_dmlh->totalframes);
-
-        GST_INFO ("dmlh tag found:");
-        GST_INFO (" totalframes: %u", dmlh.totalframes);
-
-        avi->num_frames = dmlh.totalframes;
-        gst_buffer_unref (buf);
-        break;
+      case GST_RIFF_TAG_dmlh:{
+	gst_riff_dmlh dmlh, *_dmlh;
+	GstBuffer *buf;
+
+	if (!gst_riff_read_data (riff, &tag, &buf))
+	  return FALSE;
+	if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_dmlh)) {
+	  g_warning ("DMLH entry is too small (%d bytes, %d needed)",
+	      GST_BUFFER_SIZE (buf), (int) sizeof (gst_riff_dmlh));
+	  gst_buffer_unref (buf);
+	  break;
+	}
+	_dmlh = (gst_riff_dmlh *) GST_BUFFER_DATA (buf);
+	dmlh.totalframes = GUINT32_FROM_LE (_dmlh->totalframes);
+
+	GST_INFO ("dmlh tag found:");
+	GST_INFO (" totalframes: %u", dmlh.totalframes);
+
+	avi->num_frames = dmlh.totalframes;
+	gst_buffer_unref (buf);
+	break;
       }
 
       default:
-        GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
-		     GST_FOURCC_ARGS (tag));
-        /* fall-through */
+	GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
+	    GST_FOURCC_ARGS (tag));
+	/* fall-through */
 
       case GST_RIFF_TAG_JUNK:
-        if (!gst_riff_read_skip (riff))
-          return FALSE;
-        break;
+	if (!gst_riff_read_skip (riff))
+	  return FALSE;
+	break;
     }
 
     if (avi->level_up) {
@@ -1035,7 +1006,7 @@ gst_avi_demux_stream_odml (GstAviDemux *avi)
  */
 
 gboolean
-gst_avi_demux_stream_index (GstAviDemux *avi)
+gst_avi_demux_stream_index (GstAviDemux * avi)
 {
   GstBuffer *buf = NULL;
   guint i;
@@ -1065,7 +1036,7 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
     return FALSE;
   if (tag != GST_RIFF_TAG_idx1) {
     g_warning ("No index after data, but " GST_FOURCC_FORMAT,
-	       GST_FOURCC_ARGS (tag));
+	GST_FOURCC_ARGS (tag));
     goto end;
   }
 
@@ -1075,7 +1046,8 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
 
   /* parse all entries */
   avi->index_size = GST_BUFFER_SIZE (buf) / sizeof (gst_riff_index_entry);
-  avi->index_entries = g_malloc (avi->index_size * sizeof (gst_avi_index_entry));
+  avi->index_entries =
+      g_malloc (avi->index_size * sizeof (gst_avi_index_entry));
   GST_INFO ("%u index entries", avi->index_size);
 
   for (i = 0; i < avi->index_size; i++) {
@@ -1086,16 +1058,15 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
     GstFormat format;
 
     _entry = &((gst_riff_index_entry *) GST_BUFFER_DATA (buf))[i];
-    entry.id     = GUINT32_FROM_LE (_entry->id);
+    entry.id = GUINT32_FROM_LE (_entry->id);
     entry.offset = GUINT32_FROM_LE (_entry->offset);
-    entry.flags  = GUINT32_FROM_LE (_entry->flags);
-    entry.size   = GUINT32_FROM_LE (_entry->size);
+    entry.flags = GUINT32_FROM_LE (_entry->flags);
+    entry.size = GUINT32_FROM_LE (_entry->size);
     target = &avi->index_entries[i];
 
     stream_nr = CHUNKID_TO_STREAMNR (entry.id);
     if (stream_nr >= avi->num_streams || stream_nr < 0) {
-      g_warning ("Index entry %d has invalid stream nr %d",
-		 i, stream_nr);
+      g_warning ("Index entry %d has invalid stream nr %d", i, stream_nr);
       target->stream_nr = -1;
       continue;
     }
@@ -1103,9 +1074,9 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
     stream = &avi->stream[stream_nr];
 
     target->index_nr = i;
-    target->flags    = entry.flags;
-    target->size     = entry.size;
-    target->offset   = entry.offset;
+    target->flags = entry.flags;
+    target->size = entry.size;
+    target->offset = entry.offset;
 
     /* figure out if the index is 0 based or relative to the MOVI start */
     if (i == 0) {
@@ -1123,15 +1094,15 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
       /* all audio frames are keyframes */
       target->flags |= GST_RIFF_IF_KEYFRAME;
     }
-      
+
     if (stream->strh->samplesize && stream->strh->type == GST_RIFF_FCC_auds) {
       /* constant rate stream */
       gst_pad_convert (stream->pad, GST_FORMAT_BYTES,
-		       stream->total_bytes, &format, &target->ts);
+	  stream->total_bytes, &format, &target->ts);
     } else {
       /* VBR stream */
       gst_pad_convert (stream->pad, GST_FORMAT_DEFAULT,
-		       stream->total_frames, &format, &target->ts);
+	  stream->total_frames, &format, &target->ts);
     }
 
     stream->total_bytes += target->size;
@@ -1143,8 +1114,8 @@ gst_avi_demux_stream_index (GstAviDemux *avi)
     avi_stream_context *stream;
 
     stream = &avi->stream[i];
-    GST_DEBUG ("stream %u: %u frames, %" G_GINT64_FORMAT " bytes", 
-	       i, stream->total_frames, stream->total_bytes);
+    GST_DEBUG ("stream %u: %u frames, %" G_GINT64_FORMAT " bytes",
+	i, stream->total_frames, stream->total_bytes);
   }
 
 end:
@@ -1164,7 +1135,7 @@ end:
  */
 
 gboolean
-gst_avi_demux_stream_scan (GstAviDemux *avi)
+gst_avi_demux_stream_scan (GstAviDemux * avi)
 {
   //GstRiffRead *riff = GST_RIFF_READ (avi);
 
@@ -1178,7 +1149,7 @@ gst_avi_demux_stream_scan (GstAviDemux *avi)
  */
 
 gboolean
-gst_avi_demux_stream_header (GstAviDemux *avi)
+gst_avi_demux_stream_header (GstAviDemux * avi)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint32 tag, flags, streams;
@@ -1188,16 +1159,16 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
     return FALSE;
   if (tag != GST_RIFF_TAG_LIST) {
     GST_ELEMENT_ERROR (avi, STREAM, DEMUX, (NULL),
-		       ("Invalid AVI header (no LIST at start): "
-		       GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
+	("Invalid AVI header (no LIST at start): "
+	    GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
     return FALSE;
   }
   if (!gst_riff_read_list (riff, &tag))
     return FALSE;
   if (tag != GST_RIFF_LIST_hdrl) {
     GST_ELEMENT_ERROR (avi, STREAM, DEMUX, (NULL),
-		       ("Invalid AVI header (no hdrl at start): "
-		       GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
+	("Invalid AVI header (no hdrl at start): "
+	    GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
     return FALSE;
   }
 
@@ -1206,8 +1177,8 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
     return FALSE;
   if (tag != GST_RIFF_TAG_avih) {
     GST_ELEMENT_ERROR (avi, STREAM, DEMUX, (NULL),
-		       ("Invalid AVI header (no avih at start): "
-		       GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
+	("Invalid AVI header (no avih at start): "
+	    GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
     return FALSE;
   }
   if (!gst_avi_demux_stream_avih (avi, &flags, &streams))
@@ -1224,44 +1195,44 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
 
     switch (tag) {
       case GST_RIFF_TAG_LIST:
-        if (!(tag = gst_riff_peek_list (riff)))
-          return FALSE;
-
-        switch (tag) {
-          case GST_RIFF_LIST_strl:
-            if (!gst_riff_read_list (riff, &tag) ||
-                !gst_avi_demux_add_stream (avi))
-              return FALSE;
-            break;
-
-          case GST_RIFF_LIST_odml:
-            if (!gst_riff_read_list (riff, &tag) ||
-                !gst_avi_demux_stream_odml (avi))
-              return FALSE;
-            break;
-
-          default:
-            GST_WARNING ("Unknown list " GST_FOURCC_FORMAT " in AVI header",
-			 GST_FOURCC_ARGS (tag));
-            /* fall-through */
-
-          case GST_RIFF_TAG_JUNK:
-            if (!gst_riff_read_skip (riff))
-              return FALSE;
-            break;
-        }
-
-        break;
+	if (!(tag = gst_riff_peek_list (riff)))
+	  return FALSE;
+
+	switch (tag) {
+	  case GST_RIFF_LIST_strl:
+	    if (!gst_riff_read_list (riff, &tag) ||
+		!gst_avi_demux_add_stream (avi))
+	      return FALSE;
+	    break;
+
+	  case GST_RIFF_LIST_odml:
+	    if (!gst_riff_read_list (riff, &tag) ||
+		!gst_avi_demux_stream_odml (avi))
+	      return FALSE;
+	    break;
+
+	  default:
+	    GST_WARNING ("Unknown list " GST_FOURCC_FORMAT " in AVI header",
+		GST_FOURCC_ARGS (tag));
+	    /* fall-through */
+
+	  case GST_RIFF_TAG_JUNK:
+	    if (!gst_riff_read_skip (riff))
+	      return FALSE;
+	    break;
+	}
+
+	break;
 
       default:
-        GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
-		     GST_FOURCC_ARGS (tag));
-        /* fall-through */
+	GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " in AVI header",
+	    GST_FOURCC_ARGS (tag));
+	/* fall-through */
 
       case GST_RIFF_TAG_JUNK:
-        if (!gst_riff_read_skip (riff))
-          return FALSE;
-        break;
+	if (!gst_riff_read_skip (riff))
+	  return FALSE;
+	break;
     }
 
     if (avi->level_up) {
@@ -1272,11 +1243,11 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
 
   if (avi->num_streams != streams) {
     g_warning ("Stream header mentioned %d streams, but %d available",
-	       streams, avi->num_streams);
+	streams, avi->num_streams);
   }
 
   /* we've got streaminfo now */
-  g_object_notify (G_OBJECT(avi), "streaminfo");
+  g_object_notify (G_OBJECT (avi), "streaminfo");
 
   /* Now, find the data (i.e. skip all junk between header and data) */
   while (1) {
@@ -1284,18 +1255,17 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
       return FALSE;
     if (tag != GST_RIFF_TAG_LIST) {
       if (!gst_riff_read_skip (riff))
-        return FALSE;
+	return FALSE;
       continue;
     }
     if (!(tag = gst_riff_peek_list (riff)))
       return FALSE;
     if (tag != GST_RIFF_LIST_movi) {
       if (tag == GST_RIFF_LIST_INFO) {
-        if (!gst_riff_read_list (riff, &tag) ||
-            !gst_riff_read_info (riff))
-         return FALSE;
-      } else  if (!gst_riff_read_skip (riff)) {
-        return FALSE;
+	if (!gst_riff_read_list (riff, &tag) || !gst_riff_read_info (riff))
+	  return FALSE;
+      } else if (!gst_riff_read_skip (riff)) {
+	return FALSE;
       }
       continue;
     }
@@ -1319,7 +1289,7 @@ gst_avi_demux_stream_header (GstAviDemux *avi)
  */
 
 static gboolean
-gst_avi_demux_handle_seek (GstAviDemux *avi)
+gst_avi_demux_handle_seek (GstAviDemux * avi)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint i;
@@ -1336,8 +1306,8 @@ gst_avi_demux_handle_seek (GstAviDemux *avi)
     avi_stream_context *stream = &avi->stream[i];
 
     if (GST_PAD_IS_USABLE (stream->pad)) {
-      event = gst_event_new_discontinuous (FALSE, GST_FORMAT_TIME, 
-				avi->last_seek + stream->delay , NULL);
+      event = gst_event_new_discontinuous (FALSE, GST_FORMAT_TIME,
+	  avi->last_seek + stream->delay, NULL);
       gst_pad_push (stream->pad, GST_DATA (event));
     }
   }
@@ -1350,17 +1320,17 @@ gst_avi_demux_handle_seek (GstAviDemux *avi)
  */
 
 gboolean
-gst_avi_demux_stream_data (GstAviDemux *avi)
+gst_avi_demux_stream_data (GstAviDemux * avi)
 {
   GstRiffRead *riff = GST_RIFF_READ (avi);
   guint32 tag;
   guint stream_nr;
   gst_avi_index_entry *entry;
 
-  if (avi->seek_offset != (guint64) -1) {
+  if (avi->seek_offset != (guint64) - 1) {
     if (!gst_avi_demux_handle_seek (avi))
       return FALSE;
-    avi->seek_offset = (guint64) -1;
+    avi->seek_offset = (guint64) - 1;
   }
 
   /* peek first (for the end of this 'list/movi' section) */
@@ -1377,40 +1347,40 @@ gst_avi_demux_stream_data (GstAviDemux *avi)
 
     switch (tag) {
       case GST_RIFF_TAG_LIST:
-        if (!(tag = gst_riff_peek_list (riff)))
-          return FALSE;
-
-        switch (tag) {
-          case GST_RIFF_LIST_AVIX:
-          case GST_RIFF_LIST_movi:
-            if (!gst_riff_read_list (riff, &tag))
-              return FALSE;
-            /* we're now going to read buffers! */
-            break;
-
-          default:
-            GST_WARNING ("Unknown list " GST_FOURCC_FORMAT " before AVI data",
-			 GST_FOURCC_ARGS (tag));
-            /* fall-through */
-
-          case GST_RIFF_TAG_JUNK:
-            if (!gst_riff_read_skip (riff))
-              return FALSE;
-            break;
-        }
-
-        break;
+	if (!(tag = gst_riff_peek_list (riff)))
+	  return FALSE;
+
+	switch (tag) {
+	  case GST_RIFF_LIST_AVIX:
+	  case GST_RIFF_LIST_movi:
+	    if (!gst_riff_read_list (riff, &tag))
+	      return FALSE;
+	    /* we're now going to read buffers! */
+	    break;
+
+	  default:
+	    GST_WARNING ("Unknown list " GST_FOURCC_FORMAT " before AVI data",
+		GST_FOURCC_ARGS (tag));
+	    /* fall-through */
+
+	  case GST_RIFF_TAG_JUNK:
+	    if (!gst_riff_read_skip (riff))
+	      return FALSE;
+	    break;
+	}
+
+	break;
 
       default:
-        GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " before AVI data",
-		     GST_FOURCC_ARGS (tag));
-        /* fall-through */
+	GST_WARNING ("Unknown tag " GST_FOURCC_FORMAT " before AVI data",
+	    GST_FOURCC_ARGS (tag));
+	/* fall-through */
 
       case GST_RIFF_TAG_idx1:
       case GST_RIFF_TAG_JUNK:
-        if (!gst_riff_read_skip (riff))
-          return FALSE;
-        break;
+	if (!gst_riff_read_skip (riff))
+	  return FALSE;
+	break;
     }
   }
 
@@ -1421,7 +1391,7 @@ gst_avi_demux_stream_data (GstAviDemux *avi)
   if (stream_nr < 0 || stream_nr >= avi->num_streams) {
     /* recoverable */
     g_warning ("Invalid stream ID %d (" GST_FOURCC_FORMAT ")",
-	       stream_nr, GST_FOURCC_ARGS (tag));
+	stream_nr, GST_FOURCC_ARGS (tag));
     if (!gst_riff_read_skip (riff))
       return FALSE;
   } else {
@@ -1437,20 +1407,19 @@ gst_avi_demux_stream_data (GstAviDemux *avi)
     /* get time of this buffer */
     stream = &avi->stream[stream_nr];
     entry = gst_avi_demux_index_next (avi, stream_nr,
-				      stream->current_entry + 1, 0);
+	stream->current_entry + 1, 0);
     if (entry) {
       stream->current_entry = entry->index_nr;
       if (entry->flags & GST_RIFF_IF_KEYFRAME) {
-        GST_BUFFER_FLAG_SET (buf, GST_BUFFER_KEY_UNIT);
+	GST_BUFFER_FLAG_SET (buf, GST_BUFFER_KEY_UNIT);
       }
     }
     format = GST_FORMAT_TIME;
-    gst_pad_query (stream->pad, GST_QUERY_POSITION,
-		   &format, &next_ts);
+    gst_pad_query (stream->pad, GST_QUERY_POSITION, &format, &next_ts);
 
     /* set delay (if any) */
     if (stream->strh->init_frames == stream->current_frame &&
-        stream->delay == 0)
+	stream->delay == 0)
       stream->delay = next_ts;
 
     stream->current_frame++;
@@ -1462,16 +1431,15 @@ gst_avi_demux_stream_data (GstAviDemux *avi)
       gst_buffer_unref (buf);
     } else {
       if (!stream->pad || !GST_PAD_IS_USABLE (stream->pad)) {
-        gst_buffer_unref (buf);
+	gst_buffer_unref (buf);
       } else {
-        GstClockTime dur_ts;
+	GstClockTime dur_ts;
 
-        GST_BUFFER_TIMESTAMP (buf) = next_ts;
-        gst_pad_query (stream->pad, GST_QUERY_POSITION,
-		       &format, &dur_ts);
-        GST_BUFFER_DURATION (buf) = dur_ts - next_ts;
+	GST_BUFFER_TIMESTAMP (buf) = next_ts;
+	gst_pad_query (stream->pad, GST_QUERY_POSITION, &format, &dur_ts);
+	GST_BUFFER_DURATION (buf) = dur_ts - next_ts;
 
-        gst_pad_push (stream->pad, GST_DATA (buf));
+	gst_pad_push (stream->pad, GST_DATA (buf));
       }
     }
   }
@@ -1480,26 +1448,26 @@ gst_avi_demux_stream_data (GstAviDemux *avi)
 }
 
 static void
-gst_avi_demux_loop (GstElement *element)
+gst_avi_demux_loop (GstElement * element)
 {
   GstAviDemux *avi = GST_AVI_DEMUX (element);
 
   switch (avi->state) {
     case GST_AVI_DEMUX_START:
       if (!gst_avi_demux_stream_init (avi))
-        return;
+	return;
       avi->state = GST_AVI_DEMUX_HEADER;
       /* fall-through */
 
     case GST_AVI_DEMUX_HEADER:
       if (!gst_avi_demux_stream_header (avi))
-        return;
+	return;
       avi->state = GST_AVI_DEMUX_MOVI;
       /* fall-through */
 
     case GST_AVI_DEMUX_MOVI:
       if (!gst_avi_demux_stream_data (avi))
-        return;
+	return;
       break;
 
     default:
@@ -1508,7 +1476,7 @@ gst_avi_demux_loop (GstElement *element)
 }
 
 static GstElementStateReturn
-gst_avi_demux_change_state (GstElement *element)
+gst_avi_demux_change_state (GstElement * element)
 {
   GstAviDemux *avi = GST_AVI_DEMUX (element);
 
@@ -1530,10 +1498,8 @@ gst_avi_demux_change_state (GstElement *element)
 }
 
 static void
-gst_avi_demux_get_property (GObject    *object,
-			    guint       prop_id,
-			    GValue     *value,
-			    GParamSpec *pspec)
+gst_avi_demux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
 {
   GstAviDemux *avi = GST_AVI_DEMUX (object);
 
diff --git a/gst/avi/gstavidemux.h b/gst/avi/gstavidemux.h
index d94433ae..9849bdaf 100644
--- a/gst/avi/gstavidemux.h
+++ b/gst/avi/gstavidemux.h
@@ -26,7 +26,6 @@
 #include "gst/riff/riff-read.h"
 
 G_BEGIN_DECLS
-
 #define GST_TYPE_AVI_DEMUX \
   (gst_avi_demux_get_type ())
 #define GST_AVI_DEMUX(obj) \
@@ -37,93 +36,94 @@ G_BEGIN_DECLS
   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AVI_DEMUX))
 #define GST_IS_AVI_DEMUX_CLASS(obj) \
   (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AVI_DEMUX))
-
-#define GST_AVI_DEMUX_MAX_STREAMS	16	
-
+#define GST_AVI_DEMUX_MAX_STREAMS	16
 #define CHUNKID_TO_STREAMNR(chunkid) \
   ((((chunkid) & 0xff) - '0') * 10 + \
    (((chunkid) >> 8) & 0xff) - '0')
-
-typedef struct {
-  gint 		 index_nr;
-  gint 		 stream_nr;
-  guint64 	 ts;
-  guint32	 flags;
-  guint32	 offset;
-  gint 		 size;
-  guint64	 bytes_before;
-  guint32	 frames_before;
+    typedef struct
+{
+  gint index_nr;
+  gint stream_nr;
+  guint64 ts;
+  guint32 flags;
+  guint32 offset;
+  gint size;
+  guint64 bytes_before;
+  guint32 frames_before;
 } gst_avi_index_entry;
 
-typedef struct {
+typedef struct
+{
   /* index of this streamcontext */
-  guint 	 num;
+  guint num;
 
   /* pad, strh */
-  GstPad	*pad;
-  GstCaps	*caps;
-  gst_riff_strh	*strh;
+  GstPad *pad;
+  GstCaps *caps;
+  gst_riff_strh *strh;
 
   /* current position (byte, frame, time) */
-  guint 	 current_frame;
-  guint64 	 current_byte;
-  gint		 current_entry;
+  guint current_frame;
+  guint64 current_byte;
+  gint current_entry;
 
   /* delay in time (init_frames) */
-  guint64 	 delay;
+  guint64 delay;
 
   /* stream length */
-  guint64	 total_bytes;
-  guint32	 total_frames;
+  guint64 total_bytes;
+  guint32 total_frames;
 
-  guint32	 skip;
+  guint32 skip;
 } avi_stream_context;
 
-typedef enum {
+typedef enum
+{
   GST_AVI_DEMUX_START,
   GST_AVI_DEMUX_HEADER,
   GST_AVI_DEMUX_MOVI,
 } GstAviDemuxState;
 
-typedef struct _GstAviDemux {
-  GstRiffRead	 parent;
+typedef struct _GstAviDemux
+{
+  GstRiffRead parent;
 
   /* pads */
-  GstPad 	*sinkpad;
+  GstPad *sinkpad;
 
   /* AVI decoding state */
   GstAviDemuxState state;
-  guint          level_up;
+  guint level_up;
 
   /* index */
   gst_avi_index_entry *index_entries;
-  guint 	 index_size;
-  guint64	 index_offset;
+  guint index_size;
+  guint64 index_offset;
 
   /* streams */
-  guint 	 num_streams;
-  guint 	 num_v_streams;
-  guint 	 num_a_streams;
+  guint num_streams;
+  guint num_v_streams;
+  guint num_a_streams;
   avi_stream_context stream[GST_AVI_DEMUX_MAX_STREAMS];
 
   /* some stream info for length */
-  guint32	 us_per_frame;
-  guint32	 num_frames;
+  guint32 us_per_frame;
+  guint32 num_frames;
 
   /* seeking */
-  guint64 	 seek_offset;
-  guint64	 last_seek;
+  guint64 seek_offset;
+  guint64 last_seek;
 
   /* info */
-  GstCaps	*streaminfo;
+  GstCaps *streaminfo;
 } GstAviDemux;
 
-typedef struct _GstAviDemuxClass {
+typedef struct _GstAviDemuxClass
+{
   GstRiffReadClass parent_class;
 } GstAviDemuxClass;
 
-GType 		gst_avi_demux_get_type		(void);
+GType gst_avi_demux_get_type (void);
 
 G_END_DECLS
-
 #endif /* __GST_AVI_DEMUX_H__ */
diff --git a/gst/avi/gstavimux.c b/gst/avi/gstavimux.c
index a064378f..f5287db0 100644
--- a/gst/avi/gstavimux.c
+++ b/gst/avi/gstavimux.c
@@ -45,138 +45,126 @@
 #endif
 
 /* AviMux signals and args */
-enum {
+enum
+{
   /* FILL ME */
   LAST_SIGNAL
 };
 
-enum {
+enum
+{
   ARG_0,
   ARG_BIGFILE,
 };
 
-static GstStaticPadTemplate src_factory =
-GST_STATIC_PAD_TEMPLATE (
-  "src",
-  GST_PAD_SRC,
-  GST_PAD_ALWAYS,
-  GST_STATIC_CAPS ("video/x-msvideo")
-);
-    
+static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/x-msvideo")
+    );
+
 static GstStaticPadTemplate video_sink_factory =
-GST_STATIC_PAD_TEMPLATE (
-  "video_%d",
-  GST_PAD_SINK,
-  GST_PAD_REQUEST,
-  GST_STATIC_CAPS (
-    "video/x-raw-yuv, "
-      "format = (fourcc) { YUY2, I420 }, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]; "
-    "video/x-jpeg, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]; "
-    "video/x-divx, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ], "
-      "divxversion = (int) [ 3, 5 ]; "
-    "video/x-xvid, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]; "
-    "video/x-3ivx, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]; "
-    "video/x-msmpeg, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ], "
-      "msmpegversion = (int) [ 41, 43 ]; "
-    "video/mpeg, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ], "
-      "mpegversion = (int) 1, "
-      "systemstream = (boolean) FALSE; "
-    "video/x-h263, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]; "
-    "video/x-dv, "
-      "width = (int) 720, "
-      "height = (int) { 576, 480 }, "
-      "systemstream = (boolean) FALSE; "
-    "video/x-huffyuv, "
-      "width = (int) [ 16, 4096 ], "
-      "height = (int) [ 16, 4096 ]"
-  )
-);
-    
+    GST_STATIC_PAD_TEMPLATE ("video_%d",
+    GST_PAD_SINK,
+    GST_PAD_REQUEST,
+    GST_STATIC_CAPS ("video/x-raw-yuv, "
+	"format = (fourcc) { YUY2, I420 }, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ]; "
+	"video/x-jpeg, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ]; "
+	"video/x-divx, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ], "
+	"divxversion = (int) [ 3, 5 ]; "
+	"video/x-xvid, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ]; "
+	"video/x-3ivx, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ]; "
+	"video/x-msmpeg, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ], "
+	"msmpegversion = (int) [ 41, 43 ]; "
+	"video/mpeg, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ], "
+	"mpegversion = (int) 1, "
+	"systemstream = (boolean) FALSE; "
+	"video/x-h263, "
+	"width = (int) [ 16, 4096 ], "
+	"height = (int) [ 16, 4096 ]; "
+	"video/x-dv, "
+	"width = (int) 720, "
+	"height = (int) { 576, 480 }, "
+	"systemstream = (boolean) FALSE; "
+	"video/x-huffyuv, "
+	"width = (int) [ 16, 4096 ], " "height = (int) [ 16, 4096 ]")
+    );
+
 static GstStaticPadTemplate audio_sink_factory =
-GST_STATIC_PAD_TEMPLATE (
-  "audio_%d",
-  GST_PAD_SINK,
-  GST_PAD_REQUEST,
-  GST_STATIC_CAPS (
-    "audio/x-raw-int, "
-      "endianness = (int) LITTLE_ENDIAN, "
-      "signed = (boolean) { TRUE, FALSE }, "
-      "width = (int) { 8, 16 }, "
-      "depth = (int) { 8, 16 }, "
-      "rate = (int) [ 1000, 96000 ], "
-      "channels = (int) [ 1, 2 ]; "
-    "audio/mpeg, "
-      "mpegversion = (int) 1, "
-      "layer = (int) [ 1, 3 ], "
-      "rate = (int) [ 1000, 96000 ], "
-      "channels = (int) [ 1, 2 ]; "
-    "audio/x-vorbis, "
-      "rate = (int) [ 1000, 96000 ], "
-      "channels = (int) [ 1, 2 ]; "
-    "audio/x-ac3, "
-      "rate = (int) [ 1000, 96000 ], "
-      "channels = (int) [ 1, 2 ]"
-  )
-);
-    
-
-static void 	gst_avimux_base_init		     (gpointer g_class);
-static void 	gst_avimux_class_init		     (GstAviMuxClass *klass);
-static void 	gst_avimux_init			     (GstAviMux      *avimux);
-
-static void     gst_avimux_loop                      (GstElement     *element);
-static gboolean gst_avimux_handle_event              (GstPad         *pad,
-                                                      GstEvent       *event);
-static GstPad*  gst_avimux_request_new_pad           (GstElement     *element,
-                                                      GstPadTemplate *templ,
-                                                      const gchar    *name);
-static void     gst_avimux_set_property              (GObject        *object,
-                                                      guint           prop_id,
-                                                      const GValue   *value,
-                                                      GParamSpec     *pspec);
-static void     gst_avimux_get_property              (GObject        *object,
-                                                      guint           prop_id,
-                                                      GValue         *value,
-                                                      GParamSpec     *pspec);
-static GstElementStateReturn gst_avimux_change_state (GstElement     *element);
+    GST_STATIC_PAD_TEMPLATE ("audio_%d",
+    GST_PAD_SINK,
+    GST_PAD_REQUEST,
+    GST_STATIC_CAPS ("audio/x-raw-int, "
+	"endianness = (int) LITTLE_ENDIAN, "
+	"signed = (boolean) { TRUE, FALSE }, "
+	"width = (int) { 8, 16 }, "
+	"depth = (int) { 8, 16 }, "
+	"rate = (int) [ 1000, 96000 ], "
+	"channels = (int) [ 1, 2 ]; "
+	"audio/mpeg, "
+	"mpegversion = (int) 1, "
+	"layer = (int) [ 1, 3 ], "
+	"rate = (int) [ 1000, 96000 ], "
+	"channels = (int) [ 1, 2 ]; "
+	"audio/x-vorbis, "
+	"rate = (int) [ 1000, 96000 ], "
+	"channels = (int) [ 1, 2 ]; "
+	"audio/x-ac3, "
+	"rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]")
+    );
+
+
+static void gst_avimux_base_init (gpointer g_class);
+static void gst_avimux_class_init (GstAviMuxClass * klass);
+static void gst_avimux_init (GstAviMux * avimux);
+
+static void gst_avimux_loop (GstElement * element);
+static gboolean gst_avimux_handle_event (GstPad * pad, GstEvent * event);
+static GstPad *gst_avimux_request_new_pad (GstElement * element,
+    GstPadTemplate * templ, const gchar * name);
+static void gst_avimux_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_avimux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
+static GstElementStateReturn gst_avimux_change_state (GstElement * element);
 
 static GstElementClass *parent_class = NULL;
+
 /*static guint gst_avimux_signals[LAST_SIGNAL] = { 0 }; */
 
 GType
-gst_avimux_get_type (void) 
+gst_avimux_get_type (void)
 {
   static GType avimux_type = 0;
 
   if (!avimux_type) {
     static const GTypeInfo avimux_info = {
-      sizeof(GstAviMuxClass),      
+      sizeof (GstAviMuxClass),
       gst_avimux_base_init,
       NULL,
-      (GClassInitFunc)gst_avimux_class_init,
+      (GClassInitFunc) gst_avimux_class_init,
       NULL,
       NULL,
-      sizeof(GstAviMux),
+      sizeof (GstAviMux),
       0,
-      (GInstanceInitFunc)gst_avimux_init,
+      (GInstanceInitFunc) gst_avimux_init,
     };
-    avimux_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAviMux", &avimux_info, 0);
+    avimux_type =
+	g_type_register_static (GST_TYPE_ELEMENT, "GstAviMux", &avimux_info, 0);
   }
   return avimux_type;
 }
@@ -185,12 +173,11 @@ static void
 gst_avimux_base_init (gpointer g_class)
 {
   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
-  static GstElementDetails gst_avimux_details = GST_ELEMENT_DETAILS (
-    "Avi multiplexer",
-    "Codec/Muxer",
-    "Muxes audio and video into an avi stream",
-    "Ronald Bultje <rbultje@ronald.bitfreak.net>"
-  );
+  static GstElementDetails gst_avimux_details =
+      GST_ELEMENT_DETAILS ("Avi multiplexer",
+      "Codec/Muxer",
+      "Muxes audio and video into an avi stream",
+      "Ronald Bultje <rbultje@ronald.bitfreak.net>");
 
   gst_element_class_add_pad_template (element_class,
       gst_static_pad_template_get (&src_factory));
@@ -203,20 +190,19 @@ gst_avimux_base_init (gpointer g_class)
 }
 
 static void
-gst_avimux_class_init (GstAviMuxClass *klass) 
+gst_avimux_class_init (GstAviMuxClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
 
-  gobject_class = (GObjectClass*)klass;
-  gstelement_class = (GstElementClass*)klass;
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
 
   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BIGFILE,
-    g_param_spec_boolean("bigfile","Bigfile Support",
-			 "Support for openDML-2.0 (big) AVI files",
-    0,G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BIGFILE,
+      g_param_spec_boolean ("bigfile", "Bigfile Support",
+	  "Support for openDML-2.0 (big) AVI files", 0, G_PARAM_READWRITE));
 
   gstelement_class->request_new_pad = gst_avimux_request_new_pad;
 
@@ -227,26 +213,27 @@ gst_avimux_class_init (GstAviMuxClass *klass)
 }
 
 static const GstEventMask *
-gst_avimux_get_event_masks (GstPad *pad)
+gst_avimux_get_event_masks (GstPad * pad)
 {
   static const GstEventMask gst_avimux_sink_event_masks[] = {
-    { GST_EVENT_EOS, 0 },
-    { 0, }
+    {GST_EVENT_EOS, 0},
+    {0,}
   };
 
   return gst_avimux_sink_event_masks;
 }
 
-static void 
-gst_avimux_init (GstAviMux *avimux) 
+static void
+gst_avimux_init (GstAviMux * avimux)
 {
   GstElementClass *klass = GST_ELEMENT_GET_CLASS (avimux);
 
-  avimux->srcpad = gst_pad_new_from_template (
-		  gst_element_class_get_pad_template (klass, "src"), "src");
+  avimux->srcpad =
+      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
+	  "src"), "src");
   gst_element_add_pad (GST_ELEMENT (avimux), avimux->srcpad);
 
-  GST_FLAG_SET (GST_ELEMENT(avimux), GST_ELEMENT_EVENT_AWARE);
+  GST_FLAG_SET (GST_ELEMENT (avimux), GST_ELEMENT_EVENT_AWARE);
 
   avimux->audiosinkpad = NULL;
   avimux->audio_pad_connected = FALSE;
@@ -259,15 +246,15 @@ gst_avimux_init (GstAviMux *avimux)
   avimux->num_frames = 0;
 
   /* audio/video/AVI header initialisation */
-  memset(&(avimux->avi_hdr),0,sizeof(gst_riff_avih));
-  memset(&(avimux->vids_hdr),0,sizeof(gst_riff_strh));
-  memset(&(avimux->vids),0,sizeof(gst_riff_strf_vids));
-  memset(&(avimux->auds_hdr),0,sizeof(gst_riff_strh));
-  memset(&(avimux->auds),0,sizeof(gst_riff_strf_auds));
-  avimux->vids_hdr.type = GST_MAKE_FOURCC('v','i','d','s');
+  memset (&(avimux->avi_hdr), 0, sizeof (gst_riff_avih));
+  memset (&(avimux->vids_hdr), 0, sizeof (gst_riff_strh));
+  memset (&(avimux->vids), 0, sizeof (gst_riff_strf_vids));
+  memset (&(avimux->auds_hdr), 0, sizeof (gst_riff_strh));
+  memset (&(avimux->auds), 0, sizeof (gst_riff_strf_auds));
+  avimux->vids_hdr.type = GST_MAKE_FOURCC ('v', 'i', 'd', 's');
   avimux->vids_hdr.rate = 1000000;
   avimux->avi_hdr.max_bps = 10000000;
-  avimux->auds_hdr.type = GST_MAKE_FOURCC('a','u','d','s');
+  avimux->auds_hdr.type = GST_MAKE_FOURCC ('a', 'u', 'd', 's');
   avimux->vids_hdr.quality = 0xFFFFFFFF;
   avimux->auds_hdr.quality = 0xFFFFFFFF;
 
@@ -277,33 +264,34 @@ gst_avimux_init (GstAviMux *avimux)
 
   avimux->enable_large_avi = TRUE;
 
-  gst_element_set_loop_function(GST_ELEMENT(avimux), gst_avimux_loop);
+  gst_element_set_loop_function (GST_ELEMENT (avimux), gst_avimux_loop);
 }
 
 static GstPadLinkReturn
-gst_avimux_vidsinkconnect (GstPad *pad, const GstCaps *vscaps)
+gst_avimux_vidsinkconnect (GstPad * pad, const GstCaps * vscaps)
 {
   GstAviMux *avimux;
   GstStructure *structure;
-  const gchar* mimetype;
+  const gchar *mimetype;
   gdouble fps = 0.;
   gboolean ret;
 
   avimux = GST_AVIMUX (gst_pad_get_parent (pad));
 
   GST_DEBUG ("avimux: video sinkconnect triggered on %s",
-	     gst_pad_get_name (pad));
+      gst_pad_get_name (pad));
 
   structure = gst_caps_get_structure (vscaps, 0);
   mimetype = gst_structure_get_name (structure);
 
   /* global */
-  avimux->vids.size        = sizeof(gst_riff_strf_vids);
-  avimux->vids.planes      = 1;
+  avimux->vids.size = sizeof (gst_riff_strf_vids);
+  avimux->vids.planes = 1;
   ret = gst_structure_get_int (structure, "width", &avimux->vids.width);
   ret &= gst_structure_get_int (structure, "height", &avimux->vids.height);
   ret &= gst_structure_get_double (structure, "framerate", &fps);
-  if (!ret) return GST_PAD_LINK_REFUSED;
+  if (!ret)
+    return GST_PAD_LINK_REFUSED;
 
   if (fps != 0.)
     avimux->vids_hdr.scale = avimux->vids_hdr.rate / fps;
@@ -313,13 +301,12 @@ gst_avimux_vidsinkconnect (GstPad *pad, const GstCaps *vscaps)
 
     gst_structure_get_fourcc (structure, "format", &format);
     avimux->vids.compression = format;
-    switch (format)
-    {
-      case GST_MAKE_FOURCC('Y','U','Y','2'):
-	avimux->vids.bit_cnt     = 16;
+    switch (format) {
+      case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
+	avimux->vids.bit_cnt = 16;
 	break;
-      case GST_MAKE_FOURCC('I','4','2','0'):
-	avimux->vids.bit_cnt     = 12;
+      case GST_MAKE_FOURCC ('I', '4', '2', '0'):
+	avimux->vids.bit_cnt = 12;
 	break;
     }
   } else {
@@ -328,47 +315,49 @@ gst_avimux_vidsinkconnect (GstPad *pad, const GstCaps *vscaps)
 
     /* find format */
     if (!strcmp (mimetype, "video/x-huffyuv")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('H','F','Y','U');
+      avimux->vids.compression = GST_MAKE_FOURCC ('H', 'F', 'Y', 'U');
     } else if (!strcmp (mimetype, "video/x-jpeg")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('M','J','P','G');
+      avimux->vids.compression = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');
     } else if (!strcmp (mimetype, "video/x-divx")) {
       gint divxversion;
+
       gst_structure_get_int (structure, "divxversion", &divxversion);
       switch (divxversion) {
 	case 3:
-	  avimux->vids.compression = GST_MAKE_FOURCC('D','I','V','3');
+	  avimux->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', '3');
 	  break;
 	case 4:
-	  avimux->vids.compression = GST_MAKE_FOURCC('D','I','V','X');
+	  avimux->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
 	  break;
 	case 5:
-	  avimux->vids.compression = GST_MAKE_FOURCC('D','X','5','0');
-            break;
+	  avimux->vids.compression = GST_MAKE_FOURCC ('D', 'X', '5', '0');
+	  break;
       }
     } else if (!strcmp (mimetype, "video/x-xvid")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('X','V','I','D');
+      avimux->vids.compression = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
     } else if (!strcmp (mimetype, "video/x-3ivx")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('3','I','V','2');
+      avimux->vids.compression = GST_MAKE_FOURCC ('3', 'I', 'V', '2');
     } else if (!strcmp (mimetype, "video/x-msmpeg")) {
       gint msmpegversion;
+
       gst_structure_get_int (structure, "msmpegversion", &msmpegversion);
       switch (msmpegversion) {
 	case 41:
-	  avimux->vids.compression = GST_MAKE_FOURCC('M','P','G','4');
+	  avimux->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'G', '4');
 	  break;
 	case 42:
-	  avimux->vids.compression = GST_MAKE_FOURCC('M','P','4','2');
+	  avimux->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '2');
 	  break;
 	case 43:
-	  avimux->vids.compression = GST_MAKE_FOURCC('M','P','4','3');
+	  avimux->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '3');
 	  break;
       }
     } else if (!strcmp (mimetype, "video/x-dv")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('D','V','S','D');
+      avimux->vids.compression = GST_MAKE_FOURCC ('D', 'V', 'S', 'D');
     } else if (!strcmp (mimetype, "video/x-h263")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('H','2','6','3');
+      avimux->vids.compression = GST_MAKE_FOURCC ('H', '2', '6', '3');
     } else if (!strcmp (mimetype, "video/mpeg")) {
-      avimux->vids.compression = GST_MAKE_FOURCC('M','P','E','G');
+      avimux->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'E', 'G');
     }
 
     if (!avimux->vids.compression) {
@@ -385,17 +374,17 @@ gst_avimux_vidsinkconnect (GstPad *pad, const GstCaps *vscaps)
 }
 
 static GstPadLinkReturn
-gst_avimux_audsinkconnect (GstPad *pad, const GstCaps *vscaps)
+gst_avimux_audsinkconnect (GstPad * pad, const GstCaps * vscaps)
 {
   GstAviMux *avimux;
   GstStructure *structure;
-  const gchar* mimetype;
+  const gchar *mimetype;
   int i;
 
   avimux = GST_AVIMUX (gst_pad_get_parent (pad));
 
   GST_DEBUG ("avimux: audio sinkconnect triggered on %s",
-	     gst_pad_get_name (pad));
+      gst_pad_get_name (pad));
 
   structure = gst_caps_get_structure (vscaps, 0);
   mimetype = gst_structure_get_name (structure);
@@ -407,7 +396,7 @@ gst_avimux_audsinkconnect (GstPad *pad, const GstCaps *vscaps)
   avimux->auds.rate = i;
 
   if (!strcmp (mimetype, "audio/x-raw-int")) {
-    avimux->auds.format      = GST_RIFF_WAVE_FORMAT_PCM;
+    avimux->auds.format = GST_RIFF_WAVE_FORMAT_PCM;
 
     gst_structure_get_int (structure, "width", &i);
     avimux->auds.blockalign = i;
@@ -419,18 +408,20 @@ gst_avimux_audsinkconnect (GstPad *pad, const GstCaps *vscaps)
     avimux->auds.blockalign *= avimux->auds.channels;
     avimux->auds.av_bps = avimux->auds.blockalign * avimux->auds.rate;
   } else if (!strcmp (mimetype, "audio/mpeg") ||
-	     !strcmp (mimetype, "audio/x-vorbis") ||
-	     !strcmp (mimetype, "audio/x-ac3")) {
+      !strcmp (mimetype, "audio/x-vorbis") ||
+      !strcmp (mimetype, "audio/x-ac3")) {
     avimux->auds.format = 0;
 
     if (!strcmp (mimetype, "audio/mpeg")) {
       gint layer = 3;
+
       gst_structure_get_int (structure, "layer", &layer);
       switch (layer) {
 	case 3:
 	  avimux->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL3;
 	  break;
-	case 1: case 2:
+	case 1:
+	case 2:
 	  avimux->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL12;
 	  break;
       }
@@ -449,31 +440,24 @@ gst_avimux_audsinkconnect (GstPad *pad, const GstCaps *vscaps)
     }
   }
 
-  avimux->auds_hdr.rate = avimux->auds.blockalign * avimux->auds.rate; 
+  avimux->auds_hdr.rate = avimux->auds.blockalign * avimux->auds.rate;
   avimux->auds_hdr.samplesize = avimux->auds.blockalign;
   avimux->auds_hdr.scale = avimux->auds.blockalign;
   return GST_PAD_LINK_OK;
 }
 
 static void
-gst_avimux_pad_link (GstPad   *pad,
-                     GstPad   *peer,
-                     gpointer  data)
+gst_avimux_pad_link (GstPad * pad, GstPad * peer, gpointer data)
 {
-  GstAviMux *avimux = GST_AVIMUX(data);
+  GstAviMux *avimux = GST_AVIMUX (data);
   const gchar *padname = gst_pad_get_name (pad);
 
-  if (pad == avimux->audiosinkpad)
-  {
+  if (pad == avimux->audiosinkpad) {
     avimux->audio_pad_connected = TRUE;
-  }
-  else if (pad == avimux->videosinkpad)
-  {
+  } else if (pad == avimux->videosinkpad) {
     avimux->video_pad_connected = TRUE;
-  }
-  else
-  {
-    g_warning("Unknown padname '%s'", padname);
+  } else {
+    g_warning ("Unknown padname '%s'", padname);
     return;
   }
 
@@ -481,36 +465,28 @@ gst_avimux_pad_link (GstPad   *pad,
 }
 
 static void
-gst_avimux_pad_unlink (GstPad   *pad,
-                       GstPad   *peer,
-                       gpointer  data)
+gst_avimux_pad_unlink (GstPad * pad, GstPad * peer, gpointer data)
 {
-  GstAviMux *avimux = GST_AVIMUX(data);
+  GstAviMux *avimux = GST_AVIMUX (data);
   const gchar *padname = gst_pad_get_name (pad);
 
-  if (pad == avimux->audiosinkpad)
-  {
+  if (pad == avimux->audiosinkpad) {
     avimux->audio_pad_connected = FALSE;
     avimux->audiosinkpad = NULL;
-  }
-  else if (pad == avimux->videosinkpad)
-  {
+  } else if (pad == avimux->videosinkpad) {
     avimux->video_pad_connected = FALSE;
     avimux->videosinkpad = NULL;
-  }
-  else
-  {
-    g_warning("Unknown padname '%s'", padname);
+  } else {
+    g_warning ("Unknown padname '%s'", padname);
     return;
   }
 
   GST_DEBUG ("pad '%s' unlinked", padname);
 }
 
-static GstPad*
-gst_avimux_request_new_pad (GstElement     *element,
-			    GstPadTemplate *templ,
-			    const gchar    *req_name)
+static GstPad *
+gst_avimux_request_new_pad (GstElement * element,
+    GstPadTemplate * templ, const gchar * req_name)
 {
   GstAviMux *avimux;
   GstPad *newpad;
@@ -528,29 +504,27 @@ gst_avimux_request_new_pad (GstElement     *element,
   avimux = GST_AVIMUX (element);
 
   if (templ == gst_element_class_get_pad_template (klass, "audio_%d")) {
-    g_return_val_if_fail(avimux->audiosinkpad == NULL, NULL);
+    g_return_val_if_fail (avimux->audiosinkpad == NULL, NULL);
     newpad = gst_pad_new_from_template (templ, "audio_00");
     gst_pad_set_link_function (newpad, gst_avimux_audsinkconnect);
     avimux->audiosinkpad = newpad;
-  }
-  else if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {
-    g_return_val_if_fail(avimux->videosinkpad == NULL, NULL);
+  } else if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {
+    g_return_val_if_fail (avimux->videosinkpad == NULL, NULL);
     newpad = gst_pad_new_from_template (templ, "video_00");
     gst_pad_set_link_function (newpad, gst_avimux_vidsinkconnect);
     avimux->videosinkpad = newpad;
-  }
-  else {
+  } else {
     g_warning ("avimux: this is not our template!\n");
     return NULL;
   }
 
-  g_signal_connect(newpad, "linked",
-    G_CALLBACK(gst_avimux_pad_link), (gpointer)avimux);
-  g_signal_connect(newpad, "unlinked",
-    G_CALLBACK(gst_avimux_pad_unlink), (gpointer)avimux);
+  g_signal_connect (newpad, "linked",
+      G_CALLBACK (gst_avimux_pad_link), (gpointer) avimux);
+  g_signal_connect (newpad, "unlinked",
+      G_CALLBACK (gst_avimux_pad_unlink), (gpointer) avimux);
   gst_element_add_pad (element, newpad);
-  gst_pad_set_event_mask_function(newpad, gst_avimux_get_event_masks);
-  
+  gst_pad_set_event_mask_function (newpad, gst_avimux_get_event_masks);
+
   return newpad;
 }
 
@@ -559,215 +533,301 @@ gst_avimux_request_new_pad (GstElement     *element,
 /* DISCLAIMER: this function is ugly. So be it (i.e. it makes the rest easier) */
 
 static GstBuffer *
-gst_avimux_riff_get_avi_header (GstAviMux *avimux)
+gst_avimux_riff_get_avi_header (GstAviMux * avimux)
 {
   GstBuffer *buffer;
   guint8 *buffdata;
   guint16 temp16;
   guint32 temp32;
 
-  buffer = gst_buffer_new();
+  buffer = gst_buffer_new ();
 
   /* first, let's see what actually needs to be in the buffer */
-  GST_BUFFER_SIZE(buffer) = 0;
-  GST_BUFFER_SIZE(buffer) += 32 + sizeof(gst_riff_avih); /* avi header */
-  if (avimux->video_pad_connected)
-  { /* we have video */
-    GST_BUFFER_SIZE(buffer) += 28 + sizeof(gst_riff_strh) + sizeof(gst_riff_strf_vids); /* vid hdr */
-    GST_BUFFER_SIZE(buffer) += 24; /* odml header */
+  GST_BUFFER_SIZE (buffer) = 0;
+  GST_BUFFER_SIZE (buffer) += 32 + sizeof (gst_riff_avih);	/* avi header */
+  if (avimux->video_pad_connected) {	/* we have video */
+    GST_BUFFER_SIZE (buffer) += 28 + sizeof (gst_riff_strh) + sizeof (gst_riff_strf_vids);	/* vid hdr */
+    GST_BUFFER_SIZE (buffer) += 24;	/* odml header */
   }
-  if (avimux->audio_pad_connected)
-  { /* we have audio */
-    GST_BUFFER_SIZE(buffer) += 28 + sizeof(gst_riff_strh) + sizeof(gst_riff_strf_auds); /* aud hdr */
+  if (avimux->audio_pad_connected) {	/* we have audio */
+    GST_BUFFER_SIZE (buffer) += 28 + sizeof (gst_riff_strh) + sizeof (gst_riff_strf_auds);	/* aud hdr */
   }
   /* this is the "riff size" */
-  avimux->header_size = GST_BUFFER_SIZE(buffer);
-  GST_BUFFER_SIZE(buffer) += 12; /* avi data header */
+  avimux->header_size = GST_BUFFER_SIZE (buffer);
+  GST_BUFFER_SIZE (buffer) += 12;	/* avi data header */
 
   /* allocate the buffer */
-  buffdata = GST_BUFFER_DATA(buffer) = g_malloc(GST_BUFFER_SIZE(buffer));
+  buffdata = GST_BUFFER_DATA (buffer) = g_malloc (GST_BUFFER_SIZE (buffer));
 
   /* avi header metadata */
-  memcpy(buffdata, "RIFF", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->header_size + avimux->idx_size + avimux->data_size);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  memcpy(buffdata, "AVI ", 4); buffdata += 4;
-  memcpy(buffdata, "LIST", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->header_size - 4*5);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  memcpy(buffdata, "hdrl", 4); buffdata += 4;
-  memcpy(buffdata, "avih", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(sizeof(gst_riff_avih));
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
+  memcpy (buffdata, "RIFF", 4);
+  buffdata += 4;
+  temp32 =
+      LE_FROM_GUINT32 (avimux->header_size + avimux->idx_size +
+      avimux->data_size);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  memcpy (buffdata, "AVI ", 4);
+  buffdata += 4;
+  memcpy (buffdata, "LIST", 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->header_size - 4 * 5);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  memcpy (buffdata, "hdrl", 4);
+  buffdata += 4;
+  memcpy (buffdata, "avih", 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (sizeof (gst_riff_avih));
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
   /* the AVI header itself */
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.us_frame);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.max_bps);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.pad_gran);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.flags);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.tot_frames);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.init_frames);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.streams);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.bufsize);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.width);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.height);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.scale);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.rate);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.start);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->avi_hdr.length);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-
-  if (avimux->video_pad_connected)
-  {
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.us_frame);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.max_bps);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.pad_gran);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.flags);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.tot_frames);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.init_frames);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.streams);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.bufsize);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.width);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.height);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.scale);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.rate);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.start);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->avi_hdr.length);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+
+  if (avimux->video_pad_connected) {
     /* video header metadata */
-    memcpy(buffdata, "LIST", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh) + sizeof(gst_riff_strf_vids) + 4*5);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    memcpy(buffdata, "strl", 4); buffdata += 4;
+    memcpy (buffdata, "LIST", 4);
+    buffdata += 4;
+    temp32 =
+	LE_FROM_GUINT32 (sizeof (gst_riff_strh) + sizeof (gst_riff_strf_vids) +
+	4 * 5);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    memcpy (buffdata, "strl", 4);
+    buffdata += 4;
     /* generic header */
-    memcpy(buffdata, "strh", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh));
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    memcpy (buffdata, "strh", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (gst_riff_strh));
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the actual header */
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.type);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.fcc_handler);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.flags);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.priority);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.init_frames);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.scale);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.rate);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.start);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.length);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.bufsize);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.quality);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids_hdr.samplesize);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.type);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.fcc_handler);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.flags);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.priority);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.init_frames);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.scale);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.rate);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.start);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.length);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.bufsize);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.quality);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids_hdr.samplesize);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the video header */
-    memcpy(buffdata, "strf", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strf_vids));
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    memcpy (buffdata, "strf", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (gst_riff_strf_vids));
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the actual header */
-    temp32 = LE_FROM_GUINT32(avimux->vids.size);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.width);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.height);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp16 = LE_FROM_GUINT16(avimux->vids.planes);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
-    temp16 = LE_FROM_GUINT16(avimux->vids.bit_cnt);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
-    temp32 = LE_FROM_GUINT32(avimux->vids.compression);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.image_size);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.xpels_meter);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.ypels_meter);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.num_colors);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->vids.imp_colors);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.size);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.width);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.height);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp16 = LE_FROM_GUINT16 (avimux->vids.planes);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
+    temp16 = LE_FROM_GUINT16 (avimux->vids.bit_cnt);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.compression);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.image_size);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.xpels_meter);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.ypels_meter);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.num_colors);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->vids.imp_colors);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
   }
 
-  if (avimux->audio_pad_connected)
-  {
+  if (avimux->audio_pad_connected) {
     /* audio header */
-    memcpy(buffdata, "LIST", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh) + sizeof(gst_riff_strf_auds) + 4*5);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    memcpy(buffdata, "strl", 4); buffdata += 4;
+    memcpy (buffdata, "LIST", 4);
+    buffdata += 4;
+    temp32 =
+	LE_FROM_GUINT32 (sizeof (gst_riff_strh) + sizeof (gst_riff_strf_auds) +
+	4 * 5);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    memcpy (buffdata, "strl", 4);
+    buffdata += 4;
     /* generic header */
-    memcpy(buffdata, "strh", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh));
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    memcpy (buffdata, "strh", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (gst_riff_strh));
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the actual header */
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.type);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.fcc_handler);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.flags);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.priority);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.init_frames);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.scale);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.rate);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.start);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.length);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.bufsize);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.quality);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds_hdr.samplesize);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.type);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.fcc_handler);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.flags);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.priority);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.init_frames);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.scale);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.rate);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.start);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.length);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.bufsize);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.quality);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds_hdr.samplesize);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the audio header */
-    memcpy(buffdata, "strf", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strf_auds));
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    memcpy (buffdata, "strf", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (gst_riff_strf_auds));
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
     /* the actual header */
-    temp16 = LE_FROM_GUINT16(avimux->auds.format);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
-    temp16 = LE_FROM_GUINT16(avimux->auds.channels);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
-    temp32 = LE_FROM_GUINT32(avimux->auds.rate);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->auds.av_bps);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp16 = LE_FROM_GUINT16(avimux->auds.blockalign);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
-    temp16 = LE_FROM_GUINT16(avimux->auds.size);
-    memcpy(buffdata, &temp16, 2); buffdata += 2;
+    temp16 = LE_FROM_GUINT16 (avimux->auds.format);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
+    temp16 = LE_FROM_GUINT16 (avimux->auds.channels);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
+    temp32 = LE_FROM_GUINT32 (avimux->auds.rate);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->auds.av_bps);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp16 = LE_FROM_GUINT16 (avimux->auds.blockalign);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
+    temp16 = LE_FROM_GUINT16 (avimux->auds.size);
+    memcpy (buffdata, &temp16, 2);
+    buffdata += 2;
   }
 
-  if (avimux->video_pad_connected)
-  {
+  if (avimux->video_pad_connected) {
     /* odml header */
-    memcpy(buffdata, "LIST", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(guint32)+4*3);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    memcpy(buffdata, "odml", 4); buffdata += 4;
-    memcpy(buffdata, "dmlh", 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(sizeof(guint32));
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
-    temp32 = LE_FROM_GUINT32(avimux->total_frames);
-    memcpy(buffdata, &temp32, 4); buffdata += 4;
+    memcpy (buffdata, "LIST", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (guint32) + 4 * 3);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    memcpy (buffdata, "odml", 4);
+    buffdata += 4;
+    memcpy (buffdata, "dmlh", 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (sizeof (guint32));
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
+    temp32 = LE_FROM_GUINT32 (avimux->total_frames);
+    memcpy (buffdata, &temp32, 4);
+    buffdata += 4;
   }
 
   /* avi data header */
-  memcpy(buffdata, "LIST", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(avimux->data_size);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  memcpy(buffdata, "movi", 4);
+  memcpy (buffdata, "LIST", 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (avimux->data_size);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  memcpy (buffdata, "movi", 4);
 
   return buffer;
 }
@@ -779,18 +839,23 @@ gst_avimux_riff_get_avix_header (guint32 datax_size)
   guint8 *buffdata;
   guint32 temp32;
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_SIZE(buffer) = 24;
-  buffdata = GST_BUFFER_DATA(buffer) = g_malloc(GST_BUFFER_SIZE(buffer));
-
-  memcpy(buffdata, "LIST", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(datax_size+4*4);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  memcpy(buffdata, "AVIX", 4); buffdata += 4;
-  memcpy(buffdata, "LIST", 4); buffdata += 4;
-  temp32 = LE_FROM_GUINT32(datax_size);
-  memcpy(buffdata, &temp32, 4); buffdata += 4;
-  memcpy(buffdata, "movi", 4);
+  buffer = gst_buffer_new ();
+  GST_BUFFER_SIZE (buffer) = 24;
+  buffdata = GST_BUFFER_DATA (buffer) = g_malloc (GST_BUFFER_SIZE (buffer));
+
+  memcpy (buffdata, "LIST", 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (datax_size + 4 * 4);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  memcpy (buffdata, "AVIX", 4);
+  buffdata += 4;
+  memcpy (buffdata, "LIST", 4);
+  buffdata += 4;
+  temp32 = LE_FROM_GUINT32 (datax_size);
+  memcpy (buffdata, &temp32, 4);
+  buffdata += 4;
+  memcpy (buffdata, "movi", 4);
 
   return buffer;
 }
@@ -801,12 +866,12 @@ gst_avimux_riff_get_video_header (guint32 video_frame_size)
   GstBuffer *buffer;
   guint32 temp32;
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_DATA(buffer) = g_malloc(8);
-  GST_BUFFER_SIZE(buffer) = 8;
-  memcpy(GST_BUFFER_DATA(buffer), "00db", 4);
-  temp32 = LE_FROM_GUINT32(video_frame_size);
-  memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
+  buffer = gst_buffer_new ();
+  GST_BUFFER_DATA (buffer) = g_malloc (8);
+  GST_BUFFER_SIZE (buffer) = 8;
+  memcpy (GST_BUFFER_DATA (buffer), "00db", 4);
+  temp32 = LE_FROM_GUINT32 (video_frame_size);
+  memcpy (GST_BUFFER_DATA (buffer) + 4, &temp32, 4);
 
   return buffer;
 }
@@ -817,12 +882,12 @@ gst_avimux_riff_get_audio_header (guint32 audio_sample_size)
   GstBuffer *buffer;
   guint32 temp32;
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_DATA(buffer) = g_malloc(8);
-  GST_BUFFER_SIZE(buffer) = 8;
-  memcpy(GST_BUFFER_DATA(buffer), "01wb", 4);
-  temp32 = LE_FROM_GUINT32(audio_sample_size);
-  memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
+  buffer = gst_buffer_new ();
+  GST_BUFFER_DATA (buffer) = g_malloc (8);
+  GST_BUFFER_SIZE (buffer) = 8;
+  memcpy (GST_BUFFER_DATA (buffer), "01wb", 4);
+  temp32 = LE_FROM_GUINT32 (audio_sample_size);
+  memcpy (GST_BUFFER_DATA (buffer) + 4, &temp32, 4);
 
   return buffer;
 }
@@ -830,73 +895,70 @@ gst_avimux_riff_get_audio_header (guint32 audio_sample_size)
 /* some other usable functions (thankyou xawtv ;-) ) */
 
 static void
-gst_avimux_add_index (GstAviMux *avimux, guchar *code, guint32 flags, guint32 size)
+gst_avimux_add_index (GstAviMux * avimux, guchar * code, guint32 flags,
+    guint32 size)
 {
-  if (avimux->idx_index == avimux->idx_count)
-  {
+  if (avimux->idx_index == avimux->idx_count) {
     avimux->idx_count += 256;
-    avimux->idx = realloc(avimux->idx, avimux->idx_count*sizeof(gst_riff_index_entry));
+    avimux->idx =
+	realloc (avimux->idx,
+	avimux->idx_count * sizeof (gst_riff_index_entry));
   }
-  memcpy(&(avimux->idx[avimux->idx_index].id), code, 4);
-  avimux->idx[avimux->idx_index].flags = LE_FROM_GUINT32(flags);
-  avimux->idx[avimux->idx_index].offset = LE_FROM_GUINT32(avimux->idx_offset);
-  avimux->idx[avimux->idx_index].size = LE_FROM_GUINT32(size);
+  memcpy (&(avimux->idx[avimux->idx_index].id), code, 4);
+  avimux->idx[avimux->idx_index].flags = LE_FROM_GUINT32 (flags);
+  avimux->idx[avimux->idx_index].offset = LE_FROM_GUINT32 (avimux->idx_offset);
+  avimux->idx[avimux->idx_index].size = LE_FROM_GUINT32 (size);
   avimux->idx_index++;
 }
 
 static void
-gst_avimux_write_index (GstAviMux *avimux)
+gst_avimux_write_index (GstAviMux * avimux)
 {
   GstBuffer *buffer;
   guint32 temp32;
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_SIZE(buffer) = 8;
-  GST_BUFFER_DATA(buffer) = g_malloc(8);
-  memcpy(GST_BUFFER_DATA(buffer), "idx1", 4);
-  temp32 = LE_FROM_GUINT32(avimux->idx_index * sizeof(gst_riff_index_entry)); 
-  memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
-  gst_pad_push(avimux->srcpad, GST_DATA (buffer));
+  buffer = gst_buffer_new ();
+  GST_BUFFER_SIZE (buffer) = 8;
+  GST_BUFFER_DATA (buffer) = g_malloc (8);
+  memcpy (GST_BUFFER_DATA (buffer), "idx1", 4);
+  temp32 = LE_FROM_GUINT32 (avimux->idx_index * sizeof (gst_riff_index_entry));
+  memcpy (GST_BUFFER_DATA (buffer) + 4, &temp32, 4);
+  gst_pad_push (avimux->srcpad, GST_DATA (buffer));
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_SIZE(buffer) = avimux->idx_index * sizeof(gst_riff_index_entry);
-  GST_BUFFER_DATA(buffer) = (unsigned char*) avimux->idx;
-  avimux->idx = NULL; /* will be free()'ed by gst_buffer_unref() */
-  avimux->total_data += GST_BUFFER_SIZE(buffer);
-  gst_pad_push(avimux->srcpad, GST_DATA (buffer));
+  buffer = gst_buffer_new ();
+  GST_BUFFER_SIZE (buffer) = avimux->idx_index * sizeof (gst_riff_index_entry);
+  GST_BUFFER_DATA (buffer) = (unsigned char *) avimux->idx;
+  avimux->idx = NULL;		/* will be free()'ed by gst_buffer_unref() */
+  avimux->total_data += GST_BUFFER_SIZE (buffer);
+  gst_pad_push (avimux->srcpad, GST_DATA (buffer));
 
-  avimux->idx_size += avimux->idx_index * sizeof(gst_riff_index_entry) + 8;
+  avimux->idx_size += avimux->idx_index * sizeof (gst_riff_index_entry) + 8;
 
   /* update header */
   avimux->avi_hdr.flags |= GST_RIFF_AVIH_HASINDEX;
 }
 
 static void
-gst_avimux_bigfile(GstAviMux *avimux, gboolean last)
+gst_avimux_bigfile (GstAviMux * avimux, gboolean last)
 {
   GstBuffer *header;
   GstEvent *event;
-    
-  if (avimux->is_bigfile)
-  {
+
+  if (avimux->is_bigfile) {
     /* sarch back */
-    event = gst_event_new_seek (GST_FORMAT_BYTES | 
-		    	        GST_SEEK_METHOD_SET | 
-				GST_SEEK_FLAG_FLUSH, 
-				avimux->avix_start);
+    event = gst_event_new_seek (GST_FORMAT_BYTES |
+	GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, avimux->avix_start);
     /* if the event succeeds */
-    gst_pad_push(avimux->srcpad, GST_DATA(event));
+    gst_pad_push (avimux->srcpad, GST_DATA (event));
 
     /* rewrite AVIX header */
-    header = gst_avimux_riff_get_avix_header(avimux->datax_size);
-    gst_pad_push(avimux->srcpad, GST_DATA (header));
+    header = gst_avimux_riff_get_avix_header (avimux->datax_size);
+    gst_pad_push (avimux->srcpad, GST_DATA (header));
 
     /* go back to current location */
-    event = gst_event_new_seek (GST_FORMAT_BYTES | 
-				GST_SEEK_METHOD_SET |
-				GST_SEEK_FLAG_FLUSH, 
-				avimux->total_data);
-    gst_pad_push(avimux->srcpad, GST_DATA(event));
+    event = gst_event_new_seek (GST_FORMAT_BYTES |
+	GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, avimux->total_data);
+    gst_pad_push (avimux->srcpad, GST_DATA (event));
   }
   avimux->avix_start = avimux->total_data;
 
@@ -907,21 +969,21 @@ gst_avimux_bigfile(GstAviMux *avimux, gboolean last)
   avimux->numx_frames = 0;
   avimux->datax_size = 0;
 
-  header = gst_avimux_riff_get_avix_header(0);
-  avimux->total_data += GST_BUFFER_SIZE(header);
-  gst_pad_push(avimux->srcpad, GST_DATA (header));
+  header = gst_avimux_riff_get_avix_header (0);
+  avimux->total_data += GST_BUFFER_SIZE (header);
+  gst_pad_push (avimux->srcpad, GST_DATA (header));
 }
 
 /* enough header blabla now, let's go on to actually writing the headers */
 
 static void
-gst_avimux_start_file (GstAviMux *avimux)
+gst_avimux_start_file (GstAviMux * avimux)
 {
   GstBuffer *header;
 
   avimux->total_data = 0;
   avimux->total_frames = 0;
-  avimux->data_size = 4; /* ? */
+  avimux->data_size = 4;	/* ? */
   avimux->datax_size = 0;
   avimux->num_frames = 0;
   avimux->numx_frames = 0;
@@ -930,41 +992,39 @@ gst_avimux_start_file (GstAviMux *avimux)
   avimux->avix_start = 0;
 
   avimux->idx_index = 0;
-  avimux->idx_offset = 0; /* see 10 lines below */
+  avimux->idx_offset = 0;	/* see 10 lines below */
   avimux->idx_size = 0;
   avimux->idx_count = 0;
   avimux->idx = NULL;
 
   /* header */
-  avimux->avi_hdr.streams = (avimux->video_pad_connected?1:0) + (avimux->audio_pad_connected?1:0);
+  avimux->avi_hdr.streams =
+      (avimux->video_pad_connected ? 1 : 0) +
+      (avimux->audio_pad_connected ? 1 : 0);
   avimux->is_bigfile = FALSE;
 
-  header = gst_avimux_riff_get_avi_header(avimux);
-  avimux->total_data += GST_BUFFER_SIZE(header);
+  header = gst_avimux_riff_get_avi_header (avimux);
+  avimux->total_data += GST_BUFFER_SIZE (header);
   avimux->idx_offset = avimux->total_data;
-  gst_pad_push(avimux->srcpad, GST_DATA (header));
+  gst_pad_push (avimux->srcpad, GST_DATA (header));
 
   avimux->write_header = FALSE;
   avimux->restart = FALSE;
 }
 
 static void
-gst_avimux_stop_file (GstAviMux *avimux)
+gst_avimux_stop_file (GstAviMux * avimux)
 {
   GstEvent *event;
   GstBuffer *header;
 
   /* if bigfile, rewrite header, else write indexes */
-  if (avimux->video_pad_connected)
-  {
-    if (avimux->is_bigfile)
-    {
-      gst_avimux_bigfile(avimux, TRUE);
+  if (avimux->video_pad_connected) {
+    if (avimux->is_bigfile) {
+      gst_avimux_bigfile (avimux, TRUE);
       avimux->idx_size = 0;
-    }
-    else
-    {
-      gst_avimux_write_index(avimux);
+    } else {
+      gst_avimux_write_index (avimux);
     }
   }
 
@@ -974,7 +1034,8 @@ gst_avimux_stop_file (GstAviMux *avimux)
     avimux->vids_hdr.length = avimux->num_frames;
   }
   if (avimux->audio_pad_connected) {
-    avimux->auds_hdr.length = (avimux->audio_time * avimux->auds.rate)/GST_SECOND;
+    avimux->auds_hdr.length =
+	(avimux->audio_time * avimux->auds.rate) / GST_SECOND;
   }
 
   /* set rate and everything having to do with that */
@@ -983,68 +1044,68 @@ gst_avimux_stop_file (GstAviMux *avimux)
     /* calculate bps if needed */
     if (!avimux->auds.av_bps) {
       if (avimux->audio_time) {
-        avimux->auds_hdr.rate = (GST_SECOND * avimux->audio_size) / avimux->audio_time;
+	avimux->auds_hdr.rate =
+	    (GST_SECOND * avimux->audio_size) / avimux->audio_time;
       } else {
-        GST_ELEMENT_ERROR (avimux, STREAM, MUX,
-                           (_("No or invalid input audio, AVI stream will be corrupt.")), (NULL));
-        avimux->auds_hdr.rate = 0;
+	GST_ELEMENT_ERROR (avimux, STREAM, MUX,
+	    (_("No or invalid input audio, AVI stream will be corrupt.")),
+	    (NULL));
+	avimux->auds_hdr.rate = 0;
       }
       avimux->auds.av_bps = avimux->auds_hdr.rate * avimux->auds_hdr.scale;
     }
     avimux->avi_hdr.max_bps += avimux->auds.av_bps;
   }
   if (avimux->video_pad_connected) {
-    avimux->avi_hdr.max_bps += ((avimux->vids.bit_cnt+7)/8) *
-				(1000000. / avimux->avi_hdr.us_frame) *
-				avimux->vids.image_size;
+    avimux->avi_hdr.max_bps += ((avimux->vids.bit_cnt + 7) / 8) *
+	(1000000. / avimux->avi_hdr.us_frame) * avimux->vids.image_size;
   }
 
   /* seek and rewrite the header */
-  header = gst_avimux_riff_get_avi_header(avimux);
-  event = gst_event_new_seek (GST_FORMAT_BYTES | 
-			      GST_SEEK_METHOD_SET, 0);
-  gst_pad_push(avimux->srcpad, GST_DATA(event));
-  gst_pad_push(avimux->srcpad, GST_DATA (header));
+  header = gst_avimux_riff_get_avi_header (avimux);
+  event = gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_SET, 0);
+  gst_pad_push (avimux->srcpad, GST_DATA (event));
+  gst_pad_push (avimux->srcpad, GST_DATA (header));
   event = gst_event_new_seek (GST_FORMAT_BYTES |
-			      GST_SEEK_METHOD_SET, avimux->total_data);
-  gst_pad_push(avimux->srcpad, GST_DATA(event));
+      GST_SEEK_METHOD_SET, avimux->total_data);
+  gst_pad_push (avimux->srcpad, GST_DATA (event));
 
   avimux->write_header = TRUE;
 }
 
 static void
-gst_avimux_restart_file (GstAviMux *avimux)
+gst_avimux_restart_file (GstAviMux * avimux)
 {
   GstEvent *event;
 
-  gst_avimux_stop_file(avimux);
+  gst_avimux_stop_file (avimux);
 
-  event = gst_event_new(GST_EVENT_EOS);
-  gst_pad_push(avimux->srcpad, GST_DATA(event));
+  event = gst_event_new (GST_EVENT_EOS);
+  gst_pad_push (avimux->srcpad, GST_DATA (event));
 
-  gst_avimux_start_file(avimux);
+  gst_avimux_start_file (avimux);
 }
 
 /* handle events (search) */
 static gboolean
-gst_avimux_handle_event (GstPad *pad, GstEvent *event)
+gst_avimux_handle_event (GstPad * pad, GstEvent * event)
 {
   GstAviMux *avimux;
   GstEventType type;
 
   avimux = GST_AVIMUX (gst_pad_get_parent (pad));
-  
+
   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
 
   switch (type) {
     case GST_EVENT_EOS:
       /* is this allright? */
       if (pad == avimux->videosinkpad) {
-        avimux->video_pad_eos = TRUE;
+	avimux->video_pad_eos = TRUE;
       } else if (pad == avimux->audiosinkpad) {
-        avimux->audio_pad_eos = TRUE;
+	avimux->audio_pad_eos = TRUE;
       } else {
-        g_warning("Unknown pad for EOS!");
+	g_warning ("Unknown pad for EOS!");
       }
       break;
     default:
@@ -1057,19 +1118,17 @@ gst_avimux_handle_event (GstPad *pad, GstEvent *event)
 
 /* fill the internal queue for each available pad */
 static void
-gst_avimux_fill_queue (GstAviMux *avimux)
+gst_avimux_fill_queue (GstAviMux * avimux)
 {
   GstBuffer *buffer;
 
   while (!avimux->audio_buffer_queue &&
-          avimux->audiosinkpad &&
-          avimux->audio_pad_connected &&
-          GST_PAD_IS_USABLE(avimux->audiosinkpad) &&
-         !avimux->audio_pad_eos)
-  {
-    buffer = GST_BUFFER (gst_pad_pull(avimux->audiosinkpad));
-    if (GST_IS_EVENT(buffer)) {
-      gst_avimux_handle_event(avimux->audiosinkpad, GST_EVENT(buffer));
+      avimux->audiosinkpad &&
+      avimux->audio_pad_connected &&
+      GST_PAD_IS_USABLE (avimux->audiosinkpad) && !avimux->audio_pad_eos) {
+    buffer = GST_BUFFER (gst_pad_pull (avimux->audiosinkpad));
+    if (GST_IS_EVENT (buffer)) {
+      gst_avimux_handle_event (avimux->audiosinkpad, GST_EVENT (buffer));
     } else {
       avimux->audio_buffer_queue = buffer;
       break;
@@ -1077,14 +1136,12 @@ gst_avimux_fill_queue (GstAviMux *avimux)
   }
 
   while (!avimux->video_buffer_queue &&
-          avimux->videosinkpad &&
-          avimux->video_pad_connected &&
-          GST_PAD_IS_USABLE(avimux->videosinkpad) &&
-         !avimux->video_pad_eos)
-  {
-    buffer = GST_BUFFER (gst_pad_pull(avimux->videosinkpad));
-    if (GST_IS_EVENT(buffer)) {
-      gst_avimux_handle_event(avimux->videosinkpad, GST_EVENT(buffer));
+      avimux->videosinkpad &&
+      avimux->video_pad_connected &&
+      GST_PAD_IS_USABLE (avimux->videosinkpad) && !avimux->video_pad_eos) {
+    buffer = GST_BUFFER (gst_pad_pull (avimux->videosinkpad));
+    if (GST_IS_EVENT (buffer)) {
+      gst_avimux_handle_event (avimux->videosinkpad, GST_EVENT (buffer));
     } else {
       avimux->video_buffer_queue = buffer;
       break;
@@ -1095,49 +1152,45 @@ gst_avimux_fill_queue (GstAviMux *avimux)
 
 /* send extra 'padding' data */
 static void
-gst_avimux_send_pad_data (GstAviMux *avimux,
-                          gulong     num_bytes)
+gst_avimux_send_pad_data (GstAviMux * avimux, gulong num_bytes)
 {
   GstBuffer *buffer;
 
-  buffer = gst_buffer_new();
-  GST_BUFFER_SIZE(buffer) = num_bytes;
-  GST_BUFFER_DATA(buffer) = g_malloc(num_bytes);
-  memset(GST_BUFFER_DATA(buffer), 0, num_bytes);
+  buffer = gst_buffer_new ();
+  GST_BUFFER_SIZE (buffer) = num_bytes;
+  GST_BUFFER_DATA (buffer) = g_malloc (num_bytes);
+  memset (GST_BUFFER_DATA (buffer), 0, num_bytes);
 
-  gst_pad_push(avimux->srcpad, GST_DATA (buffer));
+  gst_pad_push (avimux->srcpad, GST_DATA (buffer));
 }
 
 /* do audio buffer */
 static void
-gst_avimux_do_audio_buffer (GstAviMux *avimux)
+gst_avimux_do_audio_buffer (GstAviMux * avimux)
 {
   GstBuffer *data = avimux->audio_buffer_queue, *header;
   gulong total_size, pad_bytes = 0;
 
   /* write a audio header + index entry */
-  if (GST_BUFFER_SIZE(data) & 1) {
-    pad_bytes = 2 - (GST_BUFFER_SIZE(data) & 1);
+  if (GST_BUFFER_SIZE (data) & 1) {
+    pad_bytes = 2 - (GST_BUFFER_SIZE (data) & 1);
   }
-  header = gst_avimux_riff_get_audio_header(GST_BUFFER_SIZE(data));
-  total_size = GST_BUFFER_SIZE(header) + GST_BUFFER_SIZE(data) + pad_bytes;
+  header = gst_avimux_riff_get_audio_header (GST_BUFFER_SIZE (data));
+  total_size = GST_BUFFER_SIZE (header) + GST_BUFFER_SIZE (data) + pad_bytes;
 
-  if (avimux->is_bigfile)
-  {
+  if (avimux->is_bigfile) {
     avimux->datax_size += total_size;
-  }
-  else
-  {
+  } else {
     avimux->data_size += total_size;
-    avimux->audio_size += GST_BUFFER_SIZE(data);
-    avimux->audio_time += GST_BUFFER_DURATION(data);
-    gst_avimux_add_index(avimux, "01wb", 0x0, GST_BUFFER_SIZE(data));
+    avimux->audio_size += GST_BUFFER_SIZE (data);
+    avimux->audio_time += GST_BUFFER_DURATION (data);
+    gst_avimux_add_index (avimux, "01wb", 0x0, GST_BUFFER_SIZE (data));
   }
 
-  gst_pad_push(avimux->srcpad, GST_DATA (header));
-  gst_pad_push(avimux->srcpad, GST_DATA (data));
+  gst_pad_push (avimux->srcpad, GST_DATA (header));
+  gst_pad_push (avimux->srcpad, GST_DATA (data));
   if (pad_bytes) {
-    gst_avimux_send_pad_data(avimux, pad_bytes);
+    gst_avimux_send_pad_data (avimux, pad_bytes);
   }
   avimux->total_data += total_size;
   avimux->idx_offset += total_size;
@@ -1148,49 +1201,47 @@ gst_avimux_do_audio_buffer (GstAviMux *avimux)
 
 /* do video buffer */
 static void
-gst_avimux_do_video_buffer (GstAviMux *avimux)
+gst_avimux_do_video_buffer (GstAviMux * avimux)
 {
   GstBuffer *data = avimux->video_buffer_queue, *header;
   gulong total_size, pad_bytes = 0;
 
   if (avimux->restart)
-    gst_avimux_restart_file(avimux);
+    gst_avimux_restart_file (avimux);
 
   /* write a video header + index entry */
-  if ((avimux->is_bigfile?avimux->datax_size:avimux->data_size)+GST_BUFFER_SIZE(data)>1024*1024*2000)
-  {
+  if ((avimux->is_bigfile ? avimux->datax_size : avimux->data_size) +
+      GST_BUFFER_SIZE (data) > 1024 * 1024 * 2000) {
     if (avimux->enable_large_avi)
-      gst_avimux_bigfile(avimux, FALSE);
+      gst_avimux_bigfile (avimux, FALSE);
     else
-      gst_avimux_restart_file(avimux);
+      gst_avimux_restart_file (avimux);
   }
 
-  if (GST_BUFFER_SIZE(data) & 1) {
-    pad_bytes = 2 - (GST_BUFFER_SIZE(data) & 1);
+  if (GST_BUFFER_SIZE (data) & 1) {
+    pad_bytes = 2 - (GST_BUFFER_SIZE (data) & 1);
   }
-  header = gst_avimux_riff_get_video_header(GST_BUFFER_SIZE(data));
-  total_size = GST_BUFFER_SIZE(header) + GST_BUFFER_SIZE(data) + pad_bytes;
+  header = gst_avimux_riff_get_video_header (GST_BUFFER_SIZE (data));
+  total_size = GST_BUFFER_SIZE (header) + GST_BUFFER_SIZE (data) + pad_bytes;
   avimux->total_frames++;
 
-  if (avimux->is_bigfile)
-  {
+  if (avimux->is_bigfile) {
     avimux->datax_size += total_size;
     avimux->numx_frames++;
-  }
-  else
-  {
+  } else {
     guint flags = 0x2;
+
     if (GST_BUFFER_FLAG_IS_SET (data, GST_BUFFER_KEY_UNIT))
       flags |= 0x10;
     avimux->data_size += total_size;
     avimux->num_frames++;
-    gst_avimux_add_index(avimux, "00db", flags, GST_BUFFER_SIZE(data));
+    gst_avimux_add_index (avimux, "00db", flags, GST_BUFFER_SIZE (data));
   }
 
-  gst_pad_push(avimux->srcpad, GST_DATA (header));
-  gst_pad_push(avimux->srcpad, GST_DATA (data));
+  gst_pad_push (avimux->srcpad, GST_DATA (header));
+  gst_pad_push (avimux->srcpad, GST_DATA (data));
   if (pad_bytes) {
-    gst_avimux_send_pad_data(avimux, pad_bytes);
+    gst_avimux_send_pad_data (avimux, pad_bytes);
   }
   avimux->total_data += total_size;
   avimux->idx_offset += total_size;
@@ -1201,31 +1252,24 @@ gst_avimux_do_video_buffer (GstAviMux *avimux)
 
 /* take the oldest buffer in our internal queue and push-it */
 static gboolean
-gst_avimux_do_one_buffer (GstAviMux *avimux)
+gst_avimux_do_one_buffer (GstAviMux * avimux)
 {
-  if (avimux->video_buffer_queue &&
-      avimux->audio_buffer_queue)
-  {
-    if (GST_BUFFER_TIMESTAMP(avimux->video_buffer_queue) <=
-        GST_BUFFER_TIMESTAMP(avimux->audio_buffer_queue))
-      gst_avimux_do_video_buffer(avimux);
+  if (avimux->video_buffer_queue && avimux->audio_buffer_queue) {
+    if (GST_BUFFER_TIMESTAMP (avimux->video_buffer_queue) <=
+	GST_BUFFER_TIMESTAMP (avimux->audio_buffer_queue))
+      gst_avimux_do_video_buffer (avimux);
     else
-      gst_avimux_do_audio_buffer(avimux);
-  }
-  else if (avimux->video_buffer_queue ||
-           avimux->audio_buffer_queue)
-  {
+      gst_avimux_do_audio_buffer (avimux);
+  } else if (avimux->video_buffer_queue || avimux->audio_buffer_queue) {
     if (avimux->video_buffer_queue)
-      gst_avimux_do_video_buffer(avimux);
+      gst_avimux_do_video_buffer (avimux);
     else
-      gst_avimux_do_audio_buffer(avimux);
-  }
-  else {
+      gst_avimux_do_audio_buffer (avimux);
+  } else {
     /* simply finish off the file and send EOS */
-    gst_avimux_stop_file(avimux);
-    gst_pad_push(avimux->srcpad,
-                 GST_DATA(gst_event_new(GST_EVENT_EOS)));
-    gst_element_set_eos(GST_ELEMENT(avimux));
+    gst_avimux_stop_file (avimux);
+    gst_pad_push (avimux->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
+    gst_element_set_eos (GST_ELEMENT (avimux));
     return FALSE;
   }
 
@@ -1234,38 +1278,35 @@ gst_avimux_do_one_buffer (GstAviMux *avimux)
 
 
 static void
-gst_avimux_loop (GstElement *element)
+gst_avimux_loop (GstElement * element)
 {
   GstAviMux *avimux;
 
-  avimux = GST_AVIMUX(element);
+  avimux = GST_AVIMUX (element);
 
   /* first fill queue (some elements only set caps when
    * flowing data), then write header */
-  gst_avimux_fill_queue(avimux);
-  
+  gst_avimux_fill_queue (avimux);
+
   if (avimux->write_header)
-    gst_avimux_start_file(avimux);
+    gst_avimux_start_file (avimux);
 
-  gst_avimux_do_one_buffer(avimux);
+  gst_avimux_do_one_buffer (avimux);
 }
 
 static void
-gst_avimux_get_property (GObject    *object,
-                         guint      prop_id,
-                         GValue     *value,
-                         GParamSpec *pspec)
+gst_avimux_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
 {
   GstAviMux *avimux;
 
   /* it's not null if we got it, but it might not be ours */
-  g_return_if_fail(GST_IS_AVIMUX(object));
-  avimux = GST_AVIMUX(object);
+  g_return_if_fail (GST_IS_AVIMUX (object));
+  avimux = GST_AVIMUX (object);
 
-  switch (prop_id)
-  {
+  switch (prop_id) {
     case ARG_BIGFILE:
-      g_value_set_boolean(value, avimux->enable_large_avi);
+      g_value_set_boolean (value, avimux->enable_large_avi);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -1274,21 +1315,18 @@ gst_avimux_get_property (GObject    *object,
 }
 
 static void
-gst_avimux_set_property (GObject      *object,
-                         guint         prop_id,
-                         const GValue *value,
-                         GParamSpec   *pspec)
+gst_avimux_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec)
 {
   GstAviMux *avimux;
 
   /* it's not null if we got it, but it might not be ours */
-  g_return_if_fail(GST_IS_AVIMUX(object));
-  avimux = GST_AVIMUX(object);
+  g_return_if_fail (GST_IS_AVIMUX (object));
+  avimux = GST_AVIMUX (object);
 
-  switch (prop_id)
-  {
+  switch (prop_id) {
     case ARG_BIGFILE:
-      avimux->enable_large_avi = g_value_get_boolean(value);
+      avimux->enable_large_avi = g_value_get_boolean (value);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -1297,14 +1335,14 @@ gst_avimux_set_property (GObject      *object,
 }
 
 static GstElementStateReturn
-gst_avimux_change_state (GstElement *element)
+gst_avimux_change_state (GstElement * element)
 {
   GstAviMux *avimux;
   gint transition = GST_STATE_TRANSITION (element);
 
-  g_return_val_if_fail(GST_IS_AVIMUX(element), GST_STATE_FAILURE);
-  
-  avimux = GST_AVIMUX(element);
+  g_return_val_if_fail (GST_IS_AVIMUX (element), GST_STATE_FAILURE);
+
+  avimux = GST_AVIMUX (element);
 
   switch (transition) {
     case GST_STATE_PAUSED_TO_PLAYING:
@@ -1317,4 +1355,3 @@ gst_avimux_change_state (GstElement *element)
 
   return GST_STATE_SUCCESS;
 }
-
diff --git a/gst/avi/gstavimux.h b/gst/avi/gstavimux.h
index 452b7221..e51f3010 100644
--- a/gst/avi/gstavimux.h
+++ b/gst/avi/gstavimux.h
@@ -28,8 +28,9 @@
 
 
 #ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+extern "C"
+{
+#endif				/* __cplusplus */
 
 
 #define GST_TYPE_AVIMUX \
@@ -44,65 +45,67 @@ extern "C" {
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AVIMUX))
 
 
-typedef struct _GstAviMux GstAviMux;
-typedef struct _GstAviMuxClass GstAviMuxClass;
-
-struct _GstAviMux {
-  GstElement element;
-
-  /* pads */
-  GstPad *srcpad;
-  GstPad *audiosinkpad;
-  gboolean audio_pad_connected, audio_pad_eos;
-  GstPad *videosinkpad;
-  gboolean video_pad_connected, video_pad_eos;
-
-  /* the AVI header */
-  gst_riff_avih avi_hdr;
-  guint32 total_frames; /* total number of frames */
-  guint64 total_data; /* amount of total data */
-  guint32 data_size, datax_size; /* amount of data (bytes) in the AVI/AVIX block */
-  guint32 num_frames, numx_frames; /* num frames in the AVI/AVIX block */
-  guint32 header_size;
-  gboolean write_header;
-  gboolean restart;
-  guint32 audio_size;
-  guint64 audio_time;
-
-  /* video header */
-  gst_riff_strh vids_hdr;
-  gst_riff_strf_vids vids;
-
-  /* audio header */
-  gst_riff_strh auds_hdr;
-  gst_riff_strf_auds auds;
-
-  /* information about the AVI index ('idx') */
-  gst_riff_index_entry *idx;
-  gint idx_index, idx_count;
-  guint32 idx_offset, idx_size;
-
-  /* are we a big file already? */
-  gboolean is_bigfile;
-  guint64 avix_start;
-
-  /* whether to use "large AVI files" or just stick to small indexed files */
-  gboolean enable_large_avi;
-
-  /* in order to be usable as a loopbased element, we need an internal
-   * 'buffered' buffer for each pad, so one for audio, one for video */
-  GstBuffer *audio_buffer_queue, *video_buffer_queue;
-};
-
-struct _GstAviMuxClass {
-  GstElementClass parent_class;
-};
-
-GType gst_avimux_get_type(void);
+  typedef struct _GstAviMux GstAviMux;
+  typedef struct _GstAviMuxClass GstAviMuxClass;
+
+  struct _GstAviMux
+  {
+    GstElement element;
+
+    /* pads */
+    GstPad *srcpad;
+    GstPad *audiosinkpad;
+    gboolean audio_pad_connected, audio_pad_eos;
+    GstPad *videosinkpad;
+    gboolean video_pad_connected, video_pad_eos;
+
+    /* the AVI header */
+    gst_riff_avih avi_hdr;
+    guint32 total_frames;	/* total number of frames */
+    guint64 total_data;		/* amount of total data */
+    guint32 data_size, datax_size;	/* amount of data (bytes) in the AVI/AVIX block */
+    guint32 num_frames, numx_frames;	/* num frames in the AVI/AVIX block */
+    guint32 header_size;
+    gboolean write_header;
+    gboolean restart;
+    guint32 audio_size;
+    guint64 audio_time;
+
+    /* video header */
+    gst_riff_strh vids_hdr;
+    gst_riff_strf_vids vids;
+
+    /* audio header */
+    gst_riff_strh auds_hdr;
+    gst_riff_strf_auds auds;
+
+    /* information about the AVI index ('idx') */
+    gst_riff_index_entry *idx;
+    gint idx_index, idx_count;
+    guint32 idx_offset, idx_size;
+
+    /* are we a big file already? */
+    gboolean is_bigfile;
+    guint64 avix_start;
+
+    /* whether to use "large AVI files" or just stick to small indexed files */
+    gboolean enable_large_avi;
+
+    /* in order to be usable as a loopbased element, we need an internal
+     * 'buffered' buffer for each pad, so one for audio, one for video */
+    GstBuffer *audio_buffer_queue, *video_buffer_queue;
+  };
+
+  struct _GstAviMuxClass
+  {
+    GstElementClass parent_class;
+  };
+
+  GType gst_avimux_get_type (void);
 
 #ifdef __cplusplus
 }
-#endif /* __cplusplus */
+#endif				/* __cplusplus */
 
 
-#endif /* __GST_AVIMUX_H__ */
+#endif				/* __GST_AVIMUX_H__ */