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
test_setup(void)46 test_setup (void)
47 {
48 main_loop = g_main_loop_new (NULL, FALSE);
49 }
50
51 static void
test_teardown(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 *
setup_pipeline(GstElement * audiomixer,gint num_srcs,GstElement * capsfilter)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 *
get_element_sink_pad_caps(GstElement * pipeline,const gchar * element_name)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
set_state_and_wait(GstElement * pipeline,GstState state)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
set_playing(GstElement * element)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
play_and_wait(GstElement * pipeline)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
message_received(GstBus * bus,GstMessage * message,GstPipeline * bin)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 *
new_buffer(gsize num_bytes,gint data,GstClockTime ts,GstClockTime dur,GstBufferFlags flags)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 */
GST_START_TEST(test_caps)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 */
GST_START_TEST(test_filter_caps)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
test_event_message_received(GstBus * bus,GstMessage * message,GstPipeline * bin)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
GST_START_TEST(test_event)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
test_play_twice_message_received(GstBus * bus,GstMessage * message,GstElement * bin)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
GST_START_TEST(test_play_twice)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
GST_START_TEST(test_play_twice_then_add_and_play_again)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 */
GST_START_TEST(test_live_seeking)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 */
GST_START_TEST(test_add_pad)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 */
GST_START_TEST(test_remove_pad)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
handoff_buffer_cb(GstElement * fakesink,GstBuffer * buffer,GstPad * pad,gpointer user_data)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 */
GST_START_TEST(test_clip)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
GST_START_TEST(test_duration_is_max)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
GST_START_TEST(test_duration_unknown_overrides)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
loop_segment_done(GstBus * bus,GstMessage * message,GstElement * bin)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
GST_START_TEST(test_loop)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
GST_START_TEST(test_flush_start_flush_stop)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
handoff_buffer_collect_cb(GstElement * fakesink,GstBuffer * buffer,GstPad * pad,gpointer user_data)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
run_sync_test(SendBuffersFunction send_buffers,CheckBuffersFunction check_buffers)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
send_buffers_sync(GstPad * pad1,GstPad * pad2)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
check_buffers_sync(GList * received_buffers)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
GST_START_TEST(test_sync)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
send_buffers_sync_discont(GstPad * pad1,GstPad * pad2)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
check_buffers_sync_discont(GList * received_buffers)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
GST_START_TEST(test_sync_discont)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
send_buffers_sync_discont_backwards(GstPad * pad1,GstPad * pad2)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.15 * 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
check_buffers_sync_discont_backwards(GList * received_buffers)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_equals_int (map.data[0], 0);
1500 fail_unless_equals_int (map.data[map.size - 1], 0);
1501 } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1502 fail_unless_equals_int (map.data[0], 0);
1503 fail_unless_equals_int (map.data[map.size - 1], 0);
1504 } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1505 fail_unless_equals_int (map.data[0], 1);
1506 fail_unless_equals_int (map.data[map.size - 1], 1);
1507 } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1508 fail_unless_equals_int (map.data[0], 1);
1509 fail_unless_equals_int (map.data[map.size - 1], 1);
1510 } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1511 fail_unless_equals_int (map.data[0], 2);
1512 fail_unless_equals_int (map.data[map.size - 1], 2);
1513 } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1514 fail_unless_equals_int (map.data[0], 2);
1515 fail_unless_equals_int (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
GST_START_TEST(test_sync_discont_backwards)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 static void
send_buffers_sync_discont_and_drop_backwards(GstPad * pad1,GstPad * pad2)1534 send_buffers_sync_discont_and_drop_backwards (GstPad * pad1, GstPad * pad2)
1535 {
1536 GstBuffer *buffer;
1537 GstFlowReturn ret;
1538
1539 buffer = new_buffer (2500, 1, 1 * GST_SECOND, 1.25 * GST_SECOND, 0);
1540 ret = gst_pad_chain (pad1, buffer);
1541 ck_assert_int_eq (ret, GST_FLOW_OK);
1542
1543 buffer = new_buffer (400, 1, 2 * GST_SECOND, 0.2 * GST_SECOND,
1544 GST_BUFFER_FLAG_DISCONT);
1545 ret = gst_pad_chain (pad1, buffer);
1546 ck_assert_int_eq (ret, GST_FLOW_OK);
1547
1548 buffer = new_buffer (1600, 1, 2.2 * GST_SECOND, 0.8 * GST_SECOND, 0);
1549 ret = gst_pad_chain (pad1, buffer);
1550 ck_assert_int_eq (ret, GST_FLOW_OK);
1551
1552 gst_pad_send_event (pad1, gst_event_new_eos ());
1553
1554 buffer = new_buffer (2000, 1, 2 * GST_SECOND, 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
GST_START_TEST(test_sync_discont_and_drop_backwards)1561 GST_START_TEST (test_sync_discont_and_drop_backwards)
1562 {
1563 run_sync_test (send_buffers_sync_discont_and_drop_backwards,
1564 check_buffers_sync_discont_backwards);
1565 }
1566
1567 GST_END_TEST;
1568
1569 static void
send_buffers_sync_discont_and_drop_before_output_backwards(GstPad * pad1,GstPad * pad2)1570 send_buffers_sync_discont_and_drop_before_output_backwards (GstPad * pad1,
1571 GstPad * pad2)
1572 {
1573 GstBuffer *buffer;
1574 GstFlowReturn ret;
1575
1576 buffer = new_buffer (2500, 1, 1 * GST_SECOND, 1.25 * GST_SECOND, 0);
1577 ret = gst_pad_chain (pad1, buffer);
1578 ck_assert_int_eq (ret, GST_FLOW_OK);
1579
1580 buffer = new_buffer (800, 1, 1.5 * GST_SECOND, 0.4 * GST_SECOND,
1581 GST_BUFFER_FLAG_DISCONT);
1582 ret = gst_pad_chain (pad1, buffer);
1583 ck_assert_int_eq (ret, GST_FLOW_OK);
1584
1585 buffer = new_buffer (2200, 1, 1.9 * GST_SECOND, 1.1 * GST_SECOND, 0);
1586 ret = gst_pad_chain (pad1, buffer);
1587 ck_assert_int_eq (ret, GST_FLOW_OK);
1588
1589 gst_pad_send_event (pad1, gst_event_new_eos ());
1590
1591 buffer = new_buffer (2000, 1, 2 * GST_SECOND, 1 * GST_SECOND, 0);
1592 ret = gst_pad_chain (pad2, buffer);
1593 ck_assert_int_eq (ret, GST_FLOW_OK);
1594
1595 gst_pad_send_event (pad2, gst_event_new_eos ());
1596 }
1597
GST_START_TEST(test_sync_discont_and_drop_before_output_backwards)1598 GST_START_TEST (test_sync_discont_and_drop_before_output_backwards)
1599 {
1600 run_sync_test (send_buffers_sync_discont_and_drop_before_output_backwards,
1601 check_buffers_sync_discont_backwards);
1602 }
1603
1604 GST_END_TEST;
1605
1606 static void
send_buffers_sync_unaligned(GstPad * pad1,GstPad * pad2)1607 send_buffers_sync_unaligned (GstPad * pad1, GstPad * pad2)
1608 {
1609 GstBuffer *buffer;
1610 GstFlowReturn ret;
1611
1612 buffer = new_buffer (2000, 1, 750 * GST_MSECOND, 1 * GST_SECOND, 0);
1613 ret = gst_pad_chain (pad1, buffer);
1614 ck_assert_int_eq (ret, GST_FLOW_OK);
1615
1616 buffer = new_buffer (2000, 1, 1750 * GST_MSECOND, 1 * GST_SECOND, 0);
1617 ret = gst_pad_chain (pad1, buffer);
1618 ck_assert_int_eq (ret, GST_FLOW_OK);
1619
1620 gst_pad_send_event (pad1, gst_event_new_eos ());
1621
1622 buffer = new_buffer (2000, 2, 1750 * GST_MSECOND, 1 * GST_SECOND, 0);
1623 ret = gst_pad_chain (pad2, buffer);
1624 ck_assert_int_eq (ret, GST_FLOW_OK);
1625
1626 buffer = new_buffer (2000, 2, 2750 * GST_MSECOND, 1 * GST_SECOND, 0);
1627 ret = gst_pad_chain (pad2, buffer);
1628 ck_assert_int_eq (ret, GST_FLOW_OK);
1629
1630 gst_pad_send_event (pad2, gst_event_new_eos ());
1631 }
1632
1633 static void
check_buffers_sync_unaligned(GList * received_buffers)1634 check_buffers_sync_unaligned (GList * received_buffers)
1635 {
1636 GstBuffer *buffer;
1637 GList *l;
1638 gint i;
1639 GstMapInfo map;
1640
1641 /* Should have 8 * 0.5s buffers */
1642 fail_unless_equals_int (g_list_length (received_buffers), 8);
1643 for (i = 0, l = received_buffers; l; l = l->next, i++) {
1644 buffer = l->data;
1645
1646 gst_buffer_map (buffer, &map, GST_MAP_READ);
1647
1648 if (i == 0 && GST_BUFFER_TIMESTAMP (buffer) == 0) {
1649 fail_unless (map.data[0] == 0);
1650 fail_unless (map.data[map.size - 1] == 0);
1651 } else if (i == 1 && GST_BUFFER_TIMESTAMP (buffer) == 500 * GST_MSECOND) {
1652 fail_unless (map.data[0] == 0);
1653 fail_unless (map.data[499] == 0);
1654 fail_unless (map.data[500] == 1);
1655 fail_unless (map.data[map.size - 1] == 1);
1656 } else if (i == 2 && GST_BUFFER_TIMESTAMP (buffer) == 1000 * GST_MSECOND) {
1657 fail_unless (map.data[0] == 1);
1658 fail_unless (map.data[map.size - 1] == 1);
1659 } else if (i == 3 && GST_BUFFER_TIMESTAMP (buffer) == 1500 * GST_MSECOND) {
1660 fail_unless (map.data[0] == 1);
1661 fail_unless (map.data[499] == 1);
1662 fail_unless (map.data[500] == 3);
1663 fail_unless (map.data[map.size - 1] == 3);
1664 } else if (i == 4 && GST_BUFFER_TIMESTAMP (buffer) == 2000 * GST_MSECOND) {
1665 fail_unless (map.data[0] == 3);
1666 fail_unless (map.data[499] == 3);
1667 fail_unless (map.data[500] == 3);
1668 fail_unless (map.data[map.size - 1] == 3);
1669 } else if (i == 5 && GST_BUFFER_TIMESTAMP (buffer) == 2500 * GST_MSECOND) {
1670 fail_unless (map.data[0] == 3);
1671 fail_unless (map.data[499] == 3);
1672 fail_unless (map.data[500] == 2);
1673 fail_unless (map.data[map.size - 1] == 2);
1674 } else if (i == 6 && GST_BUFFER_TIMESTAMP (buffer) == 3000 * GST_MSECOND) {
1675 fail_unless (map.data[0] == 2);
1676 fail_unless (map.data[499] == 2);
1677 fail_unless (map.data[500] == 2);
1678 fail_unless (map.data[map.size - 1] == 2);
1679 } else if (i == 7 && GST_BUFFER_TIMESTAMP (buffer) == 3500 * GST_MSECOND) {
1680 fail_unless (map.size == 500);
1681 fail_unless (GST_BUFFER_DURATION (buffer) == 250 * GST_MSECOND);
1682 fail_unless (map.data[0] == 2);
1683 fail_unless (map.data[499] == 2);
1684 } else {
1685 g_assert_not_reached ();
1686 }
1687
1688 gst_buffer_unmap (buffer, &map);
1689
1690 }
1691 }
1692
GST_START_TEST(test_sync_unaligned)1693 GST_START_TEST (test_sync_unaligned)
1694 {
1695 run_sync_test (send_buffers_sync_unaligned, check_buffers_sync_unaligned);
1696 }
1697
1698 GST_END_TEST;
1699
GST_START_TEST(test_segment_base_handling)1700 GST_START_TEST (test_segment_base_handling)
1701 {
1702 GstElement *pipeline, *sink, *mix, *src1, *src2;
1703 GstPad *srcpad, *sinkpad;
1704 GstClockTime end_time;
1705 GstSample *last_sample = NULL;
1706 GstSample *sample;
1707 GstBuffer *buf;
1708 GstCaps *caps;
1709
1710 caps = gst_caps_new_simple ("audio/x-raw", "rate", G_TYPE_INT, 44100,
1711 "channels", G_TYPE_INT, 2, NULL);
1712
1713 pipeline = gst_pipeline_new ("pipeline");
1714 mix = gst_element_factory_make ("audiomixer", "audiomixer");
1715 sink = gst_element_factory_make ("appsink", "sink");
1716 g_object_set (sink, "caps", caps, "sync", FALSE, NULL);
1717 gst_caps_unref (caps);
1718 /* 50 buffers of 1/10 sec = 5 sec */
1719 src1 = gst_element_factory_make ("audiotestsrc", "src1");
1720 g_object_set (src1, "samplesperbuffer", 4410, "num-buffers", 50, NULL);
1721 src2 = gst_element_factory_make ("audiotestsrc", "src2");
1722 g_object_set (src2, "samplesperbuffer", 4410, "num-buffers", 50, NULL);
1723 gst_bin_add_many (GST_BIN (pipeline), src1, src2, mix, sink, NULL);
1724 fail_unless (gst_element_link (mix, sink));
1725
1726 srcpad = gst_element_get_static_pad (src1, "src");
1727 sinkpad = gst_element_request_pad_simple (mix, "sink_1");
1728 fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1729 gst_object_unref (sinkpad);
1730 gst_object_unref (srcpad);
1731
1732 srcpad = gst_element_get_static_pad (src2, "src");
1733 sinkpad = gst_element_request_pad_simple (mix, "sink_2");
1734 fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1735 /* set a pad offset of another 5 seconds */
1736 gst_pad_set_offset (sinkpad, 5 * GST_SECOND);
1737 gst_object_unref (sinkpad);
1738 gst_object_unref (srcpad);
1739
1740 gst_element_set_state (pipeline, GST_STATE_PLAYING);
1741
1742 do {
1743 g_signal_emit_by_name (sink, "pull-sample", &sample);
1744 if (sample == NULL)
1745 break;
1746 if (last_sample)
1747 gst_sample_unref (last_sample);
1748 last_sample = sample;
1749 } while (TRUE);
1750
1751 buf = gst_sample_get_buffer (last_sample);
1752 end_time = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
1753 fail_unless_equals_int64 (end_time, 10 * GST_SECOND);
1754 gst_sample_unref (last_sample);
1755
1756 gst_element_set_state (pipeline, GST_STATE_NULL);
1757 gst_object_unref (pipeline);
1758 }
1759
1760 GST_END_TEST;
1761
1762 static void
set_pad_volume_fade(GstPad * pad,GstClockTime start,gdouble start_value,GstClockTime end,gdouble end_value)1763 set_pad_volume_fade (GstPad * pad, GstClockTime start, gdouble start_value,
1764 GstClockTime end, gdouble end_value)
1765 {
1766 GstControlSource *cs;
1767 GstTimedValueControlSource *tvcs;
1768
1769 cs = gst_interpolation_control_source_new ();
1770 fail_unless (gst_object_add_control_binding (GST_OBJECT_CAST (pad),
1771 gst_direct_control_binding_new_absolute (GST_OBJECT_CAST (pad),
1772 "volume", cs)));
1773
1774 /* set volume interpolation mode */
1775 g_object_set (cs, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
1776
1777 tvcs = (GstTimedValueControlSource *) cs;
1778 fail_unless (gst_timed_value_control_source_set (tvcs, start, start_value));
1779 fail_unless (gst_timed_value_control_source_set (tvcs, end, end_value));
1780 gst_object_unref (cs);
1781 }
1782
GST_START_TEST(test_sinkpad_property_controller)1783 GST_START_TEST (test_sinkpad_property_controller)
1784 {
1785 GstBus *bus;
1786 GstMessage *msg;
1787 GstElement *pipeline, *sink, *mix, *src1;
1788 GstPad *srcpad, *sinkpad;
1789 GError *error = NULL;
1790 gchar *debug;
1791
1792 pipeline = gst_pipeline_new ("pipeline");
1793 mix = gst_element_factory_make ("audiomixer", "audiomixer");
1794 sink = gst_element_factory_make ("fakesink", "sink");
1795 src1 = gst_element_factory_make ("audiotestsrc", "src1");
1796 g_object_set (src1, "num-buffers", 100, NULL);
1797 gst_bin_add_many (GST_BIN (pipeline), src1, mix, sink, NULL);
1798 fail_unless (gst_element_link (mix, sink));
1799
1800 srcpad = gst_element_get_static_pad (src1, "src");
1801 sinkpad = gst_element_request_pad_simple (mix, "sink_0");
1802 fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK);
1803 set_pad_volume_fade (sinkpad, 0, 0, 1.0, 2.0);
1804 gst_object_unref (sinkpad);
1805 gst_object_unref (srcpad);
1806
1807 gst_element_set_state (pipeline, GST_STATE_PLAYING);
1808
1809 bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
1810 msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE,
1811 GST_MESSAGE_EOS | GST_MESSAGE_ERROR);
1812 switch (GST_MESSAGE_TYPE (msg)) {
1813 case GST_MESSAGE_ERROR:
1814 gst_message_parse_error (msg, &error, &debug);
1815 g_printerr ("ERROR from element %s: %s\n",
1816 GST_OBJECT_NAME (msg->src), error->message);
1817 g_printerr ("Debug info: %s\n", debug);
1818 g_error_free (error);
1819 g_free (debug);
1820 break;
1821 case GST_MESSAGE_EOS:
1822 break;
1823 default:
1824 g_assert_not_reached ();
1825 }
1826 gst_message_unref (msg);
1827 g_object_unref (bus);
1828
1829 gst_element_set_state (pipeline, GST_STATE_NULL);
1830 gst_object_unref (pipeline);
1831 }
1832
1833 GST_END_TEST;
1834
1835 static void
change_src_caps(GstElement * fakesink,GstBuffer * buffer,GstPad * pad,GstElement * capsfilter)1836 change_src_caps (GstElement * fakesink, GstBuffer * buffer, GstPad * pad,
1837 GstElement * capsfilter)
1838 {
1839 GstCaps *caps = gst_caps_new_simple ("audio/x-raw",
1840 "format", G_TYPE_STRING, GST_AUDIO_NE (S32),
1841 "layout", G_TYPE_STRING, "interleaved",
1842 "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1843
1844 g_object_set (capsfilter, "caps", caps, NULL);
1845 gst_caps_unref (caps);
1846 g_signal_connect (fakesink, "handoff", (GCallback) handoff_buffer_cb, NULL);
1847 g_signal_handlers_disconnect_by_func (fakesink, change_src_caps, capsfilter);
1848 }
1849
1850 /* In this test, we create an input buffer with a duration of 2 seconds,
1851 * and require the audiomixer to output 1 second long buffers.
1852 * The input buffer will thus be mixed twice, and the audiomixer will
1853 * output two buffers.
1854 *
1855 * After audiomixer has output a first buffer, we change its output format
1856 * from S8 to S32. As our sample rate stays the same at 10 fps, and we use
1857 * mono, the first buffer should be 10 bytes long, and the second 40.
1858 *
1859 * The input buffer is made up of 15 0-valued bytes, and 5 1-valued bytes.
1860 * We verify that the second buffer contains 5 0-valued integers, and
1861 * 5 1 << 24 valued integers.
1862 */
GST_START_TEST(test_change_output_caps)1863 GST_START_TEST (test_change_output_caps)
1864 {
1865 GstSegment segment;
1866 GstElement *bin, *audiomixer, *capsfilter, *sink;
1867 GstBus *bus;
1868 GstPad *sinkpad;
1869 gboolean res;
1870 GstStateChangeReturn state_res;
1871 GstFlowReturn ret;
1872 GstEvent *event;
1873 GstBuffer *buffer;
1874 GstCaps *caps;
1875 GstQuery *drain = gst_query_new_drain ();
1876 GstMapInfo inmap;
1877 GstMapInfo outmap;
1878 gsize i;
1879
1880 bin = gst_pipeline_new ("pipeline");
1881 bus = gst_element_get_bus (bin);
1882 gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1883
1884 g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1885 g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1886 g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1887
1888 audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
1889 g_object_set (audiomixer, "output-buffer-duration", GST_SECOND, NULL);
1890 capsfilter = gst_element_factory_make ("capsfilter", NULL);
1891 sink = gst_element_factory_make ("fakesink", "sink");
1892 g_object_set (sink, "signal-handoffs", TRUE, NULL);
1893 g_signal_connect (sink, "handoff", (GCallback) change_src_caps, capsfilter);
1894 gst_bin_add_many (GST_BIN (bin), audiomixer, capsfilter, sink, NULL);
1895
1896 res = gst_element_link_many (audiomixer, capsfilter, sink, NULL);
1897 fail_unless (res == TRUE, NULL);
1898
1899 state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
1900 ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
1901
1902 sinkpad = gst_element_request_pad_simple (audiomixer, "sink_%u");
1903 fail_if (sinkpad == NULL, NULL);
1904
1905 gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
1906
1907 caps = gst_caps_new_simple ("audio/x-raw",
1908 "format", G_TYPE_STRING, "S8",
1909 "layout", G_TYPE_STRING, "interleaved",
1910 "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
1911
1912 gst_pad_set_caps (sinkpad, caps);
1913 g_object_set (capsfilter, "caps", caps, NULL);
1914 gst_caps_unref (caps);
1915
1916 gst_segment_init (&segment, GST_FORMAT_TIME);
1917 segment.start = 0;
1918 segment.stop = 2 * GST_SECOND;
1919 segment.time = 0;
1920 event = gst_event_new_segment (&segment);
1921 gst_pad_send_event (sinkpad, event);
1922
1923 gst_buffer_replace (&handoff_buffer, NULL);
1924
1925 buffer = new_buffer (20, 0, 0, 2 * GST_SECOND, 0);
1926 gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
1927 memset (inmap.data + 15, 1, 5);
1928 gst_buffer_unmap (buffer, &inmap);
1929 ret = gst_pad_chain (sinkpad, buffer);
1930 ck_assert_int_eq (ret, GST_FLOW_OK);
1931 gst_pad_query (sinkpad, drain);
1932 fail_unless (handoff_buffer != NULL);
1933 fail_unless_equals_int (gst_buffer_get_size (handoff_buffer), 40);
1934
1935 gst_buffer_map (handoff_buffer, &outmap, GST_MAP_READ);
1936 for (i = 0; i < 10; i++) {
1937 guint32 sample;
1938
1939 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
1940 sample = GUINT32_FROM_LE (((guint32 *) outmap.data)[i]);
1941 #else
1942 sample = GUINT32_FROM_BE (((guint32 *) outmap.data)[i]);
1943 #endif
1944
1945 if (i < 5) {
1946 fail_unless_equals_int (sample, 0);
1947 } else {
1948 fail_unless_equals_int (sample, 1 << 24);
1949 }
1950 }
1951 gst_buffer_unmap (handoff_buffer, &outmap);
1952 gst_clear_buffer (&handoff_buffer);
1953
1954 gst_element_release_request_pad (audiomixer, sinkpad);
1955 gst_object_unref (sinkpad);
1956 gst_element_set_state (bin, GST_STATE_NULL);
1957 gst_bus_remove_signal_watch (bus);
1958 gst_object_unref (bus);
1959 gst_object_unref (bin);
1960 gst_query_unref (drain);
1961 }
1962
1963 GST_END_TEST;
1964
1965 /* In this test, we create two input buffers with a duration of 1 second,
1966 * and require the audiomixer to output 1.5 second long buffers.
1967 *
1968 * After we have input two buffers, we change the output format
1969 * from S8 to S32, then push a last buffer.
1970 *
1971 * This makes audioaggregator convert its "half-mixed" current_buffer,
1972 * we can then ensure that the second output buffer is as expected.
1973 */
GST_START_TEST(test_change_output_caps_mid_output_buffer)1974 GST_START_TEST (test_change_output_caps_mid_output_buffer)
1975 {
1976 GstSegment segment;
1977 GstElement *bin, *audiomixer, *capsfilter, *sink;
1978 GstBus *bus;
1979 GstPad *sinkpad;
1980 gboolean res;
1981 GstStateChangeReturn state_res;
1982 GstFlowReturn ret;
1983 GstEvent *event;
1984 GstBuffer *buffer;
1985 GstCaps *caps;
1986 GstQuery *drain;
1987 GstMapInfo inmap;
1988 GstMapInfo outmap;
1989 guint i;
1990
1991 bin = gst_pipeline_new ("pipeline");
1992 bus = gst_element_get_bus (bin);
1993 gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
1994
1995 g_signal_connect (bus, "message::error", (GCallback) message_received, bin);
1996 g_signal_connect (bus, "message::warning", (GCallback) message_received, bin);
1997 g_signal_connect (bus, "message::eos", (GCallback) message_received, bin);
1998
1999 audiomixer = gst_element_factory_make ("audiomixer", "audiomixer");
2000 g_object_set (audiomixer, "output-buffer-duration", 1500 * GST_MSECOND, NULL);
2001 capsfilter = gst_element_factory_make ("capsfilter", NULL);
2002 sink = gst_element_factory_make ("fakesink", "sink");
2003 gst_bin_add_many (GST_BIN (bin), audiomixer, capsfilter, sink, NULL);
2004
2005 res = gst_element_link_many (audiomixer, capsfilter, sink, NULL);
2006 fail_unless (res == TRUE, NULL);
2007
2008 state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
2009 ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
2010
2011 sinkpad = gst_element_request_pad_simple (audiomixer, "sink_%u");
2012 fail_if (sinkpad == NULL, NULL);
2013
2014 gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
2015
2016 caps = gst_caps_new_simple ("audio/x-raw",
2017 "format", G_TYPE_STRING, "S8",
2018 "layout", G_TYPE_STRING, "interleaved",
2019 "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
2020
2021 gst_pad_set_caps (sinkpad, caps);
2022 g_object_set (capsfilter, "caps", caps, NULL);
2023 gst_caps_unref (caps);
2024
2025 gst_segment_init (&segment, GST_FORMAT_TIME);
2026 segment.start = 0;
2027 segment.stop = 3 * GST_SECOND;
2028 segment.time = 0;
2029 event = gst_event_new_segment (&segment);
2030 gst_pad_send_event (sinkpad, event);
2031
2032 buffer = new_buffer (10, 0, 0, 1 * GST_SECOND, 0);
2033 ret = gst_pad_chain (sinkpad, buffer);
2034 ck_assert_int_eq (ret, GST_FLOW_OK);
2035
2036 buffer = new_buffer (10, 0, 1 * GST_SECOND, 1 * GST_SECOND, 0);
2037 gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
2038 memset (inmap.data, 1, 10);
2039 gst_buffer_unmap (buffer, &inmap);
2040 ret = gst_pad_chain (sinkpad, buffer);
2041 ck_assert_int_eq (ret, GST_FLOW_OK);
2042
2043 drain = gst_query_new_drain ();
2044 gst_pad_query (sinkpad, drain);
2045 gst_query_unref (drain);
2046
2047 caps = gst_caps_new_simple ("audio/x-raw",
2048 "format", G_TYPE_STRING, GST_AUDIO_NE (S32),
2049 "layout", G_TYPE_STRING, "interleaved",
2050 "rate", G_TYPE_INT, 10, "channels", G_TYPE_INT, 1, NULL);
2051 g_object_set (capsfilter, "caps", caps, NULL);
2052 gst_caps_unref (caps);
2053
2054 gst_buffer_replace (&handoff_buffer, NULL);
2055 g_object_set (sink, "signal-handoffs", TRUE, NULL);
2056 g_signal_connect (sink, "handoff", (GCallback) handoff_buffer_cb, NULL);
2057
2058 buffer = new_buffer (10, 0, 2 * GST_SECOND, 1 * GST_SECOND, 0);
2059 gst_buffer_map (buffer, &inmap, GST_MAP_WRITE);
2060 memset (inmap.data, 0, 10);
2061 gst_buffer_unmap (buffer, &inmap);
2062 ret = gst_pad_chain (sinkpad, buffer);
2063 ck_assert_int_eq (ret, GST_FLOW_OK);
2064
2065 drain = gst_query_new_drain ();
2066 gst_pad_query (sinkpad, drain);
2067 gst_query_unref (drain);
2068
2069 fail_unless (handoff_buffer);
2070 fail_unless_equals_int (gst_buffer_get_size (handoff_buffer), 60);
2071
2072 gst_buffer_map (handoff_buffer, &outmap, GST_MAP_READ);
2073 for (i = 0; i < 15; i++) {
2074 guint32 sample;
2075
2076 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
2077 sample = GUINT32_FROM_LE (((guint32 *) outmap.data)[i]);
2078 #else
2079 sample = GUINT32_FROM_BE (((guint32 *) outmap.data)[i]);
2080 #endif
2081
2082 if (i < 5) {
2083 fail_unless_equals_int (sample, 1 << 24);
2084 } else {
2085 fail_unless_equals_int (sample, 0);
2086 }
2087 }
2088
2089 gst_buffer_unmap (handoff_buffer, &outmap);
2090 gst_clear_buffer (&handoff_buffer);
2091
2092 gst_element_release_request_pad (audiomixer, sinkpad);
2093 gst_object_unref (sinkpad);
2094 gst_element_set_state (bin, GST_STATE_NULL);
2095 gst_bus_remove_signal_watch (bus);
2096 gst_object_unref (bus);
2097 gst_object_unref (bin);
2098 }
2099
2100 GST_END_TEST;
2101
2102 static void
check_qos_message(GstMessage * msg,GstClockTime expected_timestamp,GstClockTime expected_duration,guint64 expected_processed,guint64 expected_dropped)2103 check_qos_message (GstMessage * msg, GstClockTime expected_timestamp,
2104 GstClockTime expected_duration, guint64 expected_processed,
2105 guint64 expected_dropped)
2106 {
2107 gboolean live;
2108 guint64 running_time, stream_time, timestamp, duration;
2109 GstFormat format;
2110 guint64 processed, dropped;
2111
2112 gst_message_parse_qos (msg, &live, &running_time, &stream_time,
2113 ×tamp, &duration);
2114 gst_message_parse_qos_stats (msg, &format, &processed, &dropped);
2115
2116 fail_unless_equals_uint64 (running_time, expected_timestamp);
2117 fail_unless_equals_uint64 (stream_time, expected_timestamp);
2118 fail_unless_equals_uint64 (timestamp, expected_timestamp);
2119 fail_unless_equals_uint64 (duration, expected_duration);
2120
2121 fail_unless_equals_int64 (format, GST_FORMAT_DEFAULT);
2122 fail_unless_equals_uint64 (processed, expected_processed);
2123 fail_unless_equals_uint64 (dropped, expected_dropped);
2124
2125 gst_message_unref (msg);
2126 }
2127
GST_START_TEST(test_qos_message_live)2128 GST_START_TEST (test_qos_message_live)
2129 {
2130 GstBus *bus = gst_bus_new ();
2131 GstHarness *h, *h2;
2132 GstBuffer *b;
2133 static const char *caps_str = "audio/x-raw, format=(string)S16LE, "
2134 "rate=(int)1000, channels=(int)1, layout=(string)interleaved";
2135 GstMessage *msg;
2136 GstPad *pad;
2137
2138 h = gst_harness_new_with_padnames ("audiomixer", "sink_0", "src");
2139 g_object_set (h->element, "output-buffer-duration", GST_SECOND, NULL);
2140
2141 pad = gst_element_get_static_pad (h->element, "sink_0");
2142 g_object_set (pad, "qos-messages", TRUE, NULL);
2143 gst_object_unref (pad);
2144
2145 h2 = gst_harness_new_with_element (h->element, "sink_1", NULL);
2146 pad = gst_element_get_static_pad (h->element, "sink_1");
2147 g_object_set (pad, "qos-messages", TRUE, NULL);
2148 gst_object_unref (pad);
2149
2150 gst_element_set_bus (h->element, bus);
2151 gst_harness_play (h);
2152 gst_harness_play (h2);
2153 gst_harness_set_caps_str (h, caps_str, caps_str);
2154 gst_harness_set_src_caps_str (h2, caps_str);
2155
2156 /* Push in 1.5s of data on sink_0 and 4s on sink_1 */
2157 gst_harness_push (h, new_buffer (3000, 0, 0, 1.5 * GST_SECOND, 0));
2158 gst_harness_push (h2, new_buffer (10000, 0, 0, 5 * GST_SECOND, 0));
2159
2160 /* Pull a normal buffer at time 0 */
2161 b = gst_harness_pull (h);
2162 fail_unless_equals_int64 (GST_BUFFER_PTS (b), 0);
2163 fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2164 gst_buffer_unref (b);
2165 msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2166 fail_unless (msg == NULL);
2167
2168 gst_harness_crank_single_clock_wait (h);
2169
2170 /* Pull a buffer a time 1, the second half is faked data */
2171 b = gst_harness_pull (h);
2172 fail_unless_equals_int64 (GST_BUFFER_PTS (b), GST_SECOND);
2173 fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2174 gst_buffer_unref (b);
2175 msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2176 fail_unless (msg == NULL);
2177
2178 /* Push a buffer thar partially overlaps, expect a QoS message */
2179 b = gst_harness_push_and_pull (h, new_buffer (3000, 0, 1.5 * GST_SECOND,
2180 1.5 * GST_SECOND, GST_BUFFER_FLAG_DISCONT));
2181 fail_unless_equals_int64 (GST_BUFFER_PTS (b), 2 * GST_SECOND);
2182 fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2183 gst_buffer_unref (b);
2184
2185 msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2186 check_qos_message (msg, 1500 * GST_MSECOND, 500 * GST_MSECOND, 1500, 500);
2187
2188 /* Pull one buffer to get out the mixed data */
2189 gst_harness_crank_single_clock_wait (h);
2190 b = gst_harness_pull (h);
2191 fail_unless_equals_int64 (GST_BUFFER_PTS (b), 3 * GST_SECOND);
2192 fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2193 gst_buffer_unref (b);
2194 msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2195 fail_unless (msg == NULL);
2196
2197 /* Pull another buffer to move the time to 4s */
2198 gst_harness_crank_single_clock_wait (h);
2199 b = gst_harness_pull (h);
2200 fail_unless_equals_int64 (GST_BUFFER_PTS (b), 4 * GST_SECOND);
2201 fail_unless_equals_int64 (GST_BUFFER_DURATION (b), GST_SECOND);
2202 gst_buffer_unref (b);
2203 msg = gst_bus_pop_filtered (bus, GST_MESSAGE_QOS);
2204 fail_unless (msg == NULL);
2205
2206 /* Push a buffer that totally overlaps, it should get dropped */
2207 gst_harness_push (h, new_buffer (1000, 0, 3 * GST_SECOND,
2208 500 * GST_MSECOND, 0));
2209
2210 /* Crank it to get the next one, and expect message from the dropped buffer */
2211 gst_harness_crank_single_clock_wait (h);
2212 msg = gst_bus_timed_pop_filtered (bus, GST_SECOND, GST_MESSAGE_QOS);
2213 check_qos_message (msg, 3 * GST_SECOND, 500 * GST_MSECOND, 2500, 1000);
2214
2215 gst_element_set_bus (h->element, NULL);
2216 gst_harness_teardown (h2);
2217 gst_harness_teardown (h);
2218 gst_object_unref (bus);
2219 }
2220
2221 GST_END_TEST;
2222
2223 static Suite *
audiomixer_suite(void)2224 audiomixer_suite (void)
2225 {
2226 Suite *s = suite_create ("audiomixer");
2227 TCase *tc_chain = tcase_create ("general");
2228
2229 suite_add_tcase (s, tc_chain);
2230 tcase_add_test (tc_chain, test_caps);
2231 tcase_add_test (tc_chain, test_filter_caps);
2232 tcase_add_test (tc_chain, test_event);
2233 tcase_add_test (tc_chain, test_play_twice);
2234 tcase_add_test (tc_chain, test_play_twice_then_add_and_play_again);
2235 tcase_add_test (tc_chain, test_live_seeking);
2236 tcase_add_test (tc_chain, test_add_pad);
2237 tcase_add_test (tc_chain, test_remove_pad);
2238 tcase_add_test (tc_chain, test_clip);
2239 tcase_add_test (tc_chain, test_duration_is_max);
2240 tcase_add_test (tc_chain, test_duration_unknown_overrides);
2241 tcase_add_test (tc_chain, test_loop);
2242 tcase_add_test (tc_chain, test_flush_start_flush_stop);
2243 tcase_add_test (tc_chain, test_sync);
2244 tcase_add_test (tc_chain, test_sync_discont);
2245 tcase_add_test (tc_chain, test_sync_discont_backwards);
2246 tcase_add_test (tc_chain, test_sync_discont_and_drop_backwards);
2247 tcase_add_test (tc_chain, test_sync_discont_and_drop_before_output_backwards);
2248 tcase_add_test (tc_chain, test_sync_unaligned);
2249 tcase_add_test (tc_chain, test_segment_base_handling);
2250 tcase_add_test (tc_chain, test_sinkpad_property_controller);
2251 tcase_add_test (tc_chain, test_qos_message_live);
2252 tcase_add_checked_fixture (tc_chain, test_setup, test_teardown);
2253 tcase_add_test (tc_chain, test_change_output_caps);
2254 tcase_add_test (tc_chain, test_change_output_caps_mid_output_buffer);
2255
2256 /* Use a longer timeout */
2257 #ifdef HAVE_VALGRIND
2258 if (RUNNING_ON_VALGRIND) {
2259 tcase_set_timeout (tc_chain, 5 * 60);
2260 } else
2261 #endif
2262 {
2263 /* this is shorter than the default 60 seconds?! (tpm) */
2264 /* tcase_set_timeout (tc_chain, 6); */
2265 }
2266
2267 return s;
2268 }
2269
2270 GST_CHECK_MAIN (audiomixer);
2271