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