| /* 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){ \ | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (testData)->output_streams = g_list_append (GST_ADAPTIVE_DEMUX_TEST_CASE (testData)->output_streams, &(outputTestData)[otdPos]); \ | |
| } \ | |
| } while(0) | |
| typedef struct _GstDashDemuxTestInputData | |
| { | |
| const gchar *uri; | |
| const guint8 *payload; | |
| guint64 size; | |
| } GstDashDemuxTestInputData; | |
| typedef struct _GstTestHTTPSrcTestData | |
| { | |
| const GstDashDemuxTestInputData *input; | |
| GstStructure *data; | |
| } GstTestHTTPSrcTestData; | |
| typedef struct _GstDashDemuxTestCase | |
| { | |
| GstAdaptiveDemuxTestCase parent; | |
| /* the number of Protection Events sent to each pad */ | |
| GstStructure *countContentProtectionEvents; | |
| } GstDashDemuxTestCase; | |
| GType gst_dash_demux_test_case_get_type (void); | |
| static void gst_dash_demux_test_case_dispose (GObject * object); | |
| static void gst_dash_demux_test_case_finalize (GObject * object); | |
| static void gst_dash_demux_test_case_clear (GstDashDemuxTestCase * test_case); | |
| static GstDashDemuxTestCase * | |
| gst_dash_demux_test_case_new (void) | |
| G_GNUC_MALLOC; | |
| #define GST_TYPE_DASH_DEMUX_TEST_CASE \ | |
| (gst_dash_demux_test_case_get_type()) | |
| #define GST_DASH_DEMUX_TEST_CASE(obj) \ | |
| (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_DASH_DEMUX_TEST_CASE, GstDashDemuxTestCase)) | |
| #define GST_DASH_DEMUX_TEST_CASE_CLASS(klass) \ | |
| (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_DASH_DEMUX_TEST_CASE, GstDashDemuxTestCaseClass)) | |
| #define GST_DASH_DEMUX_TEST_CASE_GET_CLASS(obj) \ | |
| (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_DASH_DEMUX_TEST_CASE, GstDashDemuxTestCaseClass)) | |
| #define GST_IS_DASH_DEMUX_TEST_CASE(obj) \ | |
| (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_DASH_DEMUX_TEST_CASE)) | |
| #define GST_IS_DASH_DEMUX_TEST_CASE_CLASS(klass) \ | |
| (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_DASH_DEMUX_TEST_CASE)) | |
| static GstDashDemuxTestCase *gst_dash_demux_test_case_new (void) | |
| { | |
| return g_object_new (GST_TYPE_DASH_DEMUX_TEST_CASE, NULL); | |
| } | |
| typedef struct _GstDashDemuxTestCaseClass | |
| { | |
| GstAdaptiveDemuxTestCaseClass parent_class; | |
| } GstDashDemuxTestCaseClass; | |
| #define gst_dash_demux_test_case_parent_class parent_class | |
| G_DEFINE_TYPE (GstDashDemuxTestCase, gst_dash_demux_test_case, | |
| GST_TYPE_ADAPTIVE_DEMUX_TEST_CASE); | |
| static void | |
| gst_dash_demux_test_case_class_init (GstDashDemuxTestCaseClass * klass) | |
| { | |
| GObjectClass *object = G_OBJECT_CLASS (klass); | |
| object->dispose = gst_dash_demux_test_case_dispose; | |
| object->finalize = gst_dash_demux_test_case_finalize; | |
| } | |
| static void | |
| gst_dash_demux_test_case_init (GstDashDemuxTestCase * test_case) | |
| { | |
| test_case->countContentProtectionEvents = NULL; | |
| gst_dash_demux_test_case_clear (test_case); | |
| } | |
| static void | |
| gst_dash_demux_test_case_clear (GstDashDemuxTestCase * test_case) | |
| { | |
| if (test_case->countContentProtectionEvents) { | |
| gst_structure_free (test_case->countContentProtectionEvents); | |
| test_case->countContentProtectionEvents = NULL; | |
| } | |
| } | |
| static void | |
| gst_dash_demux_test_case_dispose (GObject * object) | |
| { | |
| GstDashDemuxTestCase *testData = GST_DASH_DEMUX_TEST_CASE (object); | |
| gst_dash_demux_test_case_clear (testData); | |
| G_OBJECT_CLASS (parent_class)->dispose (object); | |
| } | |
| static void | |
| gst_dash_demux_test_case_finalize (GObject * object) | |
| { | |
| /*GstDashDemuxTestCase *testData = GST_DASH_DEMUX_TEST_CASE (object); */ | |
| G_OBJECT_CLASS (parent_class)->finalize (object); | |
| } | |
| static gboolean | |
| gst_dashdemux_http_src_start (GstTestHTTPSrc * src, | |
| const gchar * uri, GstTestHTTPSrcInput * input_data, gpointer user_data) | |
| { | |
| const GstTestHTTPSrcTestData *test_case = | |
| (const GstTestHTTPSrcTestData *) user_data; | |
| guint i; | |
| for (i = 0; test_case->input[i].uri; ++i) { | |
| if (g_strcmp0 (test_case->input[i].uri, uri) == 0) { | |
| input_data->context = (gpointer) & test_case->input[i]; | |
| input_data->size = test_case->input[i].size; | |
| if (test_case->input[i].size == 0) | |
| input_data->size = strlen ((gchar *) test_case->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 *) 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; | |
| guint64 i; | |
| pattern = offset - offset % sizeof (pattern); | |
| gst_buffer_map (buf, &info, GST_MAP_WRITE); | |
| for (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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 5000, NULL}, | |
| {"video_00", 9000, NULL} | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd", | |
| &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 5001, NULL}, | |
| {"video_00", 9001, NULL}, | |
| {"audio_01", 5002, NULL}, | |
| {"video_01", 9002, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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) | |
| { | |
| /* GstDashDemuxTestCase * testData = (GstDashDemuxTestCase*)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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 5000, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd", | |
| &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 10000, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| testData = gst_dash_demux_test_case_new (); | |
| 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 | |
| */ | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (testData)->threshold_for_seek = 4687 + 1; | |
| /* seek to 5ms. | |
| * Because there is only one fragment, we expect the whole file to be | |
| * downloaded again | |
| */ | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (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_adaptive_demux_test_seek (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", GST_ADAPTIVE_DEMUX_TEST_CASE (testData)); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| /* 1 from the init segment */ | |
| {"audio_00", (segments ? 1 + segments : 0) * 10000, NULL}, | |
| }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| testData = gst_dash_demux_test_case_new (); | |
| 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) | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (testData)->threshold_for_seek = | |
| seek_threshold_bytes; | |
| else | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (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 | |
| */ | |
| GST_ADAPTIVE_DEMUX_TEST_CASE (testData)->seek_event = | |
| gst_event_new_seek (rate, GST_FORMAT_TIME, flags, start_type, | |
| seek_start, stop_type, seek_stop); | |
| gst_adaptive_demux_test_seek (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", GST_ADAPTIVE_DEMUX_TEST_CASE (testData)); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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_KEY_UNIT | 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_KEY_UNIT | 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_KEY_UNIT | 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_KEY_UNIT | 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_KEY_UNIT | 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_KEY_UNIT | 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", | |
| GST_OBJECT_NAME (msg->src), err->message); | |
| fail_unless_equals_string (GST_OBJECT_NAME (msg->src), DEMUX_ELEMENT_NAME); | |
| 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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 0, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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_unexpected_eos; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd", | |
| &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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; | |
| const GstTestHTTPSrcTestData *http_src_test_data = | |
| (const GstTestHTTPSrcTestData *) user_data; | |
| guint64 threshold_for_trigger; | |
| fail_unless (input != NULL); | |
| gst_structure_get_uint64 (http_src_test_data->data, "threshold_for_trigger", | |
| &threshold_for_trigger); | |
| if (!g_str_has_suffix (input->uri, ".mpd") && offset >= threshold_for_trigger) { | |
| GST_DEBUG ("network_error %s %" G_GUINT64_FORMAT " @ %" G_GUINT64_FORMAT, | |
| input->uri, offset, threshold_for_trigger); | |
| 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); | |
| } | |
| /* | |
| * Test header download error | |
| * Let the adaptive demux download a few bytes, then instruct the | |
| * GstTestHTTPSrc element to generate an error while the fragment header | |
| * is still being downloaded. | |
| */ | |
| GST_START_TEST (testHeaderDownloadError) | |
| { | |
| 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>"; | |
| /* generate error while the headers are still being downloaded | |
| * threshold_for_trigger must be less than the size of headers | |
| * (initialization + index) which is 4687. | |
| */ | |
| guint64 threshold_for_trigger = 2000; | |
| GstDashDemuxTestInputData inputTestData[] = { | |
| {"http://unit.test/test.mpd", (guint8 *) mpd, 0}, | |
| {"http://unit.test/audio.webm", NULL, 5000}, | |
| {NULL, NULL, 0}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| /* adaptive demux tries for 4 times (MAX_DOWNLOAD_ERROR_COUNT + 1) before giving up */ | |
| {"audio_00", threshold_for_trigger * 4, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = test_fragment_download_error_src_create; | |
| http_src_test_data.data = gst_structure_new_empty (__FUNCTION__); | |
| gst_structure_set (http_src_test_data.data, "threshold_for_trigger", | |
| G_TYPE_UINT64, threshold_for_trigger, NULL); | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| test_callbacks.appsink_received_data = | |
| gst_adaptive_demux_test_check_received_data; | |
| test_callbacks.appsink_eos = gst_adaptive_demux_test_unexpected_eos; | |
| test_callbacks.bus_error_message = testDownloadErrorMessageCallback; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| /* download in chunks of threshold_for_trigger size. | |
| * This means the first chunk will succeed, the second will generate | |
| * error because we already exceeded threshold_for_trigger bytes. | |
| */ | |
| gst_test_http_src_set_default_blocksize (threshold_for_trigger); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| GST_END_TEST; | |
| /* | |
| * Test media download error on the last media fragment. | |
| * Let the adaptive demux download a few bytes, then instruct the | |
| * GstTestHTTPSrc element to generate an error while the last media fragment | |
| * is being downloaded. | |
| * Adaptive demux will not retry downloading the last media fragment. It will | |
| * be considered eos. | |
| */ | |
| GST_START_TEST (testMediaDownloadErrorLastFragment) | |
| { | |
| 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>"; | |
| /* generate error on the first media fragment */ | |
| guint64 threshold_for_trigger = 4687; | |
| GstDashDemuxTestInputData inputTestData[] = { | |
| {"http://unit.test/test.mpd", (guint8 *) mpd, 0}, | |
| {"http://unit.test/audio.webm", NULL, 5000}, | |
| {NULL, NULL, 0}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| /* adaptive demux will not retry because this is the last fragment */ | |
| {"audio_00", threshold_for_trigger, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = test_fragment_download_error_src_create; | |
| http_src_test_data.data = gst_structure_new_empty (__FUNCTION__); | |
| gst_structure_set (http_src_test_data.data, "threshold_for_trigger", | |
| G_TYPE_UINT64, threshold_for_trigger, NULL); | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| GST_END_TEST; | |
| /* | |
| * Test media download error on a media fragment which is not the last one. | |
| * Let the adaptive demux download a few bytes, then instruct the | |
| * GstTestHTTPSrc element to generate an error while a media fragment | |
| * is being downloaded. | |
| */ | |
| GST_START_TEST (testMediaDownloadErrorMiddleFragment) | |
| { | |
| 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=\"PT10S\">" | |
| " <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>" | |
| " <SegmentList duration=\"1\">" | |
| " <SegmentURL indexRange=\"1-10\"" | |
| " mediaRange=\"11-30\">" | |
| " </SegmentURL>" | |
| " <SegmentURL indexRange=\"31-60\"" | |
| " mediaRange=\"61-100\">" | |
| " </SegmentURL>" | |
| " <SegmentURL indexRange=\"101-150\"" | |
| " mediaRange=\"151-210\">" | |
| " </SegmentURL>" | |
| " </SegmentList>" | |
| " </Representation></AdaptationSet></Period></MPD>"; | |
| /* generate error on the second media fragment */ | |
| guint64 threshold_for_trigger = 31; | |
| GstDashDemuxTestInputData inputTestData[] = { | |
| {"http://unit.test/test.mpd", (guint8 *) mpd, 0}, | |
| {"http://unit.test/audio.webm", NULL, 5000}, | |
| {NULL, NULL, 0}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| /* adaptive demux will download only the first media fragment */ | |
| {"audio_00", 20, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = test_fragment_download_error_src_create; | |
| http_src_test_data.data = gst_structure_new_empty (__FUNCTION__); | |
| gst_structure_set (http_src_test_data.data, "threshold_for_trigger", | |
| G_TYPE_UINT64, threshold_for_trigger, NULL); | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| test_callbacks.appsink_received_data = | |
| gst_adaptive_demux_test_check_received_data; | |
| test_callbacks.appsink_eos = gst_adaptive_demux_test_unexpected_eos; | |
| test_callbacks.bus_error_message = testDownloadErrorMessageCallback; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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; | |
| gboolean live; | |
| GstClockTime min_latency; | |
| GstClockTime max_latency; | |
| 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); | |
| /* duration query */ | |
| 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); | |
| /* mediaPresentationDuration=\"PT135.743S\" */ | |
| fail_unless (duration == 135743 * GST_MSECOND); | |
| gst_query_unref (query); | |
| /* seek 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); | |
| /* latency query */ | |
| query = gst_query_new_latency (); | |
| ret = gst_pad_peer_query (pad, query); | |
| fail_unless (ret == TRUE); | |
| gst_query_parse_latency (query, &live, &min_latency, &max_latency); | |
| fail_unless (live == FALSE); | |
| fail_unless (min_latency == 0); | |
| fail_unless (max_latency == -1); | |
| gst_query_unref (query); | |
| /* uri 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 (g_strcmp0 (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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 5000, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| test_callbacks.appsink_received_data = testQueryCheckDataReceived; | |
| test_callbacks.appsink_eos = | |
| gst_adaptive_demux_test_check_size_of_received_data; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, | |
| "http://unit.test/test.mpd", &test_callbacks, testData); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| GST_END_TEST; | |
| static gboolean | |
| testContentProtectionDashdemuxSendsEvent (GstAdaptiveDemuxTestEngine * engine, | |
| GstAdaptiveDemuxTestOutputStream * stream, | |
| GstEvent * event, gpointer user_data) | |
| { | |
| GstDashDemuxTestCase *test_case = GST_DASH_DEMUX_TEST_CASE (user_data); | |
| const gchar *system_id; | |
| GstBuffer *data; | |
| const gchar *origin; | |
| GstMapInfo info; | |
| gchar *value; | |
| gchar *name; | |
| guint event_count = 0; | |
| GST_DEBUG ("received event %s", GST_EVENT_TYPE_NAME (event)); | |
| if (GST_EVENT_TYPE (event) != GST_EVENT_PROTECTION) { | |
| return TRUE; | |
| } | |
| /* we expect content protection events only on video pad */ | |
| name = gst_pad_get_name (stream->pad); | |
| fail_unless (g_strcmp0 (name, "video_00") == 0); | |
| gst_event_parse_protection (event, &system_id, &data, &origin); | |
| gst_buffer_map (data, &info, GST_MAP_READ); | |
| value = g_malloc (info.size + 1); | |
| strncpy (value, (gchar *) info.data, info.size); | |
| value[info.size] = 0; | |
| gst_buffer_unmap (data, &info); | |
| if (g_strcmp0 (system_id, "11111111-AAAA-BBBB-CCCC-123456789ABC") == 0) { | |
| fail_unless (g_strcmp0 (origin, "dash/mpd") == 0); | |
| fail_unless (g_strcmp0 (value, "test value") == 0); | |
| } else if (g_strcmp0 (system_id, "5e629af5-38da-4063-8977-97ffbd9902d4") == 0) { | |
| const gchar *str; | |
| fail_unless (g_strcmp0 (origin, "dash/mpd") == 0); | |
| /* We can't do a simple compare of value (which should be an XML dump | |
| of the ContentProtection element), because the whitespace | |
| formatting from xmlDump might differ between versions of libxml */ | |
| str = strstr (value, "<ContentProtection"); | |
| fail_if (str == NULL); | |
| str = strstr (value, "<mas:MarlinContentIds>"); | |
| fail_if (str == NULL); | |
| str = strstr (value, "<mas:MarlinContentId>"); | |
| fail_if (str == NULL); | |
| str = strstr (value, "urn:marlin:kid:02020202020202020202020202020202"); | |
| fail_if (str == NULL); | |
| str = strstr (value, "</ContentProtection>"); | |
| fail_if (str == NULL); | |
| } else if (g_strcmp0 (system_id, "9a04f079-9840-4286-ab92-e65be0885f95") == 0) { | |
| fail_unless (g_strcmp0 (origin, "dash/mpd") == 0); | |
| fail_unless (g_strcmp0 (value, "dGVzdA==") == 0); | |
| } else { | |
| fail ("unexpected content protection event '%s'", system_id); | |
| } | |
| g_free (value); | |
| fail_if (test_case->countContentProtectionEvents == NULL); | |
| gst_structure_get_uint (test_case->countContentProtectionEvents, name, | |
| &event_count); | |
| event_count++; | |
| gst_structure_set (test_case->countContentProtectionEvents, name, G_TYPE_UINT, | |
| event_count, NULL); | |
| g_free (name); | |
| return TRUE; | |
| } | |
| /* | |
| * Test content protection | |
| * Configure 3 content protection sources: | |
| * - a uuid scheme/value pair | |
| * - a non uuid scheme/value pair (dash recognises only uuid schemes) | |
| * - a complex uuid scheme, with trailing spaces and capital letters in scheme uri | |
| * Only the uuid scheme will be recognised. We expect to receive 2 content | |
| * protection events | |
| */ | |
| GST_START_TEST (testContentProtection) | |
| { | |
| 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\"" | |
| " xmlns:mspr=\"urn:microsoft:playready\"" | |
| " 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\">" | |
| " <ContentProtection schemeIdUri=\"urn:uuid:11111111-AAAA-BBBB-CCCC-123456789ABC\" value=\"test value\"/>" | |
| " <ContentProtection schemeIdUri=\"urn:mpeg:dash:mp4protection:2011\" value=\"cenc\"/>" | |
| " <ContentProtection schemeIdUri=\" URN:UUID:5e629af5-38da-4063-8977-97ffbd9902d4\" xmlns:mas=\"urn:marlin:mas:1-0:services:schemas:mpd\">" | |
| " <mas:MarlinContentIds>" | |
| " <mas:MarlinContentId>urn:marlin:kid:02020202020202020202020202020202</mas:MarlinContentId>" | |
| " </mas:MarlinContentIds>" | |
| " </ContentProtection>" | |
| " <ContentProtection schemeIdUri=\"urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95\" value=\"MSPR 2.0\">" | |
| " <mspr:pro>dGVzdA==</mspr:pro>" | |
| " </ContentProtection>" | |
| " <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}, | |
| }; | |
| GstAdaptiveDemuxTestExpectedOutput outputTestData[] = { | |
| {"audio_00", 5000, NULL}, | |
| {"video_00", 9000, NULL}, | |
| }; | |
| GstTestHTTPSrcCallbacks http_src_callbacks = { 0 }; | |
| GstTestHTTPSrcTestData http_src_test_data = { 0 }; | |
| GstAdaptiveDemuxTestCallbacks test_callbacks = { 0 }; | |
| GstDashDemuxTestCase *testData; | |
| guint event_count = 0; | |
| http_src_callbacks.src_start = gst_dashdemux_http_src_start; | |
| http_src_callbacks.src_create = gst_dashdemux_http_src_create; | |
| http_src_test_data.input = inputTestData; | |
| gst_test_http_src_install_callbacks (&http_src_callbacks, | |
| &http_src_test_data); | |
| 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; | |
| test_callbacks.demux_sent_event = testContentProtectionDashdemuxSendsEvent; | |
| testData = gst_dash_demux_test_case_new (); | |
| COPY_OUTPUT_TEST_DATA (outputTestData, testData); | |
| testData->countContentProtectionEvents = | |
| gst_structure_new_empty ("countContentProtectionEvents"); | |
| gst_adaptive_demux_test_run (DEMUX_ELEMENT_NAME, "http://unit.test/test.mpd", | |
| &test_callbacks, testData); | |
| fail_unless (gst_structure_has_field_typed | |
| (testData->countContentProtectionEvents, "video_00", G_TYPE_UINT)); | |
| gst_structure_get_uint (testData->countContentProtectionEvents, "video_00", | |
| &event_count); | |
| fail_unless (event_count == 3); | |
| g_object_unref (testData); | |
| if (http_src_test_data.data) | |
| gst_structure_free (http_src_test_data.data); | |
| } | |
| 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, testHeaderDownloadError); | |
| tcase_add_test (tc_basicTest, testMediaDownloadErrorLastFragment); | |
| tcase_add_test (tc_basicTest, testMediaDownloadErrorMiddleFragment); | |
| tcase_add_test (tc_basicTest, testQuery); | |
| tcase_add_test (tc_basicTest, testContentProtection); | |
| 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); |