Add ReplayGain analysis element (#357069).

Original commit message from CVS:
Patch by: René Stadler  <mail at renestadler de>
* configure.ac:
* docs/plugins/Makefile.am:
* docs/plugins/gst-plugins-bad-plugins-docs.sgml:
* docs/plugins/gst-plugins-bad-plugins-sections.txt:
* gst/replaygain/Makefile.am:
* gst/replaygain/gstrganalysis.c: (gst_rg_analysis_base_init),
(gst_rg_analysis_class_init), (gst_rg_analysis_init),
(gst_rg_analysis_set_property), (gst_rg_analysis_get_property),
(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), (plugin_init):
* gst/replaygain/gstrganalysis.h:
* gst/replaygain/rganalysis.c: (yule_filter), (butter_filter),
(apply_filters), (reset_filters), (accumulator_add),
(accumulator_clear), (accumulator_result), (rg_analysis_new),
(rg_analysis_set_sample_rate), (rg_analysis_destroy),
(rg_analysis_analyze_mono_float),
(rg_analysis_analyze_stereo_float),
(rg_analysis_analyze_mono_int16),
(rg_analysis_analyze_stereo_int16), (rg_analysis_analyze),
(rg_analysis_track_result), (rg_analysis_album_result),
(rg_analysis_reset_album), (rg_analysis_reset):
* gst/replaygain/rganalysis.h:
Add ReplayGain analysis element (#357069).
* tests/check/Makefile.am:
* tests/check/elements/.cvsignore:
* tests/check/elements/rganalysis.c: (get_expected_gain),
(setup_rganalysis), (cleanup_rganalysis), (set_playing_state),
(send_eos_event), (send_tag_event), (poll_eos), (poll_tags),
(fail_unless_track_gain), (fail_unless_track_peak),
(fail_unless_album_gain), (fail_unless_album_peak),
(fail_if_track_tags), (fail_if_album_tags),
(fail_unless_num_tracks), (test_buffer_const_float_mono),
(test_buffer_const_float_stereo), (test_buffer_const_int16_mono),
(test_buffer_const_int16_stereo), (test_buffer_square_float_mono),
(test_buffer_square_float_stereo), (test_buffer_square_int16_mono),
(test_buffer_square_int16_stereo), (push_buffer), (GST_START_TEST),
(rganalysis_suite), (main):
Unit tests for the new replaygain element.

3 files changed, 1873 insertions, 0 deletions

diff --git a/tests/check/Makefile.am b/tests/check/Makefile.am
index 11056b4d..62bd614d 100644
--- a/tests/check/Makefile.am
+++ b/tests/check/Makefile.am
@@ -52,6 +52,7 @@ VALGRIND_TESTS_DISABLE = \
 
 check_PROGRAMS = \
 	$(check_mpeg2enc)  \
+	elements/rganalysis \
 	elements/videocrop \
 	$(check_wavpack)
 
diff --git a/tests/check/elements/.gitignore b/tests/check/elements/.gitignore
index 410abd81..2d69711f 100644
--- a/tests/check/elements/.gitignore
+++ b/tests/check/elements/.gitignore
@@ -8,3 +8,4 @@ wavpackdec
 wavpackenc
 wavpackparse
 videocrop
+rganalysis
diff --git a/tests/check/elements/rganalysis.c b/tests/check/elements/rganalysis.c
new file mode 100644
index 00000000..17b4d62f
--- /dev/null
+++ b/tests/check/elements/rganalysis.c
@@ -0,0 +1,1871 @@
+/* GStreamer ReplayGain analysis
+ *
+ * Copyright (C) 2006 Rene Stadler <mail@renestadler.de>
+ *
+ * rganalysis.c: Unit test for the rganalysis 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
+ */
+
+/* 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.
+ *
+ *  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.
+ *
+ *  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.
+ *
+ * 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.
+ */
+
+#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 */
+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.
+ *
+ * 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. */
+
+struct rate_test
+{
+  guint sample_rate;
+  gdouble gain;
+};
+
+static const struct rate_test supported_rates[] = {
+  8000, -0.91,
+  11025, -2.80,
+  12000, -3.13,
+  16000, -4.26,
+  22050, -5.64,
+  24000, -5.87,
+  32000, -6.03,
+  44100, -6.20,
+  48000, -6.14
+};
+
+/* Lookup the correct gain adjustment result in above array. */
+
+static gdouble
+get_expected_gain (guint sample_rate)
+{
+  gint i;
+
+  for (i = G_N_ELEMENTS (supported_rates); i--;)
+    if (supported_rates[i].sample_rate == sample_rate)
+      return supported_rates[i].gain;
+  g_return_val_if_reached (0.0);
+}
+
+#define SILENCE_GAIN 64.82
+
+#define REPLAY_GAIN_CAPS                                \
+  "channels = (int) { 1, 2 }, "                         \
+  "rate = (int) { 8000, 11025, 12000, 16000, 22050, "   \
+  "24000, 32000, 44100, 48000 }"
+
+#define RG_ANALYSIS_CAPS_TEMPLATE_STRING  \
+  "audio/x-raw-float, "                   \
+  "width = (int) 32, "                    \
+  "endianness = (int) BYTE_ORDER, "       \
+  REPLAY_GAIN_CAPS                        \
+  "; "                                    \
+  "audio/x-raw-int, "                     \
+  "width = (int) 16, "                    \
+  "depth = (int) [ 1, 16 ], "             \
+  "signed = (boolean) true, "             \
+  "endianness = (int) BYTE_ORDER, "       \
+  REPLAY_GAIN_CAPS
+
+static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_ANALYSIS_CAPS_TEMPLATE_STRING)
+    );
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (RG_ANALYSIS_CAPS_TEMPLATE_STRING)
+    );
+
+GstElement *
+setup_rganalysis ()
+{
+  GstElement *analysis;
+  GstBus *bus;
+
+  GST_DEBUG ("setup_rganalysis");
+  analysis = gst_check_setup_element ("rganalysis");
+  mysrcpad = gst_check_setup_src_pad (analysis, &srctemplate, NULL);
+  mysinkpad = gst_check_setup_sink_pad (analysis, &sinktemplate, NULL);
+  gst_pad_set_active (mysrcpad, TRUE);
+  gst_pad_set_active (mysinkpad, TRUE);
+
+  bus = gst_bus_new ();
+  gst_element_set_bus (analysis, bus);
+  /* gst_element_set_bus does not steal a reference. */
+  gst_object_unref (bus);
+
+  return analysis;
+}
+
+void
+cleanup_rganalysis (GstElement * element)
+{
+  GST_DEBUG ("cleanup_rganalysis");
+
+  g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
+  g_list_free (buffers);
+  buffers = NULL;
+
+  /* The bus owns references to the element: */
+  gst_element_set_bus (element, 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 void
+send_eos_event (GstElement * element)
+{
+  GstBus *bus = gst_element_get_bus (element);
+  GstPad *pad = gst_element_get_pad (element, "sink");
+  GstEvent *event = gst_event_new_eos ();
+
+  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. */
+  fail_unless (gst_bus_post (bus, gst_message_new_eos (NULL)));
+
+  gst_object_unref (bus);
+  gst_object_unref (pad);
+}
+
+static void
+send_tag_event (GstElement * element, GstTagList * tag_list)
+{
+  GstPad *pad = gst_element_get_pad (element, "sink");
+  GstEvent *event = gst_event_new_tag (tag_list);
+
+  fail_unless (gst_pad_send_event (pad, event),
+      "Cannot send TAG event: Not handled.");
+
+  gst_object_unref (pad);
+}
+
+static void
+poll_eos (GstElement * element)
+{
+  GstBus *bus = gst_element_get_bus (element);
+  GstMessage *message;
+
+  message = gst_bus_poll (bus, GST_MESSAGE_EOS | GST_MESSAGE_TAG, GST_SECOND);
+  fail_unless (message != NULL, "Could not poll for EOS message: Timed out");
+  fail_unless (message->type == GST_MESSAGE_EOS,
+      "Could not poll for eos message: got message of type %s instead",
+      gst_message_type_get_name (message->type));
+
+  gst_message_unref (message);
+  gst_object_unref (bus);
+}
+
+/* This also polls for EOS since the TAG message comes right before
+ * the end of streams. */
+
+static GstTagList *
+poll_tags (GstElement * element)
+{
+  GstBus *bus = gst_element_get_bus (element);
+  GstTagList *tag_list;
+  GstMessage *message;
+
+  message = gst_bus_poll (bus, GST_MESSAGE_TAG, GST_SECOND);
+  fail_unless (message != NULL, "Could not poll for TAG message: Timed out");
+
+  fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (element));
+
+  gst_message_parse_tag (message, &tag_list);
+  gst_message_unref (message);
+  gst_object_unref (bus);
+
+  poll_eos (element);
+
+  return tag_list;
+}
+
+#define MATCH_PEAK(p1, p2) ((p1 < p2 + 1e-6) && (p2 < p1 + 1e-6))
+#define MATCH_GAIN(g1, g2) ((g1 < g2 + 1e-13) && (g2 < g1 + 1e-13))
+
+static void
+fail_unless_track_gain (const GstTagList * tag_list, gdouble gain)
+{
+  gdouble result;
+
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &result),
+      "Tag list contains no track gain value");
+  fail_unless (MATCH_GAIN (gain, result),
+      "Track gain %+.2f does not match, expected %+.2f", result, gain);
+}
+
+static void
+fail_unless_track_peak (const GstTagList * tag_list, gdouble peak)
+{
+  gdouble result;
+
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &result),
+      "Tag list contains no track peak value");
+  fail_unless (MATCH_PEAK (peak, result),
+      "Track peak %f does not match, expected %f", result, peak);
+}
+
+static void
+fail_unless_album_gain (const GstTagList * tag_list, gdouble gain)
+{
+  gdouble result;
+
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &result),
+      "Tag list contains no album gain value");
+  fail_unless (MATCH_GAIN (result, gain),
+      "Album gain %+.2f does not match, expected %+.2f", result, gain);
+}
+
+static void
+fail_unless_album_peak (const GstTagList * tag_list, gdouble peak)
+{
+  gdouble result;
+
+  fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &result),
+      "Tag list contains no album peak value");
+  fail_unless (MATCH_PEAK (peak, result),
+      "Album peak %f does not match, expected %f", result, peak);
+}
+
+static void
+fail_if_track_tags (const GstTagList * tag_list)
+{
+  gdouble result;
+
+  fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &result),
+      "Tag list contains track gain value (but should not)");
+  fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &result),
+      "Tag list contains track peak value (but should not)");
+}
+
+static void
+fail_if_album_tags (const GstTagList * tag_list)
+{
+  gdouble result;
+
+  fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &result),
+      "Tag list contains album gain value (but should not)");
+  fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &result),
+      "Tag list contains album peak value (but should not)");
+}
+
+static void
+fail_unless_num_tracks (GstElement * element, guint num_tracks)
+{
+  guint current;
+
+  g_object_get (element, "num-tracks", &current, NULL);
+  fail_unless (current == num_tracks,
+      "num-tracks property has incorrect value %u, expected %u",
+      current, num_tracks);
+}
+
+/* Functions that create buffers with constant sample values, for peak
+ * tests. */
+
+static GstBuffer *
+test_buffer_const_float_mono (gint sample_rate, gsize n_frames, gfloat value)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gfloat));
+  gfloat *data = (gfloat *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;)
+    *data++ = value;
+
+  caps = gst_caps_new_simple ("audio/x-raw-float",
+      "rate", G_TYPE_INT, sample_rate, "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 GstBuffer *
+test_buffer_const_float_stereo (gint sample_rate, gsize n_frames,
+    gfloat value_l, gfloat value_r)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gfloat) * 2);
+  gfloat *data = (gfloat *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *data++ = value_l;
+    *data++ = value_r;
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-float",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 2,
+      "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 GstBuffer *
+test_buffer_const_int16_mono (gint sample_rate, gint depth, gsize n_frames,
+    gint16 value)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gint16));
+  gint16 *data = (gint16 *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;)
+    *data++ = value;
+
+  caps = gst_caps_new_simple ("audio/x-raw-int",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 1,
+      "endianess", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE,
+      "width", G_TYPE_INT, 16, "depth", G_TYPE_INT, depth, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+static GstBuffer *
+test_buffer_const_int16_stereo (gint sample_rate, gint depth, gsize n_frames,
+    gint16 value_l, gint16 value_r)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gint16) * 2);
+  gint16 *data = (gint16 *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *data++ = value_l;
+    *data++ = value_r;
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-int",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 2,
+      "endianess", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE,
+      "width", G_TYPE_INT, 16, "depth", G_TYPE_INT, depth, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+/* Functions that create data buffers containing square signal
+ * waveforms. */
+
+static GstBuffer *
+test_buffer_square_float_mono (gint * accumulator, gint sample_rate,
+    gsize n_frames, gfloat value)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gfloat));
+  gfloat *data = (gfloat *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *accumulator += 1;
+    *accumulator %= 96;
+
+    if (*accumulator < 48)
+      *data++ = value;
+    else
+      *data++ = -value;
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-float",
+      "rate", G_TYPE_INT, sample_rate, "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 GstBuffer *
+test_buffer_square_float_stereo (gint * accumulator, gint sample_rate,
+    gsize n_frames, gfloat value_l, gfloat value_r)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gfloat) * 2);
+  gfloat *data = (gfloat *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *accumulator += 1;
+    *accumulator %= 96;
+
+    if (*accumulator < 48) {
+      *data++ = value_l;
+      *data++ = value_r;
+    } else {
+      *data++ = -value_l;
+      *data++ = -value_r;
+    }
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-float",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 2,
+      "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 GstBuffer *
+test_buffer_square_int16_mono (gint * accumulator, gint sample_rate,
+    gint depth, gsize n_frames, gint16 value)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gint16));
+  gint16 *data = (gint16 *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *accumulator += 1;
+    *accumulator %= 96;
+
+    if (*accumulator < 48)
+      *data++ = value;
+    else
+      *data++ = -MAX (value, -32767);
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-int",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 1,
+      "endianess", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE,
+      "width", G_TYPE_INT, 16, "depth", G_TYPE_INT, depth, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+static GstBuffer *
+test_buffer_square_int16_stereo (gint * accumulator, gint sample_rate,
+    gint depth, gsize n_frames, gint16 value_l, gint16 value_r)
+{
+  GstBuffer *buf = gst_buffer_new_and_alloc (n_frames * sizeof (gint16) * 2);
+  gint16 *data = (gint16 *) GST_BUFFER_DATA (buf);
+  GstCaps *caps;
+  gint i;
+
+  for (i = n_frames; i--;) {
+    *accumulator += 1;
+    *accumulator %= 96;
+
+    if (*accumulator < 48) {
+      *data++ = value_l;
+      *data++ = value_r;
+    } else {
+      *data++ = -MAX (value_l, -32767);
+      *data++ = -MAX (value_r, -32767);
+    }
+  }
+
+  caps = gst_caps_new_simple ("audio/x-raw-int",
+      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, 2,
+      "endianess", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE,
+      "width", G_TYPE_INT, 16, "depth", G_TYPE_INT, depth, NULL);
+  gst_buffer_set_caps (buf, caps);
+  gst_caps_unref (caps);
+
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+
+  return buf;
+}
+
+static void
+push_buffer (GstBuffer * buf)
+{
+  /* gst_pad_push steals a reference. */
+  fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK);
+  ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
+}
+
+/*** Start of the tests. ***/
+
+/* This test looks redundant, but early versions of the element
+ * crashed when doing, well, nothing: */
+
+GST_START_TEST (test_no_buffer)
+{
+  GstElement *element = setup_rganalysis ();
+
+  set_playing_state (element);
+  send_eos_event (element);
+  poll_eos (element);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_no_buffer_album_1)
+{
+  GstElement *element = setup_rganalysis ();
+
+  set_playing_state (element);
+
+  /* Single track: */
+  send_eos_event (element);
+  poll_eos (element);
+
+  /* First album: */
+  g_object_set (element, "num-tracks", 3, NULL);
+
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 2);
+
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 1);
+
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  /* Second album: */
+  g_object_set (element, "num-tracks", 2, NULL);
+
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 1);
+
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  /* Single track: */
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_no_buffer_album_2)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "num-tracks", 3, NULL);
+  set_playing_state (element);
+
+  /* No buffer for the first track. */
+
+  send_eos_event (element);
+  /* No tags should be posted, there was nothing to analyze: */
+  poll_eos (element);
+  fail_unless_num_tracks (element, 2);
+
+  /* A test waveform with known gain result as second track: */
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_mono (&accumulator, 44100, 512,
+            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, -6.20);
+  /* Album is not finished yet: */
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  /* No buffer for the last track. */
+
+  send_eos_event (element);
+
+  tag_list = poll_tags (element);
+  fail_unless_album_peak (tag_list, 0.25);
+  fail_unless_album_gain (tag_list, -6.20);
+  /* No track tags should be posted, as there was no data for it: */
+  fail_if_track_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_empty_buffers)
+{
+  GstElement *element = setup_rganalysis ();
+
+  set_playing_state (element);
+
+  /* Single track: */
+  push_buffer (test_buffer_const_float_stereo (44100, 0, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+
+  /* First album: */
+  g_object_set (element, "num-tracks", 2, NULL);
+
+  push_buffer (test_buffer_const_float_stereo (44100, 0, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 1);
+
+  push_buffer (test_buffer_const_float_stereo (44100, 0, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  /* Second album, with a single track: */
+  g_object_set (element, "num-tracks", 1, NULL);
+  push_buffer (test_buffer_const_float_stereo (44100, 0, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  /* Single track: */
+  push_buffer (test_buffer_const_float_stereo (44100, 0, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+
+  cleanup_rganalysis (element);
+}
+
+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
+ * vorbis. */
+
+GST_START_TEST (test_peak_float)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+
+  set_playing_state (element);
+  push_buffer (test_buffer_const_float_stereo (8000, 512, -1.369, 0.0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.369);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_float_stereo (8000, 512, 0.0, -1.369));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.369);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_float_mono (8000, 512, -1.369));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.369);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_peak_int16_16)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+
+  set_playing_state (element);
+
+  /* Half amplitude. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 1 << 14, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 0, 1 << 14));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 16, 512, 1 << 14));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Half amplitude, negative variant. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, -1 << 14, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 0, -1 << 14));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 16, 512, -1 << 14));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+
+  /* Now check for correct normalization of the peak value: Sample
+   * values of this format range from -32768 to 32767.  So for the
+   * highest positive amplitude we do not reach 1.0, only for
+   * -32768! */
+
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 32767, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 32767. / 32768.);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 0, 32767));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 32767. / 32768.);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 16, 512, 32767));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 32767. / 32768.);
+  gst_tag_list_free (tag_list);
+
+
+  /* Negative variant, reaching 1.0. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, -32768, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 16, 512, 0, -32768));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 16, 512, -32768));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* Same as the test before, but with 8 bits (packed into 16 bits). */
+
+GST_START_TEST (test_peak_int16_8)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+
+  set_playing_state (element);
+
+  /* Half amplitude. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, 1 << 6, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, 0, 1 << 6));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 8, 512, 1 << 6));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+
+  /* Half amplitude, negative variant. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, -1 << 6, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, 0, -1 << 6));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 8, 512, -1 << 6));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+
+
+  /* Almost full amplitude (maximum positive value). */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, (1 << 7) - 1, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.9921875);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, 0, (1 << 7) - 1));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.9921875);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 8, 512, (1 << 7) - 1));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.9921875);
+  gst_tag_list_free (tag_list);
+
+
+  /* Full amplitude (maximum negative value). */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, -1 << 7, 0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  /* Swapped channels. */
+  push_buffer (test_buffer_const_int16_stereo (8000, 8, 512, 0, -1 << 7));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  /* Mono. */
+  push_buffer (test_buffer_const_int16_mono (8000, 8, 512, -1 << 7));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_peak_album)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+
+  g_object_set (element, "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 1.0, 0.0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.0, 0.5));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  fail_unless_album_peak (tag_list, 1.0);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  /* Try a second album: */
+  g_object_set (element, "num-tracks", 3, NULL);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.4, 0.4));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.4);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 2);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.45, 0.45));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.45);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.2, 0.2));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.2);
+  fail_unless_album_peak (tag_list, 0.45);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  /* And now a single track, not in album mode (num-tracks is 0
+   * now): */
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.1, 0.1));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.1);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* Switching from track to album mode. */
+
+GST_START_TEST (test_peak_track_album)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  guint num;
+
+  set_playing_state (element);
+
+  push_buffer (test_buffer_const_float_mono (8000, 1024, 1.0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  g_object_set (element, "num-tracks", 1, NULL);
+  push_buffer (test_buffer_const_float_mono (8000, 1024, 0.5));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  fail_unless_album_peak (tag_list, 0.5);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  cleanup_rganalysis (element);
+}
+
+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. */
+
+GST_START_TEST (test_peak_album_abort_to_track)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  guint num;
+
+  g_object_set (element, "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 1.0, 0.0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 1.0);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  g_object_set (element, "num-tracks", 0, NULL);
+
+  push_buffer (test_buffer_const_float_stereo (8000, 1024, 0.0, 0.5));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_gain_album)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator;
+  gint i;
+
+  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. */
+
+  accumulator = 0;
+  for (i = 8; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512,
+            0.75, 0.75));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.75);
+  fail_unless_track_gain (tag_list, -15.70);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  accumulator = 0;
+  for (i = 12; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512,
+            0.5, 0.5));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.5);
+  fail_unless_track_gain (tag_list, -12.22);
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  accumulator = 0;
+  for (i = 180; 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, -6.20);
+  fail_unless_album_peak (tag_list, 0.75);
+  /* Strangely, wavegain reports -12.17 for the album, but the fixed
+   * metaflac agrees to us.  Could be a 32767 vs. 32768 issue. */
+  fail_unless_album_gain (tag_list, -12.18);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* Checks ensuring that the "forced" property works as advertised. */
+
+GST_START_TEST (test_forced)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  /* Provided values are totally arbitrary. */
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 1.0, GST_TAG_TRACK_GAIN, 2.21, NULL);
+  send_tag_event (element, tag_list);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_const_float_stereo (44100, 512, 0.5, 0.5));
+  send_eos_event (element);
+  /* This fails if a tag message is generated: */
+  poll_eos (element);
+
+  /* Now back to a track without tags. */
+
+  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));
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* Sending track gain and peak in separate tag lists. */
+
+GST_START_TEST (test_forced_separate)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND, GST_TAG_TRACK_GAIN, 2.21,
+      NULL);
+  send_tag_event (element, tag_list);
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND, GST_TAG_TRACK_PEAK, 1.0,
+      NULL);
+  send_tag_event (element, tag_list);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512,
+            0.5, 0.5));
+  send_eos_event (element);
+  /* This fails if a tag message is generated: */
+  poll_eos (element);
+
+  /* Now a track without tags. */
+
+  accumulator = 0;
+  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));
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+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. */
+
+GST_START_TEST (test_forced_after_data)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, NULL);
+  set_playing_state (element);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_const_float_stereo (8000, 512, 0.5, 0.5));
+
+  tag_list = gst_tag_list_new ();
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 1.0, GST_TAG_TRACK_GAIN, 2.21, NULL);
+  send_tag_event (element, tag_list);
+
+  send_eos_event (element);
+  poll_eos (element);
+
+  /* Now back to a normal track, this one has no tags: */
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 8000, 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 (8000));
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* 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)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  /* Provided values are totally arbitrary. */
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 1.0, GST_TAG_TRACK_GAIN, 2.21, NULL);
+  send_tag_event (element, tag_list);
+
+  accumulator = 0;
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512,
+            0.5, 0.5));
+  send_eos_event (element);
+  /* This fails if a tag message is generated: */
+  poll_eos (element);
+
+  /* Now an album without tags. */
+  g_object_set (element, "num-tracks", 2, NULL);
+
+  accumulator = 0;
+  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));
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  accumulator = 0;
+  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));
+  fail_unless_album_peak (tag_list, 0.25);
+  fail_unless_album_gain (tag_list, get_expected_gain (44100));
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_forced_album_skip)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  tag_list = gst_tag_list_new ();
+  /* Provided values are totally arbitrary. */
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 0.75, GST_TAG_TRACK_GAIN, 2.21,
+      GST_TAG_ALBUM_PEAK, 0.80, GST_TAG_ALBUM_GAIN, -0.11, NULL);
+  send_tag_event (element, tag_list);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 8000, 512, 0.25,
+            0.25));
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 1);
+
+  /* This track has no tags, but needs to be skipped anyways since we
+   * are in album processing mode. */
+  for (i = 20; i--;)
+    push_buffer (test_buffer_const_float_stereo (8000, 512, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+  fail_unless_num_tracks (element, 0);
+
+  /* Normal track after the album.  Of course not to be skipped. */
+  accumulator = 0;
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 8000, 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 (8000));
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_forced_album_no_skip)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 8000, 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 (8000));
+  fail_if_album_tags (tag_list);
+  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. */
+  tag_list = gst_tag_list_new ();
+  /* Provided values are totally arbitrary. */
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 0.75, GST_TAG_TRACK_GAIN, 2.21,
+      GST_TAG_ALBUM_PEAK, 0.80, GST_TAG_ALBUM_GAIN, -0.11, NULL);
+  send_tag_event (element, tag_list);
+  for (i = 20; i--;)
+    push_buffer (test_buffer_const_float_stereo (8000, 512, 0.0, 0.0));
+  send_eos_event (element);
+  tag_list = poll_tags (element);
+  fail_unless_track_peak (tag_list, 0.0);
+  fail_unless_track_gain (tag_list, SILENCE_GAIN);
+  /* Second track was just silence so the album peak equals the first
+   * track's peak. */
+  fail_unless_album_peak (tag_list, 0.25);
+  /* Statistical processing leads to the second track being
+   * ignored for the gain (because it is so short): */
+  fail_unless_album_gain (tag_list, get_expected_gain (8000));
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 0);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_forced_abort_album_no_skip)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "forced", FALSE, "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  for (i = 20; i--;)
+    push_buffer (test_buffer_square_float_stereo (&accumulator, 8000, 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 (8000));
+  fail_if_album_tags (tag_list);
+  gst_tag_list_free (tag_list);
+  fail_unless_num_tracks (element, 1);
+
+  /* Disabling album processing before end of album: */
+  g_object_set (element, "num-tracks", 0, NULL);
+
+  /* Processing a track that has to be skipped. */
+  tag_list = gst_tag_list_new ();
+  /* Provided values are totally arbitrary. */
+  gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
+      GST_TAG_TRACK_PEAK, 0.75, GST_TAG_TRACK_GAIN, 2.21,
+      GST_TAG_ALBUM_PEAK, 0.80, GST_TAG_ALBUM_GAIN, -0.11, NULL);
+  send_tag_event (element, tag_list);
+  for (i = 20; i--;)
+    push_buffer (test_buffer_const_float_stereo (8000, 512, 0.0, 0.0));
+  send_eos_event (element);
+  poll_eos (element);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_reference_level)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i;
+
+  g_object_set (element, "reference-level", 83., "num-tracks", 2, NULL);
+  set_playing_state (element);
+
+  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);
+  gst_tag_list_free (tag_list);
+
+  accumulator = 0;
+  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_unless_album_peak (tag_list, 0.25);
+  /* 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.);
+  gst_tag_list_free (tag_list);
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_all_formats)
+{
+  GstElement *element = setup_rganalysis ();
+  GstTagList *tag_list;
+  gint accumulator = 0;
+  gint i, j;
+
+  set_playing_state (element);
+  for (i = G_N_ELEMENTS (supported_rates); i--;) {
+    accumulator = 0;
+    for (j = 0; j < 4; j++)
+      push_buffer (test_buffer_square_float_stereo (&accumulator,
+              supported_rates[i].sample_rate, 512, 0.25, 0.25));
+    for (j = 0; j < 3; j++)
+      push_buffer (test_buffer_square_float_mono (&accumulator,
+              supported_rates[i].sample_rate, 512, 0.25));
+    for (j = 0; j < 4; j++)
+      push_buffer (test_buffer_square_int16_stereo (&accumulator,
+              supported_rates[i].sample_rate, 16, 512, 1 << 13, 1 << 13));
+    for (j = 0; j < 3; j++)
+      push_buffer (test_buffer_square_int16_mono (&accumulator,
+              supported_rates[i].sample_rate, 16, 512, 1 << 13));
+    for (j = 0; j < 3; j++)
+      push_buffer (test_buffer_square_int16_stereo (&accumulator,
+              supported_rates[i].sample_rate, 8, 512, 1 << 5, 1 << 5));
+    for (j = 0; j < 3; j++)
+      push_buffer (test_buffer_square_int16_mono (&accumulator,
+              supported_rates[i].sample_rate, 8, 512, 1 << 5));
+    send_eos_event (element);
+    tag_list = poll_tags (element);
+    fail_unless_track_peak (tag_list, 0.25);
+    fail_unless_track_gain (tag_list, supported_rates[i].gain);
+    gst_tag_list_free (tag_list);
+  }
+
+  cleanup_rganalysis (element);
+}
+
+GST_END_TEST;
+
+/* Checks ensuring all advertised supported sample rates are really
+ * accepted, for integer and float, mono and stereo.  This also
+ * verifies that the correct gain is computed for all formats (except
+ * odd bit depths). */
+
+#define MAKE_GAIN_TEST_FLOAT_MONO(sample_rate)                        \
+  GST_START_TEST (test_gain_float_mono_##sample_rate)                 \
+{                                                                     \
+  GstElement *element = setup_rganalysis ();                          \
+  GstTagList *tag_list;                                               \
+  gint accumulator = 0;                                               \
+  gint i;                                                             \
+                                                                      \
+  set_playing_state (element);                                        \
+                                                                      \
+  for (i = 0; i < 20; i++)                                            \
+    push_buffer (test_buffer_square_float_mono (&accumulator,         \
+            sample_rate, 512, 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 (sample_rate));                               \
+  gst_tag_list_free (tag_list);                                       \
+                                                                      \
+  cleanup_rganalysis (element);                                       \
+}                                                                     \
+                                                                      \
+GST_END_TEST;
+
+#define MAKE_GAIN_TEST_FLOAT_STEREO(sample_rate)                      \
+  GST_START_TEST (test_gain_float_stereo_##sample_rate)               \
+{                                                                     \
+  GstElement *element = setup_rganalysis ();                          \
+  GstTagList *tag_list;                                               \
+  gint accumulator = 0;                                               \
+  gint i;                                                             \
+                                                                      \
+  set_playing_state (element);                                        \
+                                                                      \
+  for (i = 0; i < 20; i++)                                            \
+    push_buffer (test_buffer_square_float_stereo (&accumulator,       \
+            sample_rate, 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 (sample_rate));                               \
+  gst_tag_list_free (tag_list);                                       \
+                                                                      \
+  cleanup_rganalysis (element);                                       \
+}                                                                     \
+                                                                      \
+GST_END_TEST;
+
+#define MAKE_GAIN_TEST_INT16_MONO(sample_rate, depth)                 \
+  GST_START_TEST (test_gain_int16_##depth##_mono_##sample_rate)       \
+{                                                                     \
+  GstElement *element = setup_rganalysis ();                          \
+  GstTagList *tag_list;                                               \
+  gint accumulator = 0;                                               \
+  gint i;                                                             \
+                                                                      \
+  set_playing_state (element);                                        \
+                                                                      \
+  for (i = 0; i < 20; i++)                                            \
+    push_buffer (test_buffer_square_int16_mono (&accumulator,         \
+            sample_rate, depth, 512, 1 << (13 + depth - 16)));        \
+                                                                      \
+  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 (sample_rate));                               \
+  gst_tag_list_free (tag_list);                                       \
+                                                                      \
+  cleanup_rganalysis (element);                                       \
+}                                                                     \
+                                                                      \
+GST_END_TEST;
+
+#define MAKE_GAIN_TEST_INT16_STEREO(sample_rate, depth)               \
+  GST_START_TEST (test_gain_int16_##depth##_stereo_##sample_rate)     \
+{                                                                     \
+  GstElement *element = setup_rganalysis ();                          \
+  GstTagList *tag_list;                                               \
+  gint accumulator = 0;                                               \
+  gint i;                                                             \
+                                                                      \
+  set_playing_state (element);                                        \
+                                                                      \
+  for (i = 0; i < 20; i++)                                            \
+    push_buffer (test_buffer_square_int16_stereo (&accumulator,       \
+            sample_rate, depth, 512, 1 << (13 + depth - 16),          \
+            1 << (13 + depth - 16)));                                 \
+  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 (sample_rate));                               \
+  gst_tag_list_free (tag_list);                                       \
+                                                                      \
+  cleanup_rganalysis (element);                                       \
+}                                                                     \
+                                                                      \
+GST_END_TEST;
+
+MAKE_GAIN_TEST_FLOAT_MONO (8000);
+MAKE_GAIN_TEST_FLOAT_MONO (11025);
+MAKE_GAIN_TEST_FLOAT_MONO (12000);
+MAKE_GAIN_TEST_FLOAT_MONO (16000);
+MAKE_GAIN_TEST_FLOAT_MONO (22050);
+MAKE_GAIN_TEST_FLOAT_MONO (24000);
+MAKE_GAIN_TEST_FLOAT_MONO (32000);
+MAKE_GAIN_TEST_FLOAT_MONO (44100);
+MAKE_GAIN_TEST_FLOAT_MONO (48000);
+
+MAKE_GAIN_TEST_FLOAT_STEREO (8000);
+MAKE_GAIN_TEST_FLOAT_STEREO (11025);
+MAKE_GAIN_TEST_FLOAT_STEREO (12000);
+MAKE_GAIN_TEST_FLOAT_STEREO (16000);
+MAKE_GAIN_TEST_FLOAT_STEREO (22050);
+MAKE_GAIN_TEST_FLOAT_STEREO (24000);
+MAKE_GAIN_TEST_FLOAT_STEREO (32000);
+MAKE_GAIN_TEST_FLOAT_STEREO (44100);
+MAKE_GAIN_TEST_FLOAT_STEREO (48000);
+
+MAKE_GAIN_TEST_INT16_MONO (8000, 16);
+MAKE_GAIN_TEST_INT16_MONO (11025, 16);
+MAKE_GAIN_TEST_INT16_MONO (12000, 16);
+MAKE_GAIN_TEST_INT16_MONO (16000, 16);
+MAKE_GAIN_TEST_INT16_MONO (22050, 16);
+MAKE_GAIN_TEST_INT16_MONO (24000, 16);
+MAKE_GAIN_TEST_INT16_MONO (32000, 16);
+MAKE_GAIN_TEST_INT16_MONO (44100, 16);
+MAKE_GAIN_TEST_INT16_MONO (48000, 16);
+
+MAKE_GAIN_TEST_INT16_STEREO (8000, 16);
+MAKE_GAIN_TEST_INT16_STEREO (11025, 16);
+MAKE_GAIN_TEST_INT16_STEREO (12000, 16);
+MAKE_GAIN_TEST_INT16_STEREO (16000, 16);
+MAKE_GAIN_TEST_INT16_STEREO (22050, 16);
+MAKE_GAIN_TEST_INT16_STEREO (24000, 16);
+MAKE_GAIN_TEST_INT16_STEREO (32000, 16);
+MAKE_GAIN_TEST_INT16_STEREO (44100, 16);
+MAKE_GAIN_TEST_INT16_STEREO (48000, 16);
+
+MAKE_GAIN_TEST_INT16_MONO (8000, 8);
+MAKE_GAIN_TEST_INT16_MONO (11025, 8);
+MAKE_GAIN_TEST_INT16_MONO (12000, 8);
+MAKE_GAIN_TEST_INT16_MONO (16000, 8);
+MAKE_GAIN_TEST_INT16_MONO (22050, 8);
+MAKE_GAIN_TEST_INT16_MONO (24000, 8);
+MAKE_GAIN_TEST_INT16_MONO (32000, 8);
+MAKE_GAIN_TEST_INT16_MONO (44100, 8);
+MAKE_GAIN_TEST_INT16_MONO (48000, 8);
+
+MAKE_GAIN_TEST_INT16_STEREO (8000, 8);
+MAKE_GAIN_TEST_INT16_STEREO (11025, 8);
+MAKE_GAIN_TEST_INT16_STEREO (12000, 8);
+MAKE_GAIN_TEST_INT16_STEREO (16000, 8);
+MAKE_GAIN_TEST_INT16_STEREO (22050, 8);
+MAKE_GAIN_TEST_INT16_STEREO (24000, 8);
+MAKE_GAIN_TEST_INT16_STEREO (32000, 8);
+MAKE_GAIN_TEST_INT16_STEREO (44100, 8);
+MAKE_GAIN_TEST_INT16_STEREO (48000, 8);
+
+Suite *
+rganalysis_suite (void)
+{
+  Suite *s = suite_create ("rganalysis");
+  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_no_buffer_album_1);
+  tcase_add_test (tc_chain, test_no_buffer_album_2);
+  tcase_add_test (tc_chain, test_empty_buffers);
+
+  tcase_add_test (tc_chain, test_peak_float);
+  tcase_add_test (tc_chain, test_peak_int16_16);
+  tcase_add_test (tc_chain, test_peak_int16_8);
+
+  tcase_add_test (tc_chain, test_peak_album);
+  tcase_add_test (tc_chain, test_peak_track_album);
+  tcase_add_test (tc_chain, test_peak_album_abort_to_track);
+
+  tcase_add_test (tc_chain, test_gain_album);
+
+  tcase_add_test (tc_chain, test_forced);
+  tcase_add_test (tc_chain, test_forced_separate);
+  tcase_add_test (tc_chain, test_forced_after_data);
+  tcase_add_test (tc_chain, test_forced_album);
+  tcase_add_test (tc_chain, test_forced_album_skip);
+  tcase_add_test (tc_chain, test_forced_album_no_skip);
+  tcase_add_test (tc_chain, test_forced_abort_album_no_skip);
+
+  tcase_add_test (tc_chain, test_reference_level);
+
+  tcase_add_test (tc_chain, test_all_formats);
+
+  tcase_add_test (tc_chain, test_gain_float_mono_8000);
+  tcase_add_test (tc_chain, test_gain_float_mono_11025);
+  tcase_add_test (tc_chain, test_gain_float_mono_12000);
+  tcase_add_test (tc_chain, test_gain_float_mono_16000);
+  tcase_add_test (tc_chain, test_gain_float_mono_22050);
+  tcase_add_test (tc_chain, test_gain_float_mono_24000);
+  tcase_add_test (tc_chain, test_gain_float_mono_32000);
+  tcase_add_test (tc_chain, test_gain_float_mono_44100);
+  tcase_add_test (tc_chain, test_gain_float_mono_48000);
+
+  tcase_add_test (tc_chain, test_gain_float_stereo_8000);
+  tcase_add_test (tc_chain, test_gain_float_stereo_11025);
+  tcase_add_test (tc_chain, test_gain_float_stereo_12000);
+  tcase_add_test (tc_chain, test_gain_float_stereo_16000);
+  tcase_add_test (tc_chain, test_gain_float_stereo_22050);
+  tcase_add_test (tc_chain, test_gain_float_stereo_24000);
+  tcase_add_test (tc_chain, test_gain_float_stereo_32000);
+  tcase_add_test (tc_chain, test_gain_float_stereo_44100);
+  tcase_add_test (tc_chain, test_gain_float_stereo_48000);
+
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_8000);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_11025);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_12000);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_16000);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_22050);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_24000);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_32000);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_44100);
+  tcase_add_test (tc_chain, test_gain_int16_16_mono_48000);
+
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_8000);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_11025);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_12000);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_16000);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_22050);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_24000);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_32000);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_44100);
+  tcase_add_test (tc_chain, test_gain_int16_16_stereo_48000);
+
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_8000);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_11025);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_12000);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_16000);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_22050);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_24000);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_32000);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_44100);
+  tcase_add_test (tc_chain, test_gain_int16_8_mono_48000);
+
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_8000);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_11025);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_12000);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_16000);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_22050);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_24000);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_32000);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_44100);
+  tcase_add_test (tc_chain, test_gain_int16_8_stereo_48000);
+
+  return s;
+}
+
+int
+main (int argc, char **argv)
+{
+  gint nf;
+
+  Suite *s = rganalysis_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;
+}