tests/check/elements/audiomixer.c

   1 /* GStreamer
   2  *
   3  * unit test for audiomixer
   4  *
   5  * Copyright (C) 2005 Thomas Vander Stichele <thomas at apestaart dot org>
   6  * Copyright (C) 2013 Sebastian Dröge <sebastian@centricular.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #ifdef HAVE_VALGRIND
  29 # include <valgrind/valgrind.h>
  30 #endif
  31
  32 #include <gst/check/gstharness.h>
  33
  34 #include <gst/check/gstcheck.h>
  35 #include <gst/check/gstconsistencychecker.h>
  36 #include <gst/audio/audio.h>
  37 #include <gst/base/gstbasesrc.h>
  38 #include <gst/controller/gstdirectcontrolbinding.h>
  39 #include <gst/controller/gstinterpolationcontrolsource.h>
  40
  41 static GMainLoop *main_loop;
  42
  43 /* fixtures */
  44
  45 static void
  46 test_setup (void)
  47 {
  48   main_loop = g_main_loop_new (NULL, FALSE);
  49 }
  50
  51 static void
  52 test_teardown (void)
  53 {
  54   g_main_loop_unref (main_loop);
  55   main_loop = NULL;
  56 }
  57
  58
  59 /* some test helpers */
  60
  61 static GstElement *
  62 setup_pipeline (GstElement * audiomixer, gint num_srcs, GstElement * capsfilter)
  63 {
  64   GstElement *pipeline, *src, *sink;
  65   gint i;
  66
  67   pipeline = gst_pipeline_new ("pipeline");
  68   if (!audiomixer) {
  69     audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
  70   }
  71
  72   sink = gst_element_factory_make ("fakesink", "sink");
  73   gst_bin_add_many (GST_BIN (pipeline), audiomixer, sink, NULL);
  74
  75   if (capsfilter) {
  76     gst_bin_add (GST_BIN (pipeline), capsfilter);
  77     gst_element_link_many (audiomixer, capsfilter, sink, NULL);
  78   } else {
  79     gst_element_link (audiomixer, sink);
  80   }
  81
  82   for (i = 0; i < num_srcs; i++) {
  83     src = gst_element_factory_make ("audiotestsrc", NULL);
  84     g_object_set (src, "wave", 4, NULL);        /* silence */
  85     gst_bin_add (GST_BIN (pipeline), src);
  86     gst_element_link (src, audiomixer);
  87   }
  88   return pipeline;
  89 }
  90
  91 static GstCaps *
  92 get_element_sink_pad_caps (GstElement * pipeline, const gchar * element_name)
  93 {
  94   GstElement *sink;
  95   GstCaps *caps;
  96   GstPad *pad;
  97
  98   sink = gst_bin_get_by_name (GST_BIN (pipeline), "sink");
  99   pad = gst_element_get_static_pad (sink, "sink");
 100   caps = gst_pad_get_current_caps (pad);
 101   gst_object_unref (pad);
 102   gst_object_unref (sink);
 103
 104   return caps;
 105 }
 106
 107 static void
 108 set_state_and_wait (GstElement * pipeline, GstState state)
 109 {
 110   GstStateChangeReturn state_res;
 111
 112   /* prepare paused/playing */
 113   state_res = gst_element_set_state (pipeline, state);
 114   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 115
 116   /* wait for preroll */
 117   state_res = gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 118   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 119 }
 120
 121 static gboolean
 122 set_playing (GstElement * element)
 123 {
 124   GstStateChangeReturn state_res;
 125
 126   state_res = gst_element_set_state (element, GST_STATE_PLAYING);
 127   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 128
 129   return FALSE;
 130 }
 131
 132 static void
 133 play_and_wait (GstElement * pipeline)
 134 {
 135   GstStateChangeReturn state_res;
 136
 137   g_idle_add ((GSourceFunc) set_playing, pipeline);
 138
 139   GST_INFO ("running main loop");
 140   g_main_loop_run (main_loop);
 141
 142   state_res = gst_element_set_state (pipeline, GST_STATE_NULL);
 143   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 144 }
 145
 146 static void
 147 message_received (GstBus * bus, GstMessage * message, GstPipeline * bin)
 148 {
 149   GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
 150       GST_MESSAGE_SRC (message), message);
 151
 152   switch (message->type) {
 153     case GST_MESSAGE_EOS:
 154       g_main_loop_quit (main_loop);
 155       break;
 156     case GST_MESSAGE_WARNING:{
 157       GError *gerror;
 158       gchar *debug;
 159
 160       gst_message_parse_warning (message, &gerror, &debug);
 161       gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
 162       g_error_free (gerror);
 163       g_free (debug);
 164       break;
 165     }
 166     case GST_MESSAGE_ERROR:{
 167       GError *gerror;
 168       gchar *debug;
 169
 170       gst_message_parse_error (message, &gerror, &debug);
 171       gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
 172       g_error_free (gerror);
 173       g_free (debug);
 174       g_main_loop_quit (main_loop);
 175       break;
 176     }
 177     default:
 178       break;
 179   }
 180 }
 181
 182 static GstBuffer *
 183 new_buffer (gsize num_bytes, gint data, GstClockTime ts, GstClockTime dur,
 184     GstBufferFlags flags)
 185 {
 186   GstMapInfo map;
 187   GstBuffer *buffer = gst_buffer_new_and_alloc (num_bytes);
 188
 189   gst_buffer_map (buffer, &map, GST_MAP_WRITE);
 190   memset (map.data, data, map.size);
 191   gst_buffer_unmap (buffer, &map);
 192   GST_BUFFER_TIMESTAMP (buffer) = ts;
 193   GST_BUFFER_DURATION (buffer) = dur;
 194   if (flags)
 195     GST_BUFFER_FLAG_SET (buffer, flags);
 196   GST_DEBUG ("created buffer %p", buffer);
 197   return buffer;
 198 }
 199
 200 /* make sure downstream gets a CAPS event before buffers are sent */
 201 GST_START_TEST (test_caps)
 202 {
 203   GstElement *pipeline;
 204   GstCaps *caps;
 205
 206   /* build pipeline */
 207   pipeline = setup_pipeline (NULL, 1, NULL);
 208
 209   /* prepare playing */
 210   set_state_and_wait (pipeline, GST_STATE_PAUSED);
 211
 212   /* check caps on fakesink */
 213   caps = get_element_sink_pad_caps (pipeline, "sink");
 214   fail_unless (caps != NULL);
 215   gst_caps_unref (caps);
 216
 217   gst_element_set_state (pipeline, GST_STATE_NULL);
 218   gst_object_unref (pipeline);
 219 }
 220
 221 GST_END_TEST;
 222
 223 /* check that caps set on the property are honoured */
 224 GST_START_TEST (test_filter_caps)
 225 {
 226   GstElement *pipeline, *audiomixer, *capsfilter;
 227   GstCaps *filter_caps, *caps;
 228
 229   filter_caps = gst_caps_new_simple ("audio/x-raw",
 230       "format", G_TYPE_STRING, GST_AUDIO_NE (F32),
 231       "layout", G_TYPE_STRING, "interleaved",
 232       "rate", G_TYPE_INT, 44100, "channels", G_TYPE_INT, 1,
 233       "channel-mask", GST_TYPE_BITMASK, (guint64) 0x04, NULL);
 234
 235   capsfilter = gst_element_factory_make ("capsfilter", NULL);
 236
 237   /* build pipeline */
 238   audiomixer = gst_element_factory_make ("audiomixer", NULL);
 239   g_object_set (capsfilter, "caps", filter_caps, NULL);
 240   pipeline = setup_pipeline (audiomixer, 1, capsfilter);
 241
 242   /* prepare playing */
 243   set_state_and_wait (pipeline, GST_STATE_PAUSED);
 244
 245   /* check caps on fakesink */
 246   caps = get_element_sink_pad_caps (pipeline, "sink");
 247   fail_unless (caps != NULL);
 248   GST_INFO_OBJECT (pipeline, "received caps: %" GST_PTR_FORMAT, caps);
 249   fail_unless (gst_caps_is_equal_fixed (caps, filter_caps));
 250   gst_caps_unref (caps);
 251
 252   gst_element_set_state (pipeline, GST_STATE_NULL);
 253   gst_object_unref (pipeline);
 254
 255   gst_caps_unref (filter_caps);
 256 }
 257
 258 GST_END_TEST;
 259
 260 static GstFormat format = GST_FORMAT_UNDEFINED;
 261 static gint64 position = -1;
 262
 263 static void
 264 test_event_message_received (GstBus * bus, GstMessage * message,
 265     GstPipeline * bin)
 266 {
 267   GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
 268       GST_MESSAGE_SRC (message), message);
 269
 270   switch (message->type) {
 271     case GST_MESSAGE_SEGMENT_DONE:
 272       gst_message_parse_segment_done (message, &format, &position);
 273       GST_INFO ("received segment_done : %" G_GINT64_FORMAT, position);
 274       g_main_loop_quit (main_loop);
 275       break;
 276     default:
 277       g_assert_not_reached ();
 278       break;
 279   }
 280 }
 281
 282
 283 GST_START_TEST (test_event)
 284 {
 285   GstElement *bin, *src1, *src2, *audiomixer, *sink;
 286   GstBus *bus;
 287   GstEvent *seek_event;
 288   gboolean res;
 289   GstPad *srcpad, *sinkpad;
 290   GstStreamConsistency *chk_1, *chk_2, *chk_3;
 291
 292   GST_INFO ("preparing test");
 293
 294   /* build pipeline */
 295   bin = gst_pipeline_new ("pipeline");
 296   bus = gst_element_get_bus (bin);
 297   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 298
 299   src1 = gst_element_factory_make ("audiotestsrc", "src1");
 300   g_object_set (src1, "wave", 4, NULL); /* silence */
 301   src2 = gst_element_factory_make ("audiotestsrc", "src2");
 302   g_object_set (src2, "wave", 4, NULL); /* silence */
 303   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 304   sink = gst_element_factory_make ("fakesink", "sink");
 305   gst_bin_add_many (GST_BIN (bin), src1, src2, audiomixer, sink, NULL);
 306
 307   res = gst_element_link (src1, audiomixer);
 308   fail_unless (res == TRUE, NULL);
 309   res = gst_element_link (src2, audiomixer);
 310   fail_unless (res == TRUE, NULL);
 311   res = gst_element_link (audiomixer, sink);
 312   fail_unless (res == TRUE, NULL);
 313
 314   srcpad = gst_element_get_static_pad (audiomixer, "src");
 315   chk_3 = gst_consistency_checker_new (srcpad);
 316   gst_object_unref (srcpad);
 317
 318   /* create consistency checkers for the pads */
 319   srcpad = gst_element_get_static_pad (src1, "src");
 320   chk_1 = gst_consistency_checker_new (srcpad);
 321   sinkpad = gst_pad_get_peer (srcpad);
 322   gst_consistency_checker_add_pad (chk_3, sinkpad);
 323   gst_object_unref (sinkpad);
 324   gst_object_unref (srcpad);
 325
 326   srcpad = gst_element_get_static_pad (src2, "src");
 327   chk_2 = gst_consistency_checker_new (srcpad);
 328   sinkpad = gst_pad_get_peer (srcpad);
 329   gst_consistency_checker_add_pad (chk_3, sinkpad);
 330   gst_object_unref (sinkpad);
 331   gst_object_unref (srcpad);
 332
 333   seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
 334       GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH,
 335       GST_SEEK_TYPE_SET, (GstClockTime) 0,
 336       GST_SEEK_TYPE_SET, (GstClockTime) 2 * GST_SECOND);
 337
 338   format = GST_FORMAT_UNDEFINED;
 339   position = -1;
 340
 341   g_signal_connect (bus, "message::segment-done",
 342       (GCallback) test_event_message_received, bin);
 343   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 344   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 345   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 346
 347   GST_INFO ("starting test");
 348
 349   /* prepare playing */
 350   set_state_and_wait (bin, GST_STATE_PAUSED);
 351
 352   res = gst_element_send_event (bin, seek_event);
 353   fail_unless (res == TRUE, NULL);
 354
 355   /* run pipeline */
 356   play_and_wait (bin);
 357
 358   ck_assert_int_eq (position, 2 * GST_SECOND);
 359
 360   /* cleanup */
 361   gst_consistency_checker_free (chk_1);
 362   gst_consistency_checker_free (chk_2);
 363   gst_consistency_checker_free (chk_3);
 364   gst_bus_remove_signal_watch (bus);
 365   gst_object_unref (bus);
 366   gst_object_unref (bin);
 367 }
 368
 369 GST_END_TEST;
 370
 371 static guint play_count = 0;
 372 static GstEvent *play_seek_event = NULL;
 373
 374 static void
 375 test_play_twice_message_received (GstBus * bus, GstMessage * message,
 376     GstElement * bin)
 377 {
 378   gboolean res;
 379   GstStateChangeReturn state_res;
 380
 381   GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
 382       GST_MESSAGE_SRC (message), message);
 383
 384   switch (message->type) {
 385     case GST_MESSAGE_SEGMENT_DONE:
 386       play_count++;
 387       if (play_count == 1) {
 388         state_res = gst_element_set_state (bin, GST_STATE_READY);
 389         ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 390
 391         /* prepare playing again */
 392         set_state_and_wait (bin, GST_STATE_PAUSED);
 393
 394         gst_event_set_seqnum (play_seek_event, gst_util_seqnum_next ());
 395         res = gst_element_send_event (bin, gst_event_ref (play_seek_event));
 396         fail_unless (res == TRUE, NULL);
 397
 398         state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
 399         ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 400       } else {
 401         g_main_loop_quit (main_loop);
 402       }
 403       break;
 404     default:
 405       g_assert_not_reached ();
 406       break;
 407   }
 408 }
 409
 410
 411 GST_START_TEST (test_play_twice)
 412 {
 413   GstElement *bin, *audiomixer;
 414   GstBus *bus;
 415   gboolean res;
 416   GstPad *srcpad;
 417   GstStreamConsistency *consist;
 418
 419   GST_INFO ("preparing test");
 420
 421   /* build pipeline */
 422   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 423   bin = setup_pipeline (audiomixer, 2, NULL);
 424   bus = gst_element_get_bus (bin);
 425   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 426
 427   srcpad = gst_element_get_static_pad (audiomixer, "src");
 428   consist = gst_consistency_checker_new (srcpad);
 429   gst_object_unref (srcpad);
 430
 431   play_seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
 432       GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH,
 433       GST_SEEK_TYPE_SET, (GstClockTime) 0,
 434       GST_SEEK_TYPE_SET, (GstClockTime) 2 * GST_SECOND);
 435
 436   play_count = 0;
 437
 438   g_signal_connect (bus, "message::segment-done",
 439       (GCallback) test_play_twice_message_received, bin);
 440   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 441   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 442   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 443
 444   GST_INFO ("starting test");
 445
 446   /* prepare playing */
 447   set_state_and_wait (bin, GST_STATE_PAUSED);
 448
 449   gst_event_set_seqnum (play_seek_event, gst_util_seqnum_next ());
 450   res = gst_element_send_event (bin, gst_event_ref (play_seek_event));
 451   fail_unless (res == TRUE, NULL);
 452
 453   GST_INFO ("seeked");
 454
 455   /* run pipeline */
 456   play_and_wait (bin);
 457
 458   ck_assert_int_eq (play_count, 2);
 459
 460   /* cleanup */
 461   gst_consistency_checker_free (consist);
 462   gst_event_unref (play_seek_event);
 463   gst_bus_remove_signal_watch (bus);
 464   gst_object_unref (bus);
 465   gst_object_unref (bin);
 466 }
 467
 468 GST_END_TEST;
 469
 470 GST_START_TEST (test_play_twice_then_add_and_play_again)
 471 {
 472   GstElement *bin, *src, *audiomixer;
 473   GstBus *bus;
 474   gboolean res;
 475   GstStateChangeReturn state_res;
 476   gint i;
 477   GstPad *srcpad;
 478   GstStreamConsistency *consist;
 479
 480   GST_INFO ("preparing test");
 481
 482   /* build pipeline */
 483   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 484   bin = setup_pipeline (audiomixer, 2, NULL);
 485   bus = gst_element_get_bus (bin);
 486   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 487
 488   srcpad = gst_element_get_static_pad (audiomixer, "src");
 489   consist = gst_consistency_checker_new (srcpad);
 490   gst_object_unref (srcpad);
 491
 492   play_seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
 493       GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH,
 494       GST_SEEK_TYPE_SET, (GstClockTime) 0,
 495       GST_SEEK_TYPE_SET, (GstClockTime) 2 * GST_SECOND);
 496
 497   g_signal_connect (bus, "message::segment-done",
 498       (GCallback) test_play_twice_message_received, bin);
 499   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 500   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 501   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 502
 503   /* run it twice */
 504   for (i = 0; i < 2; i++) {
 505     play_count = 0;
 506
 507     GST_INFO ("starting test-loop %d", i);
 508
 509     /* prepare playing */
 510     set_state_and_wait (bin, GST_STATE_PAUSED);
 511
 512     gst_event_set_seqnum (play_seek_event, gst_util_seqnum_next ());
 513     res = gst_element_send_event (bin, gst_event_ref (play_seek_event));
 514     fail_unless (res == TRUE, NULL);
 515
 516     GST_INFO ("seeked");
 517
 518     /* run pipeline */
 519     play_and_wait (bin);
 520
 521     ck_assert_int_eq (play_count, 2);
 522
 523     /* plug another source */
 524     if (i == 0) {
 525       src = gst_element_factory_make ("audiotestsrc", NULL);
 526       g_object_set (src, "wave", 4, NULL);      /* silence */
 527       gst_bin_add (GST_BIN (bin), src);
 528
 529       res = gst_element_link (src, audiomixer);
 530       fail_unless (res == TRUE, NULL);
 531     }
 532
 533     gst_consistency_checker_reset (consist);
 534   }
 535
 536   state_res = gst_element_set_state (bin, GST_STATE_NULL);
 537   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 538
 539   /* cleanup */
 540   gst_event_unref (play_seek_event);
 541   gst_consistency_checker_free (consist);
 542   gst_bus_remove_signal_watch (bus);
 543   gst_object_unref (bus);
 544   gst_object_unref (bin);
 545 }
 546
 547 GST_END_TEST;
 548
 549 /* test failing seeks on live-sources */
 550 GST_START_TEST (test_live_seeking)
 551 {
 552   GstElement *bin, *src1 = NULL, *cf, *src2, *audiomixer, *sink;
 553   GstCaps *caps;
 554   GstBus *bus;
 555   gboolean res;
 556   GstPad *srcpad;
 557   GstPad *sinkpad;
 558   gint i;
 559   GstStreamConsistency *consist;
 560
 561   GST_INFO ("preparing test");
 562   play_seek_event = NULL;
 563
 564   /* build pipeline */
 565   bin = gst_pipeline_new ("pipeline");
 566   bus = gst_element_get_bus (bin);
 567   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 568
 569   src1 = gst_element_factory_make ("audiotestsrc", "src1");
 570   g_object_set (src1, "wave", 4, "is-live", TRUE, NULL);        /* silence */
 571
 572   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 573   cf = gst_element_factory_make ("capsfilter", "capsfilter");
 574   sink = gst_element_factory_make ("fakesink", "sink");
 575
 576   gst_bin_add_many (GST_BIN (bin), src1, cf, audiomixer, sink, NULL);
 577   res = gst_element_link_many (src1, cf, audiomixer, sink, NULL);
 578   fail_unless (res == TRUE, NULL);
 579
 580   /* get the caps for the livesrc, we'll reuse this for the non-live source */
 581   set_state_and_wait (bin, GST_STATE_PLAYING);
 582
 583   sinkpad = gst_element_get_static_pad (sink, "sink");
 584   fail_unless (sinkpad != NULL);
 585   caps = gst_pad_get_current_caps (sinkpad);
 586   fail_unless (caps != NULL);
 587   gst_object_unref (sinkpad);
 588
 589   gst_element_set_state (bin, GST_STATE_NULL);
 590
 591   g_object_set (cf, "caps", caps, NULL);
 592
 593   src2 = gst_element_factory_make ("audiotestsrc", "src2");
 594   g_object_set (src2, "wave", 4, NULL); /* silence */
 595   gst_bin_add (GST_BIN (bin), src2);
 596
 597   res = gst_element_link_filtered (src2, audiomixer, caps);
 598   fail_unless (res == TRUE, NULL);
 599
 600   gst_caps_unref (caps);
 601
 602   play_seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
 603       GST_SEEK_FLAG_FLUSH,
 604       GST_SEEK_TYPE_SET, (GstClockTime) 0,
 605       GST_SEEK_TYPE_SET, (GstClockTime) 2 * GST_SECOND);
 606
 607   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 608   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 609   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 610
 611   srcpad = gst_element_get_static_pad (audiomixer, "src");
 612   consist = gst_consistency_checker_new (srcpad);
 613   gst_object_unref (srcpad);
 614
 615   GST_INFO ("starting test");
 616
 617   /* run it twice */
 618   for (i = 0; i < 2; i++) {
 619
 620     GST_INFO ("starting test-loop %d", i);
 621
 622     /* prepare playing */
 623     set_state_and_wait (bin, GST_STATE_PAUSED);
 624
 625     gst_event_set_seqnum (play_seek_event, gst_util_seqnum_next ());
 626     res = gst_element_send_event (bin, gst_event_ref (play_seek_event));
 627     fail_unless (res == TRUE, NULL);
 628
 629     GST_INFO ("seeked");
 630
 631     /* run pipeline */
 632     play_and_wait (bin);
 633
 634     gst_consistency_checker_reset (consist);
 635   }
 636
 637   /* cleanup */
 638   GST_INFO ("cleaning up");
 639   gst_consistency_checker_free (consist);
 640   if (play_seek_event)
 641     gst_event_unref (play_seek_event);
 642   gst_bus_remove_signal_watch (bus);
 643   gst_object_unref (bus);
 644   gst_object_unref (bin);
 645 }
 646
 647 GST_END_TEST;
 648
 649 /* check if adding pads work as expected */
 650 GST_START_TEST (test_add_pad)
 651 {
 652   GstElement *bin, *src1, *src2, *audiomixer, *sink;
 653   GstBus *bus;
 654   GstPad *srcpad;
 655   gboolean res;
 656   GstStateChangeReturn state_res;
 657
 658   GST_INFO ("preparing test");
 659
 660   /* build pipeline */
 661   bin = gst_pipeline_new ("pipeline");
 662   bus = gst_element_get_bus (bin);
 663   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 664
 665   src1 = gst_element_factory_make ("audiotestsrc", "src1");
 666   g_object_set (src1, "num-buffers", 4, "wave", /* silence */ 4, NULL);
 667   src2 = gst_element_factory_make ("audiotestsrc", "src2");
 668   /* one buffer less, we connect with 1 buffer of delay */
 669   g_object_set (src2, "num-buffers", 3, "wave", /* silence */ 4, NULL);
 670   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 671   sink = gst_element_factory_make ("fakesink", "sink");
 672   gst_bin_add_many (GST_BIN (bin), src1, audiomixer, sink, NULL);
 673
 674   res = gst_element_link (src1, audiomixer);
 675   fail_unless (res == TRUE, NULL);
 676   res = gst_element_link (audiomixer, sink);
 677   fail_unless (res == TRUE, NULL);
 678
 679   srcpad = gst_element_get_static_pad (audiomixer, "src");
 680   gst_object_unref (srcpad);
 681
 682   g_signal_connect (bus, "message::segment-done", (GCallback) message_received,
 683       bin);
 684   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 685   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 686   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 687
 688   GST_INFO ("starting test");
 689
 690   /* prepare playing */
 691   set_state_and_wait (bin, GST_STATE_PAUSED);
 692
 693   /* add other element */
 694   gst_bin_add_many (GST_BIN (bin), src2, NULL);
 695
 696   /* now link the second element */
 697   res = gst_element_link (src2, audiomixer);
 698   fail_unless (res == TRUE, NULL);
 699
 700   /* set to PAUSED as well */
 701   state_res = gst_element_set_state (src2, GST_STATE_PAUSED);
 702   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 703
 704   /* now play all */
 705   play_and_wait (bin);
 706
 707   /* cleanup */
 708   gst_bus_remove_signal_watch (bus);
 709   gst_object_unref (bus);
 710   gst_object_unref (bin);
 711 }
 712
 713 GST_END_TEST;
 714
 715 /* check if removing pads work as expected */
 716 GST_START_TEST (test_remove_pad)
 717 {
 718   GstElement *bin, *src, *audiomixer, *sink;
 719   GstBus *bus;
 720   GstPad *pad, *srcpad;
 721   gboolean res;
 722   GstStateChangeReturn state_res;
 723
 724   GST_INFO ("preparing test");
 725
 726   /* build pipeline */
 727   bin = gst_pipeline_new ("pipeline");
 728   bus = gst_element_get_bus (bin);
 729   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 730
 731   src = gst_element_factory_make ("audiotestsrc", "src");
 732   g_object_set (src, "num-buffers", 4, "wave", 4, NULL);
 733   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 734   sink = gst_element_factory_make ("fakesink", "sink");
 735   gst_bin_add_many (GST_BIN (bin), src, audiomixer, sink, NULL);
 736
 737   res = gst_element_link (src, audiomixer);
 738   fail_unless (res == TRUE, NULL);
 739   res = gst_element_link (audiomixer, sink);
 740   fail_unless (res == TRUE, NULL);
 741
 742   /* create an unconnected sinkpad in audiomixer */
 743   pad = gst_element_request_pad_simple (audiomixer, "sink_%u");
 744   fail_if (pad == NULL, NULL);
 745
 746   srcpad = gst_element_get_static_pad (audiomixer, "src");
 747   gst_object_unref (srcpad);
 748
 749   g_signal_connect (bus, "message::segment-done", (GCallback) message_received,
 750       bin);
 751   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 752   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 753   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 754
 755   GST_INFO ("starting test");
 756
 757   /* prepare playing, this will not preroll as audiomixer is waiting
 758    * on the unconnected sinkpad. */
 759   state_res = gst_element_set_state (bin, GST_STATE_PAUSED);
 760   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 761
 762   /* wait for completion for one second, will return ASYNC */
 763   state_res = gst_element_get_state (GST_ELEMENT (bin), NULL, NULL, GST_SECOND);
 764   ck_assert_int_eq (state_res, GST_STATE_CHANGE_ASYNC);
 765
 766   /* get rid of the pad now, audiomixer should stop waiting on it and
 767    * continue the preroll */
 768   gst_element_release_request_pad (audiomixer, pad);
 769   gst_object_unref (pad);
 770
 771   /* wait for completion, should work now */
 772   state_res =
 773       gst_element_get_state (GST_ELEMENT (bin), NULL, NULL,
 774       GST_CLOCK_TIME_NONE);
 775   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 776
 777   /* now play all */
 778   play_and_wait (bin);
 779
 780   /* cleanup */
 781   gst_bus_remove_signal_watch (bus);
 782   gst_object_unref (G_OBJECT (bus));
 783   gst_object_unref (G_OBJECT (bin));
 784 }
 785
 786 GST_END_TEST;
 787
 788
 789 static GstBuffer *handoff_buffer = NULL;
 790
 791 static void
 792 handoff_buffer_cb (GstElement * fakesink, GstBuffer * buffer, GstPad * pad,
 793     gpointer user_data)
 794 {
 795   GST_DEBUG ("got buffer -- SIZE: %" G_GSIZE_FORMAT
 796       " -- %p PTS is %" GST_TIME_FORMAT " END is %" GST_TIME_FORMAT,
 797       gst_buffer_get_size (buffer), buffer,
 798       GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
 799       GST_TIME_ARGS (GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer)));
 800
 801   gst_buffer_replace (&handoff_buffer, buffer);
 802 }
 803
 804 /* check if clipping works as expected */
 805 GST_START_TEST (test_clip)
 806 {
 807   GstSegment segment;
 808   GstElement *bin, *audiomixer, *sink;
 809   GstBus *bus;
 810   GstPad *sinkpad;
 811   gboolean res;
 812   GstStateChangeReturn state_res;
 813   GstFlowReturn ret;
 814   GstEvent *event;
 815   GstBuffer *buffer;
 816   GstCaps *caps;
 817   GstQuery *drain = gst_query_new_drain ();
 818
 819   GST_INFO ("preparing test");
 820
 821   /* build pipeline */
 822   bin = gst_pipeline_new ("pipeline");
 823   bus = gst_element_get_bus (bin);
 824   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
 825
 826   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
 827   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
 828   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
 829
 830   /* just an audiomixer and a fakesink */
 831   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 832   g_object_set (audiomixer, "output-buffer-duration", 50 * GST_MSECOND, NULL);
 833   sink = gst_element_factory_make ("fakesink", "sink");
 834   g_object_set (sink, "signal-handoffs", TRUE, NULL);
 835   g_signal_connect (sink, "handoff", (GCallback) handoff_buffer_cb, NULL);
 836   gst_bin_add_many (GST_BIN (bin), audiomixer, sink, NULL);
 837
 838   res = gst_element_link (audiomixer, sink);
 839   fail_unless (res == TRUE, NULL);
 840
 841   /* set to playing */
 842   state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
 843   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
 844
 845   /* create an unconnected sinkpad in audiomixer, should also automatically activate
 846    * the pad */
 847   sinkpad = gst_element_request_pad_simple (audiomixer, "sink_%u");
 848   fail_if (sinkpad == NULL, NULL);
 849
 850   gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
 851
 852   caps = gst_caps_new_simple ("audio/x-raw",
 853       "format", G_TYPE_STRING, GST_AUDIO_NE (S16),
 854       "layout", G_TYPE_STRING, "interleaved",
 855       "rate", G_TYPE_INT, 44100, "channels", G_TYPE_INT, 2, NULL);
 856
 857   gst_pad_set_caps (sinkpad, caps);
 858   gst_caps_unref (caps);
 859
 860   /* send segment to audiomixer */
 861   gst_segment_init (&segment, GST_FORMAT_TIME);
 862   segment.start = GST_SECOND;
 863   segment.stop = 2 * GST_SECOND;
 864   segment.time = 0;
 865   event = gst_event_new_segment (&segment);
 866   gst_pad_send_event (sinkpad, event);
 867
 868   /* should be clipped and ok */
 869   buffer = new_buffer (44100, 0, 0, 250 * GST_MSECOND, 0);
 870   GST_DEBUG ("pushing buffer %p END is %" GST_TIME_FORMAT,
 871       buffer,
 872       GST_TIME_ARGS (GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer)));
 873   ret = gst_pad_chain (sinkpad, buffer);
 874   ck_assert_int_eq (ret, GST_FLOW_OK);
 875   /* The aggregation is done in a dedicated thread, so we can't
 876    * know when it is actually going to happen, so we use a DRAIN query
 877    * to wait for it to complete.
 878    */
 879   gst_pad_query (sinkpad, drain);
 880   fail_unless (handoff_buffer == NULL);
 881
 882   /* should be partially clipped */
 883   buffer = new_buffer (44100, 0, 900 * GST_MSECOND, 250 * GST_MSECOND,
 884       GST_BUFFER_FLAG_DISCONT);
 885   GST_DEBUG ("pushing buffer %p START %" GST_TIME_FORMAT " -- DURATION is %"
 886       GST_TIME_FORMAT, buffer, GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
 887       GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
 888   ret = gst_pad_chain (sinkpad, buffer);
 889   ck_assert_int_eq (ret, GST_FLOW_OK);
 890   gst_pad_query (sinkpad, drain);
 891
 892   fail_unless (handoff_buffer != NULL);
 893   ck_assert_int_eq (GST_BUFFER_PTS (handoff_buffer) +
 894       GST_BUFFER_DURATION (handoff_buffer), 150 * GST_MSECOND);
 895   gst_buffer_replace (&handoff_buffer, NULL);
 896
 897   /* should not be clipped */
 898   buffer = new_buffer (44100, 0, 1150 * GST_MSECOND, 250 * GST_MSECOND, 0);
 899   GST_DEBUG ("pushing buffer %p END is %" GST_TIME_FORMAT,
 900       buffer,
 901       GST_TIME_ARGS (GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer)));
 902   ret = gst_pad_chain (sinkpad, buffer);
 903   ck_assert_int_eq (ret, GST_FLOW_OK);
 904   gst_pad_query (sinkpad, drain);
 905   fail_unless (handoff_buffer != NULL);
 906   ck_assert_int_eq (GST_BUFFER_PTS (handoff_buffer) +
 907       GST_BUFFER_DURATION (handoff_buffer), 400 * GST_MSECOND);
 908   gst_buffer_replace (&handoff_buffer, NULL);
 909   fail_unless (handoff_buffer == NULL);
 910
 911   /* should be clipped and ok */
 912   buffer = new_buffer (44100, 0, 2 * GST_SECOND, 250 * GST_MSECOND,
 913       GST_BUFFER_FLAG_DISCONT);
 914   GST_DEBUG ("pushing buffer %p PTS is %" GST_TIME_FORMAT
 915       " END is %" GST_TIME_FORMAT,
 916       buffer,
 917       GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
 918       GST_TIME_ARGS (GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer)));
 919   ret = gst_pad_chain (sinkpad, buffer);
 920   ck_assert_int_eq (ret, GST_FLOW_OK);
 921   gst_pad_query (sinkpad, drain);
 922   fail_unless (handoff_buffer == NULL);
 923
 924   gst_element_release_request_pad (audiomixer, sinkpad);
 925   gst_object_unref (sinkpad);
 926   gst_element_set_state (bin, GST_STATE_NULL);
 927   gst_bus_remove_signal_watch (bus);
 928   gst_object_unref (bus);
 929   gst_object_unref (bin);
 930   gst_query_unref (drain);
 931 }
 932
 933 GST_END_TEST;
 934
 935 GST_START_TEST (test_duration_is_max)
 936 {
 937   GstElement *bin, *src[3], *audiomixer, *sink;
 938   GstStateChangeReturn state_res;
 939   GstFormat format = GST_FORMAT_TIME;
 940   gboolean res;
 941   gint64 duration;
 942
 943   GST_INFO ("preparing test");
 944
 945   /* build pipeline */
 946   bin = gst_pipeline_new ("pipeline");
 947
 948   /* 3 sources, an audiomixer and a fakesink */
 949   src[0] = gst_element_factory_make ("audiotestsrc", NULL);
 950   src[1] = gst_element_factory_make ("audiotestsrc", NULL);
 951   src[2] = gst_element_factory_make ("audiotestsrc", NULL);
 952   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
 953   sink = gst_element_factory_make ("fakesink", "sink");
 954   gst_bin_add_many (GST_BIN (bin), src[0], src[1], src[2], audiomixer, sink,
 955       NULL);
 956
 957   gst_element_link (src[0], audiomixer);
 958   gst_element_link (src[1], audiomixer);
 959   gst_element_link (src[2], audiomixer);
 960   gst_element_link (audiomixer, sink);
 961
 962   /* irks, duration is reset on basesrc */
 963   state_res = gst_element_set_state (bin, GST_STATE_PAUSED);
 964   fail_unless (state_res != GST_STATE_CHANGE_FAILURE, NULL);
 965
 966   /* set durations on src */
 967   GST_BASE_SRC (src[0])->segment.duration = 1000;
 968   GST_BASE_SRC (src[1])->segment.duration = 3000;
 969   GST_BASE_SRC (src[2])->segment.duration = 2000;
 970
 971   /* set to playing */
 972   set_state_and_wait (bin, GST_STATE_PLAYING);
 973
 974   res = gst_element_query_duration (GST_ELEMENT (bin), format, &duration);
 975   fail_unless (res, NULL);
 976
 977   ck_assert_int_eq (duration, 3000);
 978
 979   gst_element_set_state (bin, GST_STATE_NULL);
 980   gst_object_unref (bin);
 981 }
 982
 983 GST_END_TEST;
 984
 985 GST_START_TEST (test_duration_unknown_overrides)
 986 {
 987   GstElement *bin, *src[3], *audiomixer, *sink;
 988   GstStateChangeReturn state_res;
 989   GstFormat format = GST_FORMAT_TIME;
 990   gboolean res;
 991   gint64 duration;
 992
 993   GST_INFO ("preparing test");
 994
 995   /* build pipeline */
 996   bin = gst_pipeline_new ("pipeline");
 997
 998   /* 3 sources, an audiomixer and a fakesink */
 999   src[0] = gst_element_factory_make ("audiotestsrc", NULL);
1000   src[1] = gst_element_factory_make ("audiotestsrc", NULL);
1001   src[2] = gst_element_factory_make ("audiotestsrc", NULL);
1002   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1003   sink = gst_element_factory_make ("fakesink", "sink");
1004   gst_bin_add_many (GST_BIN (bin), src[0], src[1], src[2], audiomixer, sink,
1005       NULL);
1006
1007   gst_element_link (src[0], audiomixer);
1008   gst_element_link (src[1], audiomixer);
1009   gst_element_link (src[2], audiomixer);
1010   gst_element_link (audiomixer, sink);
1011
1012   /* irks, duration is reset on basesrc */
1013   state_res = gst_element_set_state (bin, GST_STATE_PAUSED);
1014   fail_unless (state_res != GST_STATE_CHANGE_FAILURE, NULL);
1015
1016   /* set durations on src */
1017   GST_BASE_SRC (src[0])->segment.duration = GST_CLOCK_TIME_NONE;
1018   GST_BASE_SRC (src[1])->segment.duration = 3000;
1019   GST_BASE_SRC (src[2])->segment.duration = 2000;
1020
1021   /* set to playing */
1022   set_state_and_wait (bin, GST_STATE_PLAYING);
1023
1024   res = gst_element_query_duration (GST_ELEMENT (bin), format, &duration);
1025   fail_unless (res, NULL);
1026
1027   ck_assert_int_eq (duration, GST_CLOCK_TIME_NONE);
1028
1029   gst_element_set_state (bin, GST_STATE_NULL);
1030   gst_object_unref (bin);
1031 }
1032
1033 GST_END_TEST;
1034
1035
1036 static gboolean looped = FALSE;
1037
1038 static void
1039 loop_segment_done (GstBus * bus, GstMessage * message, GstElement * bin)
1040 {
1041   GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
1042       GST_MESSAGE_SRC (message), message);
1043
1044   if (looped) {
1045     g_main_loop_quit (main_loop);
1046   } else {
1047     GstEvent *seek_event;
1048     gboolean res;
1049
1050     seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
1051         GST_SEEK_FLAG_SEGMENT,
1052         GST_SEEK_TYPE_SET, (GstClockTime) 0,
1053         GST_SEEK_TYPE_SET, (GstClockTime) 1 * GST_SECOND);
1054
1055     res = gst_element_send_event (bin, seek_event);
1056     fail_unless (res == TRUE, NULL);
1057     looped = TRUE;
1058   }
1059 }
1060
1061 GST_START_TEST (test_loop)
1062 {
1063   GstElement *bin;
1064   GstBus *bus;
1065   GstEvent *seek_event;
1066   gboolean res;
1067
1068   GST_INFO ("preparing test");
1069
1070   /* build pipeline */
1071   bin = setup_pipeline (NULL, 2, NULL);
1072   bus = gst_element_get_bus (bin);
1073   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1074
1075   seek_event = gst_event_new_seek (1.0, GST_FORMAT_TIME,
1076       GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH,
1077       GST_SEEK_TYPE_SET, (GstClockTime) 0,
1078       GST_SEEK_TYPE_SET, (GstClockTime) 1 * GST_SECOND);
1079
1080   g_signal_connect (bus, "message::segment-done",
1081       (GCallback) loop_segment_done, bin);
1082   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1083   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1084   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1085
1086   GST_INFO ("starting test");
1087
1088   /* prepare playing */
1089   set_state_and_wait (bin, GST_STATE_PAUSED);
1090
1091   res = gst_element_send_event (bin, seek_event);
1092   fail_unless (res == TRUE, NULL);
1093
1094   /* run pipeline */
1095   play_and_wait (bin);
1096
1097   fail_unless (looped);
1098
1099   /* cleanup */
1100   gst_bus_remove_signal_watch (bus);
1101   gst_object_unref (bus);
1102   gst_object_unref (bin);
1103 }
1104
1105 GST_END_TEST;
1106
1107 GST_START_TEST (test_flush_start_flush_stop)
1108 {
1109   GstPadTemplate *sink_template;
1110   GstPad *tmppad, *srcpad1, *sinkpad1, *sinkpad2, *audiomixer_src;
1111   GstElement *pipeline, *src1, *src2, *audiomixer, *sink;
1112
1113   GST_INFO ("preparing test");
1114
1115   /* build pipeline */
1116   pipeline = gst_pipeline_new ("pipeline");
1117   src1 = gst_element_factory_make ("audiotestsrc", "src1");
1118   g_object_set (src1, "wave", 4, NULL); /* silence */
1119   src2 = gst_element_factory_make ("audiotestsrc", "src2");
1120   g_object_set (src2, "wave", 4, NULL); /* silence */
1121   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1122   sink = gst_element_factory_make ("fakesink", "sink");
1123   gst_bin_add_many (GST_BIN (pipeline), src1, src2, audiomixer, sink, NULL);
1124
1125   sink_template =
1126       gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (audiomixer),
1127       "sink_%u");
1128   fail_unless (GST_IS_PAD_TEMPLATE (sink_template));
1129   sinkpad1 = gst_element_request_pad (audiomixer, sink_template, NULL, NULL);
1130   srcpad1 = gst_element_get_static_pad (src1, "src");
1131   gst_pad_link (srcpad1, sinkpad1);
1132
1133   sinkpad2 = gst_element_request_pad (audiomixer, sink_template, NULL, NULL);
1134   tmppad = gst_element_get_static_pad (src2, "src");
1135   gst_pad_link (tmppad, sinkpad2);
1136   gst_object_unref (tmppad);
1137
1138   gst_element_link (audiomixer, sink);
1139
1140   /* prepare playing */
1141   set_state_and_wait (pipeline, GST_STATE_PLAYING);
1142
1143   audiomixer_src = gst_element_get_static_pad (audiomixer, "src");
1144   fail_if (GST_PAD_IS_FLUSHING (audiomixer_src));
1145   gst_pad_send_event (sinkpad1, gst_event_new_flush_start ());
1146   fail_if (GST_PAD_IS_FLUSHING (audiomixer_src));
1147   fail_unless (GST_PAD_IS_FLUSHING (sinkpad1));
1148   /* Hold the streamlock to make sure the flush stop is not between
1149      the attempted push of a segment event and of the following buffer. */
1150   GST_PAD_STREAM_LOCK (srcpad1);
1151   gst_pad_send_event (sinkpad1, gst_event_new_flush_stop (TRUE));
1152   GST_PAD_STREAM_UNLOCK (srcpad1);
1153   fail_if (GST_PAD_IS_FLUSHING (audiomixer_src));
1154   fail_if (GST_PAD_IS_FLUSHING (sinkpad1));
1155   gst_object_unref (audiomixer_src);
1156
1157   gst_element_release_request_pad (audiomixer, sinkpad1);
1158   gst_object_unref (sinkpad1);
1159   gst_element_release_request_pad (audiomixer, sinkpad2);
1160   gst_object_unref (sinkpad2);
1161   gst_object_unref (srcpad1);
1162
1163   /* cleanup */
1164   gst_element_set_state (pipeline, GST_STATE_NULL);
1165   gst_object_unref (pipeline);
1166 }
1167
1168 GST_END_TEST;
1169
1170 static void
1171 handoff_buffer_collect_cb (GstElement * fakesink, GstBuffer * buffer,
1172     GstPad * pad, gpointer user_data)
1173 {
1174   GList **received_buffers = user_data;
1175
1176   GST_DEBUG ("got buffer %p", buffer);
1177   *received_buffers =
1178       g_list_append (*received_buffers, gst_buffer_ref (buffer));
1179 }
1180
1181 typedef void (*SendBuffersFunction) (GstPad * pad1, GstPad * pad2);
1182 typedef void (*CheckBuffersFunction) (GList * buffers);
1183
1184 static void
1185 run_sync_test (SendBuffersFunction send_buffers,
1186     CheckBuffersFunction check_buffers)
1187 {
1188   GstSegment segment;
1189   GstElement *bin, *audiomixer, *queue1, *queue2, *sink;
1190   GstBus *bus;
1191   GstPad *sinkpad1, *sinkpad2;
1192   GstPad *queue1_sinkpad, *queue2_sinkpad;
1193   GstPad *pad;
1194   gboolean res;
1195   GstStateChangeReturn state_res;
1196   GstEvent *event;
1197   GstCaps *caps;
1198   GList *received_buffers = NULL;
1199
1200   GST_INFO ("preparing test");
1201
1202   /* build pipeline */
1203   bin = gst_pipeline_new ("pipeline");
1204   bus = gst_element_get_bus (bin);
1205   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1206
1207   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1208   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1209   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1210
1211   /* just an audiomixer and a fakesink */
1212   queue1 = gst_element_factory_make ("queue", "queue1");
1213   queue2 = gst_element_factory_make ("queue", "queue2");
1214   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1215   g_object_set (audiomixer, "output-buffer-duration", 500 * GST_MSECOND, NULL);
1216   sink = gst_element_factory_make ("fakesink", "sink");
1217   g_object_set (sink, "signal-handoffs", TRUE, NULL);
1218   g_signal_connect (sink, "handoff", (GCallback) handoff_buffer_collect_cb,
1219       &received_buffers);
1220   gst_bin_add_many (GST_BIN (bin), queue1, queue2, audiomixer, sink, NULL);
1221
1222   res = gst_element_link (audiomixer, sink);
1223   fail_unless (res == TRUE, NULL);
1224
1225   /* set to paused */
1226   state_res = gst_element_set_state (bin, GST_STATE_PAUSED);
1227   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
1228
1229   /* create an unconnected sinkpad in audiomixer, should also automatically activate
1230    * the pad */
1231   sinkpad1 = gst_element_request_pad_simple (audiomixer, "sink_%u");
1232   fail_if (sinkpad1 == NULL, NULL);
1233
1234   queue1_sinkpad = gst_element_get_static_pad (queue1, "sink");
1235   pad = gst_element_get_static_pad (queue1, "src");
1236   fail_unless (gst_pad_link (pad, sinkpad1) == GST_PAD_LINK_OK);
1237   gst_object_unref (pad);
1238
1239   sinkpad2 = gst_element_request_pad_simple (audiomixer, "sink_%u");
1240   fail_if (sinkpad2 == NULL, NULL);
1241
1242   queue2_sinkpad = gst_element_get_static_pad (queue2, "sink");
1243   pad = gst_element_get_static_pad (queue2, "src");
1244   fail_unless (gst_pad_link (pad, sinkpad2) == GST_PAD_LINK_OK);
1245   gst_object_unref (pad);
1246
1247   gst_pad_send_event (queue1_sinkpad, gst_event_new_stream_start ("test"));
1248   gst_pad_send_event (queue2_sinkpad, gst_event_new_stream_start ("test"));
1249
1250   caps = gst_caps_new_simple ("audio/x-raw",
1251       "format", G_TYPE_STRING, GST_AUDIO_NE (S16),
1252       "layout", G_TYPE_STRING, "interleaved",
1253       "rate", G_TYPE_INT, 1000, "channels", G_TYPE_INT, 1, NULL);
1254
1255   gst_pad_set_caps (queue1_sinkpad, caps);
1256   gst_pad_set_caps (queue2_sinkpad, caps);
1257   gst_caps_unref (caps);
1258
1259   /* send segment to audiomixer */
1260   gst_segment_init (&segment, GST_FORMAT_TIME);
1261   event = gst_event_new_segment (&segment);
1262   gst_pad_send_event (queue1_sinkpad, gst_event_ref (event));
1263   gst_pad_send_event (queue2_sinkpad, event);
1264
1265   /* Push buffers */
1266   send_buffers (queue1_sinkpad, queue2_sinkpad);
1267
1268   /* Set PLAYING */
1269   g_idle_add ((GSourceFunc) set_playing, bin);
1270
1271   /* Collect buffers and messages */
1272   g_main_loop_run (main_loop);
1273
1274   /* Here we get once we got EOS, for errors we failed */
1275
1276   check_buffers (received_buffers);
1277
1278   g_list_free_full (received_buffers, (GDestroyNotify) gst_buffer_unref);
1279
1280   gst_element_release_request_pad (audiomixer, sinkpad1);
1281   gst_object_unref (sinkpad1);
1282   gst_object_unref (queue1_sinkpad);
1283   gst_element_release_request_pad (audiomixer, sinkpad2);
1284   gst_object_unref (sinkpad2);
1285   gst_object_unref (queue2_sinkpad);
1286   gst_element_set_state (bin, GST_STATE_NULL);
1287   gst_bus_remove_signal_watch (bus);
1288   gst_object_unref (bus);
1289   gst_object_unref (bin);
1290 }
1291
1292 static void
1293 send_buffers_sync (GstPad * pad1, GstPad * pad2)
1294 {
1295   GstBuffer *buffer;
1296   GstFlowReturn ret;
1297
1298   buffer = new_buffer (2000, 1, 1 * GST_SECOND, 1 * GST_SECOND, 0);
1299   ret = gst_pad_chain (pad1, buffer);
1300   ck_assert_int_eq (ret, GST_FLOW_OK);
1301
1302   buffer = new_buffer (2000, 1, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1303   ret = gst_pad_chain (pad1, buffer);
1304   ck_assert_int_eq (ret, GST_FLOW_OK);
1305
1306   gst_pad_send_event (pad1, gst_event_new_eos ());
1307
1308   buffer = new_buffer (2000, 2, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1309   ret = gst_pad_chain (pad2, buffer);
1310   ck_assert_int_eq (ret, GST_FLOW_OK);
1311
1312   buffer = new_buffer (2000, 2, 3 * GST_SECOND, 1 * GST_SECOND, 0);
1313   ret = gst_pad_chain (pad2, buffer);
1314   ck_assert_int_eq (ret, GST_FLOW_OK);
1315
1316   gst_pad_send_event (pad2, gst_event_new_eos ());
1317 }
1318
1319 static void
1320 check_buffers_sync (GList * received_buffers)
1321 {
1322   GstBuffer *buffer;
1323   GList *l;
1324   gint i;
1325   GstMapInfo map;
1326
1327   /* Should have 8 * 0.5s buffers */
1328   fail_unless_equals_int (g_list_length (received_buffers), 8);
1329   for (i = 0, l = received_buffers; l; l = l->next, i++) {
1330     buffer = l->data;
1331
1332     gst_buffer_map (buffer, &map, GST_MAP_READ);
1333
1334     if (i == 0 && GST_BUFFER_TIMESTAMP (buffer) == 0) {
1335       fail_unless (map.data[0] == 0);
1336       fail_unless (map.data[map.size - 1] == 0);
1337     } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1338       fail_unless (map.data[0] == 0);
1339       fail_unless (map.data[map.size - 1] == 0);
1340     } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1341       fail_unless (map.data[0] == 1);
1342       fail_unless (map.data[map.size - 1] == 1);
1343     } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1344       fail_unless (map.data[0] == 1);
1345       fail_unless (map.data[map.size - 1] == 1);
1346     } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1347       fail_unless (map.data[0] == 3);
1348       fail_unless (map.data[map.size - 1] == 3);
1349     } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1350       fail_unless (map.data[0] == 3);
1351       fail_unless (map.data[map.size - 1] == 3);
1352     } else if (i == 6 && GST_BUFFER_TIMESTAMP (buffer) == 3000 * GST_MSECOND) {
1353       fail_unless (map.data[0] == 2);
1354       fail_unless (map.data[map.size - 1] == 2);
1355     } else if (i == 7 && GST_BUFFER_TIMESTAMP (buffer) == 3500 * GST_MSECOND) {
1356       fail_unless (map.data[0] == 2);
1357       fail_unless (map.data[map.size - 1] == 2);
1358     } else {
1359       g_assert_not_reached ();
1360     }
1361
1362     gst_buffer_unmap (buffer, &map);
1363
1364   }
1365 }
1366
1367 GST_START_TEST (test_sync)
1368 {
1369   run_sync_test (send_buffers_sync, check_buffers_sync);
1370 }
1371
1372 GST_END_TEST;
1373
1374 static void
1375 send_buffers_sync_discont (GstPad * pad1, GstPad * pad2)
1376 {
1377   GstBuffer *buffer;
1378   GstFlowReturn ret;
1379
1380   buffer = new_buffer (2000, 1, 1 * GST_SECOND, 1 * GST_SECOND, 0);
1381   ret = gst_pad_chain (pad1, buffer);
1382   ck_assert_int_eq (ret, GST_FLOW_OK);
1383
1384   buffer = new_buffer (2000, 1, 3 * GST_SECOND, 1 * GST_SECOND,
1385       GST_BUFFER_FLAG_DISCONT);
1386   ret = gst_pad_chain (pad1, buffer);
1387   ck_assert_int_eq (ret, GST_FLOW_OK);
1388
1389   gst_pad_send_event (pad1, gst_event_new_eos ());
1390
1391   buffer = new_buffer (2000, 2, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1392   ret = gst_pad_chain (pad2, buffer);
1393   ck_assert_int_eq (ret, GST_FLOW_OK);
1394
1395   buffer = new_buffer (2000, 2, 3 * GST_SECOND, 1 * GST_SECOND, 0);
1396   ret = gst_pad_chain (pad2, buffer);
1397   ck_assert_int_eq (ret, GST_FLOW_OK);
1398
1399   gst_pad_send_event (pad2, gst_event_new_eos ());
1400 }
1401
1402 static void
1403 check_buffers_sync_discont (GList * received_buffers)
1404 {
1405   GstBuffer *buffer;
1406   GList *l;
1407   gint i;
1408   GstMapInfo map;
1409
1410   /* Should have 8 * 0.5s buffers */
1411   fail_unless_equals_int (g_list_length (received_buffers), 8);
1412   for (i = 0, l = received_buffers; l; l = l->next, i++) {
1413     buffer = l->data;
1414
1415     gst_buffer_map (buffer, &map, GST_MAP_READ);
1416
1417     if (i == 0 && GST_BUFFER_TIMESTAMP (buffer) == 0) {
1418       fail_unless (map.data[0] == 0);
1419       fail_unless (map.data[map.size - 1] == 0);
1420     } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1421       fail_unless (map.data[0] == 0);
1422       fail_unless (map.data[map.size - 1] == 0);
1423     } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1424       fail_unless (map.data[0] == 1);
1425       fail_unless (map.data[map.size - 1] == 1);
1426     } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1427       fail_unless (map.data[0] == 1);
1428       fail_unless (map.data[map.size - 1] == 1);
1429     } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1430       fail_unless (map.data[0] == 2);
1431       fail_unless (map.data[map.size - 1] == 2);
1432     } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1433       fail_unless (map.data[0] == 2);
1434       fail_unless (map.data[map.size - 1] == 2);
1435     } else if (i == 6 && GST_BUFFER_TIMESTAMP (buffer) == 3000 * GST_MSECOND) {
1436       fail_unless (map.data[0] == 3);
1437       fail_unless (map.data[map.size - 1] == 3);
1438     } else if (i == 7 && GST_BUFFER_TIMESTAMP (buffer) == 3500 * GST_MSECOND) {
1439       fail_unless (map.data[0] == 3);
1440       fail_unless (map.data[map.size - 1] == 3);
1441     } else {
1442       g_assert_not_reached ();
1443     }
1444
1445     gst_buffer_unmap (buffer, &map);
1446
1447   }
1448 }
1449
1450 GST_START_TEST (test_sync_discont)
1451 {
1452   run_sync_test (send_buffers_sync_discont, check_buffers_sync_discont);
1453 }
1454
1455 GST_END_TEST;
1456
1457
1458 static void
1459 send_buffers_sync_discont_backwards (GstPad * pad1, GstPad * pad2)
1460 {
1461   GstBuffer *buffer;
1462   GstFlowReturn ret;
1463
1464   buffer = new_buffer (2300, 1, 1 * GST_SECOND, 1.25 * GST_SECOND, 0);
1465   ret = gst_pad_chain (pad1, buffer);
1466   ck_assert_int_eq (ret, GST_FLOW_OK);
1467
1468   buffer = new_buffer (2000, 1, 2 * GST_SECOND, 1 * GST_SECOND,
1469       GST_BUFFER_FLAG_DISCONT);
1470   ret = gst_pad_chain (pad1, buffer);
1471   ck_assert_int_eq (ret, GST_FLOW_OK);
1472
1473   gst_pad_send_event (pad1, gst_event_new_eos ());
1474
1475   buffer = new_buffer (2000, 1, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1476   ret = gst_pad_chain (pad2, buffer);
1477   ck_assert_int_eq (ret, GST_FLOW_OK);
1478
1479
1480   gst_pad_send_event (pad2, gst_event_new_eos ());
1481 }
1482
1483 static void
1484 check_buffers_sync_discont_backwards (GList * received_buffers)
1485 {
1486   GstBuffer *buffer;
1487   GList *l;
1488   gint i;
1489   GstMapInfo map;
1490
1491   /* Should have 6 * 0.5s buffers */
1492   fail_unless_equals_int (g_list_length (received_buffers), 6);
1493   for (i = 0, l = received_buffers; l; l = l->next, i++) {
1494     buffer = l->data;
1495
1496     gst_buffer_map (buffer, &map, GST_MAP_READ);
1497
1498     if (i == 0 && GST_BUFFER_TIMESTAMP (buffer) == 0) {
1499       fail_unless (map.data[0] == 0);
1500       fail_unless (map.data[map.size - 1] == 0);
1501     } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1502       fail_unless (map.data[0] == 0);
1503       fail_unless (map.data[map.size - 1] == 0);
1504     } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1505       fail_unless (map.data[0] == 1);
1506       fail_unless (map.data[map.size - 1] == 1);
1507     } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1508       fail_unless (map.data[0] == 1);
1509       fail_unless (map.data[map.size - 1] == 1);
1510     } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1511       fail_unless (map.data[0] == 2);
1512       fail_unless (map.data[map.size - 1] == 2);
1513     } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1514       fail_unless (map.data[0] == 2);
1515       fail_unless (map.data[map.size - 1] == 2);
1516     } else {
1517       g_assert_not_reached ();
1518     }
1519
1520     gst_buffer_unmap (buffer, &map);
1521
1522   }
1523 }
1524
1525 GST_START_TEST (test_sync_discont_backwards)
1526 {
1527   run_sync_test (send_buffers_sync_discont_backwards,
1528       check_buffers_sync_discont_backwards);
1529 }
1530
1531 GST_END_TEST;
1532
1533
1534 static void
1535 send_buffers_sync_unaligned (GstPad * pad1, GstPad * pad2)
1536 {
1537   GstBuffer *buffer;
1538   GstFlowReturn ret;
1539
1540   buffer = new_buffer (2000, 1, 750 * GST_MSECOND, 1 * GST_SECOND, 0);
1541   ret = gst_pad_chain (pad1, buffer);
1542   ck_assert_int_eq (ret, GST_FLOW_OK);
1543
1544   buffer = new_buffer (2000, 1, 1750 * GST_MSECOND, 1 * GST_SECOND, 0);
1545   ret = gst_pad_chain (pad1, buffer);
1546   ck_assert_int_eq (ret, GST_FLOW_OK);
1547
1548   gst_pad_send_event (pad1, gst_event_new_eos ());
1549
1550   buffer = new_buffer (2000, 2, 1750 * GST_MSECOND, 1 * GST_SECOND, 0);
1551   ret = gst_pad_chain (pad2, buffer);
1552   ck_assert_int_eq (ret, GST_FLOW_OK);
1553
1554   buffer = new_buffer (2000, 2, 2750 * GST_MSECOND, 1 * GST_SECOND, 0);
1555   ret = gst_pad_chain (pad2, buffer);
1556   ck_assert_int_eq (ret, GST_FLOW_OK);
1557
1558   gst_pad_send_event (pad2, gst_event_new_eos ());
1559 }
1560
1561 static void
1562 check_buffers_sync_unaligned (GList * received_buffers)
1563 {
1564   GstBuffer *buffer;
1565   GList *l;
1566   gint i;
1567   GstMapInfo map;
1568
1569   /* Should have 8 * 0.5s buffers */
1570   fail_unless_equals_int (g_list_length (received_buffers), 8);
1571   for (i = 0, l = received_buffers; l; l = l->next, i++) {
1572     buffer = l->data;
1573
1574     gst_buffer_map (buffer, &map, GST_MAP_READ);
1575
1576     if (i == 0 && GST_BUFFER_TIMESTAMP (buffer) == 0) {
1577       fail_unless (map.data[0] == 0);
1578       fail_unless (map.data[map.size - 1] == 0);
1579     } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1580       fail_unless (map.data[0] == 0);
1581       fail_unless (map.data[499] == 0);
1582       fail_unless (map.data[500] == 1);
1583       fail_unless (map.data[map.size - 1] == 1);
1584     } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1585       fail_unless (map.data[0] == 1);
1586       fail_unless (map.data[map.size - 1] == 1);
1587     } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1588       fail_unless (map.data[0] == 1);
1589       fail_unless (map.data[499] == 1);
1590       fail_unless (map.data[500] == 3);
1591       fail_unless (map.data[map.size - 1] == 3);
1592     } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1593       fail_unless (map.data[0] == 3);
1594       fail_unless (map.data[499] == 3);
1595       fail_unless (map.data[500] == 3);
1596       fail_unless (map.data[map.size - 1] == 3);
1597     } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1598       fail_unless (map.data[0] == 3);
1599       fail_unless (map.data[499] == 3);
1600       fail_unless (map.data[500] == 2);
1601       fail_unless (map.data[map.size - 1] == 2);
1602     } else if (i == 6 && GST_BUFFER_TIMESTAMP (buffer) == 3000 * GST_MSECOND) {
1603       fail_unless (map.data[0] == 2);
1604       fail_unless (map.data[499] == 2);
1605       fail_unless (map.data[500] == 2);
1606       fail_unless (map.data[map.size - 1] == 2);
1607     } else if (i == 7 && GST_BUFFER_TIMESTAMP (buffer) == 3500 * GST_MSECOND) {
1608       fail_unless (map.size == 500);
1609       fail_unless (GST_BUFFER_DURATION (buffer) == 250 * GST_MSECOND);
1610       fail_unless (map.data[0] == 2);
1611       fail_unless (map.data[499] == 2);
1612     } else {
1613       g_assert_not_reached ();
1614     }
1615
1616     gst_buffer_unmap (buffer, &map);
1617
1618   }
1619 }
1620
1621 GST_START_TEST (test_sync_unaligned)
1622 {
1623   run_sync_test (send_buffers_sync_unaligned, check_buffers_sync_unaligned);
1624 }
1625
1626 GST_END_TEST;
1627
1628 GST_START_TEST (test_segment_base_handling)
1629 {
1630   GstElement *pipeline, *sink, *mix, *src1, *src2;
1631   GstPad *srcpad, *sinkpad;
1632   GstClockTime end_time;
1633   GstSample *last_sample = NULL;
1634   GstSample *sample;
1635   GstBuffer *buf;
1636   GstCaps *caps;
1637
1638   caps = gst_caps_new_simple ("audio/x-raw", "rate", G_TYPE_INT, 44100,
1639       "channels", G_TYPE_INT, 2, NULL);
1640
1641   pipeline = gst_pipeline_new ("pipeline");
1642   mix = gst_element_factory_make ("audiomixer", "audiomixer");
1643   sink = gst_element_factory_make ("appsink", "sink");
1644   g_object_set (sink, "caps", caps, "sync", FALSE, NULL);
1645   gst_caps_unref (caps);
1646   /* 50 buffers of 1/10 sec = 5 sec */
1647   src1 = gst_element_factory_make ("audiotestsrc", "src1");
1648   g_object_set (src1, "samplesperbuffer", 4410, "num-buffers", 50, NULL);
1649   src2 = gst_element_factory_make ("audiotestsrc", "src2");
1650   g_object_set (src2, "samplesperbuffer", 4410, "num-buffers", 50, NULL);
1651   gst_bin_add_many (GST_BIN (pipeline), src1, src2, mix, sink, NULL);
1652   fail_unless (gst_element_link (mix, sink));
1653
1654   srcpad = gst_element_get_static_pad (src1, "src");
1655   sinkpad = gst_element_request_pad_simple (mix, "sink_1");
1656   fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1657   gst_object_unref (sinkpad);
1658   gst_object_unref (srcpad);
1659
1660   srcpad = gst_element_get_static_pad (src2, "src");
1661   sinkpad = gst_element_request_pad_simple (mix, "sink_2");
1662   fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1663   /* set a pad offset of another 5 seconds */
1664   gst_pad_set_offset (sinkpad, 5 * GST_SECOND);
1665   gst_object_unref (sinkpad);
1666   gst_object_unref (srcpad);
1667
1668   gst_element_set_state (pipeline, GST_STATE_PLAYING);
1669
1670   do {
1671     g_signal_emit_by_name (sink, "pull-sample", &sample);
1672     if (sample == NULL)
1673       break;
1674     if (last_sample)
1675       gst_sample_unref (last_sample);
1676     last_sample = sample;
1677   } while (TRUE);
1678
1679   buf = gst_sample_get_buffer (last_sample);
1680   end_time = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
1681   fail_unless_equals_int64 (end_time, 10 * GST_SECOND);
1682   gst_sample_unref (last_sample);
1683
1684   gst_element_set_state (pipeline, GST_STATE_NULL);
1685   gst_object_unref (pipeline);
1686 }
1687
1688 GST_END_TEST;
1689
1690 static void
1691 set_pad_volume_fade (GstPad * pad, GstClockTime start, gdouble start_value,
1692     GstClockTime end, gdouble end_value)
1693 {
1694   GstControlSource *cs;
1695   GstTimedValueControlSource *tvcs;
1696
1697   cs = gst_interpolation_control_source_new ();
1698   fail_unless (gst_object_add_control_binding (GST_OBJECT_CAST (pad),
1699           gst_direct_control_binding_new_absolute (GST_OBJECT_CAST (pad),
1700               "volume", cs)));
1701
1702   /* set volume interpolation mode */
1703   g_object_set (cs, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
1704
1705   tvcs = (GstTimedValueControlSource *) cs;
1706   fail_unless (gst_timed_value_control_source_set (tvcs, start, start_value));
1707   fail_unless (gst_timed_value_control_source_set (tvcs, end, end_value));
1708   gst_object_unref (cs);
1709 }
1710
1711 GST_START_TEST (test_sinkpad_property_controller)
1712 {
1713   GstBus *bus;
1714   GstMessage *msg;
1715   GstElement *pipeline, *sink, *mix, *src1;
1716   GstPad *srcpad, *sinkpad;
1717   GError *error = NULL;
1718   gchar *debug;
1719
1720   pipeline = gst_pipeline_new ("pipeline");
1721   mix = gst_element_factory_make ("audiomixer", "audiomixer");
1722   sink = gst_element_factory_make ("fakesink", "sink");
1723   src1 = gst_element_factory_make ("audiotestsrc", "src1");
1724   g_object_set (src1, "num-buffers", 100, NULL);
1725   gst_bin_add_many (GST_BIN (pipeline), src1, mix, sink, NULL);
1726   fail_unless (gst_element_link (mix, sink));
1727
1728   srcpad = gst_element_get_static_pad (src1, "src");
1729   sinkpad = gst_element_request_pad_simple (mix, "sink_0");
1730   fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1731   set_pad_volume_fade (sinkpad, 0, 0, 1.0, 2.0);
1732   gst_object_unref (sinkpad);
1733   gst_object_unref (srcpad);
1734
1735   gst_element_set_state (pipeline, GST_STATE_PLAYING);
1736
1737   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
1738   msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE,
1739       GST_MESSAGE_EOS | GST_MESSAGE_ERROR);
1740   switch (GST_MESSAGE_TYPE (msg)) {
1741     case GST_MESSAGE_ERROR:
1742       gst_message_parse_error (msg, &error, &debug);
1743       g_printerr ("ERROR from element %s: %s\n",
1744           GST_OBJECT_NAME (msg->src), error->message);
1745       g_printerr ("Debug info: %s\n", debug);
1746       g_error_free (error);
1747       g_free (debug);
1748       break;
1749     case GST_MESSAGE_EOS:
1750       break;
1751     default:
1752       g_assert_not_reached ();
1753   }
1754   gst_message_unref (msg);
1755   g_object_unref (bus);
1756
1757   gst_element_set_state (pipeline, GST_STATE_NULL);
1758   gst_object_unref (pipeline);
1759 }
1760
1761 GST_END_TEST;
1762
1763 static void
1764 change_src_caps (GstElement * fakesink, GstBuffer * buffer, GstPad * pad,
1765     GstElement * capsfilter)
1766 {
1767   GstCaps *caps = gst_caps_new_simple ("audio/x-raw",
1768       "format", G_TYPE_STRING, GST_AUDIO_NE (S32),
1769       "layout", G_TYPE_STRING, "interleaved",
1770       "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1771
1772   g_object_set (capsfilter, "caps", caps, NULL);
1773   gst_caps_unref (caps);
1774   g_signal_connect (fakesink, "handoff", (GCallback) handoff_buffer_cb, NULL);
1775   g_signal_handlers_disconnect_by_func (fakesink, change_src_caps, capsfilter);
1776 }
1777
1778 /* In this test, we create an input buffer with a duration of 2 seconds,
1779  * and require the audiomixer to output 1 second long buffers.
1780  * The input buffer will thus be mixed twice, and the audiomixer will
1781  * output two buffers.
1782  *
1783  * After audiomixer has output a first buffer, we change its output format
1784  * from S8 to S32. As our sample rate stays the same at 10 fps, and we use
1785  * mono, the first buffer should be 10 bytes long, and the second 40.
1786  *
1787  * The input buffer is made up of 15 0-valued bytes, and 5 1-valued bytes.
1788  * We verify that the second buffer contains 5 0-valued integers, and
1789  * 5 1 << 24 valued integers.
1790  */
1791 GST_START_TEST (test_change_output_caps)
1792 {
1793   GstSegment segment;
1794   GstElement *bin, *audiomixer, *capsfilter, *sink;
1795   GstBus *bus;
1796   GstPad *sinkpad;
1797   gboolean res;
1798   GstStateChangeReturn state_res;
1799   GstFlowReturn ret;
1800   GstEvent *event;
1801   GstBuffer *buffer;
1802   GstCaps *caps;
1803   GstQuery *drain = gst_query_new_drain ();
1804   GstMapInfo inmap;
1805   GstMapInfo outmap;
1806   gsize i;
1807
1808   bin = gst_pipeline_new ("pipeline");
1809   bus = gst_element_get_bus (bin);
1810   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1811
1812   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1813   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1814   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1815
1816   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1817   g_object_set (audiomixer, "output-buffer-duration", GST_SECOND, NULL);
1818   capsfilter = gst_element_factory_make ("capsfilter", NULL);
1819   sink = gst_element_factory_make ("fakesink", "sink");
1820   g_object_set (sink, "signal-handoffs", TRUE, NULL);
1821   g_signal_connect (sink, "handoff", (GCallback) change_src_caps, capsfilter);
1822   gst_bin_add_many (GST_BIN (bin), audiomixer, capsfilter, sink, NULL);
1823
1824   res = gst_element_link_many (audiomixer, capsfilter, sink, NULL);
1825   fail_unless (res == TRUE, NULL);
1826
1827   state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
1828   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
1829
1830   sinkpad = gst_element_request_pad_simple (audiomixer, "sink_%u");
1831   fail_if (sinkpad == NULL, NULL);
1832
1833   gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
1834
1835   caps = gst_caps_new_simple ("audio/x-raw",
1836       "format", G_TYPE_STRING, "S8",
1837       "layout", G_TYPE_STRING, "interleaved",
1838       "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1839
1840   gst_pad_set_caps (sinkpad, caps);
1841   g_object_set (capsfilter, "caps", caps, NULL);
1842   gst_caps_unref (caps);
1843
1844   gst_segment_init (&segment, GST_FORMAT_TIME);
1845   segment.start = 0;
1846   segment.stop = 2 * GST_SECOND;
1847   segment.time = 0;
1848   event = gst_event_new_segment (&segment);
1849   gst_pad_send_event (sinkpad, event);
1850
1851   gst_buffer_replace (&handoff_buffer, NULL);
1852
1853   buffer = new_buffer (20, 0, 0, 2 * GST_SECOND, 0);
1854   gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
1855   memset (inmap.data + 15, 1, 5);
1856   gst_buffer_unmap (buffer, &inmap);
1857   ret = gst_pad_chain (sinkpad, buffer);
1858   ck_assert_int_eq (ret, GST_FLOW_OK);
1859   gst_pad_query (sinkpad, drain);
1860   fail_unless (handoff_buffer != NULL);
1861   fail_unless_equals_int (gst_buffer_get_size (handoff_buffer), 40);
1862
1863   gst_buffer_map (handoff_buffer, &outmap, GST_MAP_READ);
1864   for (i = 0; i < 10; i++) {
1865     guint32 sample;
1866
1867 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
1868     sample = GUINT32_FROM_LE (((guint32 *) outmap.data)[i]);
1869 #else
1870     sample = GUINT32_FROM_BE (((guint32 *) outmap.data)[i]);
1871 #endif
1872
1873     if (i < 5) {
1874       fail_unless_equals_int (sample, 0);
1875     } else {
1876       fail_unless_equals_int (sample, 1 << 24);
1877     }
1878   }
1879   gst_buffer_unmap (handoff_buffer, &outmap);
1880   gst_clear_buffer (&handoff_buffer);
1881
1882   gst_element_release_request_pad (audiomixer, sinkpad);
1883   gst_object_unref (sinkpad);
1884   gst_element_set_state (bin, GST_STATE_NULL);
1885   gst_bus_remove_signal_watch (bus);
1886   gst_object_unref (bus);
1887   gst_object_unref (bin);
1888   gst_query_unref (drain);
1889 }
1890
1891 GST_END_TEST;
1892
1893 /* In this test, we create two input buffers with a duration of 1 second,
1894  * and require the audiomixer to output 1.5 second long buffers.
1895  *
1896  * After we have input two buffers, we change the output format
1897  * from S8 to S32, then push a last buffer.
1898  *
1899  * This makes audioaggregator convert its "half-mixed" current_buffer,
1900  * we can then ensure that the second output buffer is as expected.
1901  */
1902 GST_START_TEST (test_change_output_caps_mid_output_buffer)
1903 {
1904   GstSegment segment;
1905   GstElement *bin, *audiomixer, *capsfilter, *sink;
1906   GstBus *bus;
1907   GstPad *sinkpad;
1908   gboolean res;
1909   GstStateChangeReturn state_res;
1910   GstFlowReturn ret;
1911   GstEvent *event;
1912   GstBuffer *buffer;
1913   GstCaps *caps;
1914   GstQuery *drain;
1915   GstMapInfo inmap;
1916   GstMapInfo outmap;
1917   guint i;
1918
1919   bin = gst_pipeline_new ("pipeline");
1920   bus = gst_element_get_bus (bin);
1921   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1922
1923   g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1924   g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1925   g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1926
1927   audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1928   g_object_set (audiomixer, "output-buffer-duration", 1500 * GST_MSECOND, NULL);
1929   capsfilter = gst_element_factory_make ("capsfilter", NULL);
1930   sink = gst_element_factory_make ("fakesink", "sink");
1931   gst_bin_add_many (GST_BIN (bin), audiomixer, capsfilter, sink, NULL);
1932
1933   res = gst_element_link_many (audiomixer, capsfilter, sink, NULL);
1934   fail_unless (res == TRUE, NULL);
1935
1936   state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
1937   ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
1938
1939   sinkpad = gst_element_request_pad_simple (audiomixer, "sink_%u");
1940   fail_if (sinkpad == NULL, NULL);
1941
1942   gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
1943
1944   caps = gst_caps_new_simple ("audio/x-raw",
1945       "format", G_TYPE_STRING, "S8",
1946       "layout", G_TYPE_STRING, "interleaved",
1947       "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1948
1949   gst_pad_set_caps (sinkpad, caps);
1950   g_object_set (capsfilter, "caps", caps, NULL);
1951   gst_caps_unref (caps);
1952
1953   gst_segment_init (&segment, GST_FORMAT_TIME);
1954   segment.start = 0;
1955   segment.stop = 3 * GST_SECOND;
1956   segment.time = 0;
1957   event = gst_event_new_segment (&segment);
1958   gst_pad_send_event (sinkpad, event);
1959
1960   buffer = new_buffer (10, 0, 0, 1 * GST_SECOND, 0);
1961   ret = gst_pad_chain (sinkpad, buffer);
1962   ck_assert_int_eq (ret, GST_FLOW_OK);
1963
1964   buffer = new_buffer (10, 0, 1 * GST_SECOND, 1 * GST_SECOND, 0);
1965   gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
1966   memset (inmap.data, 1, 10);
1967   gst_buffer_unmap (buffer, &inmap);
1968   ret = gst_pad_chain (sinkpad, buffer);
1969   ck_assert_int_eq (ret, GST_FLOW_OK);
1970
1971   drain = gst_query_new_drain ();
1972   gst_pad_query (sinkpad, drain);
1973   gst_query_unref (drain);
1974
1975   caps = gst_caps_new_simple ("audio/x-raw",
1976       "format", G_TYPE_STRING, GST_AUDIO_NE (S32),
1977       "layout", G_TYPE_STRING, "interleaved",
1978       "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1979   g_object_set (capsfilter, "caps", caps, NULL);
1980   gst_caps_unref (caps);
1981
1982   gst_buffer_replace (&handoff_buffer, NULL);
1983   g_object_set (sink, "signal-handoffs", TRUE, NULL);
1984   g_signal_connect (sink, "handoff", (GCallback) handoff_buffer_cb, NULL);
1985
1986   buffer = new_buffer (10, 0, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1987   gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
1988   memset (inmap.data, 0, 10);
1989   gst_buffer_unmap (buffer, &inmap);
1990   ret = gst_pad_chain (sinkpad, buffer);
1991   ck_assert_int_eq (ret, GST_FLOW_OK);
1992
1993   drain = gst_query_new_drain ();
1994   gst_pad_query (sinkpad, drain);
1995   gst_query_unref (drain);
1996
1997   fail_unless (handoff_buffer);
1998   fail_unless_equals_int (gst_buffer_get_size (handoff_buffer), 60);
1999
2000   gst_buffer_map (handoff_buffer, &outmap, GST_MAP_READ);
2001   for (i = 0; i < 15; i++) {
2002     guint32 sample;
2003
2004 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
2005     sample = GUINT32_FROM_LE (((guint32 *) outmap.data)[i]);
2006 #else
2007     sample = GUINT32_FROM_BE (((guint32 *) outmap.data)[i]);
2008 #endif
2009
2010     if (i < 5) {
2011       fail_unless_equals_int (sample, 1 << 24);
2012     } else {
2013       fail_unless_equals_int (sample, 0);
2014     }
2015   }
2016
2017   gst_buffer_unmap (handoff_buffer, &outmap);
2018   gst_clear_buffer (&handoff_buffer);
2019
2020   gst_element_release_request_pad (audiomixer, sinkpad);
2021   gst_object_unref (sinkpad);
2022   gst_element_set_state (bin, GST_STATE_NULL);
2023   gst_bus_remove_signal_watch (bus);
2024   gst_object_unref (bus);
2025   gst_object_unref (bin);
2026 }
2027
2028 GST_END_TEST;
2029
2030 static void
2031 check_qos_message (GstMessage * msg, GstClockTime expected_timestamp,
2032     GstClockTime expected_duration, guint64 expected_processed,
2033     guint64 expected_dropped)
2034 {
2035   gboolean live;
2036   guint64 running_time, stream_time, timestamp, duration;
2037   GstFormat format;
2038   guint64 processed, dropped;
2039
2040   gst_message_parse_qos (msg, &live, &running_time, &stream_time,
2041       &timestamp, &duration);
2042   gst_message_parse_qos_stats (msg, &format, &processed, &dropped);
2043
2044   fail_unless_equals_uint64 (running_time, expected_timestamp);
2045   fail_unless_equals_uint64 (stream_time, expected_timestamp);
2046   fail_unless_equals_uint64 (timestamp, expected_timestamp);
2047   fail_unless_equals_uint64 (duration, expected_duration);
2048
2049   fail_unless_equals_int64 (format, GST_FORMAT_DEFAULT);
2050   fail_unless_equals_uint64 (processed, expected_processed);
2051   fail_unless_equals_uint64 (dropped, expected_dropped);
2052
2053   gst_message_unref (msg);
2054 }
2055
2056 GST_START_TEST (test_qos_message_live)
2057 {
2058   GstBus *bus = gst_bus_new ();
2059   GstHarness *h, *h2;
2060   GstBuffer *b;
2061   static const char *caps_str = "audio/x-raw, format=(string)S16LE, "
2062       "rate=(int)1000, channels=(int)1, layout=(string)interleaved";
2063   GstMessage *msg;
2064   GstPad *pad;
2065
2066   h = gst_harness_new_with_padnames ("audiomixer", "sink_0", "src");
2067   g_object_set (h->element, "output-buffer-duration", GST_SECOND, NULL);
2068
2069   pad = gst_element_get_static_pad (h->element, "sink_0");
2070   g_object_set (pad, "qos-messages", TRUE, NULL);
2071   gst_object_unref (pad);
2072
2073   h2 = gst_harness_new_with_element (h->element, "sink_1", NULL);
2074   pad = gst_element_get_static_pad (h->element, "sink_1");
2075   g_object_set (pad, "qos-messages", TRUE, NULL);
2076   gst_object_unref (pad);
2077
2078   gst_element_set_bus (h->element, bus);
2079   gst_harness_play (h);
2080   gst_harness_play (h2);
2081   gst_harness_set_caps_str (h, caps_str, caps_str);
2082   gst_harness_set_src_caps_str (h2, caps_str);
2083
2084   /* Push in 1.5s of data on sink_0 and 4s on sink_1 */
2085   gst_harness_push (h, new_buffer (3000, 0, 0, 1.5 * GST_SECOND, 0));
2086   gst_harness_push (h2, new_buffer (10000, 0, 0, 5 * GST_SECOND, 0));
2087
2088   /* Pull a normal buffer at time 0 */
2089   b = gst_harness_pull (h);
2090   fail_unless_equals_int64 (GST_BUFFER_PTS (b), 0);
2091   fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2092   gst_buffer_unref (b);
2093   msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2094   fail_unless (msg == NULL);
2095
2096   gst_harness_crank_single_clock_wait (h);
2097
2098   /* Pull a buffer a time 1, the second half is faked data */
2099   b = gst_harness_pull (h);
2100   fail_unless_equals_int64 (GST_BUFFER_PTS (b), GST_SECOND);
2101   fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2102   gst_buffer_unref (b);
2103   msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2104   fail_unless (msg == NULL);
2105
2106   /* Push a buffer thar partially overlaps, expect a QoS message */
2107   b = gst_harness_push_and_pull (h, new_buffer (3000, 0, 1.5 * GST_SECOND,
2108           1.5 * GST_SECOND, GST_BUFFER_FLAG_DISCONT));
2109   fail_unless_equals_int64 (GST_BUFFER_PTS (b), 2 * GST_SECOND);
2110   fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2111   gst_buffer_unref (b);
2112
2113   msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2114   check_qos_message (msg, 1500 * GST_MSECOND, 500 * GST_MSECOND, 1500, 500);
2115
2116   /* Pull one buffer to get out the mixed data */
2117   gst_harness_crank_single_clock_wait (h);
2118   b = gst_harness_pull (h);
2119   fail_unless_equals_int64 (GST_BUFFER_PTS (b), 3 * GST_SECOND);
2120   fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2121   gst_buffer_unref (b);
2122   msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2123   fail_unless (msg == NULL);
2124
2125   /* Pull another buffer to move the time to 4s */
2126   gst_harness_crank_single_clock_wait (h);
2127   b = gst_harness_pull (h);
2128   fail_unless_equals_int64 (GST_BUFFER_PTS (b), 4 * GST_SECOND);
2129   fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2130   gst_buffer_unref (b);
2131   msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2132   fail_unless (msg == NULL);
2133
2134   /* Push a buffer that totally overlaps, it should get dropped */
2135   gst_harness_push (h, new_buffer (1000, 0, 3 * GST_SECOND,
2136           500 * GST_MSECOND, 0));
2137
2138   /* Crank it to get the next one, and expect message from the dropped buffer */
2139   gst_harness_crank_single_clock_wait (h);
2140   msg = gst_bus_timed_pop_filtered (bus, GST_SECOND, GST_MESSAGE_QOS);
2141   check_qos_message (msg, 3 * GST_SECOND, 500 * GST_MSECOND, 2500, 1000);
2142
2143   gst_element_set_bus (h->element, NULL);
2144   gst_harness_teardown (h2);
2145   gst_harness_teardown (h);
2146   gst_object_unref (bus);
2147 }
2148
2149 GST_END_TEST;
2150
2151 static Suite *
2152 audiomixer_suite (void)
2153 {
2154   Suite *s = suite_create ("audiomixer");
2155   TCase *tc_chain = tcase_create ("general");
2156
2157   suite_add_tcase (s, tc_chain);
2158   tcase_add_test (tc_chain, test_caps);
2159   tcase_add_test (tc_chain, test_filter_caps);
2160   tcase_add_test (tc_chain, test_event);
2161   tcase_add_test (tc_chain, test_play_twice);
2162   tcase_add_test (tc_chain, test_play_twice_then_add_and_play_again);
2163   tcase_add_test (tc_chain, test_live_seeking);
2164   tcase_add_test (tc_chain, test_add_pad);
2165   tcase_add_test (tc_chain, test_remove_pad);
2166   tcase_add_test (tc_chain, test_clip);
2167   tcase_add_test (tc_chain, test_duration_is_max);
2168   tcase_add_test (tc_chain, test_duration_unknown_overrides);
2169   tcase_add_test (tc_chain, test_loop);
2170   tcase_add_test (tc_chain, test_flush_start_flush_stop);
2171   tcase_add_test (tc_chain, test_sync);
2172   tcase_add_test (tc_chain, test_sync_discont);
2173   tcase_add_test (tc_chain, test_sync_discont_backwards);
2174   tcase_add_test (tc_chain, test_sync_unaligned);
2175   tcase_add_test (tc_chain, test_segment_base_handling);
2176   tcase_add_test (tc_chain, test_sinkpad_property_controller);
2177   tcase_add_test (tc_chain, test_qos_message_live);
2178   tcase_add_checked_fixture (tc_chain, test_setup, test_teardown);
2179   tcase_add_test (tc_chain, test_change_output_caps);
2180   tcase_add_test (tc_chain, test_change_output_caps_mid_output_buffer);
2181
2182   /* Use a longer timeout */
2183 #ifdef HAVE_VALGRIND
2184   if (RUNNING_ON_VALGRIND) {
2185     tcase_set_timeout (tc_chain, 5 * 60);
2186   } else
2187 #endif
2188   {
2189     /* this is shorter than the default 60 seconds?! (tpm) */
2190     /* tcase_set_timeout (tc_chain, 6); */
2191   }
2192
2193   return s;
2194 }
2195
2196 GST_CHECK_MAIN (audiomixer);