mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-10 11:29:55 +00:00
6efda04059
The GstDashDemuxTestCase object is allocated using g_object_newv
but in many places was being deallocated using gst_object_unref.
This was caused by commit ae3ed25025.
https://bugzilla.gnome.org/show_bug.cgi?id=762142
1028 lines
38 KiB
C
1028 lines
38 KiB
C
/* GStreamer unit test for MPEG-DASH
|
|
*
|
|
* Copyright (c) <2015> YouView TV Ltd
|
|
*
|
|
* 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 "adaptive_demux_common.h"
|
|
|
|
#define DEMUX_ELEMENT_NAME "dashdemux"
|
|
|
|
#define COPY_OUTPUT_TEST_DATA(outputTestData,testData) do { \
|
|
guint otdPos, otdLen = sizeof((outputTestData)) / sizeof((outputTestData)[0]); \
|
|
for(otdPos=0; otdPos<otdLen; ++otdPos){ \
|
|
(testData)->output_streams = g_list_append ((testData)->output_streams, &(outputTestData)[otdPos]); \
|
|
} \
|
|
} while(0)
|
|
|
|
typedef struct _GstDashDemuxTestInputData
|
|
{
|
|
const gchar *uri;
|
|
const guint8 *payload;
|
|
guint64 size;
|
|
} GstDashDemuxTestInputData;
|
|
|
|
static gboolean
|
|
gst_dashdemux_http_src_start (GstTestHTTPSrc * src,
|
|
const gchar * uri, GstTestHTTPSrcInput * input_data, gpointer user_data)
|
|
{
|
|
const GstDashDemuxTestInputData *input =
|
|
(const GstDashDemuxTestInputData *) user_data;
|
|
for (guint i = 0; input[i].uri; ++i) {
|
|
if (strcmp (input[i].uri, uri) == 0) {
|
|
input_data->context = (gpointer) & input[i];
|
|
input_data->size = input[i].size;
|
|
if (input[i].size == 0)
|
|
input_data->size = strlen ((gchar *) input[i].payload);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_dashdemux_http_src_create (GstTestHTTPSrc * src,
|
|
guint64 offset,
|
|
guint length, GstBuffer ** retbuf, gpointer context, gpointer user_data)
|
|
{
|
|
/* const GstDashDemuxTestInputData *input =
|
|
(const GstDashDemuxTestInputData *) user_data; */
|
|
const GstDashDemuxTestInputData *input =
|
|
(const GstDashDemuxTestInputData *) context;
|
|
GstBuffer *buf;
|
|
|
|
buf = gst_buffer_new_allocate (NULL, length, NULL);
|
|
fail_if (buf == NULL, "Not enough memory to allocate buffer");
|
|
|
|
if (input->payload) {
|
|
gst_buffer_fill (buf, 0, input->payload + offset, length);
|
|
} else {
|
|
GstMapInfo info;
|
|
guint pattern;
|
|
|
|
pattern = offset - offset % sizeof (pattern);
|
|
|
|
gst_buffer_map (buf, &info, GST_MAP_WRITE);
|
|
for (guint64 i = 0; i < length; ++i) {
|
|
gchar pattern_byte_to_write = (offset + i) % sizeof (pattern);
|
|
if (pattern_byte_to_write == 0) {
|
|
pattern = offset + i;
|
|
}
|
|
info.data[i] = (pattern >> (pattern_byte_to_write * 8)) & 0xFF;
|
|
}
|
|
gst_buffer_unmap (buf, &info);
|
|
}
|
|
*retbuf = buf;
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
/******************** Test specific code starts here **************************/
|
|
|
|
/*
|
|
* Test an mpd with an audio and a video stream
|
|
*
|
|
*/
|
|
GST_START_TEST (simpleTest)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT135.743S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation>"
|
|
" </AdaptationSet>"
|
|
" <AdaptationSet mimeType=\"video/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"242\""
|
|
" codecs=\"vp9\""
|
|
" width=\"426\""
|
|
" height=\"240\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"490208\">"
|
|
" <BaseURL>video.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"234-682\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-233\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio.webm", NULL, 5000},
|
|
{"http://unit.test/video.webm", NULL, 9000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 5000, NULL},
|
|
{"video_00", 9000, NULL}
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.appsink_received_data =
|
|
gst_adaptive_demux_test_check_received_data;
|
|
test_callbacks.appsink_eos =
|
|
gst_adaptive_demux_test_check_size_of_received_data;
|
|
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd",
|
|
&test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/*
|
|
* Test an mpd with 2 periods
|
|
*
|
|
*/
|
|
GST_START_TEST (testTwoPeriods)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT300S\">"
|
|
" <Period id=\"Period0\" duration=\"PT0.1S\">"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio1.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation>"
|
|
" </AdaptationSet>"
|
|
" <AdaptationSet mimeType=\"video/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"242\""
|
|
" codecs=\"vp9\""
|
|
" width=\"426\""
|
|
" height=\"240\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"490208\">"
|
|
" <BaseURL>video1.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"234-682\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-233\" />"
|
|
" </SegmentBase>"
|
|
" </Representation>"
|
|
" </AdaptationSet>"
|
|
" </Period>"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio2.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation>"
|
|
" </AdaptationSet>"
|
|
" <AdaptationSet mimeType=\"video/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"242\""
|
|
" codecs=\"vp9\""
|
|
" width=\"426\""
|
|
" height=\"240\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"490208\">"
|
|
" <BaseURL>video2.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"234-682\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-233\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio1.webm", NULL, 5001},
|
|
{"http://unit.test/video1.webm", NULL, 9001},
|
|
{"http://unit.test/audio2.webm", NULL, 5002},
|
|
{"http://unit.test/video2.webm", NULL, 9002},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 5001, NULL},
|
|
{"video_00", 9001, NULL},
|
|
{"audio_01", 5002, NULL},
|
|
{"video_01", 9002, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.appsink_received_data =
|
|
gst_adaptive_demux_test_check_received_data;
|
|
test_callbacks.appsink_eos =
|
|
gst_adaptive_demux_test_check_size_of_received_data;
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME,
|
|
"http://unit.test/test.mpd", &test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* test setting a property on an object */
|
|
#define test_int_prop(object, name, value) \
|
|
do \
|
|
{ \
|
|
int val = value; \
|
|
int val_after; \
|
|
g_object_set (object, name, val, NULL); \
|
|
g_object_get (object, name, &val_after, NULL); \
|
|
fail_unless (val_after == val, "property check failed for %s: set to %d, but got %d", \
|
|
name, val, val_after); \
|
|
} while (0)
|
|
|
|
#define test_float_prop(object, name, value) \
|
|
do \
|
|
{ \
|
|
float val = value; \
|
|
float val_after; \
|
|
g_object_set (object, name, val, NULL); \
|
|
g_object_get (object, name, &val_after, NULL); \
|
|
fail_unless (val_after == val, "property check failed for %s: set to %f, but got %f", \
|
|
name, val, val_after); \
|
|
} while (0)
|
|
|
|
/* test setting an invalid value for a property on an object.
|
|
* Expect an assert and the property to remain unchanged
|
|
*/
|
|
#define test_invalid_int_prop(object, name, value) \
|
|
do \
|
|
{ \
|
|
int val_before; \
|
|
int val_after; \
|
|
int val = value; \
|
|
g_object_get (object, name, &val_before, NULL); \
|
|
ASSERT_WARNING (g_object_set (object, name, val, NULL)); \
|
|
g_object_get (object, name, &val_after, NULL); \
|
|
fail_unless (val_after == val_before, "property check failed for %s: before %d, after %d", \
|
|
name, val_before, val_after); \
|
|
} while (0)
|
|
|
|
#define test_invalid_float_prop(object, name, value) \
|
|
do \
|
|
{ \
|
|
float val_before; \
|
|
float val_after; \
|
|
float val = value; \
|
|
g_object_get (object, name, &val_before, NULL); \
|
|
ASSERT_WARNING (g_object_set (object, name, val, NULL)); \
|
|
g_object_get (object, name, &val_after, NULL); \
|
|
fail_unless (val_after == val_before, "property check failed for %s: before %f, after %f", \
|
|
name, val_before, val_after); \
|
|
} while (0)
|
|
|
|
static void
|
|
setAndTestDashParams (GstAdaptiveDemuxTestEngine * engine, gpointer user_data)
|
|
{
|
|
/* GstAdaptiveDemuxTestCase * testData = (GstAdaptiveDemuxTestCase*)user_data; */
|
|
GObject *dashdemux = G_OBJECT (engine->demux);
|
|
|
|
test_int_prop (dashdemux, "connection-speed", 1000);
|
|
test_invalid_int_prop (dashdemux, "connection-speed", 4294967 + 1);
|
|
|
|
test_float_prop (dashdemux, "bitrate-limit", 1);
|
|
test_invalid_float_prop (dashdemux, "bitrate-limit", 2.1);
|
|
|
|
test_int_prop (dashdemux, "max-buffering-time", 15);
|
|
test_invalid_int_prop (dashdemux, "max-buffering-time", 1);
|
|
|
|
test_float_prop (dashdemux, "bandwidth-usage", 0.5);
|
|
test_invalid_float_prop (dashdemux, "bandwidth-usage", 2);
|
|
|
|
test_int_prop (dashdemux, "max-bitrate", 1000);
|
|
test_invalid_int_prop (dashdemux, "max-bitrate", 10);
|
|
}
|
|
|
|
/*
|
|
* Test setting parameters
|
|
*
|
|
*/
|
|
GST_START_TEST (testParameters)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT135.743S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio.webm", NULL, 5000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 5000, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.pre_test = setAndTestDashParams;
|
|
test_callbacks.appsink_received_data =
|
|
gst_adaptive_demux_test_check_received_data;
|
|
test_callbacks.appsink_eos =
|
|
gst_adaptive_demux_test_check_size_of_received_data;
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd",
|
|
&test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/*
|
|
* Test seeking
|
|
*
|
|
*/
|
|
GST_START_TEST (testSeek)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT135.743S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio.webm", NULL, 10000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 10000, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
|
|
/* media segment starts at 4687
|
|
* Issue a seek request after media segment has started to be downloaded
|
|
* on the first pad listed in GstAdaptiveDemuxTestOutputStreamData and the
|
|
* first chunk of at least one byte has already arrived in AppSink
|
|
*/
|
|
testData->threshold_for_seek = 4687 + 1;
|
|
|
|
/* seek to 5ms.
|
|
* Because there is only one fragment, we expect the whole file to be
|
|
* downloaded again
|
|
*/
|
|
testData->seek_event =
|
|
gst_event_new_seek (1.0, GST_FORMAT_TIME,
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT, GST_SEEK_TYPE_SET,
|
|
5 * GST_MSECOND, GST_SEEK_TYPE_NONE, 0);
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_seek (DEMUX_ELEMENT_NAME,
|
|
"http://unit.test/test.mpd", testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
#define SEGMENT_SIZE 10000
|
|
static void
|
|
run_seek_position_test (gdouble rate, GstSeekType start_type,
|
|
guint64 seek_start, GstSeekType stop_type, guint64 seek_stop,
|
|
GstSeekFlags flags, guint64 segment_start, guint64 segment_stop,
|
|
gint segments, gint seek_threshold_bytes)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT135.743S\">"
|
|
" <Period>"
|
|
" <AdaptationSet "
|
|
" mimeType=\"audio/mp4\" minBandwidth=\"128000\" "
|
|
" maxBandwidth=\"128000\" segmentAlignment=\"true\">"
|
|
" <SegmentTemplate timescale=\"48000\" "
|
|
" initialization=\"init-$RepresentationID$.mp4\" "
|
|
" media=\"$RepresentationID$-$Number$.mp4\" "
|
|
" startNumber=\"1\">"
|
|
" <SegmentTimeline>"
|
|
" <S t=\"0\" d=\"48000\" /> "
|
|
" <S d=\"48000\" /> "
|
|
" <S d=\"48000\" /> "
|
|
" <S d=\"48000\" /> "
|
|
" </SegmentTimeline>"
|
|
" </SegmentTemplate>"
|
|
" <Representation id=\"audio\" bandwidth=\"128000\" "
|
|
" codecs=\"mp4a.40.2\" audioSamplingRate=\"48000\"> "
|
|
" <AudioChannelConfiguration "
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\"> "
|
|
" </AudioChannelConfiguration> "
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/init-audio.mp4", NULL, 10000},
|
|
{"http://unit.test/audio-1.mp4", NULL, 10000},
|
|
{"http://unit.test/audio-2.mp4", NULL, 10000},
|
|
{"http://unit.test/audio-3.mp4", NULL, 10000},
|
|
{"http://unit.test/audio-4.mp4", NULL, 10000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
/* 1 from the init segment */
|
|
{"audio_00", (segments ? 1 + segments : 0) * 10000, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
|
|
/* media segment starts at 4687
|
|
* Issue a seek request after media segment has started to be downloaded
|
|
* on the first pad listed in GstAdaptiveDemuxTestOutputStreamData and the
|
|
* first chunk of at least one byte has already arrived in AppSink
|
|
*/
|
|
if (seek_threshold_bytes)
|
|
testData->threshold_for_seek = seek_threshold_bytes;
|
|
else
|
|
testData->threshold_for_seek = 4687 + 1;
|
|
|
|
/* FIXME hack to avoid having a 0 seqnum */
|
|
gst_util_seqnum_next ();
|
|
|
|
/* seek to 5ms.
|
|
* Because there is only one fragment, we expect the whole file to be
|
|
* downloaded again
|
|
*/
|
|
testData->seek_event =
|
|
gst_event_new_seek (rate, GST_FORMAT_TIME, flags, start_type,
|
|
seek_start, stop_type, seek_stop);
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_seek (DEMUX_ELEMENT_NAME,
|
|
"http://unit.test/test.mpd", testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_START_TEST (testSeekKeyUnitPosition)
|
|
{
|
|
/* Seek to 1.5s with key unit, it should go back to 1.0s. 3 segments will be
|
|
* pushed */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_SET, 1500 * GST_MSECOND,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
|
|
1000 * GST_MSECOND, -1, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (testSeekUpdateStopPosition)
|
|
{
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_NONE, 1500 * GST_MSECOND,
|
|
GST_SEEK_TYPE_SET, 3000 * GST_MSECOND, 0, 0, 3000 * GST_MSECOND, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (testSeekPosition)
|
|
{
|
|
/* Seek to 1.5s without key unit, it should keep the 1.5s, but still push
|
|
* from the 1st segment, so 3 segments will be
|
|
* pushed */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_SET, 1500 * GST_MSECOND,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH, 1500 * GST_MSECOND, -1, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (testSeekSnapBeforePosition)
|
|
{
|
|
/* Seek to 1.5s, snap before, it go to 1s */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_SET, 1500 * GST_MSECOND,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_BEFORE,
|
|
1000 * GST_MSECOND, -1, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (testSeekSnapAfterPosition)
|
|
{
|
|
/* Seek to 1.5s with snap after, it should move to 2s */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_SET, 1500 * GST_MSECOND,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_AFTER,
|
|
2000 * GST_MSECOND, -1, 2, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (testSeekSnapBeforeSamePosition)
|
|
{
|
|
/* Snap seek without position */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_BEFORE,
|
|
2 * GST_MSECOND, -1, 2, SEGMENT_SIZE * 3 + 1);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (testSeekSnapAfterSamePosition)
|
|
{
|
|
/* Snap seek without position */
|
|
run_seek_position_test (1.0, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE,
|
|
GST_SEEK_TYPE_NONE, 0, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_AFTER,
|
|
3 * GST_MSECOND, -1, 1, SEGMENT_SIZE * 3 + 1);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (testReverseSeekSnapBeforePosition)
|
|
{
|
|
run_seek_position_test (-1.0, GST_SEEK_TYPE_SET, 1000 * GST_MSECOND,
|
|
GST_SEEK_TYPE_SET, 2500 * GST_MSECOND,
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_BEFORE, 1000 * GST_MSECOND,
|
|
3000 * GST_MSECOND, 2, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (testReverseSeekSnapAfterPosition)
|
|
{
|
|
run_seek_position_test (-1.0, GST_SEEK_TYPE_SET, 1000 * GST_MSECOND,
|
|
GST_SEEK_TYPE_SET, 2500 * GST_MSECOND,
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_AFTER, 1000 * GST_MSECOND,
|
|
2000 * GST_MSECOND, 1, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static void
|
|
testDownloadErrorMessageCallback (GstAdaptiveDemuxTestEngine * engine,
|
|
GstMessage * msg, gpointer user_data)
|
|
{
|
|
GError *err = NULL;
|
|
gchar *dbg_info = NULL;
|
|
|
|
fail_unless (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR);
|
|
gst_message_parse_error (msg, &err, &dbg_info);
|
|
GST_DEBUG ("Error from element %s : %s\n",
|
|
GST_OBJECT_NAME (msg->src), err->message);
|
|
fail_unless_equals_string (GST_OBJECT_NAME (msg->src), DEMUX_ELEMENT_NAME);
|
|
/*GST_DEBUG ("dbg_info=%s\n", dbg_info); */
|
|
g_error_free (err);
|
|
g_free (dbg_info);
|
|
g_main_loop_quit (engine->loop);
|
|
}
|
|
|
|
/*
|
|
* Test error case of failing to download a segment
|
|
*/
|
|
GST_START_TEST (testDownloadError)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT0.5S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio_file_not_available.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 0, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.appsink_received_data =
|
|
gst_adaptive_demux_test_check_received_data;
|
|
test_callbacks.bus_error_message = testDownloadErrorMessageCallback;
|
|
test_callbacks.appsink_eos =
|
|
gst_adaptive_demux_test_check_size_of_received_data;
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd",
|
|
&test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* generate queries to adaptive demux */
|
|
static gboolean
|
|
testQueryCheckDataReceived (GstAdaptiveDemuxTestEngine * engine,
|
|
GstAdaptiveDemuxTestOutputStream * stream,
|
|
GstBuffer * buffer, gpointer user_data)
|
|
{
|
|
GList *pads;
|
|
GstPad *pad;
|
|
GstQuery *query;
|
|
gboolean ret;
|
|
gint64 duration;
|
|
gboolean seekable;
|
|
gint64 segment_start;
|
|
gint64 segment_end;
|
|
gchar *uri;
|
|
gchar *redirect_uri;
|
|
gboolean redirect_permanent;
|
|
|
|
pads = GST_ELEMENT_PADS (stream->appsink);
|
|
|
|
/* AppSink should have only 1 pad */
|
|
fail_unless (pads != NULL);
|
|
fail_unless (g_list_length (pads) == 1);
|
|
pad = GST_PAD (pads->data);
|
|
|
|
query = gst_query_new_duration (GST_FORMAT_TIME);
|
|
ret = gst_pad_peer_query (pad, query);
|
|
fail_unless (ret == TRUE);
|
|
gst_query_parse_duration (query, NULL, &duration);
|
|
fail_unless (duration == 135743 * GST_MSECOND);
|
|
gst_query_unref (query);
|
|
|
|
query = gst_query_new_seeking (GST_FORMAT_TIME);
|
|
ret = gst_pad_peer_query (pad, query);
|
|
fail_unless (ret == TRUE);
|
|
gst_query_parse_seeking (query, NULL, &seekable, &segment_start,
|
|
&segment_end);
|
|
fail_unless (seekable == TRUE);
|
|
fail_unless (segment_start == 0);
|
|
fail_unless (segment_end == duration);
|
|
gst_query_unref (query);
|
|
|
|
query = gst_query_new_uri ();
|
|
ret = gst_pad_peer_query (pad, query);
|
|
fail_unless (ret == TRUE);
|
|
gst_query_parse_uri (query, &uri);
|
|
gst_query_parse_uri_redirection (query, &redirect_uri);
|
|
gst_query_parse_uri_redirection_permanent (query, &redirect_permanent);
|
|
fail_unless (strcmp (uri, "http://unit.test/test.mpd") == 0);
|
|
/* adaptive demux does not reply with redirect information */
|
|
fail_unless (redirect_uri == NULL);
|
|
fail_unless (redirect_permanent == FALSE);
|
|
g_free (uri);
|
|
g_free (redirect_uri);
|
|
gst_query_unref (query);
|
|
|
|
return gst_adaptive_demux_test_check_received_data (engine,
|
|
stream, buffer, user_data);
|
|
}
|
|
|
|
/*
|
|
* Test queries
|
|
*
|
|
*/
|
|
GST_START_TEST (testQuery)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT135.743S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio.webm", NULL, 5000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 5000, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = gst_dashdemux_http_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.appsink_received_data = testQueryCheckDataReceived;
|
|
test_callbacks.appsink_eos =
|
|
gst_adaptive_demux_test_check_size_of_received_data;
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME,
|
|
"http://unit.test/test.mpd", &test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static GstFlowReturn
|
|
test_fragment_download_error_src_create (GstTestHTTPSrc * src,
|
|
guint64 offset,
|
|
guint length, GstBuffer ** retbuf, gpointer context, gpointer user_data)
|
|
{
|
|
const GstDashDemuxTestInputData *input =
|
|
(const GstDashDemuxTestInputData *) context;
|
|
fail_unless (input != NULL);
|
|
if (!g_str_has_suffix (input->uri, ".mpd") && offset > 2000) {
|
|
GST_DEBUG ("network_error %s %" G_GUINT64_FORMAT " @ %d",
|
|
input->uri, offset, 2000);
|
|
GST_ELEMENT_ERROR (src, RESOURCE, READ,
|
|
(("A network error occurred, or the server closed the connection unexpectedly.")), ("A network error occurred, or the server closed the connection unexpectedly."));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
return gst_dashdemux_http_src_create (src, offset, length, retbuf, context,
|
|
user_data);
|
|
}
|
|
|
|
/* function to check total size of data received by AppSink
|
|
* will be called when AppSink receives eos.
|
|
*/
|
|
static void
|
|
testFragmentDownloadErrorCheckSizeOfDataReceived (GstAdaptiveDemuxTestEngine *
|
|
engine, GstAdaptiveDemuxTestOutputStream * stream, gpointer user_data)
|
|
{
|
|
GstAdaptiveDemuxTestCase *testData = GST_ADAPTIVE_DEMUX_TEST_CASE (user_data);
|
|
GstAdaptiveDemuxTestExpectedOutput *testOutputStreamData;
|
|
|
|
testOutputStreamData =
|
|
gst_adaptive_demux_test_find_test_data_by_stream (testData, stream, NULL);
|
|
fail_unless (testOutputStreamData != NULL);
|
|
|
|
/* expect to receive more than 0 */
|
|
fail_unless (stream->total_received_size > 0,
|
|
"size validation failed for %s, expected > 0, received %d",
|
|
testOutputStreamData->name, stream->total_received_size);
|
|
|
|
/* expect to receive less than file size */
|
|
fail_unless (stream->total_received_size <
|
|
testOutputStreamData->expected_size,
|
|
"size validation failed for %s, expected < %d received %d",
|
|
testOutputStreamData->name, testOutputStreamData->expected_size,
|
|
stream->total_received_size);
|
|
}
|
|
|
|
/*
|
|
* Test fragment download error
|
|
* Let the adaptive demux download a few bytes, then instruct the
|
|
* GstTestHTTPSrc element to generate an error.
|
|
*/
|
|
GST_START_TEST (testFragmentDownloadError)
|
|
{
|
|
const gchar *mpd =
|
|
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
|
|
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
|
|
" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\""
|
|
" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd\""
|
|
" profiles=\"urn:mpeg:dash:profile:isoff-on-demand:2011\""
|
|
" type=\"static\""
|
|
" minBufferTime=\"PT1.500S\""
|
|
" mediaPresentationDuration=\"PT0.5S\">"
|
|
" <Period>"
|
|
" <AdaptationSet mimeType=\"audio/webm\""
|
|
" subsegmentAlignment=\"true\">"
|
|
" <Representation id=\"171\""
|
|
" codecs=\"vorbis\""
|
|
" audioSamplingRate=\"44100\""
|
|
" startWithSAP=\"1\""
|
|
" bandwidth=\"129553\">"
|
|
" <AudioChannelConfiguration"
|
|
" schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\""
|
|
" value=\"2\" />"
|
|
" <BaseURL>audio.webm</BaseURL>"
|
|
" <SegmentBase indexRange=\"4452-4686\""
|
|
" indexRangeExact=\"true\">"
|
|
" <Initialization range=\"0-4451\" />"
|
|
" </SegmentBase>"
|
|
" </Representation></AdaptationSet></Period></MPD>";
|
|
|
|
GstDashDemuxTestInputData inputTestData[] = {
|
|
{"http://unit.test/test.mpd", (guint8 *) mpd, 0},
|
|
{"http://unit.test/audio.webm", NULL, 5000},
|
|
{NULL, NULL, 0},
|
|
};
|
|
GstTestHTTPSrcCallbacks http_src_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestExpectedOutput outputTestData[] = {
|
|
{"audio_00", 5000, NULL},
|
|
};
|
|
GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 };
|
|
GstAdaptiveDemuxTestCase *testData;
|
|
|
|
testData = gst_adaptive_demux_test_case_new ();
|
|
http_src_callbacks.src_start = gst_dashdemux_http_src_start;
|
|
http_src_callbacks.src_create = test_fragment_download_error_src_create;
|
|
COPY_OUTPUT_TEST_DATA (outputTestData, testData);
|
|
test_callbacks.appsink_received_data =
|
|
gst_adaptive_demux_test_check_received_data;
|
|
test_callbacks.appsink_eos = testFragmentDownloadErrorCheckSizeOfDataReceived;
|
|
/* test_callbacks.demux_sent_eos = gst_adaptive_demux_test_check_size_of_received_data; */
|
|
|
|
test_callbacks.bus_error_message = testDownloadErrorMessageCallback;
|
|
|
|
gst_test_http_src_install_callbacks (&http_src_callbacks, inputTestData);
|
|
gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME,
|
|
"http://unit.test/test.mpd", &test_callbacks, testData);
|
|
g_object_unref (testData);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
dash_demux_suite (void)
|
|
{
|
|
Suite *s = suite_create ("dash_demux");
|
|
TCase *tc_basicTest = tcase_create ("basicTest");
|
|
|
|
tcase_add_test (tc_basicTest, simpleTest);
|
|
tcase_add_test (tc_basicTest, testTwoPeriods);
|
|
tcase_add_test (tc_basicTest, testParameters);
|
|
tcase_add_test (tc_basicTest, testSeek);
|
|
tcase_add_test (tc_basicTest, testSeekKeyUnitPosition);
|
|
tcase_add_test (tc_basicTest, testSeekPosition);
|
|
tcase_add_test (tc_basicTest, testSeekUpdateStopPosition);
|
|
tcase_add_test (tc_basicTest, testSeekSnapBeforePosition);
|
|
tcase_add_test (tc_basicTest, testSeekSnapAfterPosition);
|
|
tcase_add_test (tc_basicTest, testSeekSnapBeforeSamePosition);
|
|
tcase_add_test (tc_basicTest, testSeekSnapAfterSamePosition);
|
|
tcase_add_test (tc_basicTest, testReverseSeekSnapBeforePosition);
|
|
tcase_add_test (tc_basicTest, testReverseSeekSnapAfterPosition);
|
|
tcase_add_test (tc_basicTest, testDownloadError);
|
|
tcase_add_test (tc_basicTest, testFragmentDownloadError);
|
|
tcase_add_test (tc_basicTest, testQuery);
|
|
|
|
tcase_add_unchecked_fixture (tc_basicTest, gst_adaptive_demux_test_setup,
|
|
gst_adaptive_demux_test_teardown);
|
|
|
|
suite_add_tcase (s, tc_basicTest);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (dash_demux);
|