From 1645110f020d26eaa9700775dbedf646918fdd23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Stadler?= Date: Sat, 19 May 2007 10:01:45 +0000 Subject: Add replaygain playback elements (#412710). MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message from CVS: Patch by: René Stadler * docs/plugins/Makefile.am: * docs/plugins/gst-plugins-bad-plugins-docs.sgml: * docs/plugins/gst-plugins-bad-plugins-sections.txt: * docs/plugins/inspect/plugin-replaygain.xml: * gst/replaygain/Makefile.am: * gst/replaygain/gstrganalysis.c: (gst_rg_analysis_class_init), (gst_rg_analysis_start), (gst_rg_analysis_set_caps), (gst_rg_analysis_transform_ip), (gst_rg_analysis_event), (gst_rg_analysis_stop), (gst_rg_analysis_handle_tags), (gst_rg_analysis_handle_eos), (gst_rg_analysis_track_result), (gst_rg_analysis_album_result): * gst/replaygain/gstrganalysis.h: * gst/replaygain/gstrglimiter.c: (gst_rg_limiter_base_init), (gst_rg_limiter_class_init), (gst_rg_limiter_init), (gst_rg_limiter_set_property), (gst_rg_limiter_get_property), (gst_rg_limiter_transform_ip): * gst/replaygain/gstrglimiter.h: * gst/replaygain/gstrgvolume.c: (gst_rg_volume_base_init), (gst_rg_volume_class_init), (gst_rg_volume_init), (gst_rg_volume_set_property), (gst_rg_volume_get_property), (gst_rg_volume_dispose), (gst_rg_volume_change_state), (gst_rg_volume_sink_event), (gst_rg_volume_tag_event), (gst_rg_volume_reset), (gst_rg_volume_update_gain), (gst_rg_volume_determine_gain): * gst/replaygain/gstrgvolume.h: * gst/replaygain/replaygain.c: (plugin_init): * gst/replaygain/replaygain.h: * gst/replaygain/rganalysis.h: * tests/check/Makefile.am: * tests/check/elements/.cvsignore: * tests/check/elements/rganalysis.c: (send_eos_event), (GST_START_TEST): * tests/check/elements/rglimiter.c: (setup_rglimiter), (cleanup_rglimiter), (set_playing_state), (create_test_buffer), (verify_test_buffer), (GST_START_TEST), (rglimiter_suite), (main): * tests/check/elements/rgvolume.c: (event_func), (setup_rgvolume), (cleanup_rgvolume), (set_playing_state), (set_null_state), (send_eos_event), (send_tag_event), (test_buffer_new), (fail_unless_target_gain), (fail_unless_result_gain), (fail_unless_gain), (GST_START_TEST), (rgvolume_suite), (main): Add replaygain playback elements (#412710). --- tests/check/Makefile.am | 6 + tests/check/elements/.gitignore | 4 +- tests/check/elements/rganalysis.c | 187 +++++++------ tests/check/elements/rglimiter.c | 238 ++++++++++++++++ tests/check/elements/rgvolume.c | 573 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 919 insertions(+), 89 deletions(-) create mode 100644 tests/check/elements/rglimiter.c create mode 100644 tests/check/elements/rgvolume.c (limited to 'tests') diff --git a/tests/check/Makefile.am b/tests/check/Makefile.am index bb2540f9..d23611c9 100644 --- a/tests/check/Makefile.am +++ b/tests/check/Makefile.am @@ -57,9 +57,12 @@ VALGRIND_TESTS_DISABLE = \ $(VALGRIND_TO_FIX) check_PROGRAMS = \ + elements/deinterleave \ $(check_mpeg2enc) \ $(check_neon) \ elements/rganalysis \ + elements/rglimiter \ + elements/rgvolume \ elements/videocrop \ $(check_wavpack) \ elements/y4menc @@ -72,3 +75,6 @@ LDADD = $(GST_OBJ_LIBS) $(GST_CHECK_LIBS) $(CHECK_LIBS) elements_videocrop_LDADD = $(LDADD) $(GST_BASE_LIBS) elements_videocrop_CFLAGS = $(CFLAGS) $(AM_CFLAGS) $(GST_BASE_CFLAGS) + +elements_deinterleave_LDADD = $(LDADD) $(GST_PLUGINS_BASE_LIBS) -lgstaudio-$(GST_MAJORMINOR) +elements_deinterleave_CFLAGS = $(CFLAGS) $(AM_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) diff --git a/tests/check/elements/.gitignore b/tests/check/elements/.gitignore index a9c39de6..69674ef1 100644 --- a/tests/check/elements/.gitignore +++ b/tests/check/elements/.gitignore @@ -1,8 +1,10 @@ .dirstamp -tagid3v2mux +deinterleave gdpdepay gdppay mpeg2enc +rglimiter +rgvolume wavpackdec wavpackenc wavpackparse diff --git a/tests/check/elements/rganalysis.c b/tests/check/elements/rganalysis.c index 63e3c720..e8a9db2f 100644 --- a/tests/check/elements/rganalysis.c +++ b/tests/check/elements/rganalysis.c @@ -20,77 +20,72 @@ * 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: +/* 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. + * 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. + * 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. + * 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.). + * 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. + * 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. + * 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. + * 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 GList *buffers = NULL; -/* 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 */ +/* 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; -/* 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. +/* 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. + * 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. */ + * 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 { @@ -212,11 +207,10 @@ send_eos_event (GstElement * element) fail_unless (gst_pad_send_event (pad, event), "Cannot send 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. */ + /* 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); @@ -251,8 +245,8 @@ poll_eos (GstElement * element) gst_object_unref (bus); } -/* This also polls for EOS since the TAG message comes right before - * the end of streams. */ +/* This also polls for EOS since the TAG message comes right before the end of + * streams. */ static GstTagList * poll_tags (GstElement * element) @@ -749,14 +743,13 @@ 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 +/* 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) @@ -1089,11 +1082,10 @@ GST_START_TEST (test_peak_track_album) GST_END_TEST; -/* Disabling album processing before the end of the album. Probably a - * rare edge case and applications should not rely on this to work. - * They need to send the element to the READY state to clear up after - * an aborted album anyway since they might need to process another - * album afterwards. */ +/* Disabling album processing before the end of the album. Probably a rare edge + * case and applications should not rely on this to work. They need to send the + * element to the READY state to clear up after an aborted album anyway since + * they might need to process another album afterwards. */ GST_START_TEST (test_peak_album_abort_to_track) { @@ -1136,8 +1128,8 @@ GST_START_TEST (test_gain_album) g_object_set (element, "num-tracks", 3, NULL); set_playing_state (element); - /* The three tracks are constructed such that if any of these is in - * fact ignored for the album gain, the album gain will differ. */ + /* The three tracks are constructed such that if any of these is in fact + * ignored for the album gain, the album gain will differ. */ accumulator = 0; for (i = 8; i--;) @@ -1268,12 +1260,11 @@ GST_START_TEST (test_forced_separate) GST_END_TEST; -/* A TAG event is sent _after_ data has already been processed. In - * real pipelines, this could happen if there is more than one - * rganalysis element (by accident). While it would have analyzed all - * the data prior to receiving the event, I expect it to not post its - * results if not forced. This test is almost equivalent to - * test_forced. */ +/* A TAG event is sent _after_ data has already been processed. In real + * pipelines, this could happen if there is more than one rganalysis element (by + * accident). While it would have analyzed all the data prior to receiving the + * event, I expect it to not post its results if not forced. This test is + * almost equivalent to test_forced. */ GST_START_TEST (test_forced_after_data) { @@ -1311,8 +1302,8 @@ GST_START_TEST (test_forced_after_data) GST_END_TEST; -/* Like test_forced, but *analyze* an album afterwards. The two tests - * following this one check the *skipping* of albums. */ +/* Like test_forced, but *analyze* an album afterwards. The two tests following + * this one check the *skipping* of albums. */ GST_START_TEST (test_forced_album) { @@ -1441,9 +1432,8 @@ GST_START_TEST (test_forced_album_no_skip) gst_tag_list_free (tag_list); fail_unless_num_tracks (element, 1); - /* The second track has indeed full tags, but although being not - * forced, this one has to be processed because album processing is - * on. */ + /* The second track has indeed full tags, but although being not forced, this + * one has to be processed because album processing is on. */ tag_list = gst_tag_list_new (); /* Provided values are totally arbitrary. */ gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND, @@ -1515,12 +1505,27 @@ GST_START_TEST (test_reference_level) { GstElement *element = setup_rganalysis (); GstTagList *tag_list; + gdouble ref_level; gint accumulator = 0; gint i; - g_object_set (element, "reference-level", 83., "num-tracks", 2, NULL); set_playing_state (element); + for (i = 20; i--;) + push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512, + 0.25, 0.25)); + send_eos_event (element); + tag_list = poll_tags (element); + fail_unless_track_peak (tag_list, 0.25); + fail_unless_track_gain (tag_list, get_expected_gain (44100)); + fail_if_album_tags (tag_list); + fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL, + &ref_level) && MATCH_GAIN (ref_level, 89.), + "Incorrect reference level tag"); + gst_tag_list_free (tag_list); + + g_object_set (element, "reference-level", 83., "num-tracks", 2, NULL); + for (i = 20; i--;) push_buffer (test_buffer_square_float_stereo (&accumulator, 44100, 512, 0.25, 0.25)); @@ -1529,6 +1534,9 @@ GST_START_TEST (test_reference_level) fail_unless_track_peak (tag_list, 0.25); fail_unless_track_gain (tag_list, get_expected_gain (44100) - 6.); fail_if_album_tags (tag_list); + fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL, + &ref_level) && MATCH_GAIN (ref_level, 83.), + "Incorrect reference level tag"); gst_tag_list_free (tag_list); accumulator = 0; @@ -1543,6 +1551,9 @@ GST_START_TEST (test_reference_level) /* We provided the same waveform twice, with a reset separating * them. Therefore, the album gain matches the track gain. */ fail_unless_album_gain (tag_list, get_expected_gain (44100) - 6.); + fail_unless (gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL, + &ref_level) && MATCH_GAIN (ref_level, 83.), + "Incorrect reference level tag"); gst_tag_list_free (tag_list); cleanup_rganalysis (element); diff --git a/tests/check/elements/rglimiter.c b/tests/check/elements/rglimiter.c new file mode 100644 index 00000000..2d4a715b --- /dev/null +++ b/tests/check/elements/rglimiter.c @@ -0,0 +1,238 @@ +/* GStreamer ReplayGain limiter + * + * Copyright (C) 2007 Rene Stadler + * + * rglimiter.c: Unit test for the rglimiter 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 + */ + +#include + +#include + +GList *buffers = NULL; + +/* 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; + +#define RG_LIMITER_CAPS_TEMPLATE_STRING \ + "audio/x-raw-float, " \ + "width = (int) 32, " \ + "endianness = (int) BYTE_ORDER, " \ + "channels = (int) [ 1, MAX ], " \ + "rate = (int) [ 1, MAX ]" + +static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (RG_LIMITER_CAPS_TEMPLATE_STRING) + ); +static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (RG_LIMITER_CAPS_TEMPLATE_STRING) + ); + +GstElement * +setup_rglimiter () +{ + GstElement *element; + GstBus *bus; + + GST_DEBUG ("setup_rglimiter"); + element = gst_check_setup_element ("rglimiter"); + mysrcpad = gst_check_setup_src_pad (element, &srctemplate, NULL); + mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate, NULL); + gst_pad_set_active (mysrcpad, TRUE); + gst_pad_set_active (mysinkpad, TRUE); + + return element; +} + +void +cleanup_rglimiter (GstElement * element) +{ + GST_DEBUG ("cleanup_rglimiter"); + + g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL); + g_list_free (buffers); + buffers = NULL; + + 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 const gfloat test_input[] = { + -2.0, -1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0, 2.0 +}; +static const gfloat test_output[] = { + -0.99752737684336523, /* -2.0 */ + -0.88079707797788243, /* -1.0 */ + -0.7310585786300049, /* -0.75 */ + -0.5, -0.25, 0.0, 0.25, 0.5, + 0.7310585786300049, /* 0.75 */ + 0.88079707797788243, /* 1.0 */ + 0.99752737684336523, /* 2.0 */ +}; + +static GstBuffer * +create_test_buffer () +{ + GstBuffer *buf = gst_buffer_new_and_alloc (sizeof (test_input)); + GstCaps *caps; + + memcpy (GST_BUFFER_DATA (buf), test_input, sizeof (test_input)); + + caps = gst_caps_new_simple ("audio/x-raw-float", + "rate", G_TYPE_INT, 44100, "channels", G_TYPE_INT, 1, + "endianess", G_TYPE_INT, G_BYTE_ORDER, "width", G_TYPE_INT, 32, NULL); + gst_buffer_set_caps (buf, caps); + gst_caps_unref (caps); + + ASSERT_BUFFER_REFCOUNT (buf, "buf", 1); + + return buf; +} + +static void +verify_test_buffer (GstBuffer * buf) +{ + gfloat *output = (gfloat *) GST_BUFFER_DATA (buf); + gint i; + + fail_unless (GST_BUFFER_SIZE (buf) == sizeof (test_output)); + for (i = 0; i < G_N_ELEMENTS (test_input); i++) + fail_unless (ABS (output[i] - test_output[i]) < 1.e-6, + "Incorrect output value %.6f for input %.2f, expected %.6f", + output[i], test_input[i], test_output[i]); +} + +/* Start of tests. */ + +GST_START_TEST (test_no_buffer) +{ + GstElement *element = setup_rglimiter (); + + set_playing_state (element); + + cleanup_rglimiter (element); +} + +GST_END_TEST; + +GST_START_TEST (test_disabled) +{ + GstElement *element = setup_rglimiter (); + GstBuffer *buf, *out_buf; + + g_object_set (element, "enabled", FALSE, NULL); + set_playing_state (element); + + buf = create_test_buffer (); + fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK); + fail_unless (g_list_length (buffers) == 1); + out_buf = buffers->data; + fail_if (out_buf == NULL); + buffers = g_list_remove (buffers, out_buf); + ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1); + fail_unless (buf == out_buf); + gst_buffer_unref (out_buf); + + cleanup_rglimiter (element); +} + +GST_END_TEST; + +GST_START_TEST (test_limiting) +{ + GstElement *element = setup_rglimiter (); + GstBuffer *buf, *out_buf; + + set_playing_state (element); + + /* Mutable variant. */ + buf = create_test_buffer (); + fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK); + fail_unless (g_list_length (buffers) == 1); + out_buf = buffers->data; + fail_if (out_buf == NULL); + ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1); + verify_test_buffer (out_buf); + + /* Immutable variant. */ + buf = create_test_buffer (); + /* Extra ref: */ + gst_buffer_ref (buf); + ASSERT_BUFFER_REFCOUNT (buf, "buf", 2); + fail_unless (gst_pad_push (mysrcpad, buf) == GST_FLOW_OK); + ASSERT_BUFFER_REFCOUNT (buf, "buf", 1); + fail_unless (g_list_length (buffers) == 2); + out_buf = g_list_last (buffers)->data; + fail_if (out_buf == NULL); + ASSERT_BUFFER_REFCOUNT (out_buf, "out_buf", 1); + fail_unless (buf != out_buf); + /* Drop our extra ref: */ + gst_buffer_unref (buf); + verify_test_buffer (out_buf); + + cleanup_rglimiter (element); +} + +GST_END_TEST; + +Suite * +rglimiter_suite (void) +{ + Suite *s = suite_create ("rglimiter"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + + tcase_add_test (tc_chain, test_no_buffer); + tcase_add_test (tc_chain, test_disabled); + tcase_add_test (tc_chain, test_limiting); + + return s; +} + +int +main (int argc, char **argv) +{ + gint nf; + + Suite *s = rglimiter_suite (); + SRunner *sr = srunner_create (s); + + gst_check_init (&argc, &argv); + + srunner_run_all (sr, CK_ENV); + nf = srunner_ntests_failed (sr); + srunner_free (sr); + + return nf; +} diff --git a/tests/check/elements/rgvolume.c b/tests/check/elements/rgvolume.c new file mode 100644 index 00000000..658e98ce --- /dev/null +++ b/tests/check/elements/rgvolume.c @@ -0,0 +1,573 @@ +/* GStreamer ReplayGain volume adjustment + * + * Copyright (C) 2007 Rene Stadler + * + * rgvolume.c: Unit test for the rgvolume 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 + */ + +#include + +#include + +GList *buffers = NULL; +GList *events = NULL; + +/* 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; + +#define RG_VOLUME_CAPS_TEMPLATE_STRING \ + "audio/x-raw-float, " \ + "width = (int) 32, " \ + "endianness = (int) BYTE_ORDER, " \ + "channels = (int) [ 1, MAX ], " \ + "rate = (int) [ 1, MAX ]" + +static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (RG_VOLUME_CAPS_TEMPLATE_STRING) + ); +static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (RG_VOLUME_CAPS_TEMPLATE_STRING) + ); + +/* gstcheck sets up a chain function that appends buffers to a global list. + * This is our equivalent of that for event handling. */ +static gboolean +event_func (GstPad * pad, GstEvent * event) +{ + events = g_list_append (events, event); + + return TRUE; +} + +GstElement * +setup_rgvolume () +{ + GstElement *element; + + GST_DEBUG ("setup_rgvolume"); + element = gst_check_setup_element ("rgvolume"); + mysrcpad = gst_check_setup_src_pad (element, &srctemplate, NULL); + mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate, NULL); + + /* Capture events, to test tag filtering behavior: */ + gst_pad_set_event_function (mysinkpad, event_func); + + gst_pad_set_active (mysrcpad, TRUE); + gst_pad_set_active (mysinkpad, TRUE); + + return element; +} + +void +cleanup_rgvolume (GstElement * element) +{ + GST_DEBUG ("cleanup_rgvolume"); + + g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL); + g_list_free (buffers); + buffers = NULL; + + g_list_foreach (events, (GFunc) gst_mini_object_unref, NULL); + g_list_free (events); + events = 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 +set_null_state (GstElement * element) +{ + fail_unless (gst_element_set_state (element, + GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, + "Could not set state to NULL"); +} + +static void +send_eos_event (GstElement * element) +{ + GstEvent *event = gst_event_new_eos (); + + fail_unless (g_list_length (events) == 0); + fail_unless (gst_pad_push_event (mysrcpad, event), + "Pushing EOS event failed"); + fail_unless (g_list_length (events) == 1); + fail_unless (events->data == event); + gst_mini_object_unref ((GstMiniObject *) events->data); + events = g_list_remove (events, event); +} + +static GstEvent * +send_tag_event (GstElement * element, GstEvent * event) +{ + g_return_val_if_fail (event->type == GST_EVENT_TAG, NULL); + + fail_unless (g_list_length (events) == 0); + fail_unless (gst_pad_push_event (mysrcpad, event), + "Pushing tag event failed"); + + if (g_list_length (events) == 0) { + /* Event got filtered out. */ + event = NULL; + } else { + GstTagList *tag_list; + gdouble dummy; + + event = events->data; + events = g_list_remove (events, event); + + fail_unless (event->type == GST_EVENT_TAG); + gst_event_parse_tag (event, &tag_list); + + /* The element is supposed to filter out ReplayGain related tags. */ + fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, &dummy), + "tag event still contains track gain tag"); + fail_if (gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, &dummy), + "tag event still contains track peak tag"); + fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, &dummy), + "tag event still contains album gain tag"); + fail_if (gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, &dummy), + "tag event still contains album peak tag"); + } + + return event; +} + +static GstBuffer * +test_buffer_new (gfloat value) +{ + GstBuffer *buf; + GstCaps *caps; + gfloat *data; + gint i; + + buf = gst_buffer_new_and_alloc (8 * sizeof (gfloat)); + data = (gfloat *) GST_BUFFER_DATA (buf); + for (i = 0; i < 8; i++) + data[i] = value; + + caps = gst_caps_from_string ("audio/x-raw-float, " + "rate = 8000, channels = 1, endianess = BYTE_ORDER, width = 32"); + gst_buffer_set_caps (buf, caps); + gst_caps_unref (caps); + + ASSERT_BUFFER_REFCOUNT (buf, "buf", 1); + + return buf; +} + +#define MATCH_GAIN(g1, g2) ((g1 < g2 + 1e-6) && (g2 < g1 + 1e-6)) + +static void +fail_unless_target_gain (GstElement * element, gdouble expected_gain) +{ + gdouble prop_gain; + + g_object_get (element, "target-gain", &prop_gain, NULL); + + fail_unless (MATCH_GAIN (prop_gain, expected_gain), + "Target gain is %.2f dB, expected %.2f dB", prop_gain, expected_gain); +} + +static void +fail_unless_result_gain (GstElement * element, gdouble expected_gain) +{ + GstBuffer *input_buf, *output_buf; + gfloat input_sample, output_sample; + gdouble gain, prop_gain; + gboolean is_passthrough, expect_passthrough; + gint i; + + fail_unless (g_list_length (buffers) == 0); + + input_sample = 1.0; + input_buf = test_buffer_new (input_sample); + + /* We keep an extra reference to detect passthrough mode. */ + gst_buffer_ref (input_buf); + /* Pushing steals a reference. */ + fail_unless (gst_pad_push (mysrcpad, input_buf) == GST_FLOW_OK); + gst_buffer_unref (input_buf); + + /* The output buffer ends up on the global buffer list. */ + fail_unless (g_list_length (buffers) == 1); + output_buf = buffers->data; + fail_if (output_buf == NULL); + + buffers = g_list_remove (buffers, output_buf); + ASSERT_BUFFER_REFCOUNT (output_buf, "output_buf", 1); + fail_unless_equals_int (GST_BUFFER_SIZE (output_buf), 8 * sizeof (gfloat)); + + output_sample = *((gfloat *) GST_BUFFER_DATA (output_buf)); + + fail_if (output_sample == 0.0, "First output sample is zero"); + for (i = 1; i < 8; i++) { + gfloat output = ((gfloat *) GST_BUFFER_DATA (output_buf))[i]; + + fail_unless (output_sample == output, "Output samples not uniform"); + }; + + gain = 20. * log10 (output_sample / input_sample); + fail_unless (MATCH_GAIN (gain, expected_gain), + "Applied gain is %.2f dB, expected %.2f dB", gain, expected_gain); + g_object_get (element, "result-gain", &prop_gain, NULL); + fail_unless (MATCH_GAIN (prop_gain, expected_gain), + "Result gain is %.2f dB, expected %.2f dB", prop_gain, expected_gain); + + is_passthrough = (output_buf == input_buf); + expect_passthrough = MATCH_GAIN (expected_gain, +0.00); + fail_unless (is_passthrough == expect_passthrough, + expect_passthrough + ? "Expected operation in passthrough mode" + : "Incorrect passthrough behaviour"); + + gst_buffer_unref (output_buf); +} + +static void +fail_unless_gain (GstElement * element, gdouble expected_gain) +{ + fail_unless_target_gain (element, expected_gain); + fail_unless_result_gain (element, expected_gain); +} + +/* Start of tests. */ + +GST_START_TEST (test_no_buffer) +{ + GstElement *element = setup_rgvolume (); + + set_playing_state (element); + set_null_state (element); + set_playing_state (element); + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +GST_START_TEST (test_events) +{ + GstElement *element = setup_rgvolume (); + GstEvent *event; + GstEvent *new_event; + GstTagList *tag_list; + gchar *artist; + + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +4.95, GST_TAG_TRACK_PEAK, 0.59463, + GST_TAG_ALBUM_GAIN, -1.54, GST_TAG_ALBUM_PEAK, 0.693415, + GST_TAG_ARTIST, "Foobar", NULL); + event = gst_event_new_tag (tag_list); + new_event = send_tag_event (element, event); + /* Expect the element to modify the writable event. */ + fail_unless (event == new_event, "Writable tag event not reused"); + gst_event_parse_tag (new_event, &tag_list); + fail_unless (gst_tag_list_get_string (tag_list, GST_TAG_ARTIST, &artist)); + fail_unless (g_str_equal (artist, "Foobar")); + g_free (artist); + gst_event_unref (new_event); + + /* Same as above, but with a non-writable event. */ + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +4.95, GST_TAG_TRACK_PEAK, 0.59463, + GST_TAG_ALBUM_GAIN, -1.54, GST_TAG_ALBUM_PEAK, 0.693415, + GST_TAG_ARTIST, "Foobar", NULL); + event = gst_event_new_tag (tag_list); + /* Holding an extra ref makes the event unwritable: */ + gst_event_ref (event); + new_event = send_tag_event (element, event); + fail_unless (event != new_event, "Unwritable tag event reused"); + gst_event_parse_tag (new_event, &tag_list); + fail_unless (gst_tag_list_get_string (tag_list, GST_TAG_ARTIST, &artist)); + fail_unless (g_str_equal (artist, "Foobar")); + g_free (artist); + gst_event_unref (event); + gst_event_unref (new_event); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +GST_START_TEST (test_simple) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + g_object_set (element, "album-mode", FALSE, "headroom", +0.00, + "pre-amp", -6.00, "fallback-gain", +1.23, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, -3.45, GST_TAG_TRACK_PEAK, 1.0, + GST_TAG_ALBUM_GAIN, +2.09, GST_TAG_ALBUM_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, -9.45); /* pre-amp + track gain */ + send_eos_event (element); + + g_object_set (element, "album-mode", TRUE, NULL); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, -3.45, GST_TAG_TRACK_PEAK, 1.0, + GST_TAG_ALBUM_GAIN, +2.09, GST_TAG_ALBUM_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, -3.91); /* pre-amp + album gain */ + + /* Switching back to track mode in the middle of a stream: */ + g_object_set (element, "album-mode", FALSE, NULL); + fail_unless_gain (element, -9.45); /* pre-amp + track gain */ + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +/* If there are no gain tags at all, the fallback gain is used. */ + +GST_START_TEST (test_fallback_gain) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + /* First some track where fallback does _not_ apply. */ + + g_object_set (element, "album-mode", FALSE, "headroom", 10.00, + "pre-amp", -6.00, "fallback-gain", -3.00, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +3.5, GST_TAG_TRACK_PEAK, 1.0, + GST_TAG_ALBUM_GAIN, -0.5, GST_TAG_ALBUM_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, -2.50); /* pre-amp + track gain */ + send_eos_event (element); + + /* Now a track completely missing tags. */ + + fail_unless_gain (element, -9.00); /* pre-amp + fallback-gain */ + + /* Changing the fallback gain in the middle of a stream, going to pass-through + * mode: */ + g_object_set (element, "fallback-gain", +6.00, NULL); + fail_unless_gain (element, +0.00); /* pre-amp + fallback-gain */ + send_eos_event (element); + + /* Verify that result gain is set to +0.00 with pre-amp + fallback-gain > + * +0.00 and no headroom. */ + + g_object_set (element, "fallback-gain", +12.00, "headroom", +0.00, NULL); + fail_unless_target_gain (element, +6.00); /* pre-amp + fallback-gain */ + fail_unless_result_gain (element, +0.00); + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +/* If album gain is to be preferred but not available, the track gain is to be + * taken instead. */ + +GST_START_TEST (test_fallback_track) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + g_object_set (element, "album-mode", TRUE, "headroom", +0.00, + "pre-amp", -6.00, "fallback-gain", +1.23, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +2.11, GST_TAG_TRACK_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, -3.89); /* pre-amp + track gain */ + + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +/* If track gain is to be preferred but not available, the album gain is to be + * taken instead. */ + +GST_START_TEST (test_fallback_album) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + g_object_set (element, "album-mode", FALSE, "headroom", +0.00, + "pre-amp", -6.00, "fallback-gain", +1.23, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_ALBUM_GAIN, +3.73, GST_TAG_ALBUM_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, -2.27); /* pre-amp + album gain */ + + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +GST_START_TEST (test_headroom) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + g_object_set (element, "album-mode", FALSE, "headroom", +0.00, + "pre-amp", +0.00, "fallback-gain", +1.23, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +3.50, GST_TAG_TRACK_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_target_gain (element, +3.50); /* pre-amp + track gain */ + fail_unless_result_gain (element, +0.00); + send_eos_event (element); + + g_object_set (element, "headroom", +2.00, NULL); + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, +9.18, GST_TAG_TRACK_PEAK, 0.687149, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_target_gain (element, +9.18); /* pre-amp + track gain */ + /* Result is 20. * log10 (1. / peak) + headroom. */ + fail_unless_result_gain (element, 5.2589816238303335); + send_eos_event (element); + + g_object_set (element, "album-mode", TRUE, NULL); + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_ALBUM_GAIN, +5.50, GST_TAG_ALBUM_PEAK, 1.0, NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_target_gain (element, +5.50); /* pre-amp + album gain */ + fail_unless_result_gain (element, +2.00); /* headroom */ + send_eos_event (element); + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +GST_START_TEST (test_reference_level) +{ + GstElement *element = setup_rgvolume (); + GstTagList *tag_list; + + g_object_set (element, + "album-mode", FALSE, + "headroom", +0.00, "pre-amp", +0.00, "fallback-gain", +1.23, NULL); + set_playing_state (element); + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, 0.00, GST_TAG_TRACK_PEAK, 0.2, + GST_TAG_REFERENCE_LEVEL, 83., NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + /* Because our authorative reference is 89 dB, we bump it up by +6 dB. */ + fail_unless_gain (element, +6.00); /* pre-amp + track gain */ + send_eos_event (element); + + g_object_set (element, "album-mode", TRUE, NULL); + + /* Same as above, but with album gain. */ + + tag_list = gst_tag_list_new (); + gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, + GST_TAG_TRACK_GAIN, 1.23, GST_TAG_TRACK_PEAK, 0.1, + GST_TAG_ALBUM_GAIN, 0.00, GST_TAG_ALBUM_PEAK, 0.2, + GST_TAG_REFERENCE_LEVEL, 83., NULL); + fail_unless (send_tag_event (element, gst_event_new_tag (tag_list)) == NULL); + fail_unless_gain (element, +6.00); /* pre-amp + album gain */ + + cleanup_rgvolume (element); +} + +GST_END_TEST; + +Suite * +rgvolume_suite (void) +{ + Suite *s = suite_create ("rgvolume"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + + tcase_add_test (tc_chain, test_no_buffer); + tcase_add_test (tc_chain, test_events); + tcase_add_test (tc_chain, test_simple); + tcase_add_test (tc_chain, test_fallback_gain); + tcase_add_test (tc_chain, test_fallback_track); + tcase_add_test (tc_chain, test_fallback_album); + tcase_add_test (tc_chain, test_headroom); + tcase_add_test (tc_chain, test_reference_level); + + return s; +} + +int +main (int argc, char **argv) +{ + gint nf; + + Suite *s = rgvolume_suite (); + SRunner *sr = srunner_create (s); + + gst_check_init (&argc, &argv); + + srunner_run_all (sr, CK_ENV); + nf = srunner_ntests_failed (sr); + srunner_free (sr); + + return nf; +} -- cgit v1.2.1