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 <glib/gstdio.h>
  32
  33 #include <gst/check/gstcheck.h>
  34 #include <gst/pbutils/encoding-profile.h>
  35
  36 /* For ease of programming we use globals to keep refs for our floating
  37  * src and sink pads we create; otherwise we always have to do get_pad,
  38  * get_peer, and then remove references in every test function */
  39 static GstPad *mysrcpad, *mysinkpad;
  40
  41 #define AUDIO_CAPS_STRING "audio/mpeg, " \
  42                         "mpegversion = (int) 1, " \
  43                         "layer = (int) 3, " \
  44                         "channels = (int) 2, " \
  45                         "rate = (int) 48000"
  46
  47 #define AUDIO_AAC_CAPS_STRING "audio/mpeg, " \
  48                             "mpegversion=(int)4, " \
  49                             "channels=(int)1, " \
  50                             "rate=(int)44100, " \
  51                             "stream-format=(string)raw, " \
  52                             "level=(string)2, " \
  53                             "base-profile=(string)lc, " \
  54                             "profile=(string)lc, " \
  55                             "codec_data=(buffer)1208"
  56
  57 #define VIDEO_CAPS_STRING "video/mpeg, " \
  58                            "mpegversion = (int) 4, " \
  59                            "systemstream = (boolean) false, " \
  60                            "width = (int) 384, " \
  61                            "height = (int) 288, " \
  62                            "framerate = (fraction) 25/1"
  63
  64 #define VIDEO_CAPS_H264_STRING "video/x-h264, " \
  65                                "width=(int)320, " \
  66                                "height=(int)240, " \
  67                                "framerate=(fraction)30/1, " \
  68                                "pixel-aspect-ratio=(fraction)1/1, " \
  69                                "codec_data=(buffer)01640014ffe1001867640014a" \
  70                                    "cd94141fb0110000003001773594000f14299600" \
  71                                    "1000568ebecb22c, " \
  72                                "stream-format=(string)avc, " \
  73                                "alignment=(string)au, " \
  74                                "level=(string)2, " \
  75                                "profile=(string)high"
  76
  77 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  78     GST_PAD_SINK,
  79     GST_PAD_ALWAYS,
  80     GST_STATIC_CAPS ("video/quicktime"));
  81 static GstStaticPadTemplate srcvideotemplate = GST_STATIC_PAD_TEMPLATE ("src",
  82     GST_PAD_SRC,
  83     GST_PAD_ALWAYS,
  84     GST_STATIC_CAPS (VIDEO_CAPS_STRING));
  85
  86 static GstStaticPadTemplate srcvideoh264template =
  87 GST_STATIC_PAD_TEMPLATE ("src",
  88     GST_PAD_SRC,
  89     GST_PAD_ALWAYS,
  90     GST_STATIC_CAPS (VIDEO_CAPS_H264_STRING));
  91
  92 static GstStaticPadTemplate srcaudiotemplate = GST_STATIC_PAD_TEMPLATE ("src",
  93     GST_PAD_SRC,
  94     GST_PAD_ALWAYS,
  95     GST_STATIC_CAPS (AUDIO_CAPS_STRING));
  96
  97 static GstStaticPadTemplate srcaudioaactemplate =
  98 GST_STATIC_PAD_TEMPLATE ("src",
  99     GST_PAD_SRC,
 100     GST_PAD_ALWAYS,
 101     GST_STATIC_CAPS (AUDIO_AAC_CAPS_STRING));
 102
 103 /* setup and teardown needs some special handling for muxer */
 104 static GstPad *
 105 setup_src_pad (GstElement * element,
 106     GstStaticPadTemplate * template, GstCaps * caps, const gchar * sinkname)
 107 {
 108   GstPad *srcpad, *sinkpad;
 109
 110   GST_DEBUG_OBJECT (element, "setting up sending pad");
 111   /* sending pad */
 112   srcpad = gst_pad_new_from_static_template (template, "src");
 113   fail_if (srcpad == NULL, "Could not create a srcpad");
 114   ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
 115
 116   if (!(sinkpad = gst_element_get_static_pad (element, sinkname)))
 117     sinkpad = gst_element_get_request_pad (element, sinkname);
 118   fail_if (sinkpad == NULL, "Could not get sink pad from %s",
 119       GST_ELEMENT_NAME (element));
 120   /* references are owned by: 1) us, 2) qtmux, 3) collect pads */
 121   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
 122   if (caps)
 123     fail_unless (gst_pad_set_caps (srcpad, caps));
 124   fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK,
 125       "Could not link source and %s sink pads", GST_ELEMENT_NAME (element));
 126   gst_object_unref (sinkpad);   /* because we got it higher up */
 127
 128   /* references are owned by: 1) qtmux, 2) collect pads */
 129   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 2);
 130
 131   return srcpad;
 132 }
 133
 134 static void
 135 teardown_src_pad (GstPad * srcpad)
 136 {
 137   GstPad *sinkpad;
 138
 139   /* clean up floating src pad */
 140   sinkpad = gst_pad_get_peer (srcpad);
 141   fail_if (sinkpad == NULL);
 142   /* pad refs held by 1) qtmux 2) collectpads and 3) us (through _get_peer) */
 143   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
 144
 145   gst_pad_unlink (srcpad, sinkpad);
 146
 147   /* after unlinking, pad refs still held by
 148    * 1) qtmux and 2) collectpads and 3) us (through _get_peer) */
 149   ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3);
 150   gst_object_unref (sinkpad);
 151   /* one more ref is held by element itself */
 152
 153   /* pad refs held by creator */
 154   ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
 155   gst_object_unref (srcpad);
 156 }
 157
 158 static GstElement *
 159 setup_qtmux (GstStaticPadTemplate * srctemplate, const gchar * sinkname)
 160 {
 161   GstElement *qtmux;
 162
 163   GST_DEBUG ("setup_qtmux");
 164   qtmux = gst_check_setup_element ("qtmux");
 165   mysrcpad = setup_src_pad (qtmux, srctemplate, NULL, sinkname);
 166   mysinkpad = gst_check_setup_sink_pad (qtmux, &sinktemplate, NULL);
 167   gst_pad_set_active (mysrcpad, TRUE);
 168   gst_pad_set_active (mysinkpad, TRUE);
 169
 170   return qtmux;
 171 }
 172
 173 static void
 174 cleanup_qtmux (GstElement * qtmux, const gchar * sinkname)
 175 {
 176   GST_DEBUG ("cleanup_qtmux");
 177   gst_element_set_state (qtmux, GST_STATE_NULL);
 178
 179   gst_pad_set_active (mysrcpad, FALSE);
 180   gst_pad_set_active (mysinkpad, FALSE);
 181   teardown_src_pad (mysrcpad);
 182   gst_check_teardown_sink_pad (qtmux);
 183   gst_check_teardown_element (qtmux);
 184 }
 185
 186 static void
 187 check_qtmux_pad (GstStaticPadTemplate * srctemplate, const gchar * sinkname,
 188     guint32 dts_method)
 189 {
 190   GstElement *qtmux;
 191   GstBuffer *inbuffer, *outbuffer;
 192   GstCaps *caps;
 193   int num_buffers;
 194   int i;
 195   guint8 data0[12] = "\000\000\000\024ftypqt  ";
 196   guint8 data1[8] = "\000\000\000\001mdat";
 197   guint8 data2[4] = "moov";
 198
 199   qtmux = setup_qtmux (srctemplate, sinkname);
 200   g_object_set (qtmux, "dts-method", dts_method, NULL);
 201   fail_unless (gst_element_set_state (qtmux,
 202           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 203       "could not set to playing");
 204
 205   inbuffer = gst_buffer_new_and_alloc (1);
 206   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 207   gst_buffer_set_caps (inbuffer, caps);
 208   gst_caps_unref (caps);
 209   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 210   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 211   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 212   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 213
 214   /* send eos to have moov written */
 215   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 216
 217   num_buffers = g_list_length (buffers);
 218   /* at least expect ftyp, mdat header, buffer chunk and moov */
 219   fail_unless (num_buffers >= 4);
 220
 221   for (i = 0; i < num_buffers; ++i) {
 222     outbuffer = GST_BUFFER (buffers->data);
 223     fail_if (outbuffer == NULL);
 224     buffers = g_list_remove (buffers, outbuffer);
 225
 226     switch (i) {
 227       case 0:
 228       {
 229         /* ftyp header */
 230         guint8 *data = GST_BUFFER_DATA (outbuffer);
 231
 232         fail_unless (GST_BUFFER_SIZE (outbuffer) >= 20);
 233         fail_unless (memcmp (data, data0, sizeof (data0)) == 0);
 234         fail_unless (memcmp (data + 16, data0 + 8, 4) == 0);
 235         break;
 236       }
 237       case 1:                  /* mdat header */
 238         fail_unless (GST_BUFFER_SIZE (outbuffer) == 16);
 239         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), data1, sizeof (data1))
 240             == 0);
 241         break;
 242       case 2:                  /* buffer we put in */
 243         fail_unless (GST_BUFFER_SIZE (outbuffer) == 1);
 244         break;
 245       case 3:                  /* moov */
 246         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 247         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data2,
 248                 sizeof (data2)) == 0);
 249         break;
 250       default:
 251         break;
 252     }
 253
 254     ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 255     gst_buffer_unref (outbuffer);
 256     outbuffer = NULL;
 257   }
 258
 259   g_list_free (buffers);
 260   buffers = NULL;
 261
 262   cleanup_qtmux (qtmux, sinkname);
 263 }
 264
 265 static void
 266 check_qtmux_pad_fragmented (GstStaticPadTemplate * srctemplate,
 267     const gchar * sinkname, guint32 dts_method, gboolean streamable)
 268 {
 269   GstElement *qtmux;
 270   GstBuffer *inbuffer, *outbuffer;
 271   GstCaps *caps;
 272   int num_buffers;
 273   int i;
 274   guint8 data0[12] = "\000\000\000\024ftypqt  ";
 275   guint8 data1[4] = "mdat";
 276   guint8 data2[4] = "moov";
 277   guint8 data3[4] = "moof";
 278   guint8 data4[4] = "mfra";
 279
 280   qtmux = setup_qtmux (srctemplate, sinkname);
 281   g_object_set (qtmux, "dts-method", dts_method, NULL);
 282   g_object_set (qtmux, "fragment-duration", 2000, NULL);
 283   g_object_set (qtmux, "streamable", streamable, NULL);
 284   fail_unless (gst_element_set_state (qtmux,
 285           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 286       "could not set to playing");
 287
 288   inbuffer = gst_buffer_new_and_alloc (1);
 289   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 290   gst_buffer_set_caps (inbuffer, caps);
 291   gst_caps_unref (caps);
 292   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 293   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 294   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 295   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 296
 297   /* send eos to have all written */
 298   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 299
 300   num_buffers = g_list_length (buffers);
 301   /* at least expect ftyp, moov, moof, mdat header, buffer chunk
 302    * and optionally mfra */
 303   fail_unless (num_buffers >= 5);
 304
 305   for (i = 0; i < num_buffers; ++i) {
 306     outbuffer = GST_BUFFER (buffers->data);
 307     fail_if (outbuffer == NULL);
 308     buffers = g_list_remove (buffers, outbuffer);
 309
 310     switch (i) {
 311       case 0:
 312       {
 313         /* ftyp header */
 314         guint8 *data = GST_BUFFER_DATA (outbuffer);
 315
 316         fail_unless (GST_BUFFER_SIZE (outbuffer) >= 20);
 317         fail_unless (memcmp (data, data0, sizeof (data0)) == 0);
 318         fail_unless (memcmp (data + 16, data0 + 8, 4) == 0);
 319         break;
 320       }
 321       case 1:                  /* moov */
 322         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 323         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data2,
 324                 sizeof (data2)) == 0);
 325         break;
 326       case 2:                  /* moof */
 327         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 328         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data3,
 329                 sizeof (data3)) == 0);
 330         break;
 331       case 3:                  /* mdat header */
 332         fail_unless (GST_BUFFER_SIZE (outbuffer) == 8);
 333         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data1,
 334                 sizeof (data1)) == 0);
 335         break;
 336       case 4:                  /* buffer we put in */
 337         fail_unless (GST_BUFFER_SIZE (outbuffer) == 1);
 338         break;
 339       case 5:                  /* mfra */
 340         fail_unless (GST_BUFFER_SIZE (outbuffer) > 8);
 341         fail_unless (memcmp (GST_BUFFER_DATA (outbuffer) + 4, data4,
 342                 sizeof (data4)) == 0);
 343         break;
 344       default:
 345         break;
 346     }
 347
 348     ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 349     gst_buffer_unref (outbuffer);
 350     outbuffer = NULL;
 351   }
 352
 353   g_list_free (buffers);
 354   buffers = NULL;
 355
 356   cleanup_qtmux (qtmux, sinkname);
 357 }
 358
 359 /* dts-method dd */
 360
 361 GST_START_TEST (test_video_pad_dd)
 362 {
 363   check_qtmux_pad (&srcvideotemplate, "video_%d", 0);
 364 }
 365
 366 GST_END_TEST;
 367
 368 GST_START_TEST (test_audio_pad_dd)
 369 {
 370   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 0);
 371 }
 372
 373 GST_END_TEST;
 374
 375
 376 GST_START_TEST (test_video_pad_frag_dd)
 377 {
 378   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 0, FALSE);
 379 }
 380
 381 GST_END_TEST;
 382
 383 GST_START_TEST (test_audio_pad_frag_dd)
 384 {
 385   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 0, FALSE);
 386 }
 387
 388 GST_END_TEST;
 389
 390
 391 GST_START_TEST (test_video_pad_frag_dd_streamable)
 392 {
 393   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 0, TRUE);
 394 }
 395
 396 GST_END_TEST;
 397
 398
 399 GST_START_TEST (test_audio_pad_frag_dd_streamable)
 400 {
 401   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 0, TRUE);
 402 }
 403
 404 GST_END_TEST;
 405
 406 /* dts-method reorder */
 407
 408 GST_START_TEST (test_video_pad_reorder)
 409 {
 410   check_qtmux_pad (&srcvideotemplate, "video_%d", 1);
 411 }
 412
 413 GST_END_TEST;
 414
 415 GST_START_TEST (test_audio_pad_reorder)
 416 {
 417   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 1);
 418 }
 419
 420 GST_END_TEST;
 421
 422
 423 GST_START_TEST (test_video_pad_frag_reorder)
 424 {
 425   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 1, FALSE);
 426 }
 427
 428 GST_END_TEST;
 429
 430 GST_START_TEST (test_audio_pad_frag_reorder)
 431 {
 432   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 1, FALSE);
 433 }
 434
 435 GST_END_TEST;
 436
 437
 438 GST_START_TEST (test_video_pad_frag_reorder_streamable)
 439 {
 440   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 1, TRUE);
 441 }
 442
 443 GST_END_TEST;
 444
 445
 446 GST_START_TEST (test_audio_pad_frag_reorder_streamable)
 447 {
 448   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 1, TRUE);
 449 }
 450
 451 GST_END_TEST;
 452
 453 /* dts-method asc */
 454
 455 GST_START_TEST (test_video_pad_asc)
 456 {
 457   check_qtmux_pad (&srcvideotemplate, "video_%d", 2);
 458 }
 459
 460 GST_END_TEST;
 461
 462 GST_START_TEST (test_audio_pad_asc)
 463 {
 464   check_qtmux_pad (&srcaudiotemplate, "audio_%d", 2);
 465 }
 466
 467 GST_END_TEST;
 468
 469
 470 GST_START_TEST (test_video_pad_frag_asc)
 471 {
 472   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 2, FALSE);
 473 }
 474
 475 GST_END_TEST;
 476
 477 GST_START_TEST (test_audio_pad_frag_asc)
 478 {
 479   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 2, FALSE);
 480 }
 481
 482 GST_END_TEST;
 483
 484
 485 GST_START_TEST (test_video_pad_frag_asc_streamable)
 486 {
 487   check_qtmux_pad_fragmented (&srcvideotemplate, "video_%d", 2, TRUE);
 488 }
 489
 490 GST_END_TEST;
 491
 492
 493 GST_START_TEST (test_audio_pad_frag_asc_streamable)
 494 {
 495   check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%d", 2, TRUE);
 496 }
 497
 498 GST_END_TEST;
 499
 500 GST_START_TEST (test_reuse)
 501 {
 502   GstElement *qtmux = setup_qtmux (&srcvideotemplate, "video_%d");
 503   GstBuffer *inbuffer;
 504   GstCaps *caps;
 505
 506   gst_element_set_state (qtmux, GST_STATE_PLAYING);
 507   gst_element_set_state (qtmux, GST_STATE_NULL);
 508   gst_element_set_state (qtmux, GST_STATE_PLAYING);
 509   gst_pad_set_active (mysrcpad, TRUE);
 510   gst_pad_set_active (mysinkpad, TRUE);
 511
 512   inbuffer = gst_buffer_new_and_alloc (1);
 513   fail_unless (inbuffer != NULL);
 514   caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 515   gst_buffer_set_caps (inbuffer, caps);
 516   gst_caps_unref (caps);
 517   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
 518   GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND;
 519   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 520   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 521
 522   /* send eos to have all written */
 523   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 524
 525   cleanup_qtmux (qtmux, "video_%d");
 526 }
 527
 528 GST_END_TEST;
 529
 530 static GstEncodingContainerProfile *
 531 create_qtmux_profile (const gchar * variant)
 532 {
 533   GstEncodingContainerProfile *cprof;
 534   GstCaps *caps;
 535
 536   if (variant == NULL) {
 537     caps = gst_caps_new_simple ("video/quicktime", NULL);
 538   } else {
 539     caps = gst_caps_new_simple ("video/quicktime",
 540         "variant", G_TYPE_STRING, variant, NULL);
 541   }
 542
 543   cprof = gst_encoding_container_profile_new ("Name", "blah", caps, NULL);
 544   gst_caps_unref (caps);
 545
 546   caps = gst_caps_new_simple ("audio/x-raw-int", "width", G_TYPE_INT, 16,
 547       "depth", G_TYPE_INT, 16, "endianness", G_TYPE_INT, 4321,
 548       "channels", G_TYPE_INT, 2, "rate", G_TYPE_INT, 44100,
 549       "signed", G_TYPE_BOOLEAN, TRUE, NULL);
 550   gst_encoding_container_profile_add_profile (cprof,
 551       GST_ENCODING_PROFILE (gst_encoding_audio_profile_new (caps, NULL, NULL,
 552               1)));
 553   gst_caps_unref (caps);
 554
 555   return cprof;
 556 }
 557
 558 GST_START_TEST (test_encodebin_qtmux)
 559 {
 560   GstEncodingContainerProfile *cprof;
 561   GstElement *enc;
 562   GstPad *pad;
 563
 564   enc = gst_element_factory_make ("encodebin", NULL);
 565   if (enc == NULL)
 566     return;
 567
 568   /* Make sure encodebin finds a muxer for a profile with a variant field .. */
 569   cprof = create_qtmux_profile ("apple");
 570   g_object_set (enc, "profile", cprof, NULL);
 571   gst_encoding_profile_unref (cprof);
 572
 573   /* should have created a pad after setting the profile */
 574   pad = gst_element_get_static_pad (enc, "audio_0");
 575   fail_unless (pad != NULL);
 576   gst_object_unref (pad);
 577   gst_object_unref (enc);
 578
 579   /* ... and for a profile without a variant field */
 580   enc = gst_element_factory_make ("encodebin", NULL);
 581   cprof = create_qtmux_profile (NULL);
 582   g_object_set (enc, "profile", cprof, NULL);
 583   gst_encoding_profile_unref (cprof);
 584
 585   /* should have created a pad after setting the profile */
 586   pad = gst_element_get_static_pad (enc, "audio_0");
 587   fail_unless (pad != NULL);
 588   gst_object_unref (pad);
 589   gst_object_unref (enc);
 590 }
 591
 592 GST_END_TEST;
 593
 594 /* Fake mp3 encoder for test */
 595 typedef GstElement TestMp3Enc;
 596 typedef GstElementClass TestMp3EncClass;
 597
 598 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
 599     GST_PAD_SRC,
 600     GST_PAD_ALWAYS,
 601     GST_STATIC_CAPS ("audio/mpeg, mpegversion=1, layer=[1,3]")
 602     );
 603
 604 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
 605     GST_PAD_SINK,
 606     GST_PAD_ALWAYS,
 607     GST_STATIC_CAPS ("audio/x-raw-int")
 608     );
 609
 610 static GType test_mp3_enc_get_type (void);
 611
 612 GST_BOILERPLATE (TestMp3Enc, test_mp3_enc, GstElement, GST_TYPE_ELEMENT);
 613
 614 static void
 615 test_mp3_enc_base_init (gpointer klass)
 616 {
 617   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 618
 619   gst_element_class_add_static_pad_template (element_class, &sink_template);
 620   gst_element_class_add_static_pad_template (element_class, &src_template);
 621
 622   gst_element_class_set_details_simple (element_class, "MPEG1 Audio Encoder",
 623       "Codec/Encoder/Audio", "Pretends to encode mp3", "Foo Bar <foo@bar.com>");
 624 }
 625
 626 static void
 627 test_mp3_enc_class_init (TestMp3EncClass * klass)
 628 {
 629   /* doesn't actually need to do anything for this test */
 630 }
 631
 632 static void
 633 test_mp3_enc_init (TestMp3Enc * mp3enc, TestMp3EncClass * klass)
 634 {
 635   GstPad *pad;
 636
 637   pad = gst_pad_new_from_static_template (&sink_template, "sink");
 638   gst_element_add_pad (mp3enc, pad);
 639
 640   pad = gst_pad_new_from_static_template (&src_template, "src");
 641   gst_element_add_pad (mp3enc, pad);
 642 }
 643
 644 static gboolean
 645 plugin_init (GstPlugin * plugin)
 646 {
 647   return gst_element_register (plugin, "testmp3enc", GST_RANK_NONE,
 648       test_mp3_enc_get_type ());
 649 }
 650
 651 static GstEncodingContainerProfile *
 652 create_mp4mux_profile (void)
 653 {
 654   GstEncodingContainerProfile *cprof;
 655   GstCaps *caps;
 656
 657   caps = gst_caps_new_simple ("video/quicktime",
 658       "variant", G_TYPE_STRING, "iso", NULL);
 659
 660   cprof = gst_encoding_container_profile_new ("Name", "blah", caps, NULL);
 661   gst_caps_unref (caps);
 662
 663   caps = gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 1,
 664       "layer", G_TYPE_INT, 3, "channels", G_TYPE_INT, 2, "rate", G_TYPE_INT,
 665       44100, NULL);
 666   gst_encoding_container_profile_add_profile (cprof,
 667       GST_ENCODING_PROFILE (gst_encoding_audio_profile_new (caps, NULL, NULL,
 668               1)));
 669   gst_caps_unref (caps);
 670
 671   return cprof;
 672 }
 673
 674 GST_START_TEST (test_encodebin_mp4mux)
 675 {
 676   GstEncodingContainerProfile *cprof;
 677   GstPluginFeature *feature;
 678   GstElement *enc, *mux;
 679   GstPad *pad;
 680
 681   /* need a fake mp3 encoder because mp4 only accepts encoded formats */
 682   gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
 683       "fakemp3enc", "fakemp3enc", plugin_init, VERSION, "LGPL",
 684       "gst-plugins-good", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
 685
 686   feature = gst_default_registry_find_feature ("testmp3enc",
 687       GST_TYPE_ELEMENT_FACTORY);
 688   gst_plugin_feature_set_rank (feature, GST_RANK_PRIMARY + 100);
 689
 690   enc = gst_element_factory_make ("encodebin", NULL);
 691   if (enc == NULL)
 692     return;
 693
 694   /* Make sure encodebin finds mp4mux even though qtmux outputs a superset */
 695   cprof = create_mp4mux_profile ();
 696   g_object_set (enc, "profile", cprof, NULL);
 697   gst_encoding_profile_unref (cprof);
 698
 699   /* should have created a pad after setting the profile */
 700   pad = gst_element_get_static_pad (enc, "audio_0");
 701   fail_unless (pad != NULL);
 702   gst_object_unref (pad);
 703
 704   mux = gst_bin_get_by_interface (GST_BIN (enc), GST_TYPE_TAG_SETTER);
 705   fail_unless (mux != NULL);
 706   {
 707     GstElementFactory *f = gst_element_get_factory (mux);
 708
 709     /* make sure we got mp4mux for variant=iso */
 710     GST_INFO ("muxer: %s", G_OBJECT_TYPE_NAME (mux));
 711     fail_unless_equals_string (GST_PLUGIN_FEATURE_NAME (f), "mp4mux");
 712   }
 713   gst_object_unref (mux);
 714   gst_object_unref (enc);
 715
 716   gst_plugin_feature_set_rank (feature, GST_RANK_NONE);
 717   gst_object_unref (feature);
 718 }
 719
 720 GST_END_TEST;
 721
 722 static gboolean
 723 extract_tags (const gchar * location, GstTagList ** taglist)
 724 {
 725   gboolean ret = TRUE;
 726   GstElement *src;
 727   GstBus *bus;
 728   GstElement *pipeline =
 729       gst_parse_launch ("filesrc name=src ! qtdemux ! fakesink", NULL);
 730
 731   src = gst_bin_get_by_name (GST_BIN (pipeline), "src");
 732   g_object_set (src, "location", location, NULL);
 733
 734   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
 735   fail_unless (gst_element_set_state (pipeline, GST_STATE_PLAYING)
 736       != GST_STATE_CHANGE_FAILURE);
 737
 738   if (*taglist == NULL) {
 739     *taglist = gst_tag_list_new ();
 740   }
 741
 742   while (1) {
 743     GstMessage *msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE,
 744         GST_MESSAGE_TAG | GST_MESSAGE_ERROR | GST_MESSAGE_EOS);
 745
 746     if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS) {
 747       gst_message_unref (msg);
 748       break;
 749     } else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) {
 750       ret = FALSE;
 751       gst_message_unref (msg);
 752       break;
 753     } else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_TAG) {
 754       GstTagList *tags;
 755
 756       gst_message_parse_tag (msg, &tags);
 757       gst_tag_list_insert (*taglist, tags, GST_TAG_MERGE_REPLACE);
 758       gst_tag_list_free (tags);
 759     }
 760     gst_message_unref (msg);
 761   }
 762
 763   gst_object_unref (bus);
 764   gst_element_set_state (pipeline, GST_STATE_NULL);
 765   gst_object_unref (src);
 766   gst_object_unref (pipeline);
 767   return ret;
 768 }
 769
 770 static void
 771 test_average_bitrate_custom (const gchar * elementname,
 772     GstStaticPadTemplate * tmpl, const gchar * sinkpadname)
 773 {
 774   gchar *location;
 775   GstElement *qtmux;
 776   GstElement *filesink;
 777   GstBuffer *inbuffer;
 778   GstCaps *caps;
 779   int i;
 780   gint bytes[] = { 16, 22, 12 };
 781   gint64 durations[] = { GST_SECOND * 3, GST_SECOND * 5, GST_SECOND * 2 };
 782   gint64 total_bytes = 0;
 783   GstClockTime total_duration = 0;
 784
 785   location = g_strdup_printf ("%s/%s-%d", g_get_tmp_dir (), "qtmuxtest",
 786       g_random_int ());
 787   GST_INFO ("Using location %s for bitrate test", location);
 788   qtmux = gst_check_setup_element (elementname);
 789   filesink = gst_element_factory_make ("filesink", NULL);
 790   g_object_set (filesink, "location", location, NULL);
 791   gst_element_link (qtmux, filesink);
 792   mysrcpad = setup_src_pad (qtmux, tmpl, NULL, sinkpadname);
 793   fail_unless (mysrcpad != NULL);
 794   gst_pad_set_active (mysrcpad, TRUE);
 795
 796   fail_unless (gst_element_set_state (filesink,
 797           GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
 798       "could not set filesink to playing");
 799   fail_unless (gst_element_set_state (qtmux,
 800           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 801       "could not set to playing");
 802
 803   for (i = 0; i < 3; i++) {
 804     inbuffer = gst_buffer_new_and_alloc (bytes[i]);
 805     caps = gst_caps_copy (gst_pad_get_pad_template_caps (mysrcpad));
 806     gst_buffer_set_caps (inbuffer, caps);
 807     gst_caps_unref (caps);
 808     GST_BUFFER_TIMESTAMP (inbuffer) = total_duration;
 809     GST_BUFFER_DURATION (inbuffer) = (GstClockTime) durations[i];
 810     ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 811
 812     total_bytes += GST_BUFFER_SIZE (inbuffer);
 813     total_duration += GST_BUFFER_DURATION (inbuffer);
 814     fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 815   }
 816
 817   /* send eos to have moov written */
 818   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
 819
 820   gst_element_set_state (qtmux, GST_STATE_NULL);
 821   gst_element_set_state (filesink, GST_STATE_NULL);
 822
 823   gst_pad_set_active (mysrcpad, FALSE);
 824   teardown_src_pad (mysrcpad);
 825   gst_object_unref (filesink);
 826   gst_check_teardown_element (qtmux);
 827
 828   /* check the bitrate tag */
 829   {
 830     GstTagList *taglist = NULL;
 831     guint bitrate = 0;
 832     guint expected;
 833
 834     fail_unless (extract_tags (location, &taglist));
 835
 836     fail_unless (gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &bitrate));
 837
 838     expected =
 839         (guint) gst_util_uint64_scale_round ((guint64) total_bytes,
 840         (guint64) 8 * GST_SECOND, (guint64) total_duration);
 841     fail_unless (bitrate == expected);
 842     gst_tag_list_free (taglist);
 843   }
 844
 845   /* delete file */
 846   g_unlink (location);
 847   g_free (location);
 848 }
 849
 850 GST_START_TEST (test_average_bitrate)
 851 {
 852   test_average_bitrate_custom ("mp4mux", &srcaudioaactemplate, "audio_%d");
 853   test_average_bitrate_custom ("mp4mux", &srcvideoh264template, "video_%d");
 854
 855   test_average_bitrate_custom ("qtmux", &srcaudioaactemplate, "audio_%d");
 856   test_average_bitrate_custom ("qtmux", &srcvideoh264template, "video_%d");
 857 }
 858
 859 GST_END_TEST;
 860
 861
 862 static Suite *
 863 qtmux_suite (void)
 864 {
 865   Suite *s = suite_create ("qtmux");
 866   TCase *tc_chain = tcase_create ("general");
 867
 868   suite_add_tcase (s, tc_chain);
 869   tcase_add_test (tc_chain, test_video_pad_dd);
 870   tcase_add_test (tc_chain, test_audio_pad_dd);
 871   tcase_add_test (tc_chain, test_video_pad_frag_dd);
 872   tcase_add_test (tc_chain, test_audio_pad_frag_dd);
 873   tcase_add_test (tc_chain, test_video_pad_frag_dd_streamable);
 874   tcase_add_test (tc_chain, test_audio_pad_frag_dd_streamable);
 875
 876   tcase_add_test (tc_chain, test_video_pad_reorder);
 877   tcase_add_test (tc_chain, test_audio_pad_reorder);
 878   tcase_add_test (tc_chain, test_video_pad_frag_reorder);
 879   tcase_add_test (tc_chain, test_audio_pad_frag_reorder);
 880   tcase_add_test (tc_chain, test_video_pad_frag_reorder_streamable);
 881   tcase_add_test (tc_chain, test_audio_pad_frag_reorder_streamable);
 882
 883   tcase_add_test (tc_chain, test_video_pad_asc);
 884   tcase_add_test (tc_chain, test_audio_pad_asc);
 885   tcase_add_test (tc_chain, test_video_pad_frag_asc);
 886   tcase_add_test (tc_chain, test_audio_pad_frag_asc);
 887   tcase_add_test (tc_chain, test_video_pad_frag_asc_streamable);
 888   tcase_add_test (tc_chain, test_audio_pad_frag_asc_streamable);
 889
 890   tcase_add_test (tc_chain, test_average_bitrate);
 891
 892   tcase_add_test (tc_chain, test_reuse);
 893   tcase_add_test (tc_chain, test_encodebin_qtmux);
 894   tcase_add_test (tc_chain, test_encodebin_mp4mux);
 895
 896   return s;
 897 }
 898
 899 GST_CHECK_MAIN (qtmux)