don't mix tabs and spaces

Original commit message from CVS:
don't mix tabs and spaces

4 files changed, 265 insertions, 258 deletions

diff --git a/ext/flac/gstflac.c b/ext/flac/gstflac.c
index c1dba934..9432713f 100644
--- a/ext/flac/gstflac.c
+++ b/ext/flac/gstflac.c
@@ -38,15 +38,15 @@ plugin_init (GstPlugin * plugin)
     return FALSE;
 
   if (!gst_element_register (plugin, "flacenc", GST_RANK_NONE,
-	  GST_TYPE_FLACENC))
+          GST_TYPE_FLACENC))
     return FALSE;
 
   if (!gst_element_register (plugin, "flacdec", GST_RANK_PRIMARY,
-	  GST_TYPE_FLACDEC))
+          GST_TYPE_FLACDEC))
     return FALSE;
 
   if (!gst_element_register (plugin, "flactag", GST_RANK_PRIMARY,
-	  gst_flac_tag_get_type ()))
+          gst_flac_tag_get_type ()))
     return FALSE;
 
   return TRUE;
diff --git a/ext/flac/gstflacdec.c b/ext/flac/gstflacdec.c
index 3882df1a..af5e8b97 100644
--- a/ext/flac/gstflacdec.c
+++ b/ext/flac/gstflacdec.c
@@ -112,8 +112,9 @@ flacdec_get_type (void)
       0,
       (GInstanceInitFunc) gst_flacdec_init,
     };
+
     flacdec_type =
-	g_type_register_static (GST_TYPE_ELEMENT, "FlacDec", &flacdec_info, 0);
+        g_type_register_static (GST_TYPE_ELEMENT, "FlacDec", &flacdec_info, 0);
   }
   return flacdec_type;
 }
@@ -212,9 +213,9 @@ gst_flacdec_init (FlacDec * flacdec)
 #else
   FLAC__seekable_stream_decoder_set_write_callback (flacdec->decoder,
       (FLAC__StreamDecoderWriteStatus (*)
-	  (const FLAC__SeekableStreamDecoder * decoder,
-	      const FLAC__Frame * frame,
-	      const FLAC__int32 * buffer[], void *client_data))
+          (const FLAC__SeekableStreamDecoder * decoder,
+              const FLAC__Frame * frame,
+              const FLAC__int32 * buffer[], void *client_data))
       (gst_flacdec_write));
 #endif
   FLAC__seekable_stream_decoder_set_metadata_respond (flacdec->decoder,
@@ -394,29 +395,29 @@ gst_flacdec_read (const FLAC__SeekableStreamDecoder * decoder,
       gst_bytestream_get_status (flacdec->bs, &avail, &event);
 
       switch (GST_EVENT_TYPE (event)) {
-	case GST_EVENT_EOS:
-	  GST_DEBUG ("eos");
-	  flacdec->eos = TRUE;
-	  gst_event_unref (event);
-	  if (avail == 0) {
-	    return 0;
-	  }
-	  break;
-	case GST_EVENT_DISCONTINUOUS:
-	  GST_DEBUG ("discont");
-
-	  /* we are not yet sending the discont, we'll do that in the next write operation */
-	  flacdec->need_discont = TRUE;
-	  gst_event_unref (event);
-	  break;
-	default:
-	  gst_pad_event_default (flacdec->sinkpad, event);
-	  break;
+        case GST_EVENT_EOS:
+          GST_DEBUG ("eos");
+          flacdec->eos = TRUE;
+          gst_event_unref (event);
+          if (avail == 0) {
+            return 0;
+          }
+          break;
+        case GST_EVENT_DISCONTINUOUS:
+          GST_DEBUG ("discont");
+
+          /* we are not yet sending the discont, we'll do that in the next write operation */
+          flacdec->need_discont = TRUE;
+          gst_event_unref (event);
+          break;
+        default:
+          gst_pad_event_default (flacdec->sinkpad, event);
+          break;
       }
       if (avail > 0)
-	insize = gst_bytestream_peek_bytes (flacdec->bs, &indata, avail);
+        insize = gst_bytestream_peek_bytes (flacdec->bs, &indata, avail);
       else
-	insize = 0;
+        insize = 0;
     }
   }
 
@@ -450,36 +451,36 @@ gst_flacdec_write (const FLAC__SeekableStreamDecoder * decoder,
 
     if (!GST_PAD_CAPS (flacdec->srcpad)) {
       if (flacdec->seek_pending) {
-	flacdec->total_samples = flacdec->seek_value;
+        flacdec->total_samples = flacdec->seek_value;
       }
 
       if (GST_PAD_IS_USABLE (flacdec->srcpad)) {
-	GST_DEBUG ("send discont");
-
-	format = GST_FORMAT_TIME;
-	gst_pad_convert (flacdec->srcpad, GST_FORMAT_DEFAULT,
-	    flacdec->total_samples, &format, &time);
-	format = GST_FORMAT_BYTES;
-	gst_pad_convert (flacdec->srcpad, GST_FORMAT_DEFAULT,
-	    flacdec->total_samples, &format, &bytes);
-	discont = gst_event_new_discontinuous (FALSE, GST_FORMAT_TIME, time,
-	    GST_FORMAT_BYTES, bytes,
-	    GST_FORMAT_DEFAULT, flacdec->total_samples, NULL);
-
-	gst_pad_push (flacdec->srcpad, GST_DATA (discont));
+        GST_DEBUG ("send discont");
+
+        format = GST_FORMAT_TIME;
+        gst_pad_convert (flacdec->srcpad, GST_FORMAT_DEFAULT,
+            flacdec->total_samples, &format, &time);
+        format = GST_FORMAT_BYTES;
+        gst_pad_convert (flacdec->srcpad, GST_FORMAT_DEFAULT,
+            flacdec->total_samples, &format, &bytes);
+        discont = gst_event_new_discontinuous (FALSE, GST_FORMAT_TIME, time,
+            GST_FORMAT_BYTES, bytes,
+            GST_FORMAT_DEFAULT, flacdec->total_samples, NULL);
+
+        gst_pad_push (flacdec->srcpad, GST_DATA (discont));
       }
     }
   }
 
   if (!GST_PAD_CAPS (flacdec->srcpad)) {
     gst_pad_set_explicit_caps (flacdec->srcpad,
-	gst_caps_new_simple ("audio/x-raw-int",
-	    "endianness", G_TYPE_INT, G_BYTE_ORDER,
-	    "signed", G_TYPE_BOOLEAN, TRUE,
-	    "width", G_TYPE_INT, depth,
-	    "depth", G_TYPE_INT, depth,
-	    "rate", G_TYPE_INT, frame->header.sample_rate,
-	    "channels", G_TYPE_INT, channels, NULL));
+        gst_caps_new_simple ("audio/x-raw-int",
+            "endianness", G_TYPE_INT, G_BYTE_ORDER,
+            "signed", G_TYPE_BOOLEAN, TRUE,
+            "width", G_TYPE_INT, depth,
+            "depth", G_TYPE_INT, depth,
+            "rate", G_TYPE_INT, frame->header.sample_rate,
+            "channels", G_TYPE_INT, channels, NULL));
 
     flacdec->depth = depth;
     flacdec->channels = channels;
@@ -491,23 +492,23 @@ gst_flacdec_write (const FLAC__SeekableStreamDecoder * decoder,
     GST_BUFFER_SIZE (outbuf) = samples * channels * ((depth + 7) >> 3);
     GST_BUFFER_DATA (outbuf) = g_malloc (GST_BUFFER_SIZE (outbuf));
     GST_BUFFER_TIMESTAMP (outbuf) =
-	flacdec->total_samples * GST_SECOND / frame->header.sample_rate;
+        flacdec->total_samples * GST_SECOND / frame->header.sample_rate;
 
     if (depth == 8) {
       guint8 *outbuffer = (guint8 *) GST_BUFFER_DATA (outbuf);
 
       for (i = 0; i < samples; i++) {
-	for (j = 0; j < channels; j++) {
-	  *outbuffer++ = (guint8) buffer[j][i];
-	}
+        for (j = 0; j < channels; j++) {
+          *outbuffer++ = (guint8) buffer[j][i];
+        }
       }
     } else if (depth == 16) {
       guint16 *outbuffer = (guint16 *) GST_BUFFER_DATA (outbuf);
 
       for (i = 0; i < samples; i++) {
-	for (j = 0; j < channels; j++) {
-	  *outbuffer++ = (guint16) buffer[j][i];
-	}
+        for (j = 0; j < channels; j++) {
+          *outbuffer++ = (guint16) buffer[j][i];
+        }
       }
     } else {
       g_warning ("flacdec: invalid depth %d found\n", depth);
@@ -536,7 +537,7 @@ gst_flacdec_loop (GstElement * element)
     res = FLAC__seekable_stream_decoder_init (flacdec->decoder);
     if (res != FLAC__SEEKABLE_STREAM_DECODER_OK) {
       GST_ELEMENT_ERROR (flacdec, LIBRARY, INIT, (NULL),
-	  (FLAC__SeekableStreamDecoderStateString[res]));
+          (FLAC__SeekableStreamDecoderStateString[res]));
       return;
     }
     /*    FLAC__seekable_stream_decoder_process_metadata (flacdec->decoder); */
@@ -547,7 +548,7 @@ gst_flacdec_loop (GstElement * element)
     GST_DEBUG ("perform seek to sample %" G_GINT64_FORMAT, flacdec->seek_value);
 
     if (FLAC__seekable_stream_decoder_seek_absolute (flacdec->decoder,
-	    flacdec->seek_value)) {
+            flacdec->seek_value)) {
       flacdec->total_samples = flacdec->seek_value;
       GST_DEBUG ("seek done");
     } else {
@@ -585,6 +586,7 @@ gst_flacdec_get_src_formats (GstPad * pad)
     GST_FORMAT_TIME,
     0,
   };
+
   return formats;
 }
 
@@ -602,47 +604,47 @@ gst_flacdec_convert_src (GstPad * pad, GstFormat src_format, gint64 src_value,
   switch (src_format) {
     case GST_FORMAT_BYTES:
       switch (*dest_format) {
-	case GST_FORMAT_DEFAULT:
-	  if (bytes_per_sample == 0)
-	    return FALSE;
-	  *dest_value = src_value / bytes_per_sample;
-	  break;
-	case GST_FORMAT_TIME:
-	{
-	  gint byterate = bytes_per_sample * flacdec->frequency;
-
-	  if (byterate == 0)
-	    return FALSE;
-	  *dest_value = src_value * GST_SECOND / byterate;
-	  break;
-	}
-	default:
-	  res = FALSE;
+        case GST_FORMAT_DEFAULT:
+          if (bytes_per_sample == 0)
+            return FALSE;
+          *dest_value = src_value / bytes_per_sample;
+          break;
+        case GST_FORMAT_TIME:
+        {
+          gint byterate = bytes_per_sample * flacdec->frequency;
+
+          if (byterate == 0)
+            return FALSE;
+          *dest_value = src_value * GST_SECOND / byterate;
+          break;
+        }
+        default:
+          res = FALSE;
       }
       break;
     case GST_FORMAT_DEFAULT:
       switch (*dest_format) {
-	case GST_FORMAT_BYTES:
-	  *dest_value = src_value * bytes_per_sample;
-	  break;
-	case GST_FORMAT_TIME:
-	  if (flacdec->frequency == 0)
-	    return FALSE;
-	  *dest_value = src_value * GST_SECOND / flacdec->frequency;
-	  break;
-	default:
-	  res = FALSE;
+        case GST_FORMAT_BYTES:
+          *dest_value = src_value * bytes_per_sample;
+          break;
+        case GST_FORMAT_TIME:
+          if (flacdec->frequency == 0)
+            return FALSE;
+          *dest_value = src_value * GST_SECOND / flacdec->frequency;
+          break;
+        default:
+          res = FALSE;
       }
       break;
     case GST_FORMAT_TIME:
       switch (*dest_format) {
-	case GST_FORMAT_BYTES:
-	  scale = bytes_per_sample;
-	case GST_FORMAT_DEFAULT:
-	  *dest_value = src_value * scale * flacdec->frequency / GST_SECOND;
-	  break;
-	default:
-	  res = FALSE;
+        case GST_FORMAT_BYTES:
+          scale = bytes_per_sample;
+        case GST_FORMAT_DEFAULT:
+          *dest_value = src_value * scale * flacdec->frequency / GST_SECOND;
+          break;
+        default:
+          res = FALSE;
       }
       break;
     default:
@@ -659,6 +661,7 @@ gst_flacdec_get_src_query_types (GstPad * pad)
     GST_QUERY_POSITION,
     0,
   };
+
   return types;
 }
 
@@ -675,17 +678,17 @@ gst_flacdec_src_query (GstPad * pad, GstQueryType type,
       guint64 samples;
 
       if (flacdec->stream_samples == 0)
-	samples = flacdec->total_samples;
+        samples = flacdec->total_samples;
       else
-	samples = flacdec->stream_samples;
+        samples = flacdec->stream_samples;
 
       gst_pad_convert (flacdec->srcpad,
-	  GST_FORMAT_DEFAULT, samples, format, value);
+          GST_FORMAT_DEFAULT, samples, format, value);
       break;
     }
     case GST_QUERY_POSITION:
       gst_pad_convert (flacdec->srcpad,
-	  GST_FORMAT_DEFAULT, flacdec->total_samples, format, value);
+          GST_FORMAT_DEFAULT, flacdec->total_samples, format, value);
       break;
     default:
       res = FALSE;
@@ -702,6 +705,7 @@ gst_flacdec_get_src_event_masks (GstPad * pad)
     {GST_EVENT_SEEK, GST_SEEK_FLAG_ACCURATE},
     {0, 0},
   };
+
   return masks;
 }
 
@@ -717,11 +721,11 @@ gst_flacdec_src_event (GstPad * pad, GstEvent * event)
       format = GST_FORMAT_DEFAULT;
 
       if (gst_pad_convert (flacdec->srcpad,
-	      GST_EVENT_SEEK_FORMAT (event),
-	      GST_EVENT_SEEK_OFFSET (event), &format, &flacdec->seek_value))
-	flacdec->seek_pending = TRUE;
+              GST_EVENT_SEEK_FORMAT (event),
+              GST_EVENT_SEEK_OFFSET (event), &format, &flacdec->seek_value))
+        flacdec->seek_pending = TRUE;
       else
-	res = FALSE;
+        res = FALSE;
       break;
     default:
       res = FALSE;
@@ -744,7 +748,7 @@ gst_flacdec_change_state (GstElement * element)
       flacdec->total_samples = 0;
       flacdec->eos = FALSE;
       if (flacdec->init == FALSE) {
-	FLAC__seekable_stream_decoder_reset (flacdec->decoder);
+        FLAC__seekable_stream_decoder_reset (flacdec->decoder);
       }
       break;
     case GST_STATE_PAUSED_TO_PLAYING:
diff --git a/ext/flac/gstflacenc.c b/ext/flac/gstflacenc.c
index 7e658047..1463a1fa 100644
--- a/ext/flac/gstflacenc.c
+++ b/ext/flac/gstflacenc.c
@@ -117,9 +117,9 @@ flacenc_get_type (void)
     };
 
     flacenc_type =
-	g_type_register_static (GST_TYPE_ELEMENT, "FlacEnc", &flacenc_info, 0);
+        g_type_register_static (GST_TYPE_ELEMENT, "FlacEnc", &flacenc_info, 0);
     g_type_add_interface_static (flacenc_type, GST_TYPE_TAG_SETTER,
-	&tag_setter_info);
+        &tag_setter_info);
   }
   return flacenc_type;
 }
@@ -137,7 +137,8 @@ typedef struct
   guint rice_parameter_search_dist;
   guint max_lpc_order;
   guint blocksize;
-} FlacEncParams;
+}
+FlacEncParams;
 
 static const FlacEncParams flacenc_params[] = {
   {FALSE, FALSE, FALSE, FALSE, 0, FALSE, 2, 2, 0, 0, 1152},
@@ -174,6 +175,7 @@ gst_flacenc_quality_get_type (void)
       {9, "9", "9 - Insane"},
       {0, NULL, NULL}
     };
+
     qtype = g_enum_register_static ("FlacEncQuality", values);
   }
   return qtype;
@@ -235,78 +237,78 @@ gst_flacenc_class_init (FlacEncClass * klass)
 
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
       g_param_spec_enum ("quality",
-	  "Quality",
-	  "Speed versus compression tradeoff",
-	  GST_TYPE_FLACENC_QUALITY, DEFAULT_QUALITY, G_PARAM_READWRITE));
+          "Quality",
+          "Speed versus compression tradeoff",
+          GST_TYPE_FLACENC_QUALITY, DEFAULT_QUALITY, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_STREAMABLE_SUBSET, g_param_spec_boolean ("streamable_subset",
-	  "Streamable subset",
-	  "true to limit encoder to generating a Subset stream, else false",
-	  TRUE, G_PARAM_READWRITE));
+          "Streamable subset",
+          "true to limit encoder to generating a Subset stream, else false",
+          TRUE, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MID_SIDE_STEREO,
       g_param_spec_boolean ("mid_side_stereo", "Do mid side stereo",
-	  "Do mid side stereo (only for stereo input)",
-	  flacenc_params[DEFAULT_QUALITY].mid_side, G_PARAM_READWRITE));
+          "Do mid side stereo (only for stereo input)",
+          flacenc_params[DEFAULT_QUALITY].mid_side, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_LOOSE_MID_SIDE_STEREO, g_param_spec_boolean ("loose_mid_side_stereo",
-	  "Loose mid side stereo", "Loose mid side stereo",
-	  flacenc_params[DEFAULT_QUALITY].loose_mid_side, G_PARAM_READWRITE));
+          "Loose mid side stereo", "Loose mid side stereo",
+          flacenc_params[DEFAULT_QUALITY].loose_mid_side, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
       g_param_spec_uint ("blocksize", "Blocksize", "Blocksize in samples",
-	  FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE,
-	  flacenc_params[DEFAULT_QUALITY].blocksize, G_PARAM_READWRITE));
+          FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE,
+          flacenc_params[DEFAULT_QUALITY].blocksize, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MAX_LPC_ORDER,
       g_param_spec_uint ("max_lpc_order", "Max LPC order",
-	  "Max LPC order; 0 => use only fixed predictors", 0,
-	  FLAC__MAX_LPC_ORDER, flacenc_params[DEFAULT_QUALITY].max_lpc_order,
-	  G_PARAM_READWRITE));
+          "Max LPC order; 0 => use only fixed predictors", 0,
+          FLAC__MAX_LPC_ORDER, flacenc_params[DEFAULT_QUALITY].max_lpc_order,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_QLP_COEFF_PRECISION, g_param_spec_uint ("qlp_coeff_precision",
-	  "QLP coefficients precision",
-	  "Precision in bits of quantized linear-predictor coefficients; 0 = automatic",
-	  0, 32, flacenc_params[DEFAULT_QUALITY].qlp_coeff_precision,
-	  G_PARAM_READWRITE));
+          "QLP coefficients precision",
+          "Precision in bits of quantized linear-predictor coefficients; 0 = automatic",
+          0, 32, flacenc_params[DEFAULT_QUALITY].qlp_coeff_precision,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_QLP_COEFF_PREC_SEARCH, g_param_spec_boolean ("qlp_coeff_prec_search",
-	  "Do QLP coefficients precision search",
-	  "false = use qlp_coeff_precision, "
-	  "true = search around qlp_coeff_precision, take best",
-	  flacenc_params[DEFAULT_QUALITY].qlp_coeff_prec_search,
-	  G_PARAM_READWRITE));
+          "Do QLP coefficients precision search",
+          "false = use qlp_coeff_precision, "
+          "true = search around qlp_coeff_precision, take best",
+          flacenc_params[DEFAULT_QUALITY].qlp_coeff_prec_search,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ESCAPE_CODING,
       g_param_spec_boolean ("escape_coding", "Do Escape coding",
-	  "search for escape codes in the entropy coding stage "
-	  "for slightly better compression",
-	  flacenc_params[DEFAULT_QUALITY].escape_coding, G_PARAM_READWRITE));
+          "search for escape codes in the entropy coding stage "
+          "for slightly better compression",
+          flacenc_params[DEFAULT_QUALITY].escape_coding, G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_EXHAUSTIVE_MODEL_SEARCH,
       g_param_spec_boolean ("exhaustive_model_search",
-	  "Do exhaustive model search",
-	  "do exhaustive search of LP coefficient quantization (expensive!)",
-	  flacenc_params[DEFAULT_QUALITY].exhaustive_model_search,
-	  G_PARAM_READWRITE));
+          "Do exhaustive model search",
+          "do exhaustive search of LP coefficient quantization (expensive!)",
+          flacenc_params[DEFAULT_QUALITY].exhaustive_model_search,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_MIN_RESIDUAL_PARTITION_ORDER,
       g_param_spec_uint ("min_residual_partition_order",
-	  "Min residual partition order",
-	  "Min residual partition order (above 4 doesn't usually help much)", 0,
-	  16, flacenc_params[DEFAULT_QUALITY].min_residual_partition_order,
-	  G_PARAM_READWRITE));
+          "Min residual partition order",
+          "Min residual partition order (above 4 doesn't usually help much)", 0,
+          16, flacenc_params[DEFAULT_QUALITY].min_residual_partition_order,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_MAX_RESIDUAL_PARTITION_ORDER,
       g_param_spec_uint ("max_residual_partition_order",
-	  "Max residual partition order",
-	  "Max residual partition order (above 4 doesn't usually help much)", 0,
-	  16, flacenc_params[DEFAULT_QUALITY].max_residual_partition_order,
-	  G_PARAM_READWRITE));
+          "Max residual partition order",
+          "Max residual partition order (above 4 doesn't usually help much)", 0,
+          16, flacenc_params[DEFAULT_QUALITY].max_residual_partition_order,
+          G_PARAM_READWRITE));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_RICE_PARAMETER_SEARCH_DIST,
       g_param_spec_uint ("rice_parameter_search_dist",
-	  "rice_parameter_search_dist",
-	  "0 = try only calc'd parameter k; else try all [k-dist..k+dist] "
-	  "parameters, use best", 0, FLAC__MAX_RICE_PARTITION_ORDER,
-	  flacenc_params[DEFAULT_QUALITY].rice_parameter_search_dist,
-	  G_PARAM_READWRITE));
+          "rice_parameter_search_dist",
+          "0 = try only calc'd parameter k; else try all [k-dist..k+dist] "
+          "parameters, use best", 0, FLAC__MAX_RICE_PARTITION_ORDER,
+          flacenc_params[DEFAULT_QUALITY].rice_parameter_search_dist,
+          G_PARAM_READWRITE));
 
   gstelement_class->change_state = gst_flacenc_change_state;
 }
@@ -434,7 +436,7 @@ gst_flacenc_seek_callback (const FLAC__SeekableStreamEncoder * encoder,
 
   event =
       gst_event_new_seek ((GstSeekType) (int) (GST_FORMAT_BYTES |
-	  GST_SEEK_METHOD_SET), absolute_byte_offset);
+          GST_SEEK_METHOD_SET), absolute_byte_offset);
 
   if (event)
     gst_pad_push (flacenc->srcpad, GST_DATA (event));
@@ -484,8 +486,8 @@ add_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
     commment_entry.length = strlen (it->data);
     commment_entry.entry = it->data;
     FLAC__metadata_object_vorbiscomment_insert_comment (flacenc->meta[0],
-	flacenc->meta[0]->data.vorbis_comment.num_comments,
-	commment_entry, TRUE);
+        flacenc->meta[0]->data.vorbis_comment.num_comments,
+        commment_entry, TRUE);
     g_free (it->data);
   }
   g_list_free (comments);
@@ -511,7 +513,7 @@ gst_flacenc_set_metadata (FlacEnc * flacenc)
   gst_tag_list_foreach (copy, add_one_tag, flacenc);
 
   if (FLAC__seekable_stream_encoder_set_metadata (flacenc->encoder,
-	  flacenc->meta, 1) != true)
+          flacenc->meta, 1) != true)
     g_warning ("Dude, i'm already initialized!");
   gst_tag_list_free (copy);
 }
@@ -537,18 +539,18 @@ gst_flacenc_chain (GstPad * pad, GstData * _data)
 
     switch (GST_EVENT_TYPE (event)) {
       case GST_EVENT_EOS:
-	FLAC__seekable_stream_encoder_finish (flacenc->encoder);
-	break;
+        FLAC__seekable_stream_encoder_finish (flacenc->encoder);
+        break;
       case GST_EVENT_TAG:
-	if (flacenc->tags) {
-	  gst_tag_list_insert (flacenc->tags, gst_event_tag_get_list (event),
-	      GST_TAG_MERGE_REPLACE);
-	} else {
-	  g_assert_not_reached ();
-	}
-	break;
+        if (flacenc->tags) {
+          gst_tag_list_insert (flacenc->tags, gst_event_tag_get_list (event),
+              GST_TAG_MERGE_REPLACE);
+        } else {
+          g_assert_not_reached ();
+        }
+        break;
       default:
-	break;
+        break;
     }
     gst_pad_event_default (pad, event);
     return;
@@ -556,7 +558,7 @@ gst_flacenc_chain (GstPad * pad, GstData * _data)
 
   if (!flacenc->negotiated) {
     GST_ELEMENT_ERROR (flacenc, CORE, NEGOTIATION, (NULL),
-	("format wasn't negotiated before chain function"));
+        ("format wasn't negotiated before chain function"));
     return;
   }
 
@@ -570,9 +572,9 @@ gst_flacenc_chain (GstPad * pad, GstData * _data)
     FLAC__SeekableStreamEncoderState state;
 
     FLAC__seekable_stream_encoder_set_write_callback (flacenc->encoder,
-	gst_flacenc_write_callback);
+        gst_flacenc_write_callback);
     FLAC__seekable_stream_encoder_set_seek_callback (flacenc->encoder,
-	gst_flacenc_seek_callback);
+        gst_flacenc_seek_callback);
 
     FLAC__seekable_stream_encoder_set_client_data (flacenc->encoder, flacenc);
 
@@ -580,7 +582,7 @@ gst_flacenc_chain (GstPad * pad, GstData * _data)
     state = FLAC__seekable_stream_encoder_init (flacenc->encoder);
     if (state != FLAC__STREAM_ENCODER_OK) {
       GST_ELEMENT_ERROR (flacenc, LIBRARY, INIT, (NULL),
-	  ("could not initialize encoder (wrong parameters?)"));
+          ("could not initialize encoder (wrong parameters?)"));
       return;
     }
   }
@@ -630,51 +632,51 @@ gst_flacenc_set_property (GObject * object, guint prop_id,
       break;
     case ARG_STREAMABLE_SUBSET:
       FLAC__seekable_stream_encoder_set_streamable_subset (this->encoder,
-	  g_value_get_boolean (value));
+          g_value_get_boolean (value));
       break;
     case ARG_MID_SIDE_STEREO:
       FLAC__seekable_stream_encoder_set_do_mid_side_stereo (this->encoder,
-	  g_value_get_boolean (value));
+          g_value_get_boolean (value));
       break;
     case ARG_LOOSE_MID_SIDE_STEREO:
       FLAC__seekable_stream_encoder_set_loose_mid_side_stereo (this->encoder,
-	  g_value_get_boolean (value));
+          g_value_get_boolean (value));
       break;
     case ARG_BLOCKSIZE:
       FLAC__seekable_stream_encoder_set_blocksize (this->encoder,
-	  g_value_get_uint (value));
+          g_value_get_uint (value));
       break;
     case ARG_MAX_LPC_ORDER:
       FLAC__seekable_stream_encoder_set_max_lpc_order (this->encoder,
-	  g_value_get_uint (value));
+          g_value_get_uint (value));
       break;
     case ARG_QLP_COEFF_PRECISION:
       FLAC__seekable_stream_encoder_set_qlp_coeff_precision (this->encoder,
-	  g_value_get_uint (value));
+          g_value_get_uint (value));
       break;
     case ARG_QLP_COEFF_PREC_SEARCH:
       FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search (this->encoder,
-	  g_value_get_boolean (value));
+          g_value_get_boolean (value));
       break;
     case ARG_ESCAPE_CODING:
       FLAC__seekable_stream_encoder_set_do_escape_coding (this->encoder,
-	  g_value_get_boolean (value));
+          g_value_get_boolean (value));
       break;
     case ARG_EXHAUSTIVE_MODEL_SEARCH:
       FLAC__seekable_stream_encoder_set_do_exhaustive_model_search (this->
-	  encoder, g_value_get_boolean (value));
+          encoder, g_value_get_boolean (value));
       break;
     case ARG_MIN_RESIDUAL_PARTITION_ORDER:
       FLAC__seekable_stream_encoder_set_min_residual_partition_order (this->
-	  encoder, g_value_get_uint (value));
+          encoder, g_value_get_uint (value));
       break;
     case ARG_MAX_RESIDUAL_PARTITION_ORDER:
       FLAC__seekable_stream_encoder_set_max_residual_partition_order (this->
-	  encoder, g_value_get_uint (value));
+          encoder, g_value_get_uint (value));
       break;
     case ARG_RICE_PARAMETER_SEARCH_DIST:
       FLAC__seekable_stream_encoder_set_rice_parameter_search_dist (this->
-	  encoder, g_value_get_uint (value));
+          encoder, g_value_get_uint (value));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -696,58 +698,58 @@ gst_flacenc_get_property (GObject * object, guint prop_id,
       break;
     case ARG_STREAMABLE_SUBSET:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_streamable_subset (this->encoder));
+          FLAC__seekable_stream_encoder_get_streamable_subset (this->encoder));
       break;
     case ARG_MID_SIDE_STEREO:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_do_mid_side_stereo (this->encoder));
+          FLAC__seekable_stream_encoder_get_do_mid_side_stereo (this->encoder));
       break;
     case ARG_LOOSE_MID_SIDE_STEREO:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_loose_mid_side_stereo (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_loose_mid_side_stereo (this->
+              encoder));
       break;
     case ARG_BLOCKSIZE:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_blocksize (this->encoder));
+          FLAC__seekable_stream_encoder_get_blocksize (this->encoder));
       break;
     case ARG_MAX_LPC_ORDER:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_max_lpc_order (this->encoder));
+          FLAC__seekable_stream_encoder_get_max_lpc_order (this->encoder));
       break;
     case ARG_QLP_COEFF_PRECISION:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_qlp_coeff_precision (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_qlp_coeff_precision (this->
+              encoder));
       break;
     case ARG_QLP_COEFF_PREC_SEARCH:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search (this->
+              encoder));
       break;
     case ARG_ESCAPE_CODING:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_do_escape_coding (this->encoder));
+          FLAC__seekable_stream_encoder_get_do_escape_coding (this->encoder));
       break;
     case ARG_EXHAUSTIVE_MODEL_SEARCH:
       g_value_set_boolean (value,
-	  FLAC__seekable_stream_encoder_get_do_exhaustive_model_search (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_do_exhaustive_model_search (this->
+              encoder));
       break;
     case ARG_MIN_RESIDUAL_PARTITION_ORDER:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_min_residual_partition_order (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_min_residual_partition_order (this->
+              encoder));
       break;
     case ARG_MAX_RESIDUAL_PARTITION_ORDER:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_max_residual_partition_order (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_max_residual_partition_order (this->
+              encoder));
       break;
     case ARG_RICE_PARAMETER_SEARCH_DIST:
       g_value_set_uint (value,
-	  FLAC__seekable_stream_encoder_get_rice_parameter_search_dist (this->
-	      encoder));
+          FLAC__seekable_stream_encoder_get_rice_parameter_search_dist (this->
+              encoder));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -771,20 +773,20 @@ gst_flacenc_change_state (GstElement * element)
       break;
     case GST_STATE_PAUSED_TO_READY:
       if (FLAC__seekable_stream_encoder_get_state (flacenc->encoder) !=
-	  FLAC__STREAM_ENCODER_UNINITIALIZED) {
-	flacenc->stopped = TRUE;
-	FLAC__seekable_stream_encoder_finish (flacenc->encoder);
+          FLAC__STREAM_ENCODER_UNINITIALIZED) {
+        flacenc->stopped = TRUE;
+        FLAC__seekable_stream_encoder_finish (flacenc->encoder);
       }
       flacenc->negotiated = FALSE;
       if (flacenc->first_buf)
-	gst_buffer_unref (flacenc->first_buf);
+        gst_buffer_unref (flacenc->first_buf);
       flacenc->first_buf = NULL;
       g_free (flacenc->data);
       flacenc->data = NULL;
       if (flacenc->meta) {
-	FLAC__metadata_object_delete (flacenc->meta[0]);
-	g_free (flacenc->meta);
-	flacenc->meta = NULL;
+        FLAC__metadata_object_delete (flacenc->meta[0]);
+        g_free (flacenc->meta);
+        flacenc->meta = NULL;
       }
       break;
     case GST_STATE_READY_TO_NULL:
diff --git a/ext/flac/gstflactag.c b/ext/flac/gstflactag.c
index c931f41c..50697b7b 100644
--- a/ext/flac/gstflactag.c
+++ b/ext/flac/gstflactag.c
@@ -56,7 +56,8 @@ typedef enum
   GST_FLAC_TAG_STATE_VC_METADATA_BLOCK,
   GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT,
   GST_FLAC_TAG_STATE_AUDIO_DATA
-} GstFlacTagState;
+}
+GstFlacTagState;
 
 
 struct _GstFlacTag
@@ -157,11 +158,11 @@ gst_flac_tag_get_type (void)
     };
 
     flac_tag_type =
-	g_type_register_static (GST_TYPE_ELEMENT, "GstFlacTag", &flac_tag_info,
-	0);
+        g_type_register_static (GST_TYPE_ELEMENT, "GstFlacTag", &flac_tag_info,
+        0);
 
     g_type_add_interface_static (flac_tag_type, GST_TYPE_TAG_SETTER,
-	&tag_setter_info);
+        &tag_setter_info);
 
   }
   return flac_tag_type;
@@ -189,8 +190,8 @@ send_eos (GstFlacTag * tag)
   gst_pad_push (tag->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
   /* Seek to end of sink stream */
   if (gst_pad_send_event (GST_PAD_PEER (tag->sinkpad),
-	  gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_END |
-	      GST_SEEK_FLAG_FLUSH, 0))) {
+          gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_END |
+              GST_SEEK_FLAG_FLUSH, 0))) {
   } else {
     g_warning ("Couldn't seek to eos on sinkpad\n");
   }
@@ -209,8 +210,8 @@ caps_nego (GstFlacTag * tag)
     GST_LOG_OBJECT (tag, "normal operation, using audio/x-flac output");
   } else {
     if (gst_pad_try_set_caps (tag->srcpad,
-	    gst_caps_new_simple ("application/x-gst-tags", NULL))
-	!= GST_PAD_LINK_REFUSED) {
+            gst_caps_new_simple ("application/x-gst-tags", NULL))
+        != GST_PAD_LINK_REFUSED) {
       tag->only_output_tags = TRUE;
       GST_LOG_OBJECT (tag, "fast operation, just outputting tags");
       printf ("output tags only\n");
@@ -295,7 +296,7 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
     }
 
     if (strncmp (GST_BUFFER_DATA (tag->buffer), FLAC_MAGIC,
-	    FLAC_MAGIC_SIZE) == 0) {
+            FLAC_MAGIC_SIZE) == 0) {
       GstBuffer *sub;
 
       tag->state = GST_FLAC_TAG_STATE_METADATA_BLOCKS;
@@ -303,8 +304,8 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
 
       gst_pad_push (tag->srcpad, GST_DATA (sub));
       sub =
-	  gst_buffer_create_sub (tag->buffer, FLAC_MAGIC_SIZE,
-	  GST_BUFFER_SIZE (tag->buffer) - FLAC_MAGIC_SIZE);
+          gst_buffer_create_sub (tag->buffer, FLAC_MAGIC_SIZE,
+          GST_BUFFER_SIZE (tag->buffer) - FLAC_MAGIC_SIZE);
       gst_buffer_unref (tag->buffer);
       /* We do a copy because we need a writable buffer, and _create_sub
        * sets the buffer it uses to read-only
@@ -347,8 +348,8 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
 
     type = (GST_BUFFER_DATA (tag->buffer)[0]) & 0x7F;
     size = ((GST_BUFFER_DATA (tag->buffer)[1]) << 16)
-	| ((GST_BUFFER_DATA (tag->buffer)[2]) << 8)
-	| (GST_BUFFER_DATA (tag->buffer)[3]);
+        | ((GST_BUFFER_DATA (tag->buffer)[2]) << 8)
+        | (GST_BUFFER_DATA (tag->buffer)[3]);
 
     /* The 4 bytes long header isn't included in the metadata size */
     tag->metadata_bytes_remaining = size + 4;
@@ -372,7 +373,7 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
     g_assert (tag->metadata_bytes_remaining != 0);
 
     bytes_to_push = min (tag->metadata_bytes_remaining,
-	GST_BUFFER_SIZE (tag->buffer));
+        GST_BUFFER_SIZE (tag->buffer));
 
     sub = gst_buffer_create_sub (tag->buffer, 0, bytes_to_push);
 
@@ -380,14 +381,14 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
       gst_pad_push (tag->srcpad, GST_DATA (sub));
     } else {
       if (tag->vorbiscomment == NULL) {
-	tag->vorbiscomment = sub;
+        tag->vorbiscomment = sub;
       } else {
-	GstBuffer *merge;
+        GstBuffer *merge;
 
-	merge = gst_buffer_merge (tag->vorbiscomment, sub);
-	gst_buffer_unref (tag->vorbiscomment);
-	gst_buffer_unref (sub);
-	tag->vorbiscomment = merge;
+        merge = gst_buffer_merge (tag->vorbiscomment, sub);
+        gst_buffer_unref (tag->vorbiscomment);
+        gst_buffer_unref (sub);
+        tag->vorbiscomment = merge;
       }
     }
 
@@ -397,7 +398,7 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
       GstBuffer *sub;
 
       sub = gst_buffer_create_sub (tag->buffer, bytes_to_push,
-	  GST_BUFFER_SIZE (tag->buffer) - bytes_to_push);
+          GST_BUFFER_SIZE (tag->buffer) - bytes_to_push);
       gst_buffer_unref (tag->buffer);
 
       /* We make a copy because we need a writable buffer, and _create_sub
@@ -431,17 +432,17 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
        * that we encoutered some tags
        */
       tag->tags = gst_tag_list_from_vorbiscomment_buffer (tag->vorbiscomment,
-	  GST_BUFFER_DATA (tag->vorbiscomment), 4, NULL);
+          GST_BUFFER_DATA (tag->vorbiscomment), 4, NULL);
       if (tag->tags != NULL) {
-	gst_element_found_tags (GST_ELEMENT (tag), tag->tags);
+        gst_element_found_tags (GST_ELEMENT (tag), tag->tags);
       }
 
       gst_buffer_unref (tag->vorbiscomment);
       tag->vorbiscomment = NULL;
 
       if (tag->only_output_tags) {
-	send_eos (tag);
-	return;
+        send_eos (tag);
+        return;
       }
     }
 
@@ -450,13 +451,13 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
       tag->state = GST_FLAC_TAG_STATE_METADATA_BLOCKS;
     } else {
       if (tag->only_output_tags) {
-	/* If we finished parsing the metadata blocks, we will never find any
-	 * metadata, so just stop now
-	 */
-	send_eos (tag);
-	return;
+        /* If we finished parsing the metadata blocks, we will never find any
+         * metadata, so just stop now
+         */
+        send_eos (tag);
+        return;
       } else {
-	tag->state = GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT;
+        tag->state = GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT;
       }
     }
   }
@@ -475,7 +476,7 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
 
     user_tags = gst_tag_setter_get_list (GST_TAG_SETTER (tag));
     merged_tags = gst_tag_list_merge (tag->tags, user_tags,
-	gst_tag_setter_get_merge_mode (GST_TAG_SETTER (tag)));
+        gst_tag_setter_get_merge_mode (GST_TAG_SETTER (tag)));
 
     if (merged_tags == NULL) {
       /* If we get a NULL list of tags, we must generate a padding block
@@ -485,37 +486,37 @@ gst_flac_tag_chain (GstPad * pad, GstData * data)
       g_warning ("No tags found\n");
       buffer = gst_buffer_new_and_alloc (12);
       if (buffer == NULL) {
-	GST_ELEMENT_ERROR (tag, CORE, TOO_LAZY, (NULL),
-	    ("Error creating 12-byte buffer for padding block"));
+        GST_ELEMENT_ERROR (tag, CORE, TOO_LAZY, (NULL),
+            ("Error creating 12-byte buffer for padding block"));
       }
       memset (GST_BUFFER_DATA (buffer), 0, GST_BUFFER_SIZE (buffer));
-      GST_BUFFER_DATA (buffer)[0] = 0x81;	/* 0x80 = Last metadata block, 
-						 * 0x01 = padding block
-						 */
+      GST_BUFFER_DATA (buffer)[0] = 0x81;       /* 0x80 = Last metadata block, 
+                                                 * 0x01 = padding block
+                                                 */
     } else {
       guchar header[4];
 
       memset (header, 0, sizeof (header));
-      header[0] = 0x84;		/* 0x80 = Last metadata block, 
-				 * 0x04 = vorbiscomment block
-				 */
+      header[0] = 0x84;         /* 0x80 = Last metadata block, 
+                                 * 0x04 = vorbiscomment block
+                                 */
       buffer = gst_tag_list_to_vorbiscomment_buffer (merged_tags, header,
-	  sizeof (header), NULL);
+          sizeof (header), NULL);
       gst_tag_list_free (merged_tags);
       if (buffer == NULL) {
-	GST_ELEMENT_ERROR (tag, CORE, TAG, (NULL),
-	    ("Error converting tag list to vorbiscomment buffer"));
-	return;
+        GST_ELEMENT_ERROR (tag, CORE, TAG, (NULL),
+            ("Error converting tag list to vorbiscomment buffer"));
+        return;
       }
       size = GST_BUFFER_SIZE (buffer) - 4;
       if ((size > 0xFFFFFF) || (size < 0)) {
-	/* FLAC vorbis comment blocks are limited to 2^24 bytes, 
-	 * while the vorbis specs allow more than that. Shouldn't 
-	 * be a real world problem though
-	 */
-	GST_ELEMENT_ERROR (tag, CORE, TAG, (NULL),
-	    ("Vorbis comment of size %d too long", size));
-	return;
+        /* FLAC vorbis comment blocks are limited to 2^24 bytes, 
+         * while the vorbis specs allow more than that. Shouldn't 
+         * be a real world problem though
+         */
+        GST_ELEMENT_ERROR (tag, CORE, TAG, (NULL),
+            ("Vorbis comment of size %d too long", size));
+        return;
       }
     }
 
@@ -559,15 +560,15 @@ gst_flac_tag_change_state (GstElement * element)
       break;
     case GST_STATE_PAUSED_TO_READY:
       if (tag->buffer) {
-	gst_buffer_unref (tag->buffer);
-	tag->buffer = NULL;
+        gst_buffer_unref (tag->buffer);
+        tag->buffer = NULL;
       }
       if (tag->vorbiscomment) {
-	gst_buffer_unref (tag->vorbiscomment);
-	tag->vorbiscomment = NULL;
+        gst_buffer_unref (tag->vorbiscomment);
+        tag->vorbiscomment = NULL;
       }
       if (tag->tags) {
-	gst_tag_list_free (tag->tags);
+        gst_tag_list_free (tag->tags);
       }
       tag->state = GST_FLAC_TAG_STATE_INIT;
       break;