/* 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>

#include <gst/audio/audio.h>

/* 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;

static GstBus *mybus;

/* 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, "                             \

  "format = (string) "GST_AUDIO_NE (F32) ", " \

  "layout = (string) interleaved, "           \

  REPLAY_GAIN_CAPS                            \

  "; "                                        \

  "audio/x-raw, "                             \

  "format = (string) "GST_AUDIO_NE (S16) ", " \

  "layout = (string) interleaved, "           \

  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)

    );

static gboolean

mysink_event_func (GstPad * pad, GstObject * parent, GstEvent * event)

{

  GST_LOG_OBJECT (pad, "%s event: %" GST_PTR_FORMAT,

      GST_EVENT_TYPE_NAME (event), event);

  /* a sink would post tag events as messages, so do the same here,

   * esp. since we're polling on the bus waiting for TAG messages.. */

  if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) {

    GstTagList *taglist;

    gst_event_parse_tag (event, &taglist);

    gst_bus_post (mybus, gst_message_new_tag (GST_OBJECT (mysinkpad),

            gst_tag_list_copy (taglist)));

  }

  gst_event_unref (event);

  return TRUE;

}

static GstElement *

setup_rganalysis (void)

{

  GstElement *analysis;

  GstBus *bus;

  GST_DEBUG ("setup_rganalysis");

  analysis = gst_check_setup_element ("rganalysis");

  mysrcpad = gst_check_setup_src_pad (analysis, &srctemplate);

  mysinkpad = gst_check_setup_sink_pad (analysis, &sinktemplate);

  gst_pad_set_event_function (mysinkpad, mysink_event_func);

  gst_pad_set_active (mysrcpad, TRUE);

  gst_pad_set_active (mysinkpad, TRUE);

  bus = gst_bus_new ();

  gst_element_set_bus (analysis, bus);

  mybus = bus;                  /* keep ref */

  return analysis;

}

static 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;

  gst_object_unref (mybus);

  mybus = NULL;

  /* The bus owns references to the element: */

  gst_element_set_bus (element, 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

send_flush_events (GstElement * element)

{

  gboolean res;

  GstPad *pad;

  pad = mysrcpad;

  res = gst_pad_push_event (pad, gst_event_new_flush_start ());

  fail_unless (res, "flush-start even not handledt");

  res = gst_pad_push_event (pad, gst_event_new_flush_stop (TRUE));

  fail_unless (res, "flush-stop event not handled");

}

static void

send_stream_start_event (GstElement * element)

{

  gboolean res;

  GstPad *pad;

  pad = mysrcpad;

  res = gst_pad_push_event (pad, gst_event_new_stream_start ("test"));

  fail_unless (res, "STREAM_START event not handled");

}

static void

send_caps_event (const gchar * format, gint sample_rate, gint channels)

{

  GstCaps *caps;

  caps = gst_caps_new_simple ("audio/x-raw",

      "format", G_TYPE_STRING, format,

      "rate", G_TYPE_INT, sample_rate, "channels", G_TYPE_INT, channels,

      "layout", G_TYPE_STRING, "interleaved", NULL);

  if (channels == 2) {

    gst_caps_set_simple (caps,

        "channel-mask", GST_TYPE_BITMASK,

        G_GUINT64_CONSTANT (0x0000000000000003), NULL);

  }

  gst_pad_set_caps (mysrcpad, caps);

  gst_caps_unref (caps);

}

static void

send_segment_event (GstElement * element)

{

  GstSegment segment;

  gboolean res;

  GstPad *pad;

  pad = mysrcpad;

  gst_segment_init (&segment, GST_FORMAT_TIME);

  res = gst_pad_push_event (pad, gst_event_new_segment (&segment));

  fail_unless (res, "SEGMENT event not handled");

}

static void

send_eos_event (GstElement * element)

{

  GstBus *bus = gst_element_get_bus (element);

  GstPad *pad = mysrcpad;

  gboolean res;

  res = gst_pad_push_event (pad, gst_event_new_eos ());

  fail_unless (res, "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);

}

static void

send_tag_event (GstElement * element, GstTagList * tag_list)

{

  GstPad *pad = mysrcpad;

  GstEvent *event = gst_event_new_tag (tag_list);

  fail_unless (gst_pad_push_event (pad, event),

      "Cannot send TAG event: Not handled.");

}

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);

}

static GstTagList *

poll_tags_only (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");

  gst_message_parse_tag (message, &tag_list);

  gst_message_unref (message);

  gst_object_unref (bus);

  return tag_list;

}

/* This also polls for EOS since the TAG message comes right before the end of

 * streams. */

static GstTagList *

poll_tags_followed_by_eos (GstElement * element)

{

  GstTagList *tag_list = poll_tags_only (element);

  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));

  GstMapInfo map;

  gfloat *data;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gfloat *) map.data;

  for (i = n_frames; i--;)

    *data++ = value;

  gst_buffer_unmap (buf, &map);

  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);

  GstMapInfo map;

  gfloat *data;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gfloat *) map.data;

  for (i = n_frames; i--;) {

    *data++ = value_l;

    *data++ = value_r;

  }

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gint16 *) map.data;

  for (i = n_frames; i--;)

    *data++ = value;

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gint16 *) map.data;

  for (i = n_frames; i--;) {

    *data++ = value_l;

    *data++ = value_r;

  }

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gfloat *) map.data;

  for (i = n_frames; i--;) {

    *accumulator += 1;

    *accumulator %= 96;

    if (*accumulator < 48)

      *data++ = value;

    else

      *data++ = -value;

  }

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gfloat *) map.data;

  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;

    }

  }

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gint16 *) map.data;

  for (i = n_frames; i--;) {

    *accumulator += 1;

    *accumulator %= 96;

    if (*accumulator < 48)

      *data++ = value;

    else

      *data++ = -MAX (value, -32767);

  }

  gst_buffer_unmap (buf, &map);

  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;

  GstMapInfo map;

  gint i;

  gst_buffer_map (buf, &map, GST_MAP_WRITE);

  data = (gint16 *) map.data;

  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);

    }

  }

  gst_buffer_unmap (buf, &map);

  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_stream_start_event (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  /* First album: */

  g_object_set (element, "num-tracks", 3, NULL);

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  fail_unless_num_tracks (element, 2);

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  fail_unless_num_tracks (element, 1);

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  fail_unless_num_tracks (element, 0);

  /* Second album: */

  g_object_set (element, "num-tracks", 2, NULL);

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  fail_unless_num_tracks (element, 1);

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  poll_eos (element);

  fail_unless_num_tracks (element, 0);

  /* Single track: */

  send_flush_events (element);

  send_segment_event (element);

  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_stream_start_event (element);

  send_segment_event (element);

  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: */

  send_flush_events (element);

  send_caps_event (GST_AUDIO_NE (F32), 44100, 1);

  send_segment_event (element);

  for (i = 20; i--;)

    push_buffer (test_buffer_square_float_mono (&accumulator, 44100, 512,

            0.25));

  send_eos_event (element);

  tag_list = poll_tags_followed_by_eos (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_unref (tag_list);

  fail_unless_num_tracks (element, 1);

  /* No buffer for the last track. */

  send_flush_events (element);

  send_segment_event (element);

  send_eos_event (element);

  tag_list = poll_tags_followed_by_eos (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_unref (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: */

  send_stream_start_event (element);

  send_caps_event (GST_AUDIO_NE (F32), 44100, 2);

  send_segment_event (element);

  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);

  send_flush_events (element);

  send_segment_event (element);

  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);

  send_flush_events (element);

  send_segment_event (element);

  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);

  send_flush_events (element);

  send_segment_event (element);

  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: */

  send_flush_events (element);

  send_segment_event (element);

  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);

  send_stream_start_event (element);

  send_caps_event (GST_AUDIO_NE (F32), 8000, 2);

  send_segment_event (element);

  push_buffer (test_buffer_const_float_stereo (8000, 512, -1.369, 0.0));

  send_eos_event (element);

  tag_list = poll_tags_followed_by_eos (element);

  fail_unless_track_peak (tag_list, 1.369);

  gst_tag_list_unref (tag_list);

  /* Swapped channels. */

  send_flush_events (element);

  send_segment_event (element);

  push_buffer (test_buffer_const_float_stereo (8000, 512, 0.0, -1.369));

  send_eos_event (element);

  tag_list = poll_tags_followed_by_eos (element);

  fail_unless_track_peak (tag_list, 1.369);

  gst_tag_list_unref (tag_list);

  /* Mono. */

  send_flush_events (element);

  send_caps_event (GST_AUDIO_NE (F32), 8000, 1);

  send_segment_event (element);

  push_buffer (test_buffer_const_float_mono (8000, 512, -1.369));

  send_eos_event (element);

  tag_list = poll_tags_followed_by_eos (element);

  fail_unless_track_peak (tag_list, 1.369);

  gst_tag_list_unref (tag_list);

  cleanup_rganalysis (element);

}

GST_END_TEST;

GST_START_TEST (test_peak_int16_16)

{