ext/wavpack/: More clean-ups: use shorter variable names to make code easier to read; prefix structures we define wit...

Original commit message from CVS:
* ext/wavpack/gstwavpackenc.c: (gst_wavpack_enc_init),
(gst_wavpack_enc_finalize), (gst_wavpack_enc_sink_set_caps),
(gst_wavpack_enc_set_wp_config), (gst_wavpack_enc_format_samples),
(gst_wavpack_enc_push_block), (gst_wavpack_enc_chain),
(gst_wavpack_enc_rewrite_first_block),
(gst_wavpack_enc_sink_event), (gst_wavpack_enc_change_state),
(gst_wavpack_enc_set_property), (gst_wavpack_enc_get_property):
* ext/wavpack/gstwavpackenc.h:
* ext/wavpack/gstwavpackparse.c: (gst_wavpack_parse_reset),
(gst_wavpack_parse_src_query), (gst_wavpack_parse_src_event),
(gst_wavpack_parse_init), (gst_wavpack_parse_get_upstream_length),
(gst_wavpack_parse_loop):
More clean-ups: use shorter variable names to make code easier to
read; prefix structures we define with 'Gst' to make it clearer
where they come from.

1 files changed, 198 insertions, 207 deletions

diff --git a/ext/wavpack/gstwavpackenc.c b/ext/wavpack/gstwavpackenc.c
index 09ff3e7a..9eaf45c6 100644
--- a/ext/wavpack/gstwavpackenc.c
+++ b/ext/wavpack/gstwavpackenc.c
@@ -256,56 +256,55 @@ gst_wavpack_enc_class_init (GstWavpackEncClass * klass)
 }
 
 static void
-gst_wavpack_enc_init (GstWavpackEnc * wavpack_enc, GstWavpackEncClass * gclass)
+gst_wavpack_enc_init (GstWavpackEnc * enc, GstWavpackEncClass * gclass)
 {
-  wavpack_enc->sinkpad =
-      gst_pad_new_from_static_template (&sink_factory, "sink");
-  gst_pad_set_setcaps_function (wavpack_enc->sinkpad,
+  enc->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
+  gst_pad_set_setcaps_function (enc->sinkpad,
       GST_DEBUG_FUNCPTR (gst_wavpack_enc_sink_set_caps));
-  gst_pad_set_chain_function (wavpack_enc->sinkpad,
+  gst_pad_set_chain_function (enc->sinkpad,
       GST_DEBUG_FUNCPTR (gst_wavpack_enc_chain));
-  gst_pad_set_event_function (wavpack_enc->sinkpad,
+  gst_pad_set_event_function (enc->sinkpad,
       GST_DEBUG_FUNCPTR (gst_wavpack_enc_sink_event));
-  gst_element_add_pad (GST_ELEMENT (wavpack_enc), wavpack_enc->sinkpad);
+  gst_element_add_pad (GST_ELEMENT (enc), enc->sinkpad);
 
   /* setup src pad */
-  wavpack_enc->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
-  gst_element_add_pad (GST_ELEMENT (wavpack_enc), wavpack_enc->srcpad);
+  enc->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
+  gst_element_add_pad (GST_ELEMENT (enc), enc->srcpad);
 
   /* initialize object attributes */
-  wavpack_enc->wp_config = NULL;
-  wavpack_enc->wp_context = NULL;
-  wavpack_enc->first_block = NULL;
-  wavpack_enc->first_block_size = 0;
-  wavpack_enc->md5_context = NULL;
-  wavpack_enc->samplerate = 0;
-  wavpack_enc->width = 0;
-  wavpack_enc->channels = 0;
-
-  wavpack_enc->wv_id = (write_id *) g_malloc0 (sizeof (write_id));
-  wavpack_enc->wv_id->correction = FALSE;
-  wavpack_enc->wv_id->wavpack_enc = wavpack_enc;
-  wavpack_enc->wvc_id = (write_id *) g_malloc0 (sizeof (write_id));
-  wavpack_enc->wvc_id->correction = TRUE;
-  wavpack_enc->wvc_id->wavpack_enc = wavpack_enc;
+  enc->wp_config = NULL;
+  enc->wp_context = NULL;
+  enc->first_block = NULL;
+  enc->first_block_size = 0;
+  enc->md5_context = NULL;
+  enc->samplerate = 0;
+  enc->width = 0;
+  enc->channels = 0;
+
+  enc->wv_id = g_new0 (GstWavpackEncWriteID, 1);
+  enc->wv_id->correction = FALSE;
+  enc->wv_id->wavpack_enc = enc;
+  enc->wvc_id = g_new0 (GstWavpackEncWriteID, 1);
+  enc->wvc_id->correction = TRUE;
+  enc->wvc_id->wavpack_enc = enc;
 
   /* set default values of params */
-  wavpack_enc->mode = 1;
-  wavpack_enc->bitrate = 0.0;
-  wavpack_enc->correction_mode = 0;
-  wavpack_enc->md5 = FALSE;
-  wavpack_enc->extra_processing = FALSE;
-  wavpack_enc->joint_stereo_mode = 0;
+  enc->mode = 1;
+  enc->bitrate = 0.0;
+  enc->correction_mode = 0;
+  enc->md5 = FALSE;
+  enc->extra_processing = FALSE;
+  enc->joint_stereo_mode = 0;
 }
 
 static void
 gst_wavpack_enc_finalize (GObject * object)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (object);
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (object);
 
   /* free the blockout helpers */
-  g_free (wavpack_enc->wv_id);
-  g_free (wavpack_enc->wvc_id);
+  g_free (enc->wv_id);
+  g_free (enc->wvc_id);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -313,146 +312,144 @@ gst_wavpack_enc_finalize (GObject * object)
 static gboolean
 gst_wavpack_enc_sink_set_caps (GstPad * pad, GstCaps * caps)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
   GstStructure *structure = gst_caps_get_structure (caps, 0);
   int depth = 0;
 
   /* check caps and put relevant parts into our object attributes */
-  if ((!gst_structure_get_int (structure, "channels", &wavpack_enc->channels))
-      || (!gst_structure_get_int (structure, "rate", &wavpack_enc->samplerate))
-      || (!gst_structure_get_int (structure, "width", &wavpack_enc->width))
-      || (!(gst_structure_get_int (structure, "depth", &depth))
-          || depth != wavpack_enc->width)) {
-    GST_ELEMENT_ERROR (wavpack_enc, LIBRARY, INIT, (NULL),
+  if (!gst_structure_get_int (structure, "channels", &enc->channels) ||
+      !gst_structure_get_int (structure, "rate", &enc->samplerate) ||
+      !gst_structure_get_int (structure, "width", &enc->width) ||
+      !(gst_structure_get_int (structure, "depth", &depth) ||
+          depth != enc->width)) {
+    GST_ELEMENT_ERROR (enc, LIBRARY, INIT, (NULL),
         ("got invalid caps: %", GST_PTR_FORMAT, caps));
-    gst_object_unref (wavpack_enc);
+    gst_object_unref (enc);
     return FALSE;
   }
 
   /* set fixed src pad caps now that we know what we will get */
   caps = gst_caps_new_simple ("audio/x-wavpack",
-      "channels", G_TYPE_INT, wavpack_enc->channels,
-      "rate", G_TYPE_INT, wavpack_enc->samplerate,
-      "width", G_TYPE_INT, wavpack_enc->width,
-      "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+      "channels", G_TYPE_INT, enc->channels,
+      "rate", G_TYPE_INT, enc->samplerate,
+      "width", G_TYPE_INT, enc->width, "framed", G_TYPE_BOOLEAN, TRUE, NULL);
 
-  if (!gst_pad_set_caps (wavpack_enc->srcpad, caps)) {
-    GST_ELEMENT_ERROR (wavpack_enc, LIBRARY, INIT, (NULL),
+  if (!gst_pad_set_caps (enc->srcpad, caps)) {
+    GST_ELEMENT_ERROR (enc, LIBRARY, INIT, (NULL),
         ("setting caps failed: %", GST_PTR_FORMAT, caps));
     gst_caps_unref (caps);
-    gst_object_unref (wavpack_enc);
+    gst_object_unref (enc);
     return FALSE;
   }
-  gst_pad_use_fixed_caps (wavpack_enc->srcpad);
+  gst_pad_use_fixed_caps (enc->srcpad);
 
   gst_caps_unref (caps);
-  gst_object_unref (wavpack_enc);
+  gst_object_unref (enc);
   return TRUE;
 }
 
 static void
-gst_wavpack_enc_set_wp_config (GstWavpackEnc * wavpack_enc)
+gst_wavpack_enc_set_wp_config (GstWavpackEnc * enc)
 {
-  wavpack_enc->wp_config = (WavpackConfig *) g_malloc0 (sizeof (WavpackConfig));
+  enc->wp_config = g_new0 (WavpackConfig, 1);
   /* set general stream informations in the WavpackConfig */
-  wavpack_enc->wp_config->bytes_per_sample = (wavpack_enc->width + 7) >> 3;
-  wavpack_enc->wp_config->bits_per_sample = wavpack_enc->width;
-  wavpack_enc->wp_config->num_channels = wavpack_enc->channels;
+  enc->wp_config->bytes_per_sample = (enc->width + 7) >> 3;
+  enc->wp_config->bits_per_sample = enc->width;
+  enc->wp_config->num_channels = enc->channels;
 
   /* TODO: handle more than 2 channels correctly! */
-  if (wavpack_enc->channels == 1) {
-    wavpack_enc->wp_config->channel_mask = 0x4;
-  } else if (wavpack_enc->channels == 2) {
-    wavpack_enc->wp_config->channel_mask = 0x2 | 0x1;
+  if (enc->channels == 1) {
+    enc->wp_config->channel_mask = 0x4;
+  } else if (enc->channels == 2) {
+    enc->wp_config->channel_mask = 0x2 | 0x1;
   }
-  wavpack_enc->wp_config->sample_rate = wavpack_enc->samplerate;
+  enc->wp_config->sample_rate = enc->samplerate;
 
   /*
    * Set parameters in WavpackConfig
    */
 
   /* Encoding mode */
-  switch (wavpack_enc->mode) {
+  switch (enc->mode) {
     case 0:
-      wavpack_enc->wp_config->flags |= CONFIG_FAST_FLAG;
+      enc->wp_config->flags |= CONFIG_FAST_FLAG;
       break;
     case 1:                    /* default */
       break;
     case 2:
-      wavpack_enc->wp_config->flags |= CONFIG_HIGH_FLAG;
+      enc->wp_config->flags |= CONFIG_HIGH_FLAG;
       break;
   }
 
   /* Bitrate, enables lossy mode */
-  if (wavpack_enc->bitrate >= 2.0) {
-    wavpack_enc->wp_config->flags |= CONFIG_HYBRID_FLAG;
-    if (wavpack_enc->bitrate >= 24000.0) {
-      wavpack_enc->wp_config->bitrate = wavpack_enc->bitrate / 1000.0;
-      wavpack_enc->wp_config->flags |= CONFIG_BITRATE_KBPS;
+  if (enc->bitrate >= 2.0) {
+    enc->wp_config->flags |= CONFIG_HYBRID_FLAG;
+    if (enc->bitrate >= 24000.0) {
+      enc->wp_config->bitrate = enc->bitrate / 1000.0;
+      enc->wp_config->flags |= CONFIG_BITRATE_KBPS;
     } else {
-      wavpack_enc->wp_config->bitrate = wavpack_enc->bitrate;
+      enc->wp_config->bitrate = enc->bitrate;
     }
   }
 
   /* Correction Mode, only in lossy mode */
-  if (wavpack_enc->wp_config->flags & CONFIG_HYBRID_FLAG) {
-    if (wavpack_enc->correction_mode > 0) {
-      wavpack_enc->wvcsrcpad =
+  if (enc->wp_config->flags & CONFIG_HYBRID_FLAG) {
+    if (enc->correction_mode > 0) {
+      enc->wvcsrcpad =
           gst_pad_new_from_static_template (&wvcsrc_factory, "wvcsrc");
 
       /* try to add correction src pad, don't set correction mode on failure */
       GstCaps *caps = gst_caps_new_simple ("audio/x-wavpack-correction",
           "framed", G_TYPE_BOOLEAN, TRUE, NULL);
 
-      gst_element_no_more_pads (GST_ELEMENT (wavpack_enc));
+      gst_element_no_more_pads (GST_ELEMENT (enc));
 
-      GST_DEBUG_OBJECT (wavpack_enc, "Adding correction pad with caps %"
+      GST_DEBUG_OBJECT (enc, "Adding correction pad with caps %"
           GST_PTR_FORMAT, caps);
-      if (!gst_pad_set_caps (wavpack_enc->wvcsrcpad, caps)) {
-        wavpack_enc->correction_mode = 0;
-        GST_WARNING_OBJECT (wavpack_enc, "setting correction caps failed");
+      if (!gst_pad_set_caps (enc->wvcsrcpad, caps)) {
+        enc->correction_mode = 0;
+        GST_WARNING_OBJECT (enc, "setting correction caps failed");
       } else {
-        gst_pad_use_fixed_caps (wavpack_enc->wvcsrcpad);
-        gst_element_add_pad (GST_ELEMENT (wavpack_enc), wavpack_enc->wvcsrcpad);
-        wavpack_enc->wp_config->flags |= CONFIG_CREATE_WVC;
-        if (wavpack_enc->correction_mode == 2) {
-          wavpack_enc->wp_config->flags |= CONFIG_OPTIMIZE_WVC;
+        gst_pad_use_fixed_caps (enc->wvcsrcpad);
+        gst_element_add_pad (GST_ELEMENT (enc), enc->wvcsrcpad);
+        enc->wp_config->flags |= CONFIG_CREATE_WVC;
+        if (enc->correction_mode == 2) {
+          enc->wp_config->flags |= CONFIG_OPTIMIZE_WVC;
         }
       }
       gst_caps_unref (caps);
     }
   } else {
-    if (wavpack_enc->correction_mode > 0) {
-      wavpack_enc->correction_mode = 0;
-      GST_WARNING_OBJECT (wavpack_enc, "setting correction mode only has "
+    if (enc->correction_mode > 0) {
+      enc->correction_mode = 0;
+      GST_WARNING_OBJECT (enc, "setting correction mode only has "
           "any effect if a bitrate is provided.");
     }
   }
-  gst_element_no_more_pads (GST_ELEMENT (wavpack_enc));
+  gst_element_no_more_pads (GST_ELEMENT (enc));
 
   /* MD5, setup MD5 context */
-  if ((wavpack_enc->md5) && !(wavpack_enc->md5_context)) {
-    wavpack_enc->wp_config->flags |= CONFIG_MD5_CHECKSUM;
-    wavpack_enc->md5_context = (MD5_CTX *) g_malloc0 (sizeof (MD5_CTX));
-    MD5Init (wavpack_enc->md5_context);
+  if ((enc->md5) && !(enc->md5_context)) {
+    enc->wp_config->flags |= CONFIG_MD5_CHECKSUM;
+    enc->md5_context = g_new0 (MD5_CTX, 1);
+    MD5Init (enc->md5_context);
   }
 
   /* Extra encode processing */
-  if (wavpack_enc->extra_processing) {
-    wavpack_enc->wp_config->flags |= CONFIG_EXTRA_MODE;
+  if (enc->extra_processing) {
+    enc->wp_config->flags |= CONFIG_EXTRA_MODE;
   }
 
   /* Joint stereo mode */
-  switch (wavpack_enc->joint_stereo_mode) {
+  switch (enc->joint_stereo_mode) {
     case 0:                    /* default */
       break;
     case 1:
-      wavpack_enc->wp_config->flags |= CONFIG_JOINT_OVERRIDE;
-      wavpack_enc->wp_config->flags &= ~CONFIG_JOINT_STEREO;
+      enc->wp_config->flags |= CONFIG_JOINT_OVERRIDE;
+      enc->wp_config->flags &= ~CONFIG_JOINT_STEREO;
       break;
     case 2:
-      wavpack_enc->wp_config->flags |=
-          (CONFIG_JOINT_OVERRIDE | CONFIG_JOINT_STEREO);
+      enc->wp_config->flags |= (CONFIG_JOINT_OVERRIDE | CONFIG_JOINT_STEREO);
       break;
   }
 }
@@ -461,7 +458,7 @@ static int32_t *
 gst_wavpack_enc_format_samples (const uchar * src_data, uint32_t sample_count,
     guint width)
 {
-  int32_t *data = (int32_t *) g_malloc0 (sizeof (int32_t) * sample_count);
+  int32_t *data = g_new0 (int32_t, sample_count);
 
   /* put all samples into an int32_t*, no matter what
    * width we have and convert them from little endian
@@ -500,23 +497,23 @@ gst_wavpack_enc_format_samples (const uchar * src_data, uint32_t sample_count,
 static int
 gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
 {
-  write_id *wid = (write_id *) id;
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (wid->wavpack_enc);
+  GstWavpackEncWriteID *wid = (GstWavpackEncWriteID *) id;
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (wid->wavpack_enc);
   GstFlowReturn *flow;
   GstBuffer *buffer;
   GstPad *pad;
   guchar *block = (guchar *) data;
 
-  pad = (wid->correction) ? wavpack_enc->wvcsrcpad : wavpack_enc->srcpad;
+  pad = (wid->correction) ? enc->wvcsrcpad : enc->srcpad;
   flow =
-      (wid->correction) ? &wavpack_enc->wvcsrcpad_last_return : &wavpack_enc->
+      (wid->correction) ? &enc->wvcsrcpad_last_return : &enc->
       srcpad_last_return;
 
   *flow = gst_pad_alloc_buffer_and_set_caps (pad, GST_BUFFER_OFFSET_NONE,
       count, GST_PAD_CAPS (pad), &buffer);
 
   if (*flow != GST_FLOW_OK) {
-    GST_WARNING_OBJECT (wavpack_enc, "flow on %s:%s = %s",
+    GST_WARNING_OBJECT (enc, "flow on %s:%s = %s",
         GST_DEBUG_PAD_NAME (pad), gst_flow_get_name (*flow));
     return FALSE;
   }
@@ -527,7 +524,7 @@ gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
     /* if it's a Wavpack block set buffer timestamp and duration, etc */
     WavpackHeader wph;
 
-    GST_LOG_OBJECT (wavpack_enc, "got %d bytes of encoded wavpack %sdata",
+    GST_LOG_OBJECT (enc, "got %d bytes of encoded wavpack %sdata",
         count, (wid->correction) ? "correction " : "");
 
     gst_wavpack_read_header (&wph, block);
@@ -539,10 +536,10 @@ gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
 
       /* save header for later reference, so we can re-send it later on
        * EOS with fixed up values for total sample count etc. */
-      if (wavpack_enc->first_block == NULL && !wid->correction) {
-        gst_pad_push_event (wavpack_enc->srcpad, event);
-        wavpack_enc->first_block = g_memdup (block, count);
-        wavpack_enc->first_block_size = count;
+      if (enc->first_block == NULL && !wid->correction) {
+        gst_pad_push_event (enc->srcpad, event);
+        enc->first_block = g_memdup (block, count);
+        enc->first_block_size = count;
       }
     }
 
@@ -550,15 +547,15 @@ gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
      * the wavpack header */
     GST_BUFFER_TIMESTAMP (buffer) =
         gst_util_uint64_scale_int (GST_SECOND, wph.block_index,
-        wavpack_enc->samplerate);
+        enc->samplerate);
     GST_BUFFER_DURATION (buffer) =
         gst_util_uint64_scale_int (GST_SECOND, wph.block_samples,
-        wavpack_enc->samplerate);
+        enc->samplerate);
     GST_BUFFER_OFFSET (buffer) = wph.block_index;
     GST_BUFFER_OFFSET_END (buffer) = wph.block_index + wph.block_samples;
   } else {
     /* if it's something else set no timestamp and duration on the buffer */
-    GST_DEBUG_OBJECT (wavpack_enc, "got %d bytes of unknown data", count);
+    GST_DEBUG_OBJECT (enc, "got %d bytes of unknown data", count);
 
     GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE;
     GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
@@ -568,7 +565,7 @@ gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
   *flow = gst_pad_push (pad, buffer);
 
   if (*flow != GST_FLOW_OK) {
-    GST_WARNING_OBJECT (wavpack_enc, "flow on %s:%s = %s",
+    GST_WARNING_OBJECT (enc, "flow on %s:%s = %s",
         GST_DEBUG_PAD_NAME (pad), gst_flow_get_name (*flow));
     return FALSE;
   }
@@ -579,46 +576,44 @@ gst_wavpack_enc_push_block (void *id, void *data, int32_t count)
 static GstFlowReturn
 gst_wavpack_enc_chain (GstPad * pad, GstBuffer * buf)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
-  uint32_t sample_count =
-      GST_BUFFER_SIZE (buf) / ((wavpack_enc->width + 7) >> 3);
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
+  uint32_t sample_count = GST_BUFFER_SIZE (buf) / ((enc->width + 7) >> 3);
   int32_t *data;
   GstFlowReturn ret;
 
   /* reset the last returns to GST_FLOW_OK. This is only set to something else
    * while WavpackPackSamples() or more specific gst_wavpack_enc_push_block()
    * so not valid anymore */
-  wavpack_enc->srcpad_last_return = wavpack_enc->wvcsrcpad_last_return =
-      GST_FLOW_OK;
+  enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK;
 
   GST_DEBUG ("got %u raw samples", sample_count);
 
   /* check if we already have a valid WavpackContext, otherwise make one */
-  if (!wavpack_enc->wp_context) {
+  if (!enc->wp_context) {
     /* create raw context */
-    wavpack_enc->wp_context =
-        WavpackOpenFileOutput (gst_wavpack_enc_push_block, wavpack_enc->wv_id,
-        (wavpack_enc->correction_mode > 0) ? wavpack_enc->wvc_id : NULL);
-    if (!wavpack_enc->wp_context) {
-      GST_ELEMENT_ERROR (wavpack_enc, LIBRARY, INIT, (NULL),
+    enc->wp_context =
+        WavpackOpenFileOutput (gst_wavpack_enc_push_block, enc->wv_id,
+        (enc->correction_mode > 0) ? enc->wvc_id : NULL);
+    if (!enc->wp_context) {
+      GST_ELEMENT_ERROR (enc, LIBRARY, INIT, (NULL),
           ("error creating Wavpack context"));
-      gst_object_unref (wavpack_enc);
+      gst_object_unref (enc);
       gst_buffer_unref (buf);
       return GST_FLOW_ERROR;
     }
 
     /* set the WavpackConfig according to our parameters */
-    gst_wavpack_enc_set_wp_config (wavpack_enc);
+    gst_wavpack_enc_set_wp_config (enc);
 
     /* set the configuration to the context now that we know everything
      * and initialize the encoder */
-    if (!WavpackSetConfiguration (wavpack_enc->wp_context,
-            wavpack_enc->wp_config, (uint32_t) (-1))
-        || !WavpackPackInit (wavpack_enc->wp_context)) {
-      GST_ELEMENT_ERROR (wavpack_enc, LIBRARY, SETTINGS, (NULL),
+    if (!WavpackSetConfiguration (enc->wp_context,
+            enc->wp_config, (uint32_t) (-1))
+        || !WavpackPackInit (enc->wp_context)) {
+      GST_ELEMENT_ERROR (enc, LIBRARY, SETTINGS, (NULL),
           ("error setting up wavpack encoding context"));
-      WavpackCloseFile (wavpack_enc->wp_context);
-      gst_object_unref (wavpack_enc);
+      WavpackCloseFile (enc->wp_context);
+      gst_object_unref (enc);
       gst_buffer_unref (buf);
       return GST_FLOW_ERROR;
     }
@@ -627,9 +622,8 @@ gst_wavpack_enc_chain (GstPad * pad, GstBuffer * buf)
 
   /* if we want to append the MD5 sum to the stream update it here
    * with the current raw samples */
-  if (wavpack_enc->md5) {
-    MD5Update (wavpack_enc->md5_context, GST_BUFFER_DATA (buf),
-        GST_BUFFER_SIZE (buf));
+  if (enc->md5) {
+    MD5Update (enc->md5_context, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
   }
 
   /* put all samples into an int32_t*, no matter what
@@ -637,62 +631,61 @@ gst_wavpack_enc_chain (GstPad * pad, GstBuffer * buf)
    * to host byte order */
   data =
       gst_wavpack_enc_format_samples (GST_BUFFER_DATA (buf), sample_count,
-      wavpack_enc->width);
+      enc->width);
 
   gst_buffer_unref (buf);
 
   /* encode and handle return values from encoding */
-  if (WavpackPackSamples (wavpack_enc->wp_context, data,
-          sample_count / wavpack_enc->channels)) {
+  if (WavpackPackSamples (enc->wp_context, data, sample_count / enc->channels)) {
     GST_DEBUG ("encoding samples successful");
     ret = GST_FLOW_OK;
   } else {
-    if ((wavpack_enc->srcpad_last_return == GST_FLOW_RESEND) ||
-        (wavpack_enc->wvcsrcpad_last_return == GST_FLOW_RESEND)) {
+    if ((enc->srcpad_last_return == GST_FLOW_RESEND) ||
+        (enc->wvcsrcpad_last_return == GST_FLOW_RESEND)) {
       ret = GST_FLOW_RESEND;
-    } else if ((wavpack_enc->srcpad_last_return == GST_FLOW_OK) ||
-        (wavpack_enc->wvcsrcpad_last_return == GST_FLOW_OK)) {
+    } else if ((enc->srcpad_last_return == GST_FLOW_OK) ||
+        (enc->wvcsrcpad_last_return == GST_FLOW_OK)) {
       ret = GST_FLOW_OK;
-    } else if ((wavpack_enc->srcpad_last_return == GST_FLOW_NOT_LINKED) &&
-        (wavpack_enc->wvcsrcpad_last_return == GST_FLOW_NOT_LINKED)) {
+    } else if ((enc->srcpad_last_return == GST_FLOW_NOT_LINKED) &&
+        (enc->wvcsrcpad_last_return == GST_FLOW_NOT_LINKED)) {
       ret = GST_FLOW_NOT_LINKED;
-    } else if ((wavpack_enc->srcpad_last_return == GST_FLOW_WRONG_STATE) &&
-        (wavpack_enc->wvcsrcpad_last_return == GST_FLOW_WRONG_STATE)) {
+    } else if ((enc->srcpad_last_return == GST_FLOW_WRONG_STATE) &&
+        (enc->wvcsrcpad_last_return == GST_FLOW_WRONG_STATE)) {
       ret = GST_FLOW_WRONG_STATE;
     } else {
-      GST_ELEMENT_ERROR (wavpack_enc, LIBRARY, ENCODE, (NULL),
+      GST_ELEMENT_ERROR (enc, LIBRARY, ENCODE, (NULL),
           ("encoding samples failed"));
       ret = GST_FLOW_ERROR;
     }
   }
 
   g_free (data);
-  gst_object_unref (wavpack_enc);
+  gst_object_unref (enc);
   return ret;
 }
 
 static void
-gst_wavpack_enc_rewrite_first_block (GstWavpackEnc * wavpack_enc)
+gst_wavpack_enc_rewrite_first_block (GstWavpackEnc * enc)
 {
   GstEvent *event = gst_event_new_new_segment (TRUE, 1.0, GST_FORMAT_BYTES,
       0, GST_BUFFER_OFFSET_NONE, 0);
   gboolean ret;
 
-  g_return_if_fail (wavpack_enc);
-  g_return_if_fail (wavpack_enc->first_block);
+  g_return_if_fail (enc);
+  g_return_if_fail (enc->first_block);
 
   /* update the sample count in the first block */
-  WavpackUpdateNumSamples (wavpack_enc->wp_context, wavpack_enc->first_block);
+  WavpackUpdateNumSamples (enc->wp_context, enc->first_block);
 
   /* try to seek to the beginning of the output */
-  ret = gst_pad_push_event (wavpack_enc->srcpad, event);
+  ret = gst_pad_push_event (enc->srcpad, event);
   if (ret) {
     /* try to rewrite the first block */
-    GST_DEBUG_OBJECT (wavpack_enc, "rewriting first block ...");
-    ret = gst_wavpack_enc_push_block (wavpack_enc->wv_id,
-        wavpack_enc->first_block, wavpack_enc->first_block_size);
+    GST_DEBUG_OBJECT (enc, "rewriting first block ...");
+    ret = gst_wavpack_enc_push_block (enc->wv_id,
+        enc->first_block, enc->first_block_size);
   } else {
-    GST_WARNING_OBJECT (wavpack_enc, "rewriting of first block failed. "
+    GST_WARNING_OBJECT (enc, "rewriting of first block failed. "
         "Seeking to first block failed!");
   }
 }
@@ -700,7 +693,7 @@ gst_wavpack_enc_rewrite_first_block (GstWavpackEnc * wavpack_enc)
 static gboolean
 gst_wavpack_enc_sink_event (GstPad * pad, GstEvent * event)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
   gboolean ret = TRUE;
 
   GST_DEBUG ("Received %s event on sinkpad", GST_EVENT_TYPE_NAME (event));
@@ -708,31 +701,31 @@ gst_wavpack_enc_sink_event (GstPad * pad, GstEvent * event)
   switch (GST_EVENT_TYPE (event)) {
     case GST_EVENT_EOS:
       /* Encode all remaining samples and flush them to the src pads */
-      WavpackFlushSamples (wavpack_enc->wp_context);
+      WavpackFlushSamples (enc->wp_context);
 
       /* write the MD5 sum if we have to write one */
-      if ((wavpack_enc->md5) && (wavpack_enc->md5_context)) {
+      if ((enc->md5) && (enc->md5_context)) {
         guchar md5_digest[16];
 
-        MD5Final (md5_digest, wavpack_enc->md5_context);
-        WavpackStoreMD5Sum (wavpack_enc->wp_context, md5_digest);
+        MD5Final (md5_digest, enc->md5_context);
+        WavpackStoreMD5Sum (enc->wp_context, md5_digest);
       }
 
       /* Try to rewrite the first frame with the correct sample number */
-      if (wavpack_enc->first_block)
-        gst_wavpack_enc_rewrite_first_block (wavpack_enc);
+      if (enc->first_block)
+        gst_wavpack_enc_rewrite_first_block (enc);
 
       /* close the context if not already happened */
-      if (wavpack_enc->wp_context) {
-        WavpackCloseFile (wavpack_enc->wp_context);
-        wavpack_enc->wp_context = NULL;
+      if (enc->wp_context) {
+        WavpackCloseFile (enc->wp_context);
+        enc->wp_context = NULL;
       }
 
       ret = gst_pad_event_default (pad, event);
       break;
     case GST_EVENT_NEWSEGMENT:
-      if (wavpack_enc->wp_context) {
-        GST_WARNING_OBJECT (wavpack_enc, "got NEWSEGMENT after encoding "
+      if (enc->wp_context) {
+        GST_WARNING_OBJECT (enc, "got NEWSEGMENT after encoding "
             "already started");
       }
       /* drop NEWSEGMENT events, we create our own when pushing
@@ -745,7 +738,7 @@ gst_wavpack_enc_sink_event (GstPad * pad, GstEvent * event)
       break;
   }
 
-  gst_object_unref (wavpack_enc);
+  gst_object_unref (enc);
   return ret;
 }
 
@@ -753,15 +746,14 @@ static GstStateChangeReturn
 gst_wavpack_enc_change_state (GstElement * element, GstStateChange transition)
 {
   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (element);
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (element);
 
   switch (transition) {
     case GST_STATE_CHANGE_NULL_TO_READY:
       /* set the last returned GstFlowReturns of the two pads to GST_FLOW_OK
        * as they're only set to something else in WavpackPackSamples() or more
        * specific gst_wavpack_enc_push_block() and nothing happened there yet */
-      wavpack_enc->srcpad_last_return = wavpack_enc->wvcsrcpad_last_return =
-          GST_FLOW_OK;
+      enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK;
     case GST_STATE_CHANGE_READY_TO_PAUSED:
     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
     default:
@@ -775,29 +767,28 @@ gst_wavpack_enc_change_state (GstElement * element, GstStateChange transition)
       break;
     case GST_STATE_CHANGE_PAUSED_TO_READY:
       /* close and free everything stream related */
-      if (wavpack_enc->wp_context) {
-        WavpackCloseFile (wavpack_enc->wp_context);
-        wavpack_enc->wp_context = NULL;
+      if (enc->wp_context) {
+        WavpackCloseFile (enc->wp_context);
+        enc->wp_context = NULL;
       }
-      if (wavpack_enc->wp_config) {
-        g_free (wavpack_enc->wp_config);
-        wavpack_enc->wp_config = NULL;
+      if (enc->wp_config) {
+        g_free (enc->wp_config);
+        enc->wp_config = NULL;
       }
-      if (wavpack_enc->first_block) {
-        g_free (wavpack_enc->first_block);
-        wavpack_enc->first_block = NULL;
-        wavpack_enc->first_block_size = 0;
+      if (enc->first_block) {
+        g_free (enc->first_block);
+        enc->first_block = NULL;
+        enc->first_block_size = 0;
       }
-      if (wavpack_enc->md5_context) {
-        g_free (wavpack_enc->md5_context);
-        wavpack_enc->md5_context = NULL;
+      if (enc->md5_context) {
+        g_free (enc->md5_context);
+        enc->md5_context = NULL;
       }
 
       /* reset the last returns to GST_FLOW_OK. This is only set to something else
        * while WavpackPackSamples() or more specific gst_wavpack_enc_push_block()
        * so not valid anymore */
-      wavpack_enc->srcpad_last_return = wavpack_enc->wvcsrcpad_last_return =
-          GST_FLOW_OK;
+      enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK;
       break;
     case GST_STATE_CHANGE_READY_TO_NULL:
       break;
@@ -812,19 +803,19 @@ static void
 gst_wavpack_enc_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (object);
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (object);
 
   switch (prop_id) {
     case ARG_MODE:
-      wavpack_enc->mode = g_value_get_enum (value);
+      enc->mode = g_value_get_enum (value);
       break;
     case ARG_BITRATE:{
       gdouble val = g_value_get_double (value);
 
       if ((val >= 24000.0) && (val <= 9600000.0)) {
-        wavpack_enc->bitrate = val;
+        enc->bitrate = val;
       } else {
-        wavpack_enc->bitrate = 0.0;
+        enc->bitrate = 0.0;
       }
       break;
     }
@@ -832,23 +823,23 @@ gst_wavpack_enc_set_property (GObject * object, guint prop_id,
       gdouble val = g_value_get_double (value);
 
       if ((val >= 2.0) && (val <= 24.0)) {
-        wavpack_enc->bitrate = val;
+        enc->bitrate = val;
       } else {
-        wavpack_enc->bitrate = 0.0;
+        enc->bitrate = 0.0;
       }
       break;
     }
     case ARG_CORRECTION_MODE:
-      wavpack_enc->correction_mode = g_value_get_enum (value);
+      enc->correction_mode = g_value_get_enum (value);
       break;
     case ARG_MD5:
-      wavpack_enc->md5 = g_value_get_boolean (value);
+      enc->md5 = g_value_get_boolean (value);
       break;
     case ARG_EXTRA_PROCESSING:
-      wavpack_enc->extra_processing = g_value_get_boolean (value);
+      enc->extra_processing = g_value_get_boolean (value);
       break;
     case ARG_JOINT_STEREO_MODE:
-      wavpack_enc->joint_stereo_mode = g_value_get_enum (value);
+      enc->joint_stereo_mode = g_value_get_enum (value);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -860,37 +851,37 @@ static void
 gst_wavpack_enc_get_property (GObject * object, guint prop_id, GValue * value,
     GParamSpec * pspec)
 {
-  GstWavpackEnc *wavpack_enc = GST_WAVPACK_ENC (object);
+  GstWavpackEnc *enc = GST_WAVPACK_ENC (object);
 
   switch (prop_id) {
     case ARG_MODE:
-      g_value_set_enum (value, wavpack_enc->mode);
+      g_value_set_enum (value, enc->mode);
       break;
     case ARG_BITRATE:
-      if (wavpack_enc->bitrate >= 24000.0) {
-        g_value_set_double (value, wavpack_enc->bitrate);
+      if (enc->bitrate >= 24000.0) {
+        g_value_set_double (value, enc->bitrate);
       } else {
         g_value_set_double (value, 0.0);
       }
       break;
     case ARG_BITSPERSAMPLE:
-      if (wavpack_enc->bitrate <= 24.0) {
-        g_value_set_double (value, wavpack_enc->bitrate);
+      if (enc->bitrate <= 24.0) {
+        g_value_set_double (value, enc->bitrate);
       } else {
         g_value_set_double (value, 0.0);
       }
       break;
     case ARG_CORRECTION_MODE:
-      g_value_set_enum (value, wavpack_enc->correction_mode);
+      g_value_set_enum (value, enc->correction_mode);
       break;
     case ARG_MD5:
-      g_value_set_boolean (value, wavpack_enc->md5);
+      g_value_set_boolean (value, enc->md5);
       break;
     case ARG_EXTRA_PROCESSING:
-      g_value_set_boolean (value, wavpack_enc->extra_processing);
+      g_value_set_boolean (value, enc->extra_processing);
       break;
     case ARG_JOINT_STEREO_MODE:
-      g_value_set_enum (value, wavpack_enc->joint_stereo_mode);
+      g_value_set_enum (value, enc->joint_stereo_mode);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);