mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
398 lines
14 KiB
C
398 lines
14 KiB
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);
|