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