3 * unit test for qtdemux
5 * Copyright (C) <2016> Edward Hervey <edward@centricular.com>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
24 #include <glib/gprintf.h>
25 #include <gst/check/gstharness.h>
31 GstClockTime expected_time;
34 static GstPadProbeReturn
35 qtdemux_probe (GstPad * pad, GstPadProbeInfo * info, CommonTestData * data)
37 if (GST_IS_EVENT (GST_PAD_PROBE_INFO_DATA (info))) {
38 GstEvent *ev = GST_PAD_PROBE_INFO_EVENT (info);
40 switch (GST_EVENT_TYPE (ev)) {
41 case GST_EVENT_SEGMENT:
43 const GstSegment *segment;
44 gst_event_parse_segment (ev, &segment);
45 fail_unless (GST_CLOCK_TIME_IS_VALID (segment->format));
46 fail_unless (GST_CLOCK_TIME_IS_VALID (segment->start));
47 fail_unless (GST_CLOCK_TIME_IS_VALID (segment->base));
48 fail_unless (GST_CLOCK_TIME_IS_VALID (segment->time));
49 fail_unless (GST_CLOCK_TIME_IS_VALID (segment->position));
57 return GST_PAD_PROBE_OK;
58 } else if (GST_IS_BUFFER (GST_PAD_PROBE_INFO_DATA (info))) {
59 GstBuffer *buf = GST_PAD_PROBE_INFO_BUFFER (info);
61 fail_unless_equals_int (gst_buffer_get_size (buf), data->expected_size);
62 fail_unless_equals_uint64 (GST_BUFFER_PTS (buf), data->expected_time);
65 return GST_PAD_PROBE_DROP;
69 qtdemux_pad_added_cb (GstElement * element, GstPad * pad, CommonTestData * data)
72 gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
73 (GstPadProbeCallback) qtdemux_probe, data, NULL);
76 GST_START_TEST (test_qtdemux_fuzzed0)
80 guchar *fuzzed_qtdemux;
81 gsize fuzzed_qtdemux_len;
83 /* The goal of this test is to check that qtdemux can properly handle
84 * a stream that does not contain any stsd entries, by correctly identifying
85 * the case and erroring out appropriately.
88 h = gst_harness_new_parse ("qtdemux");
89 gst_harness_set_src_caps_str (h, "video/quicktime");
93 ("AAAAIGZ0eXBtcDQyAAAAAG1wNDJtcDQxaXNvbWlzbzIAAAAIZnJlZQAAAMltZGF0AAAADGdCwAyV"
94 "oQkgHhEI1AAAAARozjyAAAAAIWW4AA5///wRRQAfHAxwABAJkxWTk6xWuuuupaupa6668AAAABJB"
95 "4CBX8Zd3d3d3d3d3eJ7E8ZAAAABWQeBAO/wpFAYoDFAYoDFAYkeKAzx4+gAA+kcPHBQGePPHF6jj"
96 "HP0Qdj/og7H/SHY/6jsf9R2P+o7H/Udj/qOx/1HY/6jsf9R2P+o7H/Udj/qOx/1HY/AAAAAGQeBg"
97 "O8IwAAAABkHggDvCMAAAA1dtb292AAAAbG12aGQAAAAA1lbpxdZW6cYAAAfQAAAH0AABAAABAAAA"
98 "AAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAA"
99 "AAAAAAAAAAAAAAAAAAACAAACpnRyYWsAAABcdGtoZAAAAAfWVunF1lbpxgAAAAEAAAAAAAAH0AAA"
100 "AAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAQAAAAEA"
101 "AAAAACRlZHRzAAAAHGVsc3QAAIAAAAAAAQAAB9AAAAAAAAEAAAAAAeFtZGlhAAAAIG1kaGQAAAAA"
102 "1lbpxdZW6cYAAAH0AAAB9FXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZUAAAAAAAAAAAAAAAFZpZGVv"
103 "SGFuZGxlcgAAAAGMbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAA"
104 "AAABAAAADHVybCAAAAABAAABTHN0YmwAAADAc3RzZAAAAAAAAAAAAAAAsGF2YzEAAAAAAAAAAQAA"
105 "AAAAAAAZAAAAAAAAAAAAQABAAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
106 "AAAAAAAAAAAY//8AAAAjYXZjQwFCwAz/4QAMZ0LADJWhCSAeEQjUAQAEaM48gAAAABRidHJ0AAAA"
107 "AAAAAAAAAAYIAAAAE2NvbHJuY2x4AAYAAQAGAAAAABBwYXNwAAAAAQAAAAEAAAAYc3R0cwAAAAAA"
108 "AAABAAAABQAAAAAAAAAUc3RzcwAAAAAAAAABAAAAAQAAABxzdHNjAAAAAAAAAAEAAAABAAAABQAA"
109 "AAEAAAAoc3RzegAAAAAAAAAAAAAAAQAAAAAAAAAWAAAAWgAAAAoAAAAKAAAAFHN0Y28AAAAAAAAA"
110 "AQAAADAAAAA9dWR0YQAAADVtZXRhAAAAAAAAACFoZGxyAAAAAG1obJJtZGlyAAAAAAAAAAAAAAAA"
111 "AAAAAAhpbHN0AAAAPXVkdGEAAAA1bWV0YQAAAAAAAAAhaGRscgAAAABtaGxybWRpcgAAAAAAAAAA"
112 "AAAAAAAAAAAIaWxzdA==", &fuzzed_qtdemux_len);
114 buf = gst_buffer_new_and_alloc (fuzzed_qtdemux_len);
115 gst_buffer_fill (buf, 0, fuzzed_qtdemux, fuzzed_qtdemux_len);
116 fail_unless_equals_int (gst_harness_push (h, buf), GST_FLOW_OK);
118 fail_unless (gst_harness_buffers_received (h) == 0);
120 g_free (fuzzed_qtdemux);
121 gst_harness_teardown (h);
126 GST_START_TEST (test_qtdemux_fuzzed1)
130 guchar *fuzzed_qtdemux;
131 gsize fuzzed_qtdemux_len;
133 /* The goal of this test is to check that qtdemux can properly handle
134 * a stream that claims it contains more stsd entries than it can possibly have,
135 * by correctly identifying the case and erroring out appropriately.
138 h = gst_harness_new_parse ("qtdemux");
139 gst_harness_set_src_caps_str (h, "video/quicktime");
143 ("AAAAIGZ0eXBtcDQyAAAAAG1wNDJtcDQxaXNvbWlzbzIAAAAIZnJlZQAAAMltZGF0AAAADGdCwAyV"
144 "oQkgHhEI1AAAAARozjyAAAAAIWW4BA5///wRRQAfHAxwABAJkxWTk6xWuuuupaupa6668AAAABJB"
145 "4CBX8Zd3d3d3d3d3eJ7E8ZAAAABWQeBAO+opFAYoDFAYoDFAYkeKAzx4oDFAYkcPHBQGePPHF6jj"
146 "HP0Qdj/og7H/SHY/6jsf9R2P+o7H/Udj/qOx/1HY/6jsf9R2P+o7H/Udj/qOx/1HY/AAAAAGQeBg"
147 "O8IwAAAABkHggDvCMAAAA1dtb292AAAAbG12aGQAAAAA1lbpxdZW6cYAAAfQAAAH0AABAAABAAAA"
148 "AAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAA"
149 "AAAAAAAAAAAAAAAAAAACAAACpnRyYWsAAABcdGtoZAAAAAfWVunF1lbpxgAAAAEAAAAAAAAH0AAA"
150 "AAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAQAAAAEA"
151 "AAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAB9AAAAAAAAEAAAAAAeFtZGlhAAAAIG1kaGQAAAAA"
152 "1lbpxdZW6cYAAAH0AAAB9FXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVv"
153 "SGFuZGxlcgAAAAGMbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAA"
154 "AAABAAAADHVybCAAAAABAAABTHN0YmwAAADAc3RzZAAAAADv/wABAAAAsGF2YzEAAAAAAAAAAQAA"
155 "AAAAAAAAAAAAAAAAAAAAQABAAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
156 "AAAAAAAAAAAY//8AAAAjYXZjQwFCwAz/4QAMZ0LADJWhCSAeEQjUAQAEaM48gAAAABRidHJ0AAAA"
157 "AAAAAAAAAAYIAAAAE2NvbHJuY2x4AAYAAQAGAAAAABBwYXNwAAAAAQAAAAEAAAAYc3R0cwAAAAAA"
158 "AAABAAAABQAAAGQAAAAUc3RzcwAAAAAAAAABAAAAAQAAABxzdHNjAAAAAAAAAAEAAAABAAAABQAA"
159 "AAEAAAAoc3RzegAAAAAAAAAAAAAABQAAAD0AAAAWAAAAWgAAAAoAAAAKAAAAFHN0Y28AAAAAAAAA"
160 "AQAAADAAAAA9dWR0YQAAADVtZXRhAAAAAAAAACFoZGxyAAAAAG1obHJtZGlyAAAAAAAAAAAAAAAA"
161 "AAAAAAhpbHN0AAAAPXVkdGEAAAA1bWV0YQAAAAAAAAAhaGRscgAAAABtaGxybWRpcgAAAAAAAAAA"
162 "AAAAAAAAAAAIaWxzdA==", &fuzzed_qtdemux_len);
164 buf = gst_buffer_new_and_alloc (fuzzed_qtdemux_len);
165 gst_buffer_fill (buf, 0, fuzzed_qtdemux, fuzzed_qtdemux_len);
166 fail_unless_equals_int (gst_harness_push (h, buf), GST_FLOW_OK);
168 fail_unless (gst_harness_buffers_received (h) == 0);
170 g_free (fuzzed_qtdemux);
171 gst_harness_teardown (h);
176 GST_START_TEST (test_qtdemux_input_gap)
180 CommonTestData data = { 0, };
187 /* The goal of this test is to check that qtdemux can properly handle
188 * fragmented input from dashdemux, with gaps in it.
193 * - The offset is set on buffers, it corresponds to the offset
194 * within the current fragment.
195 * - Buffer of the beginning of a fragment has the PTS set, others
197 * - By extension, the beginning of a fragment also has an offset
201 qtdemux = gst_element_factory_make ("qtdemux", NULL);
202 gst_element_set_state (qtdemux, GST_STATE_PLAYING);
203 sinkpad = gst_element_get_static_pad (qtdemux, "sink");
205 /* We'll want to know when the source pad is added */
206 g_signal_connect (qtdemux, "pad-added", (GCallback) qtdemux_pad_added_cb,
209 /* Send the initial STREAM_START and segment (TIME) event */
210 event = gst_event_new_stream_start ("TEST");
211 GST_DEBUG ("Pushing stream-start event");
212 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
213 gst_segment_init (&segment, GST_FORMAT_TIME);
214 event = gst_event_new_segment (&segment);
215 GST_DEBUG ("Pushing segment event");
216 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
218 /* Feed the init buffer, should create the source pad */
219 inbuf = gst_buffer_new_and_alloc (init_mp4_len);
220 gst_buffer_fill (inbuf, 0, init_mp4, init_mp4_len);
221 GST_BUFFER_PTS (inbuf) = 0;
222 GST_BUFFER_OFFSET (inbuf) = 0;
223 GST_DEBUG ("Pushing header buffer");
224 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
226 /* Now send the trun of the first fragment */
227 inbuf = gst_buffer_new_and_alloc (seg_1_moof_size);
228 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_moof_size);
229 GST_BUFFER_PTS (inbuf) = 0;
230 GST_BUFFER_OFFSET (inbuf) = 0;
231 /* We are simulating that this fragment can happen at any point */
232 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
233 GST_DEBUG ("Pushing trun buffer");
234 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
235 fail_if (data.srcpad == NULL);
237 /* We are now ready to send some buffers with gaps */
238 offset = seg_1_sample_0_offset;
241 GST_DEBUG ("Pushing gap'ed buffers");
242 for (i = 0; i < 129; i++) {
243 /* Let's send one every 3 */
245 GST_DEBUG ("Pushing buffer #%d offset:%" G_GUINT32_FORMAT, i, offset);
246 inbuf = gst_buffer_new_and_alloc (seg_1_sample_sizes[i]);
247 gst_buffer_fill (inbuf, 0, seg_1_m4f + offset, seg_1_sample_sizes[i]);
248 GST_BUFFER_OFFSET (inbuf) = offset;
249 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
251 gst_util_uint64_scale (pts, GST_SECOND, seg_1_timescale);
252 data.expected_size = seg_1_sample_sizes[i];
253 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
255 /* Finally move offset forward */
256 offset += seg_1_sample_sizes[i];
257 pts += seg_1_sample_duration;
260 gst_object_unref (sinkpad);
261 gst_element_set_state (qtdemux, GST_STATE_NULL);
262 gst_object_unref (qtdemux);
271 GstEventType *expected_events;
274 guint expected_num_srcpad;
278 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
281 GST_STATIC_CAPS_ANY);
284 _sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
286 gst_event_unref (event);
291 _sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
293 gst_buffer_unref (buffer);
297 static GstPadProbeReturn
298 qtdemux_block_for_reconfig (GstPad * pad, GstPadProbeInfo * info,
299 ReconfigTestData * data)
301 fail_unless (data->pending_pad);
302 fail_unless (data->pending_pad == pad);
304 GST_DEBUG_OBJECT (pad, "Unblock pad");
306 if (gst_pad_is_linked (data->sinkpad)) {
307 GstPad *peer = gst_pad_get_peer (data->sinkpad);
309 gst_pad_unlink (peer, data->sinkpad);
312 fail_unless (gst_pad_link (data->pending_pad, data->sinkpad) ==
314 data->pending_pad = NULL;
316 return GST_PAD_PROBE_REMOVE;
319 static GstPadProbeReturn
320 qtdemux_probe_for_reconfig (GstPad * pad, GstPadProbeInfo * info,
321 ReconfigTestData * data)
323 GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
324 GstEventType expected;
326 if (data->step < data->total_step) {
327 expected = data->expected_events[data->step];
329 expected = GST_EVENT_UNKNOWN;
332 GST_DEBUG ("Got event %p %s", event, GST_EVENT_TYPE_NAME (event));
334 fail_unless (GST_EVENT_TYPE (event) == expected,
335 "Received unexpected event: %s (expected: %s)",
336 GST_EVENT_TYPE_NAME (event), gst_event_type_get_name (expected));
339 if (GST_EVENT_TYPE (event) == GST_EVENT_EOS && data->step < data->total_step) {
340 /* If current EOS is for draining, there should be pending srcpad */
341 fail_unless (data->pending_pad != NULL);
344 return GST_PAD_PROBE_OK;
348 qtdemux_pad_added_cb_for_reconfig (GstElement * element, GstPad * pad,
349 ReconfigTestData * data)
353 fail_unless (data->num_srcpad <= data->expected_num_srcpad);
354 fail_unless (data->pending_pad == NULL);
356 GST_DEBUG_OBJECT (pad, "New pad added");
358 data->pending_pad = pad;
359 gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
360 (GstPadProbeCallback) qtdemux_block_for_reconfig, data, NULL);
362 if (!data->sinkpad) {
363 GstPad *sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
365 gst_pad_set_event_function (sinkpad, _sink_event);
366 gst_pad_set_chain_function (sinkpad, _sink_chain);
368 gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
369 (GstPadProbeCallback) qtdemux_probe_for_reconfig, data, NULL);
370 gst_pad_set_active (sinkpad, TRUE);
371 data->sinkpad = sinkpad;
375 GST_START_TEST (test_qtdemux_duplicated_moov)
379 ReconfigTestData data = { 0, };
383 GstEventType expected[] = {
384 GST_EVENT_STREAM_START,
392 data.expected_events = expected;
393 data.expected_num_srcpad = 1;
394 data.total_step = G_N_ELEMENTS (expected);
396 /* The goal of this test is to check that qtdemux can properly handle
397 * duplicated moov without redundant events and pad exposing
400 * - Push events stream-start and segment to qtdemux
401 * - Push init and media data
402 * - Push the same init and media data again
405 * - Expose srcpad only once
406 * - No additional downstream events when the second init and media data is
410 qtdemux = gst_element_factory_make ("qtdemux", NULL);
411 gst_element_set_state (qtdemux, GST_STATE_PLAYING);
412 sinkpad = gst_element_get_static_pad (qtdemux, "sink");
414 /* We'll want to know when the source pad is added */
415 g_signal_connect (qtdemux, "pad-added", (GCallback)
416 qtdemux_pad_added_cb_for_reconfig, &data);
418 /* Send the initial STREAM_START and segment (TIME) event */
419 event = gst_event_new_stream_start ("TEST");
420 GST_DEBUG ("Pushing stream-start event");
421 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
422 gst_segment_init (&segment, GST_FORMAT_TIME);
423 event = gst_event_new_segment (&segment);
424 GST_DEBUG ("Pushing segment event");
425 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
427 /* Feed the init buffer, should create the source pad */
428 inbuf = gst_buffer_new_and_alloc (init_mp4_len);
429 gst_buffer_fill (inbuf, 0, init_mp4, init_mp4_len);
430 GST_BUFFER_PTS (inbuf) = 0;
431 GST_BUFFER_OFFSET (inbuf) = 0;
432 GST_DEBUG ("Pushing moov buffer");
433 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
434 fail_if (data.sinkpad == NULL);
435 fail_unless_equals_int (data.num_srcpad, 1);
437 /* Now send the moof and mdat of the first fragment */
438 inbuf = gst_buffer_new_and_alloc (seg_1_m4f_len);
439 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_m4f_len);
440 GST_BUFFER_PTS (inbuf) = 0;
441 GST_BUFFER_OFFSET (inbuf) = 0;
442 GST_DEBUG ("Pushing moof and mdat buffer");
443 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
445 /* Resend the init, moof and mdat, no additional event and pad are expected */
446 inbuf = gst_buffer_new_and_alloc (init_mp4_len);
447 gst_buffer_fill (inbuf, 0, init_mp4, init_mp4_len);
448 GST_BUFFER_PTS (inbuf) = 0;
449 GST_BUFFER_OFFSET (inbuf) = 0;
450 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
451 GST_DEBUG ("Pushing moov buffer again");
452 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
453 fail_if (data.sinkpad == NULL);
454 fail_unless_equals_int (data.num_srcpad, 1);
456 inbuf = gst_buffer_new_and_alloc (seg_1_m4f_len);
457 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_m4f_len);
458 GST_BUFFER_PTS (inbuf) = 0;
459 GST_BUFFER_OFFSET (inbuf) = init_mp4_len;
460 GST_DEBUG ("Pushing moof and mdat buffer again");
461 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
462 fail_unless (gst_pad_send_event (sinkpad, gst_event_new_eos ()) == TRUE);
463 fail_unless_equals_int (data.step, data.total_step);
464 fail_unless (data.pending_pad == NULL);
466 gst_object_unref (sinkpad);
467 gst_pad_set_active (data.sinkpad, FALSE);
468 gst_object_unref (data.sinkpad);
469 gst_element_set_state (qtdemux, GST_STATE_NULL);
470 gst_object_unref (qtdemux);
475 GST_START_TEST (test_qtdemux_stream_change)
479 ReconfigTestData data = { 0, };
483 const gchar *upstream_id;
484 const gchar *stream_id = NULL;
485 gchar *expected_stream_id = NULL;
487 GstEventType expected[] = {
489 GST_EVENT_STREAM_START,
494 /* 2nd group (track-id change without upstream stream-start) */
496 GST_EVENT_STREAM_START,
501 /* 3rd group (no track-id change with upstream stream-start) */
503 GST_EVENT_STREAM_START,
508 /* last group (track-id change with upstream stream-start) */
510 GST_EVENT_STREAM_START,
518 data.expected_events = expected;
519 data.expected_num_srcpad = 4;
520 data.total_step = G_N_ELEMENTS (expected);
522 /* The goal of this test is to check that qtdemux can properly handle
523 * stream change regardless of track-id change.
524 * This test is simulating DASH bitrate switching (for both playbin and plabyin3)
525 * and period-change for playbin3
527 * NOTE: During bitrate switching in DASH, track-id might be changed
528 * NOTE: stream change with new stream-start to qtdemux is playbin3 specific behaviour,
529 * because playbin configures new demux per period and existing demux never ever get
530 * new stream-start again.
534 * - Push events stream-start and segment to qtdemux
535 * - Push init and media data to qtdemux
537 * - Push different (track-id change) init and media data to qtdemux
538 * without new downstream sticky events to qtdemux
540 * - Push events stream-start and segment to qtdemux again
541 * - Push the init and media data which are the same as GROUP 2
543 * - Push events stream-start and segment to qtdemux again
544 * - Push different (track-id change) init and media data to qtdemux
547 * - Demux exposes srcpad four times, per test GROUP, regardless of track-id change
548 * - Whenever exposing new pads, downstream sticky events should be detected
552 qtdemux = gst_element_factory_make ("qtdemux", NULL);
553 gst_element_set_state (qtdemux, GST_STATE_PLAYING);
554 sinkpad = gst_element_get_static_pad (qtdemux, "sink");
556 /* We'll want to know when the source pad is added */
557 g_signal_connect (qtdemux, "pad-added", (GCallback)
558 qtdemux_pad_added_cb_for_reconfig, &data);
564 /* Send the initial STREAM_START and segment (TIME) event */
565 upstream_id = "TEST-GROUP-1";
567 expected_stream_id = g_strdup_printf ("%s/%03u", upstream_id, track_id);
568 event = gst_event_new_stream_start (upstream_id);
569 GST_DEBUG ("Pushing stream-start event");
570 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
571 gst_segment_init (&segment, GST_FORMAT_TIME);
572 event = gst_event_new_segment (&segment);
573 GST_DEBUG ("Pushing segment event");
574 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
576 /* Feed the init buffer, should create the source pad */
577 inbuf = gst_buffer_new_and_alloc (init_mp4_len);
578 gst_buffer_fill (inbuf, 0, init_mp4, init_mp4_len);
579 GST_BUFFER_PTS (inbuf) = 0;
580 GST_BUFFER_OFFSET (inbuf) = 0;
581 GST_DEBUG ("Pushing moov buffer");
582 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
583 fail_if (data.sinkpad == NULL);
584 fail_unless_equals_int (data.num_srcpad, 1);
586 /* Check stream-id */
587 event = gst_pad_get_sticky_event (data.sinkpad, GST_EVENT_STREAM_START, 0);
588 fail_unless (event != NULL);
589 gst_event_parse_stream_start (event, &stream_id);
590 fail_unless_equals_string (stream_id, expected_stream_id);
591 g_free (expected_stream_id);
592 gst_event_unref (event);
594 /* Now send the moof and mdat of the first fragment */
595 inbuf = gst_buffer_new_and_alloc (seg_1_m4f_len);
596 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_m4f_len);
597 GST_BUFFER_PTS (inbuf) = 0;
598 GST_BUFFER_OFFSET (inbuf) = init_mp4_len;
599 GST_DEBUG ("Pushing moof and mdat buffer");
600 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
606 * - track-id change without new upstream stream-start event
608 /* Resend the init */
609 inbuf = gst_buffer_new_and_alloc (BBB_32k_init_mp4_len);
610 gst_buffer_fill (inbuf, 0, BBB_32k_init_mp4, BBB_32k_init_mp4_len);
611 GST_BUFFER_PTS (inbuf) = 0;
612 GST_BUFFER_OFFSET (inbuf) = 0;
613 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
614 GST_DEBUG ("Pushing moov buffer again");
615 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
616 fail_if (data.sinkpad == NULL);
617 /* new srcpad should be exposed */
618 fail_unless_equals_int (data.num_srcpad, 2);
620 /* Check stream-id */
621 upstream_id = "TEST-GROUP-1"; /* upstream-id does not changed from GROUP 1 */
622 track_id = 1; /* track-id is changed from 2 to 1 */
623 expected_stream_id = g_strdup_printf ("%s/%03u", upstream_id, track_id);
624 event = gst_pad_get_sticky_event (data.sinkpad, GST_EVENT_STREAM_START, 0);
625 fail_unless (event != NULL);
626 gst_event_parse_stream_start (event, &stream_id);
627 fail_unless_equals_string (stream_id, expected_stream_id);
628 g_free (expected_stream_id);
629 gst_event_unref (event);
631 /* push the moof and mdat again */
632 inbuf = gst_buffer_new_and_alloc (BBB_32k_1_mp4_len);
633 gst_buffer_fill (inbuf, 0, BBB_32k_1_mp4, BBB_32k_1_mp4_len);
634 GST_BUFFER_PTS (inbuf) = 0;
635 GST_BUFFER_OFFSET (inbuf) = BBB_32k_init_mp4_len;
636 GST_DEBUG ("Pushing moof and mdat buffer");
637 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
642 * - Push new stream-start and segment to qtdemux
643 * - Reuse init and media data of GROUP 2 (no track-id change)
645 /* Send STREAM_START and segment (TIME) event */
646 upstream_id = "TEST-GROUP-3";
648 expected_stream_id = g_strdup_printf ("%s/%03u", upstream_id, track_id);
649 event = gst_event_new_stream_start (upstream_id);
650 GST_DEBUG ("Pushing stream-start event");
651 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
652 gst_segment_init (&segment, GST_FORMAT_TIME);
653 event = gst_event_new_segment (&segment);
654 GST_DEBUG ("Pushing segment event");
655 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
657 /* Resend the init */
658 inbuf = gst_buffer_new_and_alloc (BBB_32k_init_mp4_len);
659 gst_buffer_fill (inbuf, 0, BBB_32k_init_mp4, BBB_32k_init_mp4_len);
660 GST_BUFFER_PTS (inbuf) = 0;
661 GST_BUFFER_OFFSET (inbuf) = 0;
662 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
663 GST_DEBUG ("Pushing moov buffer again");
664 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
665 fail_if (data.sinkpad == NULL);
666 /* new srcpad should be exposed */
667 fail_unless_equals_int (data.num_srcpad, 3);
669 /* Check stream-id */
670 event = gst_pad_get_sticky_event (data.sinkpad, GST_EVENT_STREAM_START, 0);
671 fail_unless (event != NULL);
672 gst_event_parse_stream_start (event, &stream_id);
673 fail_unless_equals_string (stream_id, expected_stream_id);
674 g_free (expected_stream_id);
675 gst_event_unref (event);
677 /* push the moof and mdat again */
678 inbuf = gst_buffer_new_and_alloc (BBB_32k_1_mp4_len);
679 gst_buffer_fill (inbuf, 0, BBB_32k_1_mp4, BBB_32k_1_mp4_len);
680 GST_BUFFER_PTS (inbuf) = 0;
681 GST_BUFFER_OFFSET (inbuf) = BBB_32k_init_mp4_len;
682 GST_DEBUG ("Pushing moof and mdat buffer");
683 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
688 * - Push new stream-start and segment to qtdemux
689 * - track-id change from 1 to 2
691 /* Send STREAM_START and segment (TIME) event */
692 upstream_id = "TEST-GROUP-4";
694 expected_stream_id = g_strdup_printf ("%s/%03u", upstream_id, track_id);
695 event = gst_event_new_stream_start (upstream_id);
696 GST_DEBUG ("Pushing stream-start event");
697 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
698 gst_segment_init (&segment, GST_FORMAT_TIME);
699 event = gst_event_new_segment (&segment);
700 GST_DEBUG ("Pushing segment event");
701 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
703 /* Resend the init */
704 inbuf = gst_buffer_new_and_alloc (init_mp4_len);
705 gst_buffer_fill (inbuf, 0, init_mp4, init_mp4_len);
706 GST_BUFFER_PTS (inbuf) = 0;
707 GST_BUFFER_OFFSET (inbuf) = 0;
708 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
709 GST_DEBUG ("Pushing moov buffer again");
710 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
711 fail_if (data.sinkpad == NULL);
712 /* new srcpad should be exposed */
713 fail_unless_equals_int (data.num_srcpad, 4);
715 /* Check stream-id */
716 event = gst_pad_get_sticky_event (data.sinkpad, GST_EVENT_STREAM_START, 0);
717 fail_unless (event != NULL);
718 gst_event_parse_stream_start (event, &stream_id);
719 fail_unless_equals_string (stream_id, expected_stream_id);
720 g_free (expected_stream_id);
721 gst_event_unref (event);
723 /* push the moof and mdat again */
724 inbuf = gst_buffer_new_and_alloc (seg_1_m4f_len);
725 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_m4f_len);
726 GST_BUFFER_PTS (inbuf) = 0;
727 GST_BUFFER_OFFSET (inbuf) = init_mp4_len;
728 GST_DEBUG ("Pushing moof and mdat buffer again");
729 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
730 fail_unless (gst_pad_send_event (sinkpad, gst_event_new_eos ()) == TRUE);
731 fail_unless_equals_int (data.step, data.total_step);
732 fail_unless (data.pending_pad == NULL);
734 gst_object_unref (sinkpad);
735 gst_pad_set_active (data.sinkpad, FALSE);
736 gst_object_unref (data.sinkpad);
737 gst_element_set_state (qtdemux, GST_STATE_NULL);
738 gst_object_unref (qtdemux);
744 qtdemux_pad_added_cb_check_name (GstElement * element, GstPad * pad,
747 gchar *pad_name = gst_pad_get_name (pad);
749 GST_DEBUG_OBJECT (pad, "New pad added");
750 fail_unless (!g_strcmp0 (pad_name, data));
754 GST_START_TEST (test_qtdemux_pad_names)
756 GstElement *qtdemux_v;
757 GstElement *qtdemux_a;
759 gchar *expected_video_pad_name;
760 gchar *expected_audio_pad_name;
767 /* The goal of this test is to check that qtdemux can create proper
768 * pad names with encrypted stream caps in mss mode.
771 * - media-caps with cenc
774 * - Demux exposes src pad with names in accordance to their media types
776 expected_video_pad_name = g_strdup ("video_0");
777 qtdemux_v = gst_element_factory_make ("qtdemux", NULL);
778 gst_element_set_state (qtdemux_v, GST_STATE_PLAYING);
779 sinkpad = gst_element_get_static_pad (qtdemux_v, "sink");
781 /* We'll want to know when the source pad is added */
782 g_signal_connect (qtdemux_v, "pad-added", (GCallback)
783 qtdemux_pad_added_cb_check_name, expected_video_pad_name);
785 /* Send the initial STREAM_START and segment (TIME) event */
786 event = gst_event_new_stream_start ("TEST");
787 GST_DEBUG ("Pushing stream-start event");
788 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
790 /* Send CAPS event* */
791 mediacaps = gst_caps_new_simple ("application/x-cenc",
792 "stream-format", G_TYPE_STRING, "avc",
793 "format", G_TYPE_STRING, "H264",
794 "width", G_TYPE_INT, 512,
795 "height", G_TYPE_INT, 288,
796 "original-media-type", G_TYPE_STRING, "video/x-h264",
797 "protection-system", G_TYPE_STRING,
798 "9a04f079-9840-4286-ab92-e65be0885f95", NULL);
800 gst_caps_new_simple ("video/quicktime",
801 "variant", G_TYPE_STRING, "mss-fragmented",
802 "timescale", G_TYPE_UINT64, G_GUINT64_CONSTANT (10000000),
803 "media-caps", GST_TYPE_CAPS, mediacaps, NULL);
805 /* Send segment event* */
806 event = gst_event_new_caps (caps);
807 GST_DEBUG ("Pushing caps event");
808 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
809 gst_caps_unref (mediacaps);
810 gst_caps_unref (caps);
812 gst_segment_init (&segment, GST_FORMAT_TIME);
813 event = gst_event_new_segment (&segment);
814 GST_DEBUG ("Pushing segment event");
815 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
817 /* Send the first fragment */
818 /* NOTE: mss streams don't have moov */
819 inbuf = gst_buffer_new_and_alloc (seg_1_moof_size);
820 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_moof_size);
821 GST_BUFFER_PTS (inbuf) = 0;
822 GST_BUFFER_OFFSET (inbuf) = 0;
823 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
824 GST_DEBUG ("Pushing video fragment");
825 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
827 gst_object_unref (sinkpad);
828 gst_element_set_state (qtdemux_v, GST_STATE_NULL);
829 gst_object_unref (qtdemux_v);
830 g_free (expected_video_pad_name);
832 /* Repeat test for audio media type */
833 expected_audio_pad_name = g_strdup ("audio_0");
834 qtdemux_a = gst_element_factory_make ("qtdemux", NULL);
835 gst_element_set_state (qtdemux_a, GST_STATE_PLAYING);
836 sinkpad = gst_element_get_static_pad (qtdemux_a, "sink");
838 /* We'll want to know when the source pad is added */
839 g_signal_connect (qtdemux_a, "pad-added", (GCallback)
840 qtdemux_pad_added_cb_check_name, expected_audio_pad_name);
842 /* Send the initial STREAM_START and segment (TIME) event */
843 event = gst_event_new_stream_start ("TEST");
844 GST_DEBUG ("Pushing stream-start event");
845 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
847 /* Send CAPS event* */
848 mediacaps = gst_caps_new_simple ("application/x-cenc",
849 "mpegversion", G_TYPE_INT, 4,
850 "channels", G_TYPE_INT, 2,
851 "rate", G_TYPE_INT, 48000,
852 "original-media-type", G_TYPE_STRING, "audio/mpeg",
853 "protection-system", G_TYPE_STRING,
854 "9a04f079-9840-4286-ab92-e65be0885f95", NULL);
856 gst_caps_new_simple ("video/quicktime",
857 "variant", G_TYPE_STRING, "mss-fragmented",
858 "timescale", G_TYPE_UINT64, G_GUINT64_CONSTANT (10000000),
859 "media-caps", GST_TYPE_CAPS, mediacaps, NULL);
861 /* Send segment event* */
862 event = gst_event_new_caps (caps);
863 GST_DEBUG ("Pushing caps event");
864 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
865 gst_caps_unref (mediacaps);
866 gst_caps_unref (caps);
868 gst_segment_init (&segment, GST_FORMAT_TIME);
869 event = gst_event_new_segment (&segment);
870 GST_DEBUG ("Pushing segment event");
871 fail_unless (gst_pad_send_event (sinkpad, event) == TRUE);
873 /* Send the first fragment */
874 /* NOTE: mss streams don't have moov */
875 inbuf = gst_buffer_new_and_alloc (seg_1_moof_size);
876 gst_buffer_fill (inbuf, 0, seg_1_m4f, seg_1_moof_size);
877 GST_BUFFER_PTS (inbuf) = 0;
878 GST_BUFFER_OFFSET (inbuf) = 0;
879 GST_BUFFER_FLAG_SET (inbuf, GST_BUFFER_FLAG_DISCONT);
880 GST_DEBUG ("Pushing audio fragment");
881 fail_unless (gst_pad_chain (sinkpad, inbuf) == GST_FLOW_OK);
883 gst_object_unref (sinkpad);
884 gst_element_set_state (qtdemux_a, GST_STATE_NULL);
885 gst_object_unref (qtdemux_a);
886 g_free (expected_audio_pad_name);
894 Suite *s = suite_create ("qtdemux");
895 TCase *tc_chain = tcase_create ("general");
897 suite_add_tcase (s, tc_chain);
898 tcase_add_test (tc_chain, test_qtdemux_fuzzed0);
899 tcase_add_test (tc_chain, test_qtdemux_fuzzed1);
900 tcase_add_test (tc_chain, test_qtdemux_input_gap);
901 tcase_add_test (tc_chain, test_qtdemux_duplicated_moov);
902 tcase_add_test (tc_chain, test_qtdemux_stream_change);
903 tcase_add_test (tc_chain, test_qtdemux_pad_names);
908 GST_CHECK_MAIN (qtdemux)