Add replaygain playback elements (#412710).

Original commit message from CVS:
Patch by: René Stadler <mail at renestadler de>
* docs/plugins/Makefile.am:
* docs/plugins/gst-plugins-bad-plugins-docs.sgml:
* docs/plugins/gst-plugins-bad-plugins-sections.txt:
* docs/plugins/inspect/plugin-replaygain.xml:
* gst/replaygain/Makefile.am:
* gst/replaygain/gstrganalysis.c: (gst_rg_analysis_class_init),
(gst_rg_analysis_start), (gst_rg_analysis_set_caps),
(gst_rg_analysis_transform_ip), (gst_rg_analysis_event),
(gst_rg_analysis_stop), (gst_rg_analysis_handle_tags),
(gst_rg_analysis_handle_eos), (gst_rg_analysis_track_result),
(gst_rg_analysis_album_result):
* gst/replaygain/gstrganalysis.h:
* gst/replaygain/gstrglimiter.c: (gst_rg_limiter_base_init),
(gst_rg_limiter_class_init), (gst_rg_limiter_init),
(gst_rg_limiter_set_property), (gst_rg_limiter_get_property),
(gst_rg_limiter_transform_ip):
* gst/replaygain/gstrglimiter.h:
* gst/replaygain/gstrgvolume.c: (gst_rg_volume_base_init),
(gst_rg_volume_class_init), (gst_rg_volume_init),
(gst_rg_volume_set_property), (gst_rg_volume_get_property),
(gst_rg_volume_dispose), (gst_rg_volume_change_state),
(gst_rg_volume_sink_event), (gst_rg_volume_tag_event),
(gst_rg_volume_reset), (gst_rg_volume_update_gain),
(gst_rg_volume_determine_gain):
* gst/replaygain/gstrgvolume.h:
* gst/replaygain/replaygain.c: (plugin_init):
* gst/replaygain/replaygain.h:
* gst/replaygain/rganalysis.h:
* tests/check/Makefile.am:
* tests/check/elements/.cvsignore:
* tests/check/elements/rganalysis.c: (send_eos_event),
(GST_START_TEST):
* tests/check/elements/rglimiter.c: (setup_rglimiter),
(cleanup_rglimiter), (set_playing_state), (create_test_buffer),
(verify_test_buffer), (GST_START_TEST), (rglimiter_suite), (main):
* tests/check/elements/rgvolume.c: (event_func), (setup_rgvolume),
(cleanup_rgvolume), (set_playing_state), (set_null_state),
(send_eos_event), (send_tag_event), (test_buffer_new),
(fail_unless_target_gain), (fail_unless_result_gain),
(fail_unless_gain), (GST_START_TEST), (rgvolume_suite), (main):
Add replaygain playback elements (#412710).

3 files changed, 910 insertions, 88 deletions

diff --git a/tests/check/elements/rganalysis.c b/tests/check/elements/rganalysis.c
index 63e3c720..e8a9db2f 100644
--- a/tests/check/elements/rganalysis.c
+++ b/tests/check/elements/rganalysis.c
@@ -20,77 +20,72 @@
  * 02110-1301 USA
  */
 
-/* Some things to note about the RMS window length of the analysis
- * algorithm and thus the implementation used in the element:
- * Processing divides input data into 50ms windows at some point.
- * Some details about this that normally do not matter:
+/* Some things to note about the RMS window length of the analysis algorithm and
+ * thus the implementation used in the element: Processing divides input data
+ * into 50ms windows at some point.  Some details about this that normally do
+ * not matter:
  *
- *  1. At the end of a stream, the remainder of data that did not fill
- *     up the last 50ms window is simply discarded.
+ *  1. At the end of a stream, the remainder of data that did not fill up the
+ *     last 50ms window is simply discarded.
  *
- *  2. If the sample rate changes during a stream, the currently
- *     running window is discarded and the equal loudness filter gets
- *     reset as if a new stream started.
+ *  2. If the sample rate changes during a stream, the currently running window
+ *     is discarded and the equal loudness filter gets reset as if a new stream
+ *     started.
  *
- *  3. For the album gain, it is not entirely correct to think of
- *     obtaining it like "as if all the tracks are analyzed as one
- *     track".  There isn't a separate window being tracked for album
- *     processing, so at stream (track) end, the remaining unfilled
- *     window does not contribute to the album gain either.
+ *  3. For the album gain, it is not entirely correct to think of obtaining it
+ *     like "as if all the tracks are analyzed as one track".  There isn't a
+ *     separate window being tracked for album processing, so at stream (track)
+ *     end, the remaining unfilled window does not contribute to the album gain
+ *     either.
  *
- *  4. If a waveform with a result gain G is concatenated to itself
- *     and the result processed as a track, the gain can be different
- *     from G if and only if the duration of the original waveform is
- *     not an integer multiple of 50ms.  If the original waveform gets
- *     processed as a single track and then the same data again as a
- *     subsequent track, the album result gain will always match G
- *     (this is implied by 3.).
+ *  4. If a waveform with a result gain G is concatenated to itself and the
+ *     result processed as a track, the gain can be different from G if and only
+ *     if the duration of the original waveform is not an integer multiple of
+ *     50ms.  If the original waveform gets processed as a single track and then
+ *     the same data again as a subsequent track, the album result gain will
+ *     always match G (this is implied by 3.).
  *
- *  5. A stream shorter than 50ms cannot be analyzed.  At 8000 and
- *     48000 Hz, this corresponds to 400 resp. 2400 frames.  If a
- *     stream is shorter than 50ms, the element will not generate tags
- *     at EOS (only if an album finished, but only album tags are
- *     generated then).  This is not an erroneous condition, the
- *     element should behave normally.
+ *  5. A stream shorter than 50ms cannot be analyzed.  At 8000 and 48000 Hz,
+ *     this corresponds to 400 resp. 2400 frames.  If a stream is shorter than
+ *     50ms, the element will not generate tags at EOS (only if an album
+ *     finished, but only album tags are generated then).  This is not an
+ *     erroneous condition, the element should behave normally.
  *
- * The limitations outlined in 1.-4. do not apply to the peak values.
- * Every single sample is accounted for when looking for the peak.
- * Thus the album peak is guaranteed to be the maximum value of all
- * track peaks.
+ * The limitations outlined in 1.-4. do not apply to the peak values.  Every
+ * single sample is accounted for when looking for the peak.  Thus the album
+ * peak is guaranteed to be the maximum value of all track peaks.
  *
- * In normal day-to-day use, these little facts are unlikely to be
- * relevant, but they have to be kept in mind for writing the tests
- * here.
+ * In normal day-to-day use, these little facts are unlikely to be relevant, but
+ * they have to be kept in mind for writing the tests here.
  */
 
 #include <gst/check/gstcheck.h>
 
 GList *buffers = NULL;
 
-/* For ease of programming we use globals to keep refs for our floating
- * src and sink pads we create; otherwise we always have to do get_pad,
- * get_peer, and then remove references in every test function */
+/* For ease of programming we use globals to keep refs for our floating src and
+ * sink pads we create; otherwise we always have to do get_pad, get_peer, and
+ * then remove references in every test function */
 static GstPad *mysrcpad, *mysinkpad;
 
-/* Mapping from supported sample rates to the correct result gain for
- * the following test waveform: 20 * 512 samples with a quarter-full
- * amplitude of toggling sign, changing every 48 samples and starting
- * with the positive value.
+/* Mapping from supported sample rates to the correct result gain for the
+ * following test waveform: 20 * 512 samples with a quarter-full amplitude of
+ * toggling sign, changing every 48 samples and starting with the positive
+ * value.
  *
- * Even if we would generate a wave describing a signal with the same
- * frequency at each sampling rate, the results would vary (slightly).
- * Hence the simple generation method, since we cannot use a constant
- * value as expected result anyways.  For all sample rates, changing
- * the sign every 48 frames gives a sane frequency.  Buffers
- * containing data that forms such a waveform is created using the
- * test_buffer_square_{float,int16}_{mono,stereo} functions below.
+ * Even if we would generate a wave describing a signal with the same frequency
+ * at each sampling rate, the results would vary (slightly).  Hence the simple
+ * generation method, since we cannot use a constant value as expected result
+ * anyways.  For all sample rates, changing the sign every 48 frames gives a
+ * sane frequency.  Buffers containing data that forms such a waveform is
+ * created using the test_buffer_square_{float,int16}_{mono,stereo} functions
+ * below.
  *
- * The results have been checked against what the metaflac and
- * wavegain programs generate for such a stream.  If you want to
- * verify these, be sure that the metaflac program does not produce
- * incorrect results in your environment: I found a strange bug in the
- * (defacto) reference code for the analysis that sometimes leads to
- * incorrect RMS window lengths. */
+ * The results have been checked against what the metaflac and wavegain programs
+ * generate for such a stream.  If you want to verify these, be sure that the
+ * metaflac program does not produce incorrect results in your environment: I
+ * found a strange bug in the (defacto) reference code for the analysis that
+ * sometimes leads to incorrect RMS window lengths. */
 
 struct rate_test
 {
@@ -212,11 +207,10 @@ send_eos_event (GstElement * element)
   fail_unless (gst_pad_send_event (pad, event),
       "Cannot send EOS event: Not handled.");
 
-  /* There is no sink element, so _we_ post the EOS message on the bus
-   * here.  Of course we generate any EOS ourselves, but this allows
-   * us to poll for the EOS message in poll_eos if we expect the
-   * element to _not_ generate a TAG message.  That's better than
-   * waiting for a timeout to lapse. */
+  /* There is no sink element, so _we_ post the EOS message on the bus here.  Of
+   * course we generate any EOS ourselves, but this allows us to poll for the
+   * EOS message in poll_eos if we expect the element to _not_ generate a TAG
+   * message.  That's better than waiting for a timeout to lapse. */
   fail_unless (gst_bus_post (bus, gst_message_new_eos (NULL)));
 
   gst_object_unref (bus);
@@ -251,8 +245,8 @@ poll_eos (GstElement * element)
   gst_object_unref (bus);
 }
 
-/* This also polls for EOS since the TAG message comes right before
- * the end of streams. */
+/* This also polls for EOS since the TAG message comes right before the end of
+ * streams. */
 
 static GstTagList *
 poll_tags (GstElement * element)
@@ -749,14 +743,13 @@ GST_END_TEST;
 
 /* Tests for correctness of the peak values. */
 
-/* Float peak test.  For stereo, one channel has the constant value of
- * -1.369, the other one 0.0.  This tests many things: The result peak
- * value should occur on any channel.  The peak is of course the
- * absolute amplitude, so 1.369 should be the result.  This will also
- * detect if the code uses the absolute value during the comparison.
- * If it is buggy it will return 0.0 since 0.0 > -1.369.  Furthermore,
- * this makes sure that there is no problem with headroom (exceeding
- * 0dBFS).  In the wild you get float samples > 1.0 from stuff like
+/* Float peak test.  For stereo, one channel has the constant value of -1.369,
+ * the other one 0.0.  This tests many things: The result peak value should
+ * occur on any channel.  The peak is of course the absolute amplitude, so 1.369
+ * should be the result.  This will also detect if the code uses the absolute
+ * value during the comparison.  If it is buggy it will return 0.0 since 0.0 >
+ * -1.369.  Furthermore, this makes sure that there is no problem with headroom
+ * (exceeding 0dBFS).  In the wild you get float samples > 1.0 from stuff like
  * vorbis. */
 
 GST_START_TEST (test_peak_float)
@@ -1089,11 +1082,10 @@ GST_START_TEST (test_peak_track_album)
 
 GST_END_TEST;
 
-/* Disabling album processing before the end of the album.  Probably a
- * rare edge case and applications should not rely on this to work.
- * They need to send the element to the READY state to clear up after
- * an aborted album anyway since they might need to process another
- * album afterwards. */
+/* Disabling album processing before the end of the album.  Probably a rare edge
+ * case and applications should not rely on this to work.  They need to send the
+ * element to the READY state to clear up after an aborted album anyway since
+ * they might need to process another album afterwards. */
 
 GST_START_TEST (test_peak_album_abort_to_track)
 {
@@ -1136,8 +1128,8 @@ GST_START_TEST (test_gain_album)
   g_object_set (element, "num-tracks", 3, NULL);
   set_playing_state (element);
 
-  /* The three tracks are constructed such that if any of these is in
-   * fact ignored for the album gain, the album gain will differ. */
+  /* The three tracks are constructed such that if any of these is in fact
+   * ignored for the album gain, the album gain will differ. */
 
   accumulator = 0;
   for (i = 8; i--;)
@@ -1268,12 +1260,11 @@ GST_START_TEST (test_forced_separate)
 
 GST_END_TEST;
 
-/* A TAG event is sent _after_ data has already been processed.  In
- * real pipelines, this could happen if there is more than one
- * rganalysis element (by accident).  While it would have analyzed all
- * the data prior to receiving the event, I expect it to not post its
- * results if not forced.  This test is almost equivalent to
- * test_forced. */
+/* A TAG event is sent _after_ data has already been processed.  In real
+ * pipelines, this could happen if there is more than one rganalysis element (by
+ * accident).  While it would have analyzed all the data prior to receiving the
+ * event, I expect it to not post its results if not forced.  This test is
+ * almost equivalent to test_forced. */
 
 GST_START_TEST (test_forced_after_data)
 {
@@ -1311,8 +1302,8 @@ GST_START_TEST (test_forced_after_data)
 
 GST_END_TEST;
 
-/* Like test_forced, but *analyze* an album afterwards.  The two tests
- * following this one check the *skipping* of albums. */
+/* Like test_forced, but *analyze* an album afterwards.  The two tests following
+ * this one check the *skipping* of albums. */
 
 GST_START_TEST (test_forced_album)
 {
@@ -1441,9 +1432,8 @@ GST_START_TEST (test_forced_album_no_skip)
   gst_tag_list_free (tag_list);
   fail_unless_num_tracks (element, 1);
 
-  /* The second track has indeed full tags, but although being not
-   * forced, this one has to be processed because album processing is
-   * on. */
+  /* The second track has indeed full tags, but although being not forced, this
+   * one has to be processed because album processing is on. */
   tag_list = gst_tag_list_new ();
   /* Provided values are totally arbitrary. */
   gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
@@ -1515,10 +1505,10 @@ GST_START_TEST (test_reference_level)
 {
   GstElement *element = setup_rganalysis ();
   GstTagList *tag_list;
+  gdouble ref_level;
   gint accumulator = 0;
   gint i;
 
-  g_object_set (element, "reference-level", 83., "num-tracks", 2, NULL);
   set_playing_state (element);
 
   for (i = 20; i--;)
@@ -1527,8 +1517,26 @@ GST_START_TEST (test_reference_level)
   send_eos_event (element);
   tag_list = poll_tags (element);
   fail_unless_track_peak (tag_list, 0.25);
+  fail_unless_track_gain (tag_list, get_expected_gain (44100));
+  fail_if_album_tags (tag_list);
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL,
+          &ref_level) && MATCH_GAIN (ref_level, 89.),
+      "Incorrect reference level tag");
+  gst_tag_list_free (tag_list);
+
+  g_object_set (element, "reference-level", 83., "num-tracks", 2, NULL);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512,
+            0.25, 0.25));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.25);
   fail_unless_track_gain (tag_list, get_expected_gain (44100) - 6.);
   fail_if_album_tags (tag_list);
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL,
+          &ref_level) && MATCH_GAIN (ref_level, 83.),
+      "Incorrect reference level tag");
   gst_tag_list_free (tag_list);
 
   accumulator = 0;
@@ -1543,6 +1551,9 @@ GST_START_TEST (test_reference_level)
   /* We provided the same waveform twice, with a reset separating
    * them.  Therefore, the album gain matches the track gain. */
   fail_unless_album_gain (tag_list, get_expected_gain (44100) - 6.);
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL,
+          &ref_level) && MATCH_GAIN (ref_level, 83.),
+      "Incorrect reference level tag");
   gst_tag_list_free (tag_list);
 
   cleanup_rganalysis (element);
diff --git a/tests/check/elements/rglimiter.c b/tests/check/elements/rglimiter.c
new file mode 100644
index 00000000..2d4a715b
--- /dev/null
+++ b/tests/check/elements/rglimiter.c
@@ -0,0 +1,238 @@
+/* GStreamer ReplayGain limiter
+ *
+ * Copyright (C) 2007 Rene Stadler <mail@renestadler.de>
+ *
+ * rglimiter.c: Unit test for the rglimiter element
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <gst/check/gstcheck.h>
+
+#include <math.h>
+
+GList *buffers = NULL;
+
+/* For ease of programming we use globals to keep refs for our floating
+ * src and sink pads we create; otherwise we always have to do get_pad,
+ * get_peer, and then remove references in every test function */
+static GstPad *mysrcpad, *mysinkpad;
+
+#define RG_LIMITER_CAPS_TEMPLATE_STRING   \
+  "audio/x-raw-float, "                   \
+  "width = (int) 32, "                    \
+  "endianness = (int) BYTE_ORDER, "       \
+  "channels = (int) [ 1, MAX ], "         \
+  "rate = (int) [ 1, MAX ]"
+
+static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_LIMITER_CAPS_TEMPLATE_STRING)
+    );
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_LIMITER_CAPS_TEMPLATE_STRING)
+    );
+
+GstElement *
+setup_rglimiter ()
+{
+  GstElement *element;
+  GstBus *bus;
+
+  GST_DEBUG ("setup_rglimiter");
+  element = gst_check_setup_element ("rglimiter");
+  mysrcpad = gst_check_setup_src_pad (element, &srctemplate, NULL);
+  mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate, NULL);
+  gst_pad_set_active (mysrcpad, TRUE);
+  gst_pad_set_active (mysinkpad, TRUE);
+
+  return element;
+}
+
+void
+cleanup_rglimiter (GstElement * element)
+{
+  GST_DEBUG ("cleanup_rglimiter");
+
+  g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
+  g_list_free (buffers);
+  buffers = NULL;
+
+  gst_check_teardown_src_pad (element);
+  gst_check_teardown_sink_pad (element);
+  gst_check_teardown_element (element);
+}
+
+static void
+set_playing_state (GstElement * element)
+{
+  fail_unless (gst_element_set_state (element,
+          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+      "Could not set state to PLAYING");
+}
+
+static const gfloat test_input[] = {
+  -2.0, -1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0, 2.0
+};
+static const gfloat test_output[] = {
+  -0.99752737684336523,         /* -2.0  */
+  -0.88079707797788243,         /* -1.0  */
+  -0.7310585786300049,          /* -0.75 */
+  -0.5, -0.25, 0.0, 0.25, 0.5,
+  0.7310585786300049,           /* 0.75 */
+  0.88079707797788243,          /* 1.0  */
+  0.99752737684336523,          /* 2.0  */
+};
+
+static GstBuffer *
+create_test_buffer ()
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (sizeof (test_input));
+  GstCaps *caps;
+
+  memcpy (GST_BUFFER_DATA (buf), test_input, sizeof (test_input));
+
+  caps = gst_caps_new_simple ("audio/x-raw-float",
+      "rate", G_TYPE_INT, 44100, "channels", G_TYPE_INT, 1,
+      "endianess", G_TYPE_INT, G_BYTE_ORDER, "width", G_TYPE_INT, 32, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+static void
+verify_test_buffer (GstBuffer * buf)
+{
+  gfloat *output = (gfloat *) GST_BUFFER_DATA (buf);
+  gint i;
+
+  fail_unless (GST_BUFFER_SIZE (buf) == sizeof (test_output));
+  for (i = 0; i < G_N_ELEMENTS (test_input); i++)
+    fail_unless (ABS (output[i] - test_output[i]) < 1.e-6,
+        "Incorrect output value %.6f for input %.2f, expected %.6f",
+        output[i], test_input[i], test_output[i]);
+}
+
+/* Start of tests. */
+
+GST_START_TEST (test_no_buffer)
+{
+  GstElement *element = setup_rglimiter ();
+
+  set_playing_state (element);
+
+  cleanup_rglimiter (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_disabled)
+{
+  GstElement *element = setup_rglimiter ();
+  GstBuffer *buf, *out_buf;
+
+  g_object_set (element, "enabled", FALSE, NULL);
+  set_playing_state (element);
+
+  buf = create_test_buffer ();
+  fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK);
+  fail_unless (g_list_length (buffers) == 1);
+  out_buf = buffers->data;
+  fail_if (out_buf == NULL);
+  buffers = g_list_remove (buffers, out_buf);
+  ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1);
+  fail_unless (buf == out_buf);
+  gst_buffer_unref (out_buf);
+
+  cleanup_rglimiter (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_limiting)
+{
+  GstElement *element = setup_rglimiter ();
+  GstBuffer *buf, *out_buf;
+
+  set_playing_state (element);
+
+  /* Mutable variant. */
+  buf = create_test_buffer ();
+  fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK);
+  fail_unless (g_list_length (buffers) == 1);
+  out_buf = buffers->data;
+  fail_if (out_buf == NULL);
+  ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1);
+  verify_test_buffer (out_buf);
+
+  /* Immutable variant. */
+  buf = create_test_buffer ();
+  /* Extra ref: */
+  gst_buffer_ref (buf);
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
+  fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK);
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+  fail_unless (g_list_length (buffers) == 2);
+  out_buf = g_list_last (buffers)->data;
+  fail_if (out_buf == NULL);
+  ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1);
+  fail_unless (buf != out_buf);
+  /* Drop our extra ref: */
+  gst_buffer_unref (buf);
+  verify_test_buffer (out_buf);
+
+  cleanup_rglimiter (element);
+}
+
+GST_END_TEST;
+
+Suite *
+rglimiter_suite (void)
+{
+  Suite *s = suite_create ("rglimiter");
+  TCase *tc_chain = tcase_create ("general");
+
+  suite_add_tcase (s, tc_chain);
+
+  tcase_add_test (tc_chain, test_no_buffer);
+  tcase_add_test (tc_chain, test_disabled);
+  tcase_add_test (tc_chain, test_limiting);
+
+  return s;
+}
+
+int
+main (int argc, char **argv)
+{
+  gint nf;
+
+  Suite *s = rglimiter_suite ();
+  SRunner *sr = srunner_create (s);
+
+  gst_check_init (&argc, &argv);
+
+  srunner_run_all (sr, CK_ENV);
+  nf = srunner_ntests_failed (sr);
+  srunner_free (sr);
+
+  return nf;
+}
diff --git a/tests/check/elements/rgvolume.c b/tests/check/elements/rgvolume.c
new file mode 100644
index 00000000..658e98ce
--- /dev/null
+++ b/tests/check/elements/rgvolume.c
@@ -0,0 +1,573 @@
+/* GStreamer ReplayGain volume adjustment
+ *
+ * Copyright (C) 2007 Rene Stadler <mail@renestadler.de>
+ *
+ * rgvolume.c: Unit test for the rgvolume element
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <gst/check/gstcheck.h>
+
+#include <math.h>
+
+GList *buffers = NULL;
+GList *events = NULL;
+
+/* For ease of programming we use globals to keep refs for our floating src and
+ * sink pads we create; otherwise we always have to do get_pad, get_peer, and
+ * then remove references in every test function */
+static GstPad *mysrcpad, *mysinkpad;
+
+#define RG_VOLUME_CAPS_TEMPLATE_STRING    \
+  "audio/x-raw-float, "                   \
+  "width = (int) 32, "                    \
+  "endianness = (int) BYTE_ORDER, "       \
+  "channels = (int) [ 1, MAX ], "         \
+  "rate = (int) [ 1, MAX ]"
+
+static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_VOLUME_CAPS_TEMPLATE_STRING)
+    );
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_VOLUME_CAPS_TEMPLATE_STRING)
+    );
+
+/* gstcheck sets up a chain function that appends buffers to a global list.
+ * This is our equivalent of that for event handling. */
+static gboolean
+event_func (GstPad * pad, GstEvent * event)
+{
+  events = g_list_append (events, event);
+
+  return TRUE;
+}
+
+GstElement *
+setup_rgvolume ()
+{
+  GstElement *element;
+
+  GST_DEBUG ("setup_rgvolume");
+  element = gst_check_setup_element ("rgvolume");
+  mysrcpad = gst_check_setup_src_pad (element, &srctemplate, NULL);
+  mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate, NULL);
+
+  /* Capture events, to test tag filtering behavior: */
+  gst_pad_set_event_function (mysinkpad, event_func);
+
+  gst_pad_set_active (mysrcpad, TRUE);
+  gst_pad_set_active (mysinkpad, TRUE);
+
+  return element;
+}
+
+void
+cleanup_rgvolume (GstElement * element)
+{
+  GST_DEBUG ("cleanup_rgvolume");
+
+  g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
+  g_list_free (buffers);
+  buffers = NULL;
+
+  g_list_foreach (events, (GFunc) gst_mini_object_unref, NULL);
+  g_list_free (events);
+  events = NULL;
+
+  gst_pad_set_active (mysrcpad, FALSE);
+  gst_pad_set_active (mysinkpad, FALSE);
+  gst_check_teardown_src_pad (element);
+  gst_check_teardown_sink_pad (element);
+  gst_check_teardown_element (element);
+}
+
+static void
+set_playing_state (GstElement * element)
+{
+  fail_unless (gst_element_set_state (element,
+          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+      "Could not set state to PLAYING");
+}
+
+static void
+set_null_state (GstElement * element)
+{
+  fail_unless (gst_element_set_state (element,
+          GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS,
+      "Could not set state to NULL");
+}
+
+static void
+send_eos_event (GstElement * element)
+{
+  GstEvent *event = gst_event_new_eos ();
+
+  fail_unless (g_list_length (events) == 0);
+  fail_unless (gst_pad_push_event (mysrcpad, event),
+      "Pushing EOS event failed");
+  fail_unless (g_list_length (events) == 1);
+  fail_unless (events->data == event);
+  gst_mini_object_unref ((GstMiniObject *) events->data);
+  events = g_list_remove (events, event);
+}
+
+static GstEvent *
+send_tag_event (GstElement * element, GstEvent * event)
+{
+  g_return_val_if_fail (event->type == GST_EVENT_TAG, NULL);
+
+  fail_unless (g_list_length (events) == 0);
+  fail_unless (gst_pad_push_event (mysrcpad, event),
+      "Pushing tag event failed");
+
+  if (g_list_length (events) == 0) {
+    /* Event got filtered out. */
+    event = NULL;
+  } else {
+    GstTagList *tag_list;
+    gdouble dummy;
+
+    event = events->data;
+    events = g_list_remove (events, event);
+
+    fail_unless (event->type == GST_EVENT_TAG);
+    gst_event_parse_tag (event, &tag_list);
+
+    /* The element is supposed to filter out ReplayGain related tags. */
+    fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &dummy),
+        "tag event still contains track gain tag");
+    fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &dummy),
+        "tag event still contains track peak tag");
+    fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &dummy),
+        "tag event still contains album gain tag");
+    fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &dummy),
+        "tag event still contains album peak tag");
+  }
+
+  return event;
+}
+
+static GstBuffer *
+test_buffer_new (gfloat value)
+{
+  GstBuffer *buf;
+  GstCaps *caps;
+  gfloat *data;
+  gint i;
+
+  buf = gst_buffer_new_and_alloc (8 * sizeof (gfloat));
+  data = (gfloat *) GST_BUFFER_DATA (buf);
+  for (i = 0; i < 8; i++)
+    data[i] = value;
+
+  caps = gst_caps_from_string ("audio/x-raw-float, "
+      "rate = 8000, channels = 1, endianess = BYTE_ORDER, width = 32");
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+#define MATCH_GAIN(g1, g2) ((g1 < g2 + 1e-6) && (g2 < g1 + 1e-6))
+
+static void
+fail_unless_target_gain (GstElement * element, gdouble expected_gain)
+{
+  gdouble prop_gain;
+
+  g_object_get (element, "target-gain", &prop_gain, NULL);
+
+  fail_unless (MATCH_GAIN (prop_gain, expected_gain),
+      "Target gain is %.2f dB, expected %.2f dB", prop_gain, expected_gain);
+}
+
+static void
+fail_unless_result_gain (GstElement * element, gdouble expected_gain)
+{
+  GstBuffer *input_buf, *output_buf;
+  gfloat input_sample, output_sample;
+  gdouble gain, prop_gain;
+  gboolean is_passthrough, expect_passthrough;
+  gint i;
+
+  fail_unless (g_list_length (buffers) == 0);
+
+  input_sample = 1.0;
+  input_buf = test_buffer_new (input_sample);
+
+  /* We keep an extra reference to detect passthrough mode. */
+  gst_buffer_ref (input_buf);
+  /* Pushing steals a reference. */
+  fail_unless (gst_pad_push (mysrcpad, input_buf) == GST_FLOW_OK);
+  gst_buffer_unref (input_buf);
+
+  /* The output buffer ends up on the global buffer list. */
+  fail_unless (g_list_length (buffers) == 1);
+  output_buf = buffers->data;
+  fail_if (output_buf == NULL);
+
+  buffers = g_list_remove (buffers, output_buf);
+  ASSERT_BUFFER_REFCOUNT (output_buf, "output_buf", 1);
+  fail_unless_equals_int (GST_BUFFER_SIZE (output_buf), 8 * sizeof (gfloat));
+
+  output_sample = *((gfloat *) GST_BUFFER_DATA (output_buf));
+
+  fail_if (output_sample == 0.0, "First output sample is zero");
+  for (i = 1; i < 8; i++) {
+    gfloat output = ((gfloat *) GST_BUFFER_DATA (output_buf))[i];
+
+    fail_unless (output_sample == output, "Output samples not uniform");
+  };
+
+  gain = 20. * log10 (output_sample / input_sample);
+  fail_unless (MATCH_GAIN (gain, expected_gain),
+      "Applied gain is %.2f dB, expected %.2f dB", gain, expected_gain);
+  g_object_get (element, "result-gain", &prop_gain, NULL);
+  fail_unless (MATCH_GAIN (prop_gain, expected_gain),
+      "Result gain is %.2f dB, expected %.2f dB", prop_gain, expected_gain);
+
+  is_passthrough = (output_buf == input_buf);
+  expect_passthrough = MATCH_GAIN (expected_gain, +0.00);
+  fail_unless (is_passthrough == expect_passthrough,
+      expect_passthrough
+      ? "Expected operation in passthrough mode"
+      : "Incorrect passthrough behaviour");
+
+  gst_buffer_unref (output_buf);
+}
+
+static void
+fail_unless_gain (GstElement * element, gdouble expected_gain)
+{
+  fail_unless_target_gain (element, expected_gain);
+  fail_unless_result_gain (element, expected_gain);
+}
+
+/* Start of tests. */
+
+GST_START_TEST (test_no_buffer)
+{
+  GstElement *element = setup_rgvolume ();
+
+  set_playing_state (element);
+  set_null_state (element);
+  set_playing_state (element);
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_events)
+{
+  GstElement *element = setup_rgvolume ();
+  GstEvent *event;
+  GstEvent *new_event;
+  GstTagList *tag_list;
+  gchar *artist;
+
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +4.95, GST_TAG_TRACK_PEAK, 0.59463,
+      GST_TAG_ALBUM_GAIN, -1.54, GST_TAG_ALBUM_PEAK, 0.693415,
+      GST_TAG_ARTIST, "Foobar", NULL);
+  event = gst_event_new_tag (tag_list);
+  new_event = send_tag_event (element, event);
+  /* Expect the element to modify the writable event. */
+  fail_unless (event == new_event, "Writable tag event not reused");
+  gst_event_parse_tag (new_event, &tag_list);
+  fail_unless (gst_tag_list_get_string (tag_list, GST_TAG_ARTIST, &artist));
+  fail_unless (g_str_equal (artist, "Foobar"));
+  g_free (artist);
+  gst_event_unref (new_event);
+
+  /* Same as above, but with a non-writable event. */
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +4.95, GST_TAG_TRACK_PEAK, 0.59463,
+      GST_TAG_ALBUM_GAIN, -1.54, GST_TAG_ALBUM_PEAK, 0.693415,
+      GST_TAG_ARTIST, "Foobar", NULL);
+  event = gst_event_new_tag (tag_list);
+  /* Holding an extra ref makes the event unwritable: */
+  gst_event_ref (event);
+  new_event = send_tag_event (element, event);
+  fail_unless (event != new_event, "Unwritable tag event reused");
+  gst_event_parse_tag (new_event, &tag_list);
+  fail_unless (gst_tag_list_get_string (tag_list, GST_TAG_ARTIST, &artist));
+  fail_unless (g_str_equal (artist, "Foobar"));
+  g_free (artist);
+  gst_event_unref (event);
+  gst_event_unref (new_event);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_simple)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  g_object_set (element, "album-mode", FALSE, "headroom", +0.00,
+      "pre-amp", -6.00, "fallback-gain", +1.23, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, -3.45, GST_TAG_TRACK_PEAK, 1.0,
+      GST_TAG_ALBUM_GAIN, +2.09, GST_TAG_ALBUM_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, -9.45);    /* pre-amp + track gain */
+  send_eos_event (element);
+
+  g_object_set (element, "album-mode", TRUE, NULL);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, -3.45, GST_TAG_TRACK_PEAK, 1.0,
+      GST_TAG_ALBUM_GAIN, +2.09, GST_TAG_ALBUM_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, -3.91);    /* pre-amp + album gain */
+
+  /* Switching back to track mode in the middle of a stream: */
+  g_object_set (element, "album-mode", FALSE, NULL);
+  fail_unless_gain (element, -9.45);    /* pre-amp + track gain */
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+/* If there are no gain tags at all, the fallback gain is used. */
+
+GST_START_TEST (test_fallback_gain)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  /* First some track where fallback does _not_ apply. */
+
+  g_object_set (element, "album-mode", FALSE, "headroom", 10.00,
+      "pre-amp", -6.00, "fallback-gain", -3.00, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +3.5, GST_TAG_TRACK_PEAK, 1.0,
+      GST_TAG_ALBUM_GAIN, -0.5, GST_TAG_ALBUM_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, -2.50);    /* pre-amp + track gain */
+  send_eos_event (element);
+
+  /* Now a track completely missing tags. */
+
+  fail_unless_gain (element, -9.00);    /* pre-amp + fallback-gain */
+
+  /* Changing the fallback gain in the middle of a stream, going to pass-through
+   * mode: */
+  g_object_set (element, "fallback-gain", +6.00, NULL);
+  fail_unless_gain (element, +0.00);    /* pre-amp + fallback-gain */
+  send_eos_event (element);
+
+  /* Verify that result gain is set to +0.00 with pre-amp + fallback-gain >
+   * +0.00 and no headroom. */
+
+  g_object_set (element, "fallback-gain", +12.00, "headroom", +0.00, NULL);
+  fail_unless_target_gain (element, +6.00);     /* pre-amp + fallback-gain */
+  fail_unless_result_gain (element, +0.00);
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+/* If album gain is to be preferred but not available, the track gain is to be
+ * taken instead. */
+
+GST_START_TEST (test_fallback_track)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  g_object_set (element, "album-mode", TRUE, "headroom", +0.00,
+      "pre-amp", -6.00, "fallback-gain", +1.23, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +2.11, GST_TAG_TRACK_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, -3.89);    /* pre-amp + track gain */
+
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+/* If track gain is to be preferred but not available, the album gain is to be
+ * taken instead. */
+
+GST_START_TEST (test_fallback_album)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  g_object_set (element, "album-mode", FALSE, "headroom", +0.00,
+      "pre-amp", -6.00, "fallback-gain", +1.23, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_ALBUM_GAIN, +3.73, GST_TAG_ALBUM_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, -2.27);    /* pre-amp + album gain */
+
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_headroom)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  g_object_set (element, "album-mode", FALSE, "headroom", +0.00,
+      "pre-amp", +0.00, "fallback-gain", +1.23, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +3.50, GST_TAG_TRACK_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_target_gain (element, +3.50);     /* pre-amp + track gain */
+  fail_unless_result_gain (element, +0.00);
+  send_eos_event (element);
+
+  g_object_set (element, "headroom", +2.00, NULL);
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, +9.18, GST_TAG_TRACK_PEAK, 0.687149, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_target_gain (element, +9.18);     /* pre-amp + track gain */
+  /* Result is 20. * log10 (1. / peak) + headroom. */
+  fail_unless_result_gain (element, 5.2589816238303335);
+  send_eos_event (element);
+
+  g_object_set (element, "album-mode", TRUE, NULL);
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_ALBUM_GAIN, +5.50, GST_TAG_ALBUM_PEAK, 1.0, NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_target_gain (element, +5.50);     /* pre-amp + album gain */
+  fail_unless_result_gain (element, +2.00);     /* headroom */
+  send_eos_event (element);
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_reference_level)
+{
+  GstElement *element = setup_rgvolume ();
+  GstTagList *tag_list;
+
+  g_object_set (element,
+      "album-mode", FALSE,
+      "headroom", +0.00, "pre-amp", +0.00, "fallback-gain", +1.23, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, 0.00, GST_TAG_TRACK_PEAK, 0.2,
+      GST_TAG_REFERENCE_LEVEL, 83., NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  /* Because our authorative reference is 89 dB, we bump it up by +6 dB. */
+  fail_unless_gain (element, +6.00);    /* pre-amp + track gain */
+  send_eos_event (element);
+
+  g_object_set (element, "album-mode", TRUE, NULL);
+
+  /* Same as above, but with album gain. */
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE,
+      GST_TAG_TRACK_GAIN, 1.23, GST_TAG_TRACK_PEAK, 0.1,
+      GST_TAG_ALBUM_GAIN, 0.00, GST_TAG_ALBUM_PEAK, 0.2,
+      GST_TAG_REFERENCE_LEVEL, 83., NULL);
+  fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL);
+  fail_unless_gain (element, +6.00);    /* pre-amp + album gain */
+
+  cleanup_rgvolume (element);
+}
+
+GST_END_TEST;
+
+Suite *
+rgvolume_suite (void)
+{
+  Suite *s = suite_create ("rgvolume");
+  TCase *tc_chain = tcase_create ("general");
+
+  suite_add_tcase (s, tc_chain);
+
+  tcase_add_test (tc_chain, test_no_buffer);
+  tcase_add_test (tc_chain, test_events);
+  tcase_add_test (tc_chain, test_simple);
+  tcase_add_test (tc_chain, test_fallback_gain);
+  tcase_add_test (tc_chain, test_fallback_track);
+  tcase_add_test (tc_chain, test_fallback_album);
+  tcase_add_test (tc_chain, test_headroom);
+  tcase_add_test (tc_chain, test_reference_level);
+
+  return s;
+}
+
+int
+main (int argc, char **argv)
+{
+  gint nf;
+
+  Suite *s = rgvolume_suite ();
+  SRunner *sr = srunner_create (s);
+
+  gst_check_init (&argc, &argv);
+
+  srunner_run_all (sr, CK_ENV);
+  nf = srunner_ntests_failed (sr);
+  srunner_free (sr);
+
+  return nf;
+}