1 /* GStreamer
2 *
3 * unit test for qtdemux
4 *
5 * Copyright (C) <2016> Edward Hervey <edward@centricular.com>
6 *
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.
11 *
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.
16 *
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.
21 */
22
23 #include "qtdemux.h"
24 #include <glib/gprintf.h>
25 #include <gst/check/gstharness.h>
26
27 typedef struct
28 {
29 GstPad *srcpad;
30 guint expected_size;
31 GstClockTime expected_time;
32 } CommonTestData;
33
34 static GstPadProbeReturn
qtdemux_probe(GstPad * pad,GstPadProbeInfo * info,CommonTestData * data)35 qtdemux_probe (GstPad * pad, GstPadProbeInfo * info, CommonTestData * data)
36 {
37 if (GST_IS_EVENT (GST_PAD_PROBE_INFO_DATA (info))) {
38 GstEvent *ev = GST_PAD_PROBE_INFO_EVENT (info);
39
40 switch (GST_EVENT_TYPE (ev)) {
41 case GST_EVENT_SEGMENT:
42 {
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));
50 break;
51 }
52 break;
53 default:
54 break;
55 }
56
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);
60
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);
63 }
64
65 return GST_PAD_PROBE_DROP;
66 }
67
68 static void
qtdemux_pad_added_cb(GstElement * element,GstPad * pad,CommonTestData * data)69 qtdemux_pad_added_cb (GstElement * element, GstPad * pad, CommonTestData * data)
70 {
71 data->srcpad = pad;
72 gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
73 (GstPadProbeCallback) qtdemux_probe, data, NULL);
74 }
75
GST_START_TEST(test_qtdemux_fuzzed0)76 GST_START_TEST (test_qtdemux_fuzzed0)
77 {
78 GstHarness *h;
79 GstBuffer *buf;
80 guchar *fuzzed_qtdemux;
81 gsize fuzzed_qtdemux_len;
82
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.
86 */
87
88 h = gst_harness_new_parse ("qtdemux");
89 gst_harness_set_src_caps_str (h, "video/quicktime");
90
91 fuzzed_qtdemux =
92 g_base64_decode
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);
113
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);
117
118 fail_unless (gst_harness_buffers_received (h) == 0);
119
120 g_free (fuzzed_qtdemux);
121 gst_harness_teardown (h);
122 }
123
124 GST_END_TEST;
125
GST_START_TEST(test_qtdemux_fuzzed1)126 GST_START_TEST (test_qtdemux_fuzzed1)
127 {
128 GstHarness *h;
129 GstBuffer *buf;
130 guchar *fuzzed_qtdemux;
131 gsize fuzzed_qtdemux_len;
132
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.
136 */
137
138 h = gst_harness_new_parse ("qtdemux");
139 gst_harness_set_src_caps_str (h, "video/quicktime");
140
141 fuzzed_qtdemux =
142 g_base64_decode
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);
163
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);
167
168 fail_unless (gst_harness_buffers_received (h) == 0);
169
170 g_free (fuzzed_qtdemux);
171 gst_harness_teardown (h);
172 }
173
174 GST_END_TEST;
175
GST_START_TEST(test_qtdemux_input_gap)176 GST_START_TEST (test_qtdemux_input_gap)
177 {
178 GstElement *qtdemux;
179 GstPad *sinkpad;
180 CommonTestData data = { 0, };
181 GstBuffer *inbuf;
182 GstSegment segment;
183 GstEvent *event;
184 guint i, offset;
185 GstClockTime pts;
186
187 /* The goal of this test is to check that qtdemux can properly handle
188 * fragmented input from dashdemux, with gaps in it.
189 *
190 * Input segment :
191 * - TIME
192 * Input buffers :
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
196 * don't.
197 * - By extension, the beginning of a fragment also has an offset
198 * of 0.
199 */
200
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");
204
205 /* We'll want to know when the source pad is added */
206 g_signal_connect (qtdemux, "pad-added", (GCallback) qtdemux_pad_added_cb,
207 &data);
208
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);
217
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);
225
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);
236
237 /* We are now ready to send some buffers with gaps */
238 offset = seg_1_sample_0_offset;
239 pts = 0;
240
241 GST_DEBUG ("Pushing gap'ed buffers");
242 for (i = 0; i < 129; i++) {
243 /* Let's send one every 3 */
244 if ((i % 3) == 0) {
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);
250 data.expected_time =
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);
254 }
255 /* Finally move offset forward */
256 offset += seg_1_sample_sizes[i];
257 pts += seg_1_sample_duration;
258 }
259
260 gst_object_unref (sinkpad);
261 gst_element_set_state (qtdemux, GST_STATE_NULL);
262 gst_object_unref (qtdemux);
263 }
264
265 GST_END_TEST;
266
267 typedef struct
268 {
269 GstPad *sinkpad;
270 GstPad *pending_pad;
271 GstEventType *expected_events;
272 guint step;
273 guint total_step;
274 guint expected_num_srcpad;
275 guint num_srcpad;
276 } ReconfigTestData;
277
278 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
279 GST_PAD_SINK,
280 GST_PAD_SOMETIMES,
281 GST_STATIC_CAPS_ANY);
282
283 static gboolean
_sink_event(GstPad * pad,GstObject * parent,GstEvent * event)284 _sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
285 {
286 gst_event_unref (event);
287 return TRUE;
288 }
289
290 static GstFlowReturn
_sink_chain(GstPad * pad,GstObject * parent,GstBuffer * buffer)291 _sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
292 {
293 gst_buffer_unref (buffer);
294 return GST_FLOW_OK;
295 }
296
297 static GstPadProbeReturn
qtdemux_block_for_reconfig(GstPad * pad,GstPadProbeInfo * info,ReconfigTestData * data)298 qtdemux_block_for_reconfig (GstPad * pad, GstPadProbeInfo * info,
299 ReconfigTestData * data)
300 {
301 fail_unless (data->pending_pad);
302 fail_unless (data->pending_pad == pad);
303
304 GST_DEBUG_OBJECT (pad, "Unblock pad");
305
306 if (gst_pad_is_linked (data->sinkpad)) {
307 GstPad *peer = gst_pad_get_peer (data->sinkpad);
308 fail_unless (peer);
309 gst_pad_unlink (peer, data->sinkpad);
310 }
311
312 fail_unless (gst_pad_link (data->pending_pad, data->sinkpad) ==
313 GST_PAD_LINK_OK);
314 data->pending_pad = NULL;
315
316 return GST_PAD_PROBE_REMOVE;
317 }
318
319 static GstPadProbeReturn
qtdemux_probe_for_reconfig(GstPad * pad,GstPadProbeInfo * info,ReconfigTestData * data)320 qtdemux_probe_for_reconfig (GstPad * pad, GstPadProbeInfo * info,
321 ReconfigTestData * data)
322 {
323 GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
324 GstEventType expected;
325
326 if (data->step < data->total_step) {
327 expected = data->expected_events[data->step];
328 } else {
329 expected = GST_EVENT_UNKNOWN;
330 }
331
332 GST_DEBUG ("Got event %p %s", event, GST_EVENT_TYPE_NAME (event));
333
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));
337 data->step++;
338
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);
342 }
343
344 return GST_PAD_PROBE_OK;
345 }
346
347 static void
qtdemux_pad_added_cb_for_reconfig(GstElement * element,GstPad * pad,ReconfigTestData * data)348 qtdemux_pad_added_cb_for_reconfig (GstElement * element, GstPad * pad,
349 ReconfigTestData * data)
350 {
351 data->num_srcpad++;
352
353 fail_unless (data->num_srcpad <= data->expected_num_srcpad);
354 fail_unless (data->pending_pad == NULL);
355
356 GST_DEBUG_OBJECT (pad, "New pad added");
357
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);
361
362 if (!data->sinkpad) {
363 GstPad *sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
364
365 gst_pad_set_event_function (sinkpad, _sink_event);
366 gst_pad_set_chain_function (sinkpad, _sink_chain);
367
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;
372 }
373 }
374
GST_START_TEST(test_qtdemux_duplicated_moov)375 GST_START_TEST (test_qtdemux_duplicated_moov)
376 {
377 GstElement *qtdemux;
378 GstPad *sinkpad;
379 ReconfigTestData data = { 0, };
380 GstBuffer *inbuf;
381 GstSegment segment;
382 GstEvent *event;
383 GstEventType expected[] = {
384 GST_EVENT_STREAM_START,
385 GST_EVENT_CAPS,
386 GST_EVENT_SEGMENT,
387 GST_EVENT_TAG,
388 GST_EVENT_TAG,
389 GST_EVENT_EOS
390 };
391
392 data.expected_events = expected;
393 data.expected_num_srcpad = 1;
394 data.total_step = G_N_ELEMENTS (expected);
395
396 /* The goal of this test is to check that qtdemux can properly handle
397 * duplicated moov without redundant events and pad exposing
398 *
399 * Testing step
400 * - Push events stream-start and segment to qtdemux
401 * - Push init and media data
402 * - Push the same init and media data again
403 *
404 * Expected behaviour
405 * - Expose srcpad only once
406 * - No additional downstream events when the second init and media data is
407 * pushed to qtdemux
408 */
409
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");
413
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);
417
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);
426
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);
436
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);
444
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);
455
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);
465
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);
471 }
472
473 GST_END_TEST;
474
GST_START_TEST(test_qtdemux_stream_change)475 GST_START_TEST (test_qtdemux_stream_change)
476 {
477 GstElement *qtdemux;
478 GstPad *sinkpad;
479 ReconfigTestData data = { 0, };
480 GstBuffer *inbuf;
481 GstSegment segment;
482 GstEvent *event;
483 const gchar *upstream_id;
484 const gchar *stream_id = NULL;
485 gchar *expected_stream_id = NULL;
486 guint track_id;
487 GstEventType expected[] = {
488 /* 1st group */
489 GST_EVENT_STREAM_START,
490 GST_EVENT_CAPS,
491 GST_EVENT_SEGMENT,
492 GST_EVENT_TAG,
493 GST_EVENT_TAG,
494 /* 2nd group (track-id change without upstream stream-start) */
495 GST_EVENT_EOS,
496 GST_EVENT_STREAM_START,
497 GST_EVENT_CAPS,
498 GST_EVENT_SEGMENT,
499 GST_EVENT_TAG,
500 GST_EVENT_TAG,
501 /* 3rd group (no track-id change with upstream stream-start) */
502 GST_EVENT_EOS,
503 GST_EVENT_STREAM_START,
504 GST_EVENT_CAPS,
505 GST_EVENT_SEGMENT,
506 GST_EVENT_TAG,
507 GST_EVENT_TAG,
508 /* last group (track-id change with upstream stream-start) */
509 GST_EVENT_EOS,
510 GST_EVENT_STREAM_START,
511 GST_EVENT_CAPS,
512 GST_EVENT_SEGMENT,
513 GST_EVENT_TAG,
514 GST_EVENT_TAG,
515 GST_EVENT_EOS
516 };
517
518 data.expected_events = expected;
519 data.expected_num_srcpad = 4;
520 data.total_step = G_N_ELEMENTS (expected);
521
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
526 *
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.
531 *
532 * Testing step
533 * [GROUP 1]
534 * - Push events stream-start and segment to qtdemux
535 * - Push init and media data to qtdemux
536 * [GROUP 2]
537 * - Push different (track-id change) init and media data to qtdemux
538 * without new downstream sticky events to qtdemux
539 * [GROUP 3]
540 * - Push events stream-start and segment to qtdemux again
541 * - Push the init and media data which are the same as GROUP 2
542 * [GROUP 4]
543 * - Push events stream-start and segment to qtdemux again
544 * - Push different (track-id change) init and media data to qtdemux
545 *
546 * Expected behaviour
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
549 * at demux srcpad
550 */
551
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");
555
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);
559
560 /***************
561 * TEST GROUP 1
562 * (track-id: 2)
563 **************/
564 /* Send the initial STREAM_START and segment (TIME) event */
565 upstream_id = "TEST-GROUP-1";
566 track_id = 2;
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);
575
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);
585
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);
593
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);
601
602
603 /***************
604 * TEST GROUP 2
605 * (track-id: 1)
606 * - track-id change without new upstream stream-start event
607 **************/
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);
619
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);
630
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);
638
639 /***************
640 * TEST GROUP 3
641 * (track-id: 1)
642 * - Push new stream-start and segment to qtdemux
643 * - Reuse init and media data of GROUP 2 (no track-id change)
644 **************/
645 /* Send STREAM_START and segment (TIME) event */
646 upstream_id = "TEST-GROUP-3";
647 track_id = 1;
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);
656
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);
668
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);
676
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);
684
685 /***************
686 * TEST GROUP 4
687 * (track-id: 2)
688 * - Push new stream-start and segment to qtdemux
689 * - track-id change from 1 to 2
690 **************/
691 /* Send STREAM_START and segment (TIME) event */
692 upstream_id = "TEST-GROUP-4";
693 track_id = 2;
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);
702
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);
714
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);
722
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);
733
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);
739 }
740
741 GST_END_TEST;
742
743 static void
qtdemux_pad_added_cb_check_name(GstElement * element,GstPad * pad,gchar * data)744 qtdemux_pad_added_cb_check_name (GstElement * element, GstPad * pad,
745 gchar * data)
746 {
747 gchar *pad_name = gst_pad_get_name (pad);
748
749 GST_DEBUG_OBJECT (pad, "New pad added");
750 fail_unless (!g_strcmp0 (pad_name, data));
751 g_free (pad_name);
752 }
753
GST_START_TEST(test_qtdemux_pad_names)754 GST_START_TEST (test_qtdemux_pad_names)
755 {
756 GstElement *qtdemux_v;
757 GstElement *qtdemux_a;
758 GstPad *sinkpad;
759 gchar *expected_video_pad_name;
760 gchar *expected_audio_pad_name;
761 GstBuffer *inbuf;
762 GstSegment segment;
763 GstEvent *event;
764 GstCaps *caps;
765 GstCaps *mediacaps;
766
767 /* The goal of this test is to check that qtdemux can create proper
768 * pad names with encrypted stream caps in mss mode.
769 *
770 * Input Caps:
771 * - media-caps with cenc
772 *
773 * Expected behaviour
774 * - Demux exposes src pad with names in accordance to their media types
775 */
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");
780
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);
784
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);
789
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);
799 caps =
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);
804
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);
811
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);
816
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);
826
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);
831
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");
837
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);
841
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);
846
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);
855 caps =
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);
860
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);
867
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);
872
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);
882
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);
887 }
888
889 GST_END_TEST;
890
891 static Suite *
qtdemux_suite(void)892 qtdemux_suite (void)
893 {
894 Suite *s = suite_create ("qtdemux");
895 TCase *tc_chain = tcase_create ("general");
896
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);
904
905 return s;
906 }
907
908 GST_CHECK_MAIN (qtdemux)
909