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