subprojects/gst-plugins-good/tests/check/elements/qtdemux.c

   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
  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
  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
  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
 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
 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
 284 _sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 285 {
 286   gst_event_unref (event);
 287   return TRUE;
 288 }
 289
 290 static GstFlowReturn
 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
 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
 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
 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
 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
 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
 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
 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 *
 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)