gstreamer/tests/check/elements/rawaudioparse.c

/* GStreamer
 *
 * unit test for rawaudioparse
 *
 * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

/* FIXME: GValueArray is deprecated, but there is currently no viable alternatives
 * See https://bugzilla.gnome.org/show_bug.cgi?id=667228 */
#define GLIB_DISABLE_DEPRECATION_WARNINGS

#include <gst/check/gstcheck.h>
#include <gst/audio/audio.h>

/* Checks are hardcoded to expect stereo 16-bit data. The sample rate
 * however varies from the default of 40 kHz in some tests to see the
 * differences in calculated buffer durations. */
#define NUM_TEST_SAMPLES 512
#define NUM_TEST_CHANNELS 2
#define TEST_SAMPLE_RATE 40000
#define TEST_SAMPLE_FORMAT GST_AUDIO_FORMAT_S16

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

typedef struct
{
  GstElement *rawaudioparse;
  GstAdapter *test_data_adapter;
}
RawAudParseTestCtx;

/* Sets up a rawaudioparse element and a GstAdapter that contains 512 test
 * audio samples. The samples a monotonically increasing set from the values
 * 0 to 511 for the left and 512 to 1023 for the right channel. The result
 * is a GstAdapter that contains the interleaved 16-bit integer values:
 * 0,512,1,513,2,514, ... 511,1023 . This set is used in the checks to see
 * if rawaudioparse's output buffers contain valid data. */
static void
setup_rawaudioparse (RawAudParseTestCtx * testctx, gboolean use_sink_caps,
    gboolean set_properties, GstCaps * incaps, GstFormat format)
{
  GstElement *rawaudioparse;
  GstAdapter *test_data_adapter;
  GstBuffer *buffer;
  guint i;
  guint16 samples[NUM_TEST_SAMPLES * NUM_TEST_CHANNELS];


  /* Setup the rawaudioparse element and the pads */

  static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
      GST_PAD_SINK,
      GST_PAD_ALWAYS,
      GST_STATIC_CAPS (GST_AUDIO_CAPS_MAKE (GST_AUDIO_FORMATS_ALL))
      );
  static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
      GST_PAD_SRC,
      GST_PAD_ALWAYS,
      GST_STATIC_CAPS_ANY);

  rawaudioparse = gst_check_setup_element ("rawaudioparse");

  g_object_set (G_OBJECT (rawaudioparse), "use-sink-caps", use_sink_caps, NULL);
  if (set_properties)
    g_object_set (G_OBJECT (rawaudioparse), "sample-rate", TEST_SAMPLE_RATE,
        "num-channels", NUM_TEST_CHANNELS, "pcm-format", TEST_SAMPLE_FORMAT,
        NULL);

  fail_unless (gst_element_set_state (rawaudioparse,
          GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
      "could not set to paused");

  mysrcpad = gst_check_setup_src_pad (rawaudioparse, &srctemplate);
  mysinkpad = gst_check_setup_sink_pad (rawaudioparse, &sinktemplate);

  gst_pad_set_active (mysrcpad, TRUE);
  gst_pad_set_active (mysinkpad, TRUE);

  gst_check_setup_events (mysrcpad, rawaudioparse, incaps, format);
  if (incaps)
    gst_caps_unref (incaps);


  /* Fill the adapter with the interleaved 0..511 and
   * 512..1023 samples */
  for (i = 0; i < NUM_TEST_SAMPLES; ++i) {
    guint c;
    for (c = 0; c < NUM_TEST_CHANNELS; ++c)
      samples[i * NUM_TEST_CHANNELS + c] = c * NUM_TEST_SAMPLES + i;
  }

  test_data_adapter = gst_adapter_new ();
  buffer = gst_buffer_new_allocate (NULL, sizeof (samples), NULL);
  gst_buffer_fill (buffer, 0, samples, sizeof (samples));
  gst_adapter_push (test_data_adapter, buffer);


  testctx->rawaudioparse = rawaudioparse;
  testctx->test_data_adapter = test_data_adapter;
}

static void
cleanup_rawaudioparse (RawAudParseTestCtx * testctx)
{
  int num_buffers, i;

  gst_pad_set_active (mysrcpad, FALSE);
  gst_pad_set_active (mysinkpad, FALSE);
  gst_check_teardown_src_pad (testctx->rawaudioparse);
  gst_check_teardown_sink_pad (testctx->rawaudioparse);
  gst_check_teardown_element (testctx->rawaudioparse);

  g_object_unref (G_OBJECT (testctx->test_data_adapter));

  if (buffers != NULL) {
    num_buffers = g_list_length (buffers);
    for (i = 0; i < num_buffers; ++i) {
      GstBuffer *buf = GST_BUFFER (buffers->data);
      buffers = g_list_remove (buffers, buf);
      gst_buffer_unref (buf);
    }

    g_list_free (buffers);
    buffers = NULL;
  }
}


static void
push_data_and_check_output (RawAudParseTestCtx * testctx, gsize num_in_bytes,
    gsize expected_num_out_bytes, gint64 expected_pts, gint64 expected_dur,
    guint expected_num_buffers_in_list, guint bpf, guint16 channel0_start,
    guint16 channel1_start)
{
  GstBuffer *inbuf, *outbuf;
  guint num_buffers;

  /* Simulate upstream input by taking num_in_bytes bytes from the adapter */
  inbuf = gst_adapter_take_buffer (testctx->test_data_adapter, num_in_bytes);
  fail_unless (inbuf != NULL);

  /* Push the input data and check that the output buffers list grew as
   * expected */
  fail_unless (gst_pad_push (mysrcpad, inbuf) == GST_FLOW_OK);
  num_buffers = g_list_length (buffers);
  fail_unless_equals_int (num_buffers, expected_num_buffers_in_list);

  /* Take the latest output buffer */
  outbuf = g_list_nth_data (buffers, num_buffers - 1);
  fail_unless (outbuf != NULL);

  /* Verify size, PTS, duration of the output buffer */
  fail_unless_equals_uint64 (expected_num_out_bytes,
      gst_buffer_get_size (outbuf));
  fail_unless_equals_uint64 (expected_pts, GST_BUFFER_PTS (outbuf));
  fail_unless_equals_uint64 (expected_dur, GST_BUFFER_DURATION (outbuf));

  /* Go through all of the samples in the output buffer and check that they are
   * valid. The samples are interleaved. The offsets specified by channel0_start
   * and channel1_start are the expected values of the first sample for each
   * channel in the buffer. So, if channel0_start is 512, then sample #0 in the
   * buffer must have value 512, and if channel1_start is 700, then sample #1
   * in the buffer must have value 700 etc. */
  {
    guint i, num_frames;
    guint16 *s;
    GstMapInfo map_info;
    guint channel_starts[2] = { channel0_start, channel1_start };

    gst_buffer_map (outbuf, &map_info, GST_MAP_READ);
    num_frames = map_info.size / bpf;
    s = (guint16 *) (map_info.data);

    for (i = 0; i < num_frames; ++i) {
      guint c;

      for (c = 0; i < NUM_TEST_CHANNELS; ++i) {
        guint16 expected = channel_starts[c] + i;
        guint16 actual = s[i * NUM_TEST_CHANNELS + c];

        fail_unless_equals_int (expected, actual);
      }
    }

    gst_buffer_unmap (outbuf, &map_info);
  }
}


GST_START_TEST (test_push_unaligned_data_properties_config)
{
  RawAudParseTestCtx testctx;

  setup_rawaudioparse (&testctx, FALSE, TRUE, NULL, GST_FORMAT_BYTES);

  /* Send in data buffers that are not aligned to multiples of the
   * frame size (= sample size * num_channels). This tests if rawaudioparse
   * aligns output data properly.
   *
   * The second line sends in 99 bytes, and expects 100 bytes in the
   * output buffer. This is because the first buffer contains 45 bytes,
   * and rawaudioparse is expected to output 44 bytes (which is an integer
   * multiple of the frame size). The leftover 1 byte then gets prepended
   * to the input buffer with 99 bytes, resulting in 100 bytes, which is
   * an integer multiple of the frame size.
   */

  push_data_and_check_output (&testctx, 45, 44, GST_USECOND * 0,
      GST_USECOND * 275, 1, 4, 0, 512);
  push_data_and_check_output (&testctx, 99, 100, GST_USECOND * 275,
      GST_USECOND * 625, 2, 4, 11, 523);
  push_data_and_check_output (&testctx, 18, 16, GST_USECOND * 900,
      GST_USECOND * 100, 3, 4, 36, 548);

  cleanup_rawaudioparse (&testctx);
}

GST_END_TEST;

GST_START_TEST (test_push_unaligned_data_sink_caps_config)
{
  RawAudParseTestCtx testctx;
  GstAudioInfo ainfo;
  GstCaps *caps;

  /* This test is essentially the same as test_push_unaligned_data_properties_config,
   * except that rawaudioparse uses the sink caps config instead of the property config. */

  gst_audio_info_set_format (&ainfo, TEST_SAMPLE_FORMAT, TEST_SAMPLE_RATE,
      NUM_TEST_CHANNELS, NULL);
  caps = gst_audio_info_to_caps (&ainfo);

  setup_rawaudioparse (&testctx, TRUE, FALSE, caps, GST_FORMAT_BYTES);

  push_data_and_check_output (&testctx, 45, 44, GST_USECOND * 0,
      GST_USECOND * 275, 1, 4, 0, 512);
  push_data_and_check_output (&testctx, 99, 100, GST_USECOND * 275,
      GST_USECOND * 625, 2, 4, 11, 523);
  push_data_and_check_output (&testctx, 18, 16, GST_USECOND * 900,
      GST_USECOND * 100, 3, 4, 36, 548);

  cleanup_rawaudioparse (&testctx);
}

GST_END_TEST;

GST_START_TEST (test_push_swapped_channels)
{
  RawAudParseTestCtx testctx;
  GValueArray *valarray;
  GValue val = G_VALUE_INIT;

  /* Send in 40 bytes and use a nonstandard channel order (left and right channels
   * swapped). Expected behavior is for rawaudioparse to reorder the samples inside
   * output buffers to conform to the GStreamer channel order. For this reason,
   * channel0 offset is 512 and channel1 offset is 0 in the check below. */

  setup_rawaudioparse (&testctx, FALSE, TRUE, NULL, GST_FORMAT_BYTES);

  valarray = g_value_array_new (2);
  g_value_init (&val, GST_TYPE_AUDIO_CHANNEL_POSITION);
  g_value_set_enum (&val, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
  g_value_array_insert (valarray, 0, &val);
  g_value_set_enum (&val, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);
  g_value_array_insert (valarray, 1, &val);
  g_object_set (G_OBJECT (testctx.rawaudioparse), "channel-positions",
      valarray, NULL);
  g_value_array_free (valarray);
  g_value_unset (&val);

  push_data_and_check_output (&testctx, 40, 40, GST_USECOND * 0,
      GST_USECOND * 250, 1, 4, 512, 0);

  cleanup_rawaudioparse (&testctx);
}

GST_END_TEST;

GST_START_TEST (test_config_switch)
{
  RawAudParseTestCtx testctx;
  GstAudioInfo ainfo;
  GstCaps *caps;

  /* Start processing with the properties config active, then mid-stream switch to
   * the sink caps config. The properties config is altered to have a different
   * sample rate than the sink caps to be able to detect the switch. The net effect
   * is that output buffer durations are altered. For example, 40 bytes equal
   * 10 samples, and this equals 500 us with 20 kHz or 250 us with 40 kHz. */

  gst_audio_info_set_format (&ainfo, TEST_SAMPLE_FORMAT, TEST_SAMPLE_RATE,
      NUM_TEST_CHANNELS, NULL);
  caps = gst_audio_info_to_caps (&ainfo);

  setup_rawaudioparse (&testctx, FALSE, TRUE, caps, GST_FORMAT_BYTES);

  g_object_set (G_OBJECT (testctx.rawaudioparse), "sample-rate", 20000, NULL);

  /* Push in data with properties config active, expecting duration calculations
   * to be based on the 20 kHz sample rate */
  push_data_and_check_output (&testctx, 40, 40, GST_USECOND * 0,
      GST_USECOND * 500, 1, 4, 0, 512);
  push_data_and_check_output (&testctx, 20, 20, GST_USECOND * 500,
      GST_USECOND * 250, 2, 4, 10, 522);

  /* Perform the switch */
  g_object_set (G_OBJECT (testctx.rawaudioparse), "use-sink-caps", TRUE, NULL);

  /* Push in data with sink caps config active, expecting duration calculations
   * to be based on the 40 kHz sample rate */
  push_data_and_check_output (&testctx, 40, 40, GST_USECOND * 750,
      GST_USECOND * 250, 3, 4, 15, 527);

  cleanup_rawaudioparse (&testctx);
}

GST_END_TEST;

GST_START_TEST (test_change_caps)
{
  RawAudParseTestCtx testctx;
  GstAudioInfo ainfo;
  GstCaps *caps;

  /* Start processing with the sink caps config active, using the
   * default channel count and sample format and 20 kHz sample rate
   * for the caps. Push some data, then change caps (20 kHz -> 40 kHz).
   * Check that the changed caps are handled properly. */

  gst_audio_info_set_format (&ainfo, TEST_SAMPLE_FORMAT, 20000,
      NUM_TEST_CHANNELS, NULL);
  caps = gst_audio_info_to_caps (&ainfo);

  setup_rawaudioparse (&testctx, TRUE, FALSE, caps, GST_FORMAT_BYTES);

  /* Push in data with caps sink config active, expecting duration calculations
   * to be based on the 20 kHz sample rate */
  push_data_and_check_output (&testctx, 40, 40, GST_USECOND * 0,
      GST_USECOND * 500, 1, 4, 0, 512);
  push_data_and_check_output (&testctx, 20, 20, GST_USECOND * 500,
      GST_USECOND * 250, 2, 4, 10, 522);

  /* Change caps */
  gst_audio_info_set_format (&ainfo, TEST_SAMPLE_FORMAT, 40000,
      NUM_TEST_CHANNELS, NULL);
  caps = gst_audio_info_to_caps (&ainfo);
  fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_caps (caps)));
  gst_caps_unref (caps);

  /* Push in data with the new caps, expecting duration calculations
   * to be based on the 40 kHz sample rate */
  push_data_and_check_output (&testctx, 40, 40, GST_USECOND * 750,
      GST_USECOND * 250, 3, 4, 15, 527);

  cleanup_rawaudioparse (&testctx);
}

GST_END_TEST;


static Suite *
rawaudioparse_suite (void)
{
  Suite *s = suite_create ("rawaudioparse");
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_push_unaligned_data_properties_config);
  tcase_add_test (tc_chain, test_push_unaligned_data_sink_caps_config);
  tcase_add_test (tc_chain, test_push_swapped_channels);
  tcase_add_test (tc_chain, test_config_switch);
  tcase_add_test (tc_chain, test_change_caps);

  return s;
}

GST_CHECK_MAIN (rawaudioparse);