tests/check/elements/qtmux.c

   1 /* GStreamer
   2  *
   3  * unit test for qtmux
   4  *
   5  * Copyright (C) <2008> Mark Nauwelaerts <mnauw@users.sf.net>
   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., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #ifdef HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30
  31 #include <gst/check/gstcheck.h>
  32 #include <gst/pbutils/encoding-profile.h>
  33
  34 /* For ease of programming we use globals to keep refs for our floating
  35  * src and sink pads we create; otherwise we always have to do get_pad,
  36  * get_peer, and then remove references in every test function */
  37 static GstPad *mysrcpad, *mysinkpad;
  38
  39 #define AUDIO_CAPS_STRING "audio/mpeg, " \
  40                         "mpegversion = (int) 1, " \
  41                         "layer = (int) 3, " \
  42                         "channels = (int) 2, " \
  43                         "rate = (int) 48000"
  44 #define VIDEO_CAPS_STRING "video/mpeg, " \
  45                            "mpegversion = (int) 4, " \
  46                            "width = (int) 384, " \
  47                            "height = (int) 288, " \
  48                            "framerate = (fraction) 25/1"
  49
  50 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  51     GST_PAD_SINK,
  52     GST_PAD_ALWAYS,
  53     GST_STATIC_CAPS ("video/quicktime"));
  54 static GstStaticPadTemplate srcvideotemplate = GST_STATIC_PAD_TEMPLATE ("src",
  55     GST_PAD_SRC,
  56     GST_PAD_ALWAYS,
  57     GST_STATIC_CAPS (VIDEO_CAPS_STRING));
  58
  59 static GstStaticPadTemplate srcaudiotemplate = GST_STATIC_PAD_TEMPLATE ("src",
  60     GST_PAD_SRC,
  61     GST_PAD_ALWAYS,
  62     GST_STATIC_CAPS (AUDIO_CAPS_STRING));
  63
  64
  65 /* setup and teardown needs some special handling for muxer */
  66 static GstPad *
  67 setup_src_pad (GstElement * element,
  68     GstStaticPadTemplate * template, GstCaps * caps, const gchar * sinkname)
  69 {
  70   GstPad *srcpad, *sinkpad;
  71
  72   GST_DEBUG_OBJECT (element, "setting up sending pad");
  73   /* sending pad */
  74   srcpad = gst_pad_new_from_static_template (template, "src");
  75   fail_if (srcpad == NULL, "Could not create a srcpad");
  76   ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
  77
  78   if (!(sinkpad = gst_element_get_static_pad (element, sinkname)))
  79     sinkpad = gst_element_get_request_pad (element, sinkname);
  80   fail_if (sinkpad == NULL, "Could not get sink pad from %s",
  81       GST_ELEMENT_NAME (element));
  82   /* references are owned by: 1) us, 2) qtmux, 3) collect pads */
  83   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
  84   if (caps)
  85     fail_unless (gst_pad_set_caps (srcpad, caps));
  86   fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK,
  87       "Could not link source and %s sink pads", GST_ELEMENT_NAME (element));
  88   gst_object_unref (sinkpad);   /* because we got it higher up */
  89
  90   /* references are owned by: 1) qtmux, 2) collect pads */
  91   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 2);
  92
  93   return srcpad;
  94 }
  95
  96 static void
  97 teardown_src_pad (GstPad * srcpad)
  98 {
  99   GstPad *sinkpad;
 100
 101   /* clean up floating src pad */
 102   sinkpad = gst_pad_get_peer (srcpad);
 103   fail_if (sinkpad == NULL);
 104   /* pad refs held by 1) qtmux 2) collectpads and 3) us (through _get_peer) */
 105   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
 106
 107   gst_pad_unlink (srcpad, sinkpad);
 108
 109   /* after unlinking, pad refs still held by
 110    * 1) qtmux and 2) collectpads and 3) us (through _get_peer) */
 111   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
 112   gst_object_unref (sinkpad);
 113   /* one more ref is held by element itself */
 114
 115   /* pad refs held by creator */
 116   ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
 117   gst_object_unref (srcpad);
 118 }
 119
 120 static GstElement *
 121 setup_qtmux (GstStaticPadTemplate * srctemplate, const gchar * sinkname)
 122 {
 123   GstElement *qtmux;
 124
 125   GST_DEBUG ("setup_qtmux");
 126   qtmux = gst_check_setup_element ("qtmux");
 127   mysrcpad = setup_src_pad (qtmux, srctemplate, NULL, sinkname);
 128   mysinkpad = gst_check_setup_sink_pad (qtmux, &sinktemplate, NULL);
 129   gst_pad_set_active (mysrcpad, TRUE);
 130   gst_pad_set_active (mysinkpad, TRUE);
 131
 132   return qtmux;
 133 }
 134
 135 static void
 136 cleanup_qtmux (GstElement * qtmux, const gchar * sinkname)
 137 {
 138   GST_DEBUG ("cleanup_qtmux");
 139   gst_element_set_state (qtmux, GST_STATE_NULL);
 140
 141   gst_pad_set_active (mysrcpad, FALSE);
 142   gst_pad_set_active (mysinkpad, FALSE);
 143   teardown_src_pad (mysrcpad);
 144   gst_check_teardown_sink_pad (qtmux);
 145   gst_check_teardown_element (qtmux);
 146 }
 147
 148 static void
 149 check_qtmux_pad (GstStaticPadTemplate * srctemplate, const gchar * sinkname,
 150     guint32 dts_method)
 151 {
 152   GstElement *qtmux;
 153   GstBuffer *inbuffer, *outbuffer;
 154   GstCaps *caps;
 155   int num_buffers;
 156   int i;
 157   guint8 data0[12] = "\000\000\000\024ftypqt  ";
 158   guint8 data1[8] = "\000\000\000\001mdat";
 159   guint8 data2[4] = "moov";
 160
 161   qtmux = setup_qtmux (srctemplate, sinkname);
 162   g_object_set (qtmux, "dts-method", dts_method, NULL);
 163   fail_unless (gst_element_set_state (qtmux,
 164           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 165       "could not set to playing");
 166
 167   inbuffer = gst_buffer_new_and_alloc (1);
 168   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 169   gst_buffer_set_caps (inbuffer, caps);
 170   gst_caps_unref (caps);
 171   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 172   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 173   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 174   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 175
 176   /* send eos to have moov written */
 177   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 178
 179   num_buffers = g_list_length (buffers);
 180   /* at least expect ftyp, mdat header, buffer chunk and moov */
 181   fail_unless (num_buffers >= 4);
 182
 183   for (i = 0; i < num_buffers; ++i) {
 184     outbuffer = GST_BUFFER (buffers->data);
 185     fail_if (outbuffer == NULL);
 186     buffers = g_list_remove (buffers, outbuffer);
 187
 188     switch (i) {
 189       case 0:
 190       {
 191         /* ftyp header */
 192         guint8 *data = GST_BUFFER_DATA (outbuffer);
 193
 194         fail_unless (GST_BUFFER_SIZE (outbuffer) >= 20);
 195         fail_unless (memcmp (data, data0, sizeof (data0)) == 0);
 196         fail_unless (memcmp (data + 16, data0 + 8, 4) == 0);
 197         break;
 198       }
 199       case 1:                  /* mdat header */
 200         fail_unless (GST_BUFFER_SIZE (outbuffer) == 16);
 201         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), data1, sizeof (data1))
 202             == 0);
 203         break;
 204       case 2:                  /* buffer we put in */
 205         fail_unless (GST_BUFFER_SIZE (outbuffer) == 1);
 206         break;
 207       case 3:                  /* moov */
 208         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 209         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data2,
 210                 sizeof (data2)) == 0);
 211         break;
 212       default:
 213         break;
 214     }
 215
 216     ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 217     gst_buffer_unref (outbuffer);
 218     outbuffer = NULL;
 219   }
 220
 221   g_list_free (buffers);
 222   buffers = NULL;
 223
 224   cleanup_qtmux (qtmux, sinkname);
 225 }
 226
 227 static void
 228 check_qtmux_pad_fragmented (GstStaticPadTemplate * srctemplate,
 229     const gchar * sinkname, guint32 dts_method, gboolean streamable)
 230 {
 231   GstElement *qtmux;
 232   GstBuffer *inbuffer, *outbuffer;
 233   GstCaps *caps;
 234   int num_buffers;
 235   int i;
 236   guint8 data0[12] = "\000\000\000\024ftypqt  ";
 237   guint8 data1[4] = "mdat";
 238   guint8 data2[4] = "moov";
 239   guint8 data3[4] = "moof";
 240   guint8 data4[4] = "mfra";
 241
 242   qtmux = setup_qtmux (srctemplate, sinkname);
 243   g_object_set (qtmux, "dts-method", dts_method, NULL);
 244   g_object_set (qtmux, "fragment-duration", 2000, NULL);
 245   g_object_set (qtmux, "streamable", streamable, NULL);
 246   fail_unless (gst_element_set_state (qtmux,
 247           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 248       "could not set to playing");
 249
 250   inbuffer = gst_buffer_new_and_alloc (1);
 251   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 252   gst_buffer_set_caps (inbuffer, caps);
 253   gst_caps_unref (caps);
 254   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 255   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 256   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 257   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 258
 259   /* send eos to have all written */
 260   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 261
 262   num_buffers = g_list_length (buffers);
 263   /* at least expect ftyp, moov, moof, mdat header, buffer chunk
 264    * and optionally mfra */
 265   fail_unless (num_buffers >= 5);
 266
 267   for (i = 0; i < num_buffers; ++i) {
 268     outbuffer = GST_BUFFER (buffers->data);
 269     fail_if (outbuffer == NULL);
 270     buffers = g_list_remove (buffers, outbuffer);
 271
 272     switch (i) {
 273       case 0:
 274       {
 275         /* ftyp header */
 276         guint8 *data = GST_BUFFER_DATA (outbuffer);
 277
 278         fail_unless (GST_BUFFER_SIZE (outbuffer) >= 20);
 279         fail_unless (memcmp (data, data0, sizeof (data0)) == 0);
 280         fail_unless (memcmp (data + 16, data0 + 8, 4) == 0);
 281         break;
 282       }
 283       case 1:                  /* moov */
 284         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 285         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data2,
 286                 sizeof (data2)) == 0);
 287         break;
 288       case 2:                  /* moof */
 289         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 290         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data3,
 291                 sizeof (data3)) == 0);
 292         break;
 293       case 3:                  /* mdat header */
 294         fail_unless (GST_BUFFER_SIZE (outbuffer) == 8);
 295         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data1,
 296                 sizeof (data1)) == 0);
 297         break;
 298       case 4:                  /* buffer we put in */
 299         fail_unless (GST_BUFFER_SIZE (outbuffer) == 1);
 300         break;
 301       case 5:                  /* mfra */
 302         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 303         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data4,
 304                 sizeof (data4)) == 0);
 305         break;
 306       default:
 307         break;
 308     }
 309
 310     ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 311     gst_buffer_unref (outbuffer);
 312     outbuffer = NULL;
 313   }
 314
 315   g_list_free (buffers);
 316   buffers = NULL;
 317
 318   cleanup_qtmux (qtmux, sinkname);
 319 }
 320
 321 /* dts-method dd */
 322
 323 GST_START_TEST (test_video_pad_dd)
 324 {
 325   check_qtmux_pad (&srcvideotemplate, "video_%d", 0);
 326 }
 327
 328 GST_END_TEST;
 329
 330 GST_START_TEST (test_audio_pad_dd)
 331 {
 332   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 0);
 333 }
 334
 335 GST_END_TEST;
 336
 337
 338 GST_START_TEST (test_video_pad_frag_dd)
 339 {
 340   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 0, FALSE);
 341 }
 342
 343 GST_END_TEST;
 344
 345 GST_START_TEST (test_audio_pad_frag_dd)
 346 {
 347   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 0, FALSE);
 348 }
 349
 350 GST_END_TEST;
 351
 352
 353 GST_START_TEST (test_video_pad_frag_dd_streamable)
 354 {
 355   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 0, TRUE);
 356 }
 357
 358 GST_END_TEST;
 359
 360
 361 GST_START_TEST (test_audio_pad_frag_dd_streamable)
 362 {
 363   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 0, TRUE);
 364 }
 365
 366 GST_END_TEST;
 367
 368 /* dts-method reorder */
 369
 370 GST_START_TEST (test_video_pad_reorder)
 371 {
 372   check_qtmux_pad (&srcvideotemplate, "video_%d", 1);
 373 }
 374
 375 GST_END_TEST;
 376
 377 GST_START_TEST (test_audio_pad_reorder)
 378 {
 379   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 1);
 380 }
 381
 382 GST_END_TEST;
 383
 384
 385 GST_START_TEST (test_video_pad_frag_reorder)
 386 {
 387   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 1, FALSE);
 388 }
 389
 390 GST_END_TEST;
 391
 392 GST_START_TEST (test_audio_pad_frag_reorder)
 393 {
 394   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 1, FALSE);
 395 }
 396
 397 GST_END_TEST;
 398
 399
 400 GST_START_TEST (test_video_pad_frag_reorder_streamable)
 401 {
 402   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 1, TRUE);
 403 }
 404
 405 GST_END_TEST;
 406
 407
 408 GST_START_TEST (test_audio_pad_frag_reorder_streamable)
 409 {
 410   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 1, TRUE);
 411 }
 412
 413 GST_END_TEST;
 414
 415 /* dts-method asc */
 416
 417 GST_START_TEST (test_video_pad_asc)
 418 {
 419   check_qtmux_pad (&srcvideotemplate, "video_%d", 2);
 420 }
 421
 422 GST_END_TEST;
 423
 424 GST_START_TEST (test_audio_pad_asc)
 425 {
 426   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 2);
 427 }
 428
 429 GST_END_TEST;
 430
 431
 432 GST_START_TEST (test_video_pad_frag_asc)
 433 {
 434   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 2, FALSE);
 435 }
 436
 437 GST_END_TEST;
 438
 439 GST_START_TEST (test_audio_pad_frag_asc)
 440 {
 441   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 2, FALSE);
 442 }
 443
 444 GST_END_TEST;
 445
 446
 447 GST_START_TEST (test_video_pad_frag_asc_streamable)
 448 {
 449   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 2, TRUE);
 450 }
 451
 452 GST_END_TEST;
 453
 454
 455 GST_START_TEST (test_audio_pad_frag_asc_streamable)
 456 {
 457   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 2, TRUE);
 458 }
 459
 460 GST_END_TEST;
 461
 462 GST_START_TEST (test_reuse)
 463 {
 464   GstElement *qtmux = setup_qtmux (&srcvideotemplate, "video_%d");
 465   GstBuffer *inbuffer;
 466   GstCaps *caps;
 467
 468   gst_element_set_state (qtmux, GST_STATE_PLAYING);
 469   gst_element_set_state (qtmux, GST_STATE_NULL);
 470   gst_element_set_state (qtmux, GST_STATE_PLAYING);
 471   gst_pad_set_active (mysrcpad, TRUE);
 472   gst_pad_set_active (mysinkpad, TRUE);
 473
 474   inbuffer = gst_buffer_new_and_alloc (1);
 475   fail_unless (inbuffer != NULL);
 476   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 477   gst_buffer_set_caps (inbuffer, caps);
 478   gst_caps_unref (caps);
 479   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 480   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 481   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 482   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 483
 484   /* send eos to have all written */
 485   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 486
 487   cleanup_qtmux (qtmux, "video_%d");
 488 }
 489
 490 GST_END_TEST;
 491
 492 static GstEncodingContainerProfile *
 493 create_qtmux_profile (const gchar * variant)
 494 {
 495   GstEncodingContainerProfile *cprof;
 496   GstCaps *caps;
 497
 498   if (variant == NULL) {
 499     caps = gst_caps_new_simple ("video/quicktime", NULL);
 500   } else {
 501     caps = gst_caps_new_simple ("video/quicktime",
 502         "variant", G_TYPE_STRING, variant, NULL);
 503   }
 504
 505   cprof = gst_encoding_container_profile_new ("Name", "blah", caps, NULL);
 506   gst_caps_unref (caps);
 507
 508   caps = gst_caps_new_simple ("audio/x-raw-int", "width", G_TYPE_INT, 16,
 509       "depth", G_TYPE_INT, 16, "endianness", G_TYPE_INT, 4321,
 510       "channels", G_TYPE_INT, 2, "rate", G_TYPE_INT, 44100,
 511       "signed", G_TYPE_BOOLEAN, TRUE, NULL);
 512   gst_encoding_container_profile_add_profile (cprof,
 513       GST_ENCODING_PROFILE (gst_encoding_audio_profile_new (caps, NULL, NULL,
 514               1)));
 515   gst_caps_unref (caps);
 516
 517   return cprof;
 518 }
 519
 520 GST_START_TEST (test_encodebin)
 521 {
 522   GstEncodingContainerProfile *cprof;
 523   GstElement *enc;
 524   GstPad *pad;
 525
 526   enc = gst_element_factory_make ("encodebin", NULL);
 527   if (enc == NULL)
 528     return;
 529
 530   /* Make sure encodebin finds a muxer for a profile with a variant field .. */
 531   cprof = create_qtmux_profile ("apple");
 532   g_object_set (enc, "profile", cprof, NULL);
 533   gst_encoding_profile_unref (cprof);
 534
 535   /* should have created a pad after setting the profile */
 536   pad = gst_element_get_static_pad (enc, "audio_0");
 537   fail_unless (pad != NULL);
 538   gst_object_unref (pad);
 539   gst_object_unref (enc);
 540
 541   /* ... and for a profile without a variant field */
 542   enc = gst_element_factory_make ("encodebin", NULL);
 543   cprof = create_qtmux_profile (NULL);
 544   g_object_set (enc, "profile", cprof, NULL);
 545   gst_encoding_profile_unref (cprof);
 546
 547   /* should have created a pad after setting the profile */
 548   pad = gst_element_get_static_pad (enc, "audio_0");
 549   fail_unless (pad != NULL);
 550   gst_object_unref (pad);
 551   gst_object_unref (enc);
 552 }
 553
 554 GST_END_TEST;
 555
 556 static Suite *
 557 qtmux_suite (void)
 558 {
 559   Suite *s = suite_create ("qtmux");
 560   TCase *tc_chain = tcase_create ("general");
 561
 562   suite_add_tcase (s, tc_chain);
 563   tcase_add_test (tc_chain, test_video_pad_dd);
 564   tcase_add_test (tc_chain, test_audio_pad_dd);
 565   tcase_add_test (tc_chain, test_video_pad_frag_dd);
 566   tcase_add_test (tc_chain, test_audio_pad_frag_dd);
 567   tcase_add_test (tc_chain, test_video_pad_frag_dd_streamable);
 568   tcase_add_test (tc_chain, test_audio_pad_frag_dd_streamable);
 569
 570   tcase_add_test (tc_chain, test_video_pad_reorder);
 571   tcase_add_test (tc_chain, test_audio_pad_reorder);
 572   tcase_add_test (tc_chain, test_video_pad_frag_reorder);
 573   tcase_add_test (tc_chain, test_audio_pad_frag_reorder);
 574   tcase_add_test (tc_chain, test_video_pad_frag_reorder_streamable);
 575   tcase_add_test (tc_chain, test_audio_pad_frag_reorder_streamable);
 576
 577   tcase_add_test (tc_chain, test_video_pad_asc);
 578   tcase_add_test (tc_chain, test_audio_pad_asc);
 579   tcase_add_test (tc_chain, test_video_pad_frag_asc);
 580   tcase_add_test (tc_chain, test_audio_pad_frag_asc);
 581   tcase_add_test (tc_chain, test_video_pad_frag_asc_streamable);
 582   tcase_add_test (tc_chain, test_audio_pad_frag_asc_streamable);
 583
 584   tcase_add_test (tc_chain, test_reuse);
 585   tcase_add_test (tc_chain, test_encodebin);
 586
 587   return s;
 588 }
 589
 590 GST_CHECK_MAIN (qtmux)