gstreamer/subprojects/gst-plugins-good/tests/check/elements/mpegaudioparse.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

447 lines
15 KiB
C
Raw Normal View History

/*
* GStreamer
*
* unit test for aacparse
*
* Copyright (C) 2008 Nokia Corporation. All rights reserved.
*
* Contact: Stefan Kost <stefan.kost@nokia.com>
*
* 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.
*/
#include <gst/check/gstcheck.h>
#include <gst/app/gstappsink.h>
#include <gst/audio/audio.h>
#include "parser.h"
#define SRC_CAPS_TMPL "audio/mpeg, parsed=(boolean)false, mpegversion=(int)1"
#define SINK_CAPS_TMPL "audio/mpeg, parsed=(boolean)true, mpegversion=(int)1"
GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (SINK_CAPS_TMPL)
);
GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (SRC_CAPS_TMPL)
);
/* some data */
static guint8 mp3_frame[384] = {
0xff, 0xfb, 0x94, 0xc4, 0xff, 0x83, 0xc0, 0x00,
0x01, 0xa4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
0x34, 0x80, 0x00, 0x00, 0x04, 0x00,
};
static guint8 garbage_frame[] = {
0xff, 0xff, 0xff, 0xff, 0xff
};
GST_START_TEST (test_parse_normal)
{
gst_parser_test_normal (mp3_frame, sizeof (mp3_frame));
}
GST_END_TEST;
GST_START_TEST (test_parse_drain_single)
{
gst_parser_test_drain_single (mp3_frame, sizeof (mp3_frame));
}
GST_END_TEST;
GST_START_TEST (test_parse_drain_garbage)
{
gst_parser_test_drain_garbage (mp3_frame, sizeof (mp3_frame),
garbage_frame, sizeof (garbage_frame));
}
GST_END_TEST;
GST_START_TEST (test_parse_split)
{
gst_parser_test_split (mp3_frame, sizeof (mp3_frame));
}
GST_END_TEST;
GST_START_TEST (test_parse_skip_garbage)
{
gst_parser_test_skip_garbage (mp3_frame, sizeof (mp3_frame),
garbage_frame, sizeof (garbage_frame));
}
GST_END_TEST;
#define structure_get_int(s,f) \
(g_value_get_int(gst_structure_get_value(s,f)))
#define fail_unless_structure_field_int_equals(s,field,num) \
fail_unless_equals_int (structure_get_int(s,field), num)
GST_START_TEST (test_parse_detect_stream)
{
GstStructure *s;
GstCaps *caps;
caps = gst_parser_test_get_output_caps (mp3_frame, sizeof (mp3_frame), NULL);
fail_unless (caps != NULL);
GST_LOG ("mpegaudio output caps: %" GST_PTR_FORMAT, caps);
s = gst_caps_get_structure (caps, 0);
fail_unless (gst_structure_has_name (s, "audio/mpeg"));
fail_unless_structure_field_int_equals (s, "mpegversion", 1);
fail_unless_structure_field_int_equals (s, "layer", 3);
fail_unless_structure_field_int_equals (s, "channels", 1);
fail_unless_structure_field_int_equals (s, "rate", 48000);
gst_caps_unref (caps);
}
GST_END_TEST;
/* Gapless tests are performed using a test signal that contains 30 MPEG
* frames, has padding samples at the beginning and at the end, a LAME
* tag to inform about said padding samples, and a sample rate of 32 kHz
* and 1 channel. The test signal is 1009ms long. setup_gapless_test_info()
* fills the GaplessTestInfo struct with details about this test signal. */
typedef struct
{
const gchar *filename;
guint num_mpeg_frames;
guint num_samples_per_frame;
guint num_start_padding_samples;
guint num_end_padding_samples;
guint sample_rate;
guint first_padded_end_frame;
guint64 num_samples_with_padding;
guint64 num_samples_without_padding;
GstClockTime first_frame_duration;
GstClockTime regular_frame_duration;
GstClockTime total_duration_without_padding;
GstElement *appsink;
GstElement *parser;
} GaplessTestInfo;
static void
setup_gapless_test_info (GaplessTestInfo * info)
{
info->filename = "sine-1009ms-1ch-32000hz-gapless-with-lame-tag.mp3";
info->num_mpeg_frames = 31;
info->num_samples_per_frame = 1152; /* standard for MP3s */
info->sample_rate = 32000;
/* Note that these start and end padding figures are not exactly like
* those that we get from the LAME tag. That's because that tag only
* contains the _encoder_ delay & padding. In the figures below, the
* _decoder_ delay is also factored in (529 samples). mpegaudioparse
* does the same, so we have to apply it here. */
info->num_start_padding_samples = 1105;
info->num_end_padding_samples = 1167;
/* In MP3s with LAME tags, the first frame is a frame made of Xing/LAME
* metadata and dummy nullsamples (this is for backwards compatibility).
* num_start_padding_samples defines how many padding samples are there
* (this does not include the nullsamples from the first dummy frame).
* Likewise, num_end_padding_samples defines how many padding samples
* are there at the end of the MP3 stream.
* There may be more padding samples than the size of one frame, meaning
* that there may be frames that are made entirely of padding samples.
* Such frames are output by mpegaudioparse, but their duration is set
* to 0, and their PTS corresponds to the last valid PTS in the stream
* (= the last PTS that is within the actual media data).
* For this reason, we cannot just assume that the last frame is the
* one containing padding - there may be more. So, calculate the number
* of the first frame that contains padding sames from the _end_ of
* the stream. We'll need that later for buffer PTS and duration checks. */
info->first_padded_end_frame = (info->num_mpeg_frames - 1 -
info->num_end_padding_samples / info->num_samples_per_frame);
info->num_samples_with_padding = (info->num_mpeg_frames - 1) *
info->num_samples_per_frame;
info->num_samples_without_padding = info->num_samples_with_padding -
info->num_start_padding_samples - info->num_end_padding_samples;
/* The first frame (excluding the dummy frame at the beginning) will be
* clipped due to the padding samples at the start of the stream, so we
* have to calculate this separately. */
info->first_frame_duration =
gst_util_uint64_scale_int (info->num_samples_per_frame -
info->num_start_padding_samples, GST_SECOND, info->sample_rate);
/* Regular, unclipped MPEG frame duration. */
info->regular_frame_duration =
gst_util_uint64_scale_int (info->num_samples_per_frame, GST_SECOND,
info->sample_rate);
/* The total actual playtime duration. */
info->total_duration_without_padding =
gst_util_uint64_scale_int (info->num_samples_without_padding, GST_SECOND,
info->sample_rate);
}
static void
check_parsed_mpeg_frame (GaplessTestInfo * info, guint frame_num)
{
GstClockTime expected_pts = GST_CLOCK_TIME_NONE;
GstClockTime expected_duration = GST_CLOCK_TIME_NONE;
gboolean expect_audioclipmeta = FALSE;
guint64 expected_audioclipmeta_start = 0;
guint64 expected_audioclipmeta_end = 0;
GstSample *sample;
GstBuffer *buffer;
GstAudioClippingMeta *audioclip_meta;
GST_DEBUG ("checking frame %u", frame_num);
/* This is called after the frame with the given number has been output by
* mpegaudioparse. We can then pull that frame from appsink, and check its
* PTS, duration, and audioclipmeta (if we expect it to be there). */
if (frame_num == 0) {
expected_pts = 0;
expected_duration = 0;
expect_audioclipmeta = FALSE;
} else if (frame_num == 1) {
/* First frame (excluding the dummy metadata frame at the beginning of
* the MPEG stream that mpegaudioparse internally drops). This one will be
* clipped due to the padding samples at the beginning, so we expect a
* clipping meta to be there. Also, its duration will be smaller than that
* of regular, unclipped frames. */
expected_pts = 0;
expected_duration = info->first_frame_duration;
expect_audioclipmeta = TRUE;
expected_audioclipmeta_start = info->num_start_padding_samples;
expected_audioclipmeta_end = 0;
} else if (frame_num > 1 && frame_num < info->first_padded_end_frame) {
/* Regular, unclipped frame. */
expected_pts = info->first_frame_duration + (frame_num - 2) *
info->regular_frame_duration;
expected_duration = info->regular_frame_duration;
} else if (frame_num == info->first_padded_end_frame) {
/* The first frame at the end with padding samples. This one will have
* the last few valid samples, followed by the first padding samples. */
guint64 num_valid_samples = (info->num_samples_with_padding -
info->num_end_padding_samples) - (frame_num - 1) *
info->num_samples_per_frame;
guint64 num_padding_samples = info->num_samples_per_frame -
num_valid_samples;
expected_pts = info->first_frame_duration + (frame_num - 2) *
info->regular_frame_duration;
expected_duration = gst_util_uint64_scale_int (num_valid_samples,
GST_SECOND, info->sample_rate);
expect_audioclipmeta = TRUE;
expected_audioclipmeta_start = 0;
expected_audioclipmeta_end = num_padding_samples;
} else {
/* A fully clipped frame at the end of the stream. */
expected_pts = info->total_duration_without_padding;
expected_duration = 0;
expect_audioclipmeta = TRUE;
expected_audioclipmeta_start = 0;
expected_audioclipmeta_end = info->num_samples_per_frame;
}
/* Pull the frame from appsink so we can check it. */
sample = gst_app_sink_pull_sample (GST_APP_SINK (info->appsink));
fail_if (sample == NULL);
fail_unless (GST_IS_SAMPLE (sample));
buffer = gst_sample_get_buffer (sample);
fail_if (buffer == NULL);
/* Verify the sample's PTS and duration. */
fail_unless_equals_uint64 (GST_BUFFER_PTS (buffer), expected_pts);
fail_unless_equals_uint64 (GST_BUFFER_DURATION (buffer), expected_duration);
/* Check if there's audio clip metadata, and verify it if it exists. */
if (expect_audioclipmeta) {
audioclip_meta = gst_buffer_get_audio_clipping_meta (buffer);
fail_if (audioclip_meta == NULL);
fail_unless_equals_uint64 (audioclip_meta->start,
expected_audioclipmeta_start);
fail_unless_equals_uint64 (audioclip_meta->end, expected_audioclipmeta_end);
}
gst_sample_unref (sample);
}
GST_START_TEST (test_parse_gapless_and_skip_padding_samples)
{
GstElement *source, *parser, *appsink, *pipeline;
GstStateChangeReturn state_ret;
guint frame_num;
GaplessTestInfo info;
setup_gapless_test_info (&info);
pipeline = gst_pipeline_new (NULL);
source = gst_element_factory_make ("filesrc", NULL);
parser = gst_element_factory_make ("mpegaudioparse", NULL);
appsink = gst_element_factory_make ("appsink", NULL);
info.appsink = appsink;
info.parser = parser;
gst_bin_add_many (GST_BIN (pipeline), source, parser, appsink, NULL);
gst_element_link_many (source, parser, appsink, NULL);
{
char *full_filename =
g_build_filename (GST_TEST_FILES_PATH, info.filename, NULL);
g_object_set (G_OBJECT (source), "location", full_filename, NULL);
g_free (full_filename);
}
g_object_set (G_OBJECT (appsink), "async", FALSE, "sync", FALSE,
"max-buffers", 1, "enable-last-sample", FALSE, "processing-deadline",
G_MAXUINT64, NULL);
state_ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
fail_unless (state_ret != GST_STATE_CHANGE_FAILURE);
if (state_ret == GST_STATE_CHANGE_ASYNC) {
GST_LOG ("waiting for pipeline to reach PAUSED state");
state_ret = gst_element_get_state (pipeline, NULL, NULL, -1);
fail_unless_equals_int (state_ret, GST_STATE_CHANGE_SUCCESS);
}
/* Verify all frames from the test signal. */
for (frame_num = 0; frame_num < info.num_mpeg_frames; ++frame_num)
check_parsed_mpeg_frame (&info, frame_num);
/* Check what duration is returned by a query. This duration must exclude
* the padding samples. */
{
GstQuery *query;
gint64 duration;
GstFormat format;
query = gst_query_new_duration (GST_FORMAT_TIME);
fail_unless (gst_element_query (pipeline, query));
gst_query_parse_duration (query, &format, &duration);
fail_unless_equals_int (format, GST_FORMAT_TIME);
fail_unless_equals_uint64 ((guint64) duration,
info.total_duration_without_padding);
gst_query_unref (query);
}
/* Seek tests: Here we seek to a certain position that corresponds to a
* certain frame. Then we check if we indeed got that frame. */
/* Seek back to the first frame. */
{
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
GST_STATE_CHANGE_SUCCESS);
gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_KEY_UNIT, 0);
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
GST_STATE_CHANGE_SUCCESS);
check_parsed_mpeg_frame (&info, 1);
}
/* Seek to the second frame. */
{
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
GST_STATE_CHANGE_SUCCESS);
gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_KEY_UNIT, info.first_frame_duration);
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
GST_STATE_CHANGE_SUCCESS);
check_parsed_mpeg_frame (&info, 2);
}
/* Seek to the last frame with valid samples (= the first frame with padding
* samples at the end of the stream). */
{
GstClockTime pts = info.first_frame_duration +
(info.first_padded_end_frame - 2) * info.regular_frame_duration;
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
GST_STATE_CHANGE_SUCCESS);
gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_KEY_UNIT, pts);
fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
GST_STATE_CHANGE_SUCCESS);
check_parsed_mpeg_frame (&info, info.first_padded_end_frame);
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
}
GST_END_TEST;
static Suite *
mpegaudioparse_suite (void)
{
Suite *s = suite_create ("mpegaudioparse");
TCase *tc_chain = tcase_create ("general");
/* init test context */
ctx_factory = "mpegaudioparse";
ctx_sink_template = &sinktemplate;
ctx_src_template = &srctemplate;
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_parse_normal);
tcase_add_test (tc_chain, test_parse_drain_single);
tcase_add_test (tc_chain, test_parse_drain_garbage);
tcase_add_test (tc_chain, test_parse_split);
tcase_add_test (tc_chain, test_parse_skip_garbage);
tcase_add_test (tc_chain, test_parse_detect_stream);
tcase_add_test (tc_chain, test_parse_gapless_and_skip_padding_samples);
return s;
}
/*
* TODO:
* - Both push- and pull-modes need to be tested
* * Pull-mode & EOS
*/
GST_CHECK_MAIN (mpegaudioparse);