3 * Unit test for gstrtpbin sending rtp packets using GstBufferList.
4 * Copyright (C) 2009 Branko Subasic <branko dot subasic at axis dot com>
5 * Copyright 2019, Collabora Ltd.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
23 #include <gst/check/gstcheck.h>
25 #include <gst/rtp/gstrtpbuffer.h>
26 #include <gst/rtp/gstrtcpbuffer.h>
28 /* UDP/IP is assumed for bandwidth calculation */
29 #define UDP_IP_HEADER_OVERHEAD 28
31 /* This test makes sure that RTP packets sent as buffer lists are sent through
32 * the rtpbin as they are supposed to, and not corrupted in any way.
37 "application/x-rtp, " \
38 "media=(string)video, " \
39 "clock-rate=(int)90000, " \
40 "encoding-name=(string)H264, " \
41 "profile-level-id=(string)4d4015, " \
43 "ssrc=(guint)2633237432, " \
44 "clock-base=(guint)1868267015, " \
45 "seqnum-base=(guint)54229"
48 /* RTP headers and the first 2 bytes of the payload (FU indicator and FU header)
50 static const guint8 rtp_header[2][14] = {
51 {0x80, 0x60, 0xbb, 0xb7, 0x5c, 0xe9, 0x09,
52 0x0d, 0xf5, 0x9c, 0x43, 0x55, 0x1c, 0x86},
53 {0x80, 0x60, 0xbb, 0xb8, 0x5c, 0xe9, 0x09,
54 0x0d, 0xf5, 0x9c, 0x43, 0x55, 0x1c, 0x46}
57 static const guint rtp_header_len[] = {
64 static const char *payload =
65 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
66 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
67 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
68 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
69 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
70 "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
71 "0123456789ABSDEF0123456";
73 static const guint payload_offset[] = {
77 static const guint payload_len[] = {
82 static GstBuffer *original_buffer = NULL;
84 static GstStaticPadTemplate sinktemplate_rtcp = GST_STATIC_PAD_TEMPLATE ("sink",
87 GST_STATIC_CAPS ("application/x-rtcp"));
89 static GstStaticPadTemplate srctemplate_rtcp = GST_STATIC_PAD_TEMPLATE ("src",
92 GST_STATIC_CAPS ("application/x-rtcp"));
94 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
97 GST_STATIC_CAPS ("application/x-rtp"));
99 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
102 GST_STATIC_CAPS ("application/x-rtp"));
106 create_original_buffer (void)
108 if (original_buffer != NULL)
109 return original_buffer;
112 gst_buffer_new_wrapped ((guint8 *) payload, strlen (payload));
113 fail_unless (original_buffer != NULL);
115 GST_BUFFER_TIMESTAMP (original_buffer) =
116 gst_clock_get_internal_time (gst_system_clock_obtain ());
118 return original_buffer;
122 create_rtp_packet_buffer (gconstpointer header, gint header_size,
123 GstBuffer * payload_buffer, gint payload_offset, gint payload_size)
126 GstBuffer *sub_buffer;
128 /* Create buffer with RTP header. */
129 buffer = gst_buffer_new_allocate (NULL, header_size, NULL);
130 gst_buffer_fill (buffer, 0, header, header_size);
131 gst_buffer_copy_into (buffer, payload_buffer, GST_BUFFER_COPY_METADATA, 0,
134 /* Create the payload buffer and add it to the current buffer. */
136 gst_buffer_copy_region (payload_buffer, GST_BUFFER_COPY_MEMORY,
137 payload_offset, payload_size);
139 buffer = gst_buffer_append (buffer, sub_buffer);
140 fail_if (buffer == NULL);
146 create_rtp_buffer_fields (gconstpointer header, gint header_size,
147 GstBuffer * payload_buffer, gint payload_offset, gint payload_size,
148 guint16 seqnum, guint32 timestamp)
157 create_rtp_packet_buffer (header, header_size, payload_buffer,
158 payload_offset, payload_size);
159 fail_if (buffer == NULL);
161 memory = gst_buffer_get_memory (buffer, 0);
162 ret = gst_memory_map (memory, &info, GST_MAP_READ);
163 fail_if (ret == FALSE);
165 info.data[2] = (seqnum >> 8) & 0xff;
166 info.data[3] = seqnum & 0xff;
168 tmp = (guint32 *) & (info.data[4]);
169 *tmp = g_htonl (timestamp);
171 gst_memory_unmap (memory, &info);
172 gst_memory_unref (memory);
178 check_seqnum (GstBuffer * buffer, guint16 seqnum)
183 guint16 current_seqnum;
185 fail_if (buffer == NULL);
187 memory = gst_buffer_get_memory (buffer, 0);
188 ret = gst_memory_map (memory, &info, GST_MAP_READ);
189 fail_if (ret == FALSE);
191 current_seqnum = info.data[2] << 8 | info.data[3];
192 fail_unless (current_seqnum == seqnum);
194 gst_memory_unmap (memory, &info);
195 gst_memory_unref (memory);
199 check_timestamp (GstBuffer * buffer, guint32 timestamp)
204 guint32 current_timestamp;
206 fail_if (buffer == NULL);
208 memory = gst_buffer_get_memory (buffer, 0);
209 ret = gst_memory_map (memory, &info, GST_MAP_READ);
210 fail_if (ret == FALSE);
212 current_timestamp = g_ntohl (*((guint32 *) & (info.data[4])));
213 fail_unless (current_timestamp == timestamp);
215 gst_memory_unmap (memory, &info);
216 gst_memory_unref (memory);
220 check_header (GstBuffer * buffer, guint index)
226 fail_if (buffer == NULL);
227 fail_unless (index < 2);
229 memory = gst_buffer_get_memory (buffer, 0);
230 ret = gst_memory_map (memory, &info, GST_MAP_READ);
231 fail_if (ret == FALSE);
233 fail_unless (info.size == rtp_header_len[index]);
235 /* Can't do a memcmp() on the whole header, cause the SSRC (bytes 8-11) will
236 * most likely be changed in gstrtpbin.
238 fail_unless (info.data != NULL);
239 fail_unless_equals_uint64 (*(guint64 *) info.data,
240 *(guint64 *) rtp_header[index]);
241 fail_unless (*(guint16 *) (info.data + 12) ==
242 *(guint16 *) (rtp_header[index] + 12));
244 gst_memory_unmap (memory, &info);
245 gst_memory_unref (memory);
249 check_payload (GstBuffer * buffer, guint index)
255 fail_if (buffer == NULL);
256 fail_unless (index < 2);
258 memory = gst_buffer_get_memory (buffer, 1);
259 ret = gst_memory_map (memory, &info, GST_MAP_READ);
260 fail_if (ret == FALSE);
262 fail_unless (info.size == payload_len[index]);
263 fail_if (info.data != (gpointer) (payload + payload_offset[index]));
264 fail_if (memcmp (info.data, payload + payload_offset[index],
265 payload_len[index]));
267 gst_memory_unmap (memory, &info);
268 gst_memory_unref (memory);
272 check_packet (GstBufferList * list, guint list_index, guint packet_index)
276 fail_unless (list != NULL);
278 fail_unless ((buffer = gst_buffer_list_get (list, list_index)) != NULL);
279 fail_unless (gst_buffer_n_memory (buffer) == 2);
281 fail_unless (GST_BUFFER_TIMESTAMP (buffer) ==
282 GST_BUFFER_TIMESTAMP (original_buffer));
284 check_header (buffer, packet_index);
285 check_payload (buffer, packet_index);
289 * Used to verify that the chain_list function is actually implemented by the
290 * element and called when executing the pipeline. This is needed because pads
291 * always have a default chain_list handler which handle buffers in a buffer
292 * list individually, and pushing a list to a pad can succeed even if no
293 * chain_list handler has been set.
295 static gboolean chain_list_func_called;
296 static guint chain_list_bytes_received;
298 /* Create two packets with different payloads. */
299 static GstBufferList *
300 create_buffer_list (void)
303 GstBuffer *orig_buffer;
306 orig_buffer = create_original_buffer ();
307 fail_if (orig_buffer == NULL);
309 list = gst_buffer_list_new ();
310 fail_if (list == NULL);
312 /*** First packet. **/
314 create_rtp_packet_buffer (&rtp_header[0], rtp_header_len[0], orig_buffer,
315 payload_offset[0], payload_len[0]);
316 gst_buffer_list_add (list, buffer);
318 /*** Second packet. ***/
320 create_rtp_packet_buffer (&rtp_header[1], rtp_header_len[1], orig_buffer,
321 payload_offset[1], payload_len[1]);
322 gst_buffer_list_add (list, buffer);
327 /* Check that the correct packets have been pushed out of the element. */
329 sink_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list)
331 GstCaps *current_caps;
334 chain_list_func_called = TRUE;
336 current_caps = gst_pad_get_current_caps (pad);
337 fail_unless (current_caps != NULL);
339 caps = gst_caps_from_string (TEST_CAPS);
340 fail_unless (caps != NULL);
342 fail_unless (gst_caps_is_equal (caps, current_caps));
343 gst_caps_unref (caps);
344 gst_caps_unref (current_caps);
346 fail_unless (GST_IS_BUFFER_LIST (list));
347 fail_unless (gst_buffer_list_length (list) == 2);
349 /* received bytes include lower level protocol overhead */
350 chain_list_bytes_received = gst_buffer_list_calculate_size (list) +
351 2 * UDP_IP_HEADER_OVERHEAD;
353 fail_unless (gst_buffer_list_get (list, 0));
354 check_packet (list, 0, 0);
356 fail_unless (gst_buffer_list_get (list, 1));
357 check_packet (list, 1, 1);
359 gst_buffer_list_unref (list);
365 /* Non-consecutive seqnums makes probation fail. */
366 static GstBufferList *
367 create_buffer_list_fail_probation (void)
370 GstBuffer *orig_buffer;
373 guint16 seqnums[] = { 1, 3, 5 };
376 orig_buffer = create_original_buffer ();
377 fail_if (orig_buffer == NULL);
379 list = gst_buffer_list_new ();
380 fail_if (list == NULL);
382 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
384 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
385 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], 0);
386 gst_buffer_list_add (list, buffer);
392 /* When probation fails this function shouldn't be called. */
394 sink_chain_list_probation_failed (GstPad * pad, GstObject * parent,
395 GstBufferList * list)
397 chain_list_func_called = TRUE;
402 /* After probation succeeds, a small gap in seqnums is allowed. */
403 static GstBufferList *
404 create_buffer_list_permissible_gap (void)
407 GstBuffer *orig_buffer;
410 /* probation succeeds, but then there is a permissible out of sequence */
411 guint16 seqnums[] = { 1, 2, 4, 5 };
414 orig_buffer = create_original_buffer ();
415 fail_if (orig_buffer == NULL);
417 list = gst_buffer_list_new ();
418 fail_if (list == NULL);
420 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
422 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
423 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], 0);
424 gst_buffer_list_add (list, buffer);
430 /* All buffers should have been pushed. */
432 sink_chain_list_permissible_gap (GstPad * pad, GstObject * parent,
433 GstBufferList * list)
437 chain_list_func_called = TRUE;
439 fail_unless (GST_IS_BUFFER_LIST (list));
440 fail_unless (gst_buffer_list_length (list) == 4);
442 /* Verify sequence numbers */
443 buffer = gst_buffer_list_get (list, 0);
444 check_seqnum (buffer, 1);
446 buffer = gst_buffer_list_get (list, 1);
447 check_seqnum (buffer, 2);
449 buffer = gst_buffer_list_get (list, 2);
450 check_seqnum (buffer, 4);
452 buffer = gst_buffer_list_get (list, 3);
453 check_seqnum (buffer, 5);
455 gst_buffer_list_unref (list);
461 /* After probation succeeds, wrapping seqnum is allowed. */
462 static GstBufferList *
463 create_buffer_list_wrapping_seqnums (void)
466 GstBuffer *orig_buffer;
469 /* probation succeeds, but then seqnum wraps around */
470 guint16 seqnums[] = { 65533, 65534, 65535, 0 };
473 orig_buffer = create_original_buffer ();
474 fail_if (orig_buffer == NULL);
476 list = gst_buffer_list_new ();
477 fail_if (list == NULL);
479 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
481 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
482 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], 0);
483 gst_buffer_list_add (list, buffer);
489 /* All buffers should have been pushed. */
491 sink_chain_list_wrapping_seqnums (GstPad * pad, GstObject * parent,
492 GstBufferList * list)
496 chain_list_func_called = TRUE;
498 fail_unless (GST_IS_BUFFER_LIST (list));
499 fail_unless (gst_buffer_list_length (list) == 4);
501 /* Verify sequence numbers */
502 buffer = gst_buffer_list_get (list, 0);
503 check_seqnum (buffer, 65533);
505 buffer = gst_buffer_list_get (list, 1);
506 check_seqnum (buffer, 65534);
508 buffer = gst_buffer_list_get (list, 2);
509 check_seqnum (buffer, 65535);
511 buffer = gst_buffer_list_get (list, 3);
512 check_seqnum (buffer, 0);
514 gst_buffer_list_unref (list);
520 /* Large jump, packet discarded. */
521 static GstBufferList *
522 create_buffer_list_large_jump_discarded (void)
525 GstBuffer *orig_buffer;
529 * Probation succeeds, but then a large jump happens and the bogus packet
530 * gets discarded, receiving continues normally afterwards.
532 guint16 seqnums[] = { 1, 2, 3, 4, 50000, 5 };
535 orig_buffer = create_original_buffer ();
536 fail_if (orig_buffer == NULL);
538 list = gst_buffer_list_new ();
539 fail_if (list == NULL);
541 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
543 * Make the timestamps proportional to seqnums, to make it easier to predict
546 guint32 timestamp = seqnums[i] * 100;
549 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
550 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], timestamp);
551 gst_buffer_list_add (list, buffer);
557 /* One buffer has been discarded. */
559 sink_chain_list_large_jump_discarded (GstPad * pad, GstObject * parent,
560 GstBufferList * list)
564 chain_list_func_called = TRUE;
566 fail_unless (GST_IS_BUFFER_LIST (list));
567 fail_unless (gst_buffer_list_length (list) == 5);
569 /* Verify sequence numbers */
570 buffer = gst_buffer_list_get (list, 0);
571 check_seqnum (buffer, 1);
573 buffer = gst_buffer_list_get (list, 1);
574 check_seqnum (buffer, 2);
576 buffer = gst_buffer_list_get (list, 2);
577 check_seqnum (buffer, 3);
579 buffer = gst_buffer_list_get (list, 3);
580 check_seqnum (buffer, 4);
582 buffer = gst_buffer_list_get (list, 4);
583 check_seqnum (buffer, 5);
585 gst_buffer_list_unref (list);
591 /* Large jump, with recovery. */
592 static GstBufferList *
593 create_buffer_list_large_jump_recovery (void)
596 GstBuffer *orig_buffer;
600 * Probation succeeds, but then a large jump happens.
601 * A consecutive next packet makes the session manager recover: it assumes
602 * that the other side restarted without telling.
604 guint16 seqnums[] = { 1, 2, 3, 4, 50000, 50001 };
607 orig_buffer = create_original_buffer ();
608 fail_if (orig_buffer == NULL);
610 list = gst_buffer_list_new ();
611 fail_if (list == NULL);
613 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
615 * Make the timestamps proportional to seqnums, to make it easier to predict
618 guint32 timestamp = seqnums[i] * 100;
621 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
622 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], timestamp);
623 gst_buffer_list_add (list, buffer);
629 /* All buffers should have been pushed. */
631 sink_chain_list_large_jump_recovery (GstPad * pad, GstObject * parent,
632 GstBufferList * list)
636 chain_list_func_called = TRUE;
638 fail_unless (GST_IS_BUFFER_LIST (list));
639 fail_unless (gst_buffer_list_length (list) == 6);
641 /* Verify sequence numbers */
642 buffer = gst_buffer_list_get (list, 0);
643 check_seqnum (buffer, 1);
645 buffer = gst_buffer_list_get (list, 1);
646 check_seqnum (buffer, 2);
648 buffer = gst_buffer_list_get (list, 2);
649 check_seqnum (buffer, 3);
651 buffer = gst_buffer_list_get (list, 3);
652 check_seqnum (buffer, 4);
654 buffer = gst_buffer_list_get (list, 4);
655 check_seqnum (buffer, 50000);
657 buffer = gst_buffer_list_get (list, 5);
658 check_seqnum (buffer, 50001);
660 gst_buffer_list_unref (list);
666 /* After probation succeeds, reordered and duplicated packets are allowed. */
667 static GstBufferList *
668 create_buffer_list_reordered_packets (void)
671 GstBuffer *orig_buffer;
674 /* probation succeeds, but then there are reordered or duplicated packets */
675 guint16 seqnums[] = { 4, 5, 2, 2 };
678 orig_buffer = create_original_buffer ();
679 fail_if (orig_buffer == NULL);
681 list = gst_buffer_list_new ();
682 fail_if (list == NULL);
684 for (i = 0; i < sizeof (seqnums) / sizeof (seqnums[0]); i++) {
686 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
687 orig_buffer, payload_offset[0], payload_len[0], seqnums[i], 0);
688 gst_buffer_list_add (list, buffer);
694 /* All buffers should have been pushed, they will be filtered by jitterbuffer */
696 sink_chain_list_reordered_packets (GstPad * pad, GstObject * parent,
697 GstBufferList * list)
701 chain_list_func_called = TRUE;
703 fail_unless (GST_IS_BUFFER_LIST (list));
704 fail_unless (gst_buffer_list_length (list) == 4);
706 /* Verify sequence numbers */
707 buffer = gst_buffer_list_get (list, 0);
708 check_seqnum (buffer, 4);
710 buffer = gst_buffer_list_get (list, 1);
711 check_seqnum (buffer, 5);
713 buffer = gst_buffer_list_get (list, 2);
714 check_seqnum (buffer, 2);
716 buffer = gst_buffer_list_get (list, 3);
717 check_seqnum (buffer, 2);
719 gst_buffer_list_unref (list);
725 /* Frames with different timestamps in the same buffer list. */
726 static GstBufferList *
727 create_buffer_list_different_frames (void)
730 GstBuffer *orig_buffer;
733 guint32 timestamps[] = { 0, 0, 1000, 1000 };
736 orig_buffer = create_original_buffer ();
737 fail_if (orig_buffer == NULL);
739 list = gst_buffer_list_new ();
740 fail_if (list == NULL);
742 for (i = 0; i < sizeof (timestamps) / sizeof (timestamps[0]); i++) {
744 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
745 orig_buffer, payload_offset[0], payload_len[0], i, timestamps[i]);
746 gst_buffer_list_add (list, buffer);
752 /* All buffers should have been pushed, regardless of the timestamp. */
754 sink_chain_list_different_frames (GstPad * pad, GstObject * parent,
755 GstBufferList * list)
759 chain_list_func_called = TRUE;
761 fail_unless (GST_IS_BUFFER_LIST (list));
762 fail_unless (gst_buffer_list_length (list) == 4);
764 /* Verify seqnums and timestamps. */
765 buffer = gst_buffer_list_get (list, 0);
766 check_seqnum (buffer, 0);
767 check_timestamp (buffer, 0);
769 buffer = gst_buffer_list_get (list, 1);
770 check_seqnum (buffer, 1);
771 check_timestamp (buffer, 0);
773 buffer = gst_buffer_list_get (list, 2);
774 check_seqnum (buffer, 2);
775 check_timestamp (buffer, 1000);
777 buffer = gst_buffer_list_get (list, 3);
778 check_seqnum (buffer, 3);
779 check_timestamp (buffer, 1000);
781 gst_buffer_list_unref (list);
788 * RTP and RTCP can be multiplexed in the same channel and end up in the same
791 static GstBufferList *
792 create_buffer_list_muxed_rtcp (void)
795 GstBuffer *orig_buffer;
797 GstRTCPBuffer rtcpbuf = GST_RTCP_BUFFER_INIT;
798 GstRTCPPacket rtcppacket;
802 orig_buffer = create_original_buffer ();
803 fail_if (orig_buffer == NULL);
805 list = gst_buffer_list_new ();
806 fail_if (list == NULL);
809 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
810 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
811 gst_buffer_list_add (list, buffer);
816 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
817 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
818 gst_buffer_list_add (list, buffer);
822 buffer = gst_rtcp_buffer_new (1500);
823 gst_rtcp_buffer_map (buffer, GST_MAP_READWRITE, &rtcpbuf);
824 gst_rtcp_buffer_add_packet (&rtcpbuf, GST_RTCP_TYPE_SR, &rtcppacket);
825 gst_rtcp_packet_sr_set_sender_info (&rtcppacket, 0, 0, 0, 0, 0);
826 gst_rtcp_buffer_add_packet (&rtcpbuf, GST_RTCP_TYPE_RR, &rtcppacket);
827 gst_rtcp_packet_rr_set_ssrc (&rtcppacket, 1);
828 gst_rtcp_packet_add_rb (&rtcppacket, 0, 0, 0, 0, 0, 0, 0);
829 gst_rtcp_buffer_add_packet (&rtcpbuf, GST_RTCP_TYPE_SDES, &rtcppacket);
830 gst_rtcp_packet_sdes_add_item (&rtcppacket, 1);
831 gst_rtcp_packet_sdes_add_entry (&rtcppacket, GST_RTCP_SDES_CNAME, 3,
833 gst_rtcp_packet_sdes_add_entry (&rtcppacket, GST_RTCP_SDES_NAME, 2,
835 gst_rtcp_packet_sdes_add_entry (&rtcppacket, GST_RTCP_SDES_END, 0,
837 gst_rtcp_buffer_unmap (&rtcpbuf);
839 gst_buffer_list_add (list, buffer);
842 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
843 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
844 gst_buffer_list_add (list, buffer);
850 * All RTP buffers should have been pushed to recv_rtp_src, the RTCP packet
851 * should have been pushed to sync_src.
854 sink_chain_list_muxed_rtcp (GstPad * pad, GstObject * parent,
855 GstBufferList * list)
859 chain_list_func_called = TRUE;
861 fail_unless (GST_IS_BUFFER_LIST (list));
862 fail_unless (gst_buffer_list_length (list) == 3);
864 /* Verify seqnums of RTP packets. */
865 buffer = gst_buffer_list_get (list, 0);
866 check_seqnum (buffer, 0);
868 buffer = gst_buffer_list_get (list, 1);
869 check_seqnum (buffer, 1);
871 buffer = gst_buffer_list_get (list, 2);
872 check_seqnum (buffer, 2);
874 gst_buffer_list_unref (list);
879 /* count multiplexed rtcp packets */
880 static guint rtcp_packets;
883 sink_chain_muxed_rtcp (GstPad * pad, GstObject * parent, GstBuffer * buffer)
886 gst_buffer_unref (buffer);
891 /* Invalid data can be received muxed with valid RTP packets */
892 static GstBufferList *
893 create_buffer_list_muxed_invalid (void)
896 GstBuffer *orig_buffer;
901 orig_buffer = create_original_buffer ();
902 fail_if (orig_buffer == NULL);
904 list = gst_buffer_list_new ();
905 fail_if (list == NULL);
908 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
909 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
910 gst_buffer_list_add (list, buffer);
915 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
916 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
917 gst_buffer_list_add (list, buffer);
921 /* add an invalid RTP packet to the list */
922 buffer = gst_buffer_new_allocate (NULL, 10, NULL);
923 /* initialize the memory to make valgrind happy */
924 gst_buffer_memset (buffer, 0, 0, 10);
926 gst_buffer_list_add (list, buffer);
929 create_rtp_buffer_fields (&rtp_header[0], rtp_header_len[0],
930 orig_buffer, payload_offset[0], payload_len[0], seqnum, 0);
931 gst_buffer_list_add (list, buffer);
937 * Only valid RTP buffers should have been pushed to recv_rtp_src.
940 sink_chain_list_muxed_invalid (GstPad * pad, GstObject * parent,
941 GstBufferList * list)
945 chain_list_func_called = TRUE;
947 fail_unless (GST_IS_BUFFER_LIST (list));
948 fail_unless (gst_buffer_list_length (list) == 3);
950 /* Verify seqnums of valid RTP packets. */
951 buffer = gst_buffer_list_get (list, 0);
952 check_seqnum (buffer, 0);
954 buffer = gst_buffer_list_get (list, 1);
955 check_seqnum (buffer, 1);
957 buffer = gst_buffer_list_get (list, 2);
958 check_seqnum (buffer, 2);
960 gst_buffer_list_unref (list);
966 /* Get the stats of the **first** source of the given type (get_sender) */
968 get_source_stats (GstElement * rtpsession,
969 gboolean get_sender, GstStructure ** source_stats)
972 GValueArray *stats_arr;
975 g_object_get (rtpsession, "stats", &stats, NULL);
977 g_value_get_boxed (gst_structure_get_value (stats, "source-stats"));
978 g_assert (stats_arr != NULL);
979 fail_unless (stats_arr->n_values >= 1);
981 *source_stats = NULL;
982 for (i = 0; i < stats_arr->n_values; i++) {
983 GstStructure *tmp_source_stats;
986 tmp_source_stats = g_value_dup_boxed (&stats_arr->values[i]);
987 gst_structure_get (tmp_source_stats, "is-sender", G_TYPE_BOOLEAN,
990 /* Return the stats of the **first** source of the given type. */
991 if (is_sender == get_sender) {
992 *source_stats = tmp_source_stats;
995 gst_structure_free (tmp_source_stats);
998 gst_structure_free (stats);
1001 /* Get the source stats given a session and a source type (get_sender) */
1003 get_session_source_stats (GstElement * rtpbin, guint session,
1004 gboolean get_sender, GstStructure ** source_stats)
1006 GstElement *rtpsession;
1008 g_signal_emit_by_name (rtpbin, "get-session", session, &rtpsession);
1009 fail_if (rtpsession == NULL);
1011 get_source_stats (rtpsession, get_sender, source_stats);
1013 gst_object_unref (rtpsession);
1016 GST_START_TEST (test_bufferlist)
1022 GstBufferList *list;
1023 GstStructure *stats;
1024 guint64 packets_sent;
1025 guint64 packets_received;
1027 list = create_buffer_list ();
1028 fail_unless (list != NULL);
1030 rtpbin = gst_check_setup_element ("rtpbin");
1033 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "send_rtp_sink_0");
1034 fail_if (srcpad == NULL);
1036 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate,
1038 fail_if (sinkpad == NULL);
1040 gst_pad_set_chain_list_function (sinkpad,
1041 GST_DEBUG_FUNCPTR (sink_chain_list));
1043 gst_pad_set_active (srcpad, TRUE);
1044 gst_pad_set_active (sinkpad, TRUE);
1046 caps = gst_caps_from_string (TEST_CAPS);
1047 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1048 gst_caps_unref (caps);
1050 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1052 chain_list_func_called = FALSE;
1053 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1054 fail_if (chain_list_func_called == FALSE);
1056 /* make sure that stats about the number of sent packets are OK too */
1057 get_session_source_stats (rtpbin, 0, TRUE, &stats);
1058 fail_if (stats == NULL);
1060 gst_structure_get (stats,
1061 "packets-sent", G_TYPE_UINT64, &packets_sent,
1062 "packets-received", G_TYPE_UINT64, &packets_received, NULL);
1063 fail_unless (packets_sent == 2);
1064 fail_unless (packets_received == 2);
1065 gst_structure_free (stats);
1067 gst_pad_set_active (sinkpad, FALSE);
1068 gst_pad_set_active (srcpad, FALSE);
1070 gst_check_teardown_pad_by_name (rtpbin, "send_rtp_src_0");
1071 gst_check_teardown_pad_by_name (rtpbin, "send_rtp_sink_0");
1072 gst_check_teardown_element (rtpbin);
1078 GST_START_TEST (test_bufferlist_recv)
1084 GstBufferList *list;
1085 GstStructure *stats;
1086 guint64 bytes_received;
1087 guint64 packets_received;
1089 list = create_buffer_list ();
1090 fail_unless (list != NULL);
1092 rtpbin = gst_check_setup_element ("rtpsession");
1095 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1096 fail_if (srcpad == NULL);
1099 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1100 fail_if (sinkpad == NULL);
1102 gst_pad_set_chain_list_function (sinkpad,
1103 GST_DEBUG_FUNCPTR (sink_chain_list));
1105 gst_pad_set_active (srcpad, TRUE);
1106 gst_pad_set_active (sinkpad, TRUE);
1108 caps = gst_caps_from_string (TEST_CAPS);
1109 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1110 gst_caps_unref (caps);
1112 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1114 chain_list_func_called = FALSE;
1115 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1116 fail_if (chain_list_func_called == FALSE);
1118 /* make sure that stats about the number of received packets are OK too */
1119 /* The source becomes a sender after probation succeeds, pass TRUE here. */
1120 get_source_stats (rtpbin, TRUE, &stats);
1121 fail_if (stats == NULL);
1123 gst_structure_get (stats,
1124 "bytes-received", G_TYPE_UINT64, &bytes_received,
1125 "packets-received", G_TYPE_UINT64, &packets_received, NULL);
1126 fail_unless (packets_received == 2);
1127 fail_unless (bytes_received == chain_list_bytes_received);
1128 gst_structure_free (stats);
1131 gst_pad_set_active (sinkpad, FALSE);
1132 gst_pad_set_active (srcpad, FALSE);
1134 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1135 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1136 gst_check_teardown_element (rtpbin);
1142 GST_START_TEST (test_bufferlist_recv_probation_failed)
1148 GstBufferList *list;
1150 list = create_buffer_list_fail_probation ();
1151 fail_unless (list != NULL);
1153 rtpbin = gst_check_setup_element ("rtpsession");
1156 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1157 fail_if (srcpad == NULL);
1160 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1161 fail_if (sinkpad == NULL);
1163 gst_pad_set_chain_list_function (sinkpad,
1164 GST_DEBUG_FUNCPTR (sink_chain_list_probation_failed));
1166 gst_pad_set_active (srcpad, TRUE);
1167 gst_pad_set_active (sinkpad, TRUE);
1169 caps = gst_caps_from_string (TEST_CAPS);
1170 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1171 gst_caps_unref (caps);
1173 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1175 chain_list_func_called = FALSE;
1176 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1177 /* when probation fails the list should not be pushed at all, and the
1178 * chain_list functions should not be called, fail if it has been. */
1179 fail_if (chain_list_func_called == TRUE);
1181 gst_pad_set_active (sinkpad, FALSE);
1182 gst_pad_set_active (srcpad, FALSE);
1184 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1185 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1186 gst_check_teardown_element (rtpbin);
1192 GST_START_TEST (test_bufferlist_recv_permissible_gap)
1198 GstBufferList *list;
1200 list = create_buffer_list_permissible_gap ();
1201 fail_unless (list != NULL);
1203 rtpbin = gst_check_setup_element ("rtpsession");
1206 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1207 fail_if (srcpad == NULL);
1210 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1211 fail_if (sinkpad == NULL);
1213 gst_pad_set_chain_list_function (sinkpad,
1214 GST_DEBUG_FUNCPTR (sink_chain_list_permissible_gap));
1216 gst_pad_set_active (srcpad, TRUE);
1217 gst_pad_set_active (sinkpad, TRUE);
1219 caps = gst_caps_from_string (TEST_CAPS);
1220 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1221 gst_caps_unref (caps);
1223 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1225 chain_list_func_called = FALSE;
1226 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1227 fail_if (chain_list_func_called == FALSE);
1229 gst_pad_set_active (sinkpad, FALSE);
1230 gst_pad_set_active (srcpad, FALSE);
1232 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1233 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1234 gst_check_teardown_element (rtpbin);
1240 GST_START_TEST (test_bufferlist_recv_wrapping_seqnums)
1246 GstBufferList *list;
1248 list = create_buffer_list_wrapping_seqnums ();
1249 fail_unless (list != NULL);
1251 rtpbin = gst_check_setup_element ("rtpsession");
1254 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1255 fail_if (srcpad == NULL);
1258 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1259 fail_if (sinkpad == NULL);
1261 gst_pad_set_chain_list_function (sinkpad,
1262 GST_DEBUG_FUNCPTR (sink_chain_list_wrapping_seqnums));
1264 gst_pad_set_active (srcpad, TRUE);
1265 gst_pad_set_active (sinkpad, TRUE);
1267 caps = gst_caps_from_string (TEST_CAPS);
1268 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1269 gst_caps_unref (caps);
1271 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1273 chain_list_func_called = FALSE;
1274 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1275 fail_if (chain_list_func_called == FALSE);
1277 gst_pad_set_active (sinkpad, FALSE);
1278 gst_pad_set_active (srcpad, FALSE);
1280 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1281 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1282 gst_check_teardown_element (rtpbin);
1288 GST_START_TEST (test_bufferlist_recv_large_jump_discarded)
1294 GstBufferList *list;
1296 list = create_buffer_list_large_jump_discarded ();
1297 fail_unless (list != NULL);
1299 rtpbin = gst_check_setup_element ("rtpsession");
1302 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1303 fail_if (srcpad == NULL);
1306 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1307 fail_if (sinkpad == NULL);
1309 gst_pad_set_chain_list_function (sinkpad,
1310 GST_DEBUG_FUNCPTR (sink_chain_list_large_jump_discarded));
1312 gst_pad_set_active (srcpad, TRUE);
1313 gst_pad_set_active (sinkpad, TRUE);
1315 caps = gst_caps_from_string (TEST_CAPS);
1316 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1317 gst_caps_unref (caps);
1319 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1321 chain_list_func_called = FALSE;
1322 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1323 fail_if (chain_list_func_called == FALSE);
1325 gst_pad_set_active (sinkpad, FALSE);
1326 gst_pad_set_active (srcpad, FALSE);
1328 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1329 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1330 gst_check_teardown_element (rtpbin);
1336 GST_START_TEST (test_bufferlist_recv_large_jump_recovery)
1342 GstBufferList *list;
1344 list = create_buffer_list_large_jump_recovery ();
1345 fail_unless (list != NULL);
1347 rtpbin = gst_check_setup_element ("rtpsession");
1350 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1351 fail_if (srcpad == NULL);
1354 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1355 fail_if (sinkpad == NULL);
1357 gst_pad_set_chain_list_function (sinkpad,
1358 GST_DEBUG_FUNCPTR (sink_chain_list_large_jump_recovery));
1360 gst_pad_set_active (srcpad, TRUE);
1361 gst_pad_set_active (sinkpad, TRUE);
1363 caps = gst_caps_from_string (TEST_CAPS);
1364 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1365 gst_caps_unref (caps);
1367 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1369 chain_list_func_called = FALSE;
1370 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1371 fail_if (chain_list_func_called == FALSE);
1373 gst_pad_set_active (sinkpad, FALSE);
1374 gst_pad_set_active (srcpad, FALSE);
1376 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1377 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1378 gst_check_teardown_element (rtpbin);
1384 GST_START_TEST (test_bufferlist_recv_reordered_packets)
1390 GstBufferList *list;
1392 list = create_buffer_list_reordered_packets ();
1393 fail_unless (list != NULL);
1395 rtpbin = gst_check_setup_element ("rtpsession");
1398 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1399 fail_if (srcpad == NULL);
1402 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1403 fail_if (sinkpad == NULL);
1405 gst_pad_set_chain_list_function (sinkpad,
1406 GST_DEBUG_FUNCPTR (sink_chain_list_reordered_packets));
1408 gst_pad_set_active (srcpad, TRUE);
1409 gst_pad_set_active (sinkpad, TRUE);
1411 caps = gst_caps_from_string (TEST_CAPS);
1412 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1413 gst_caps_unref (caps);
1415 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1417 chain_list_func_called = FALSE;
1418 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1419 fail_if (chain_list_func_called == FALSE);
1421 gst_pad_set_active (sinkpad, FALSE);
1422 gst_pad_set_active (srcpad, FALSE);
1424 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1425 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1426 gst_check_teardown_element (rtpbin);
1431 GST_START_TEST (test_bufferlist_recv_different_frames)
1437 GstBufferList *list;
1439 list = create_buffer_list_different_frames ();
1440 fail_unless (list != NULL);
1442 rtpbin = gst_check_setup_element ("rtpsession");
1445 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1446 fail_if (srcpad == NULL);
1449 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1450 fail_if (sinkpad == NULL);
1452 gst_pad_set_chain_list_function (sinkpad,
1453 GST_DEBUG_FUNCPTR (sink_chain_list_different_frames));
1455 gst_pad_set_active (srcpad, TRUE);
1456 gst_pad_set_active (sinkpad, TRUE);
1458 caps = gst_caps_from_string (TEST_CAPS);
1459 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1460 gst_caps_unref (caps);
1462 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1464 chain_list_func_called = FALSE;
1465 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1466 fail_if (chain_list_func_called == FALSE);
1468 gst_pad_set_active (sinkpad, FALSE);
1469 gst_pad_set_active (srcpad, FALSE);
1471 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1472 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1473 gst_check_teardown_element (rtpbin);
1479 GST_START_TEST (test_bufferlist_recv_muxed_rtcp)
1484 GstPad *srcpad_rtcp;
1485 GstPad *sinkpad_rtcp;
1487 GstBufferList *list;
1489 list = create_buffer_list_muxed_rtcp ();
1490 fail_unless (list != NULL);
1492 rtpbin = gst_check_setup_element ("rtpsession");
1495 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1496 fail_if (srcpad == NULL);
1499 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1500 fail_if (sinkpad == NULL);
1502 gst_pad_set_chain_list_function (sinkpad,
1503 GST_DEBUG_FUNCPTR (sink_chain_list_muxed_rtcp));
1505 gst_pad_set_active (srcpad, TRUE);
1506 gst_pad_set_active (sinkpad, TRUE);
1508 caps = gst_caps_from_string (TEST_CAPS);
1509 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1510 gst_caps_unref (caps);
1513 * Create supplementary pads after gst_check_setup_events() to avoid
1514 * a failure in gst_pad_create_stream_id().
1517 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate_rtcp,
1519 fail_if (srcpad_rtcp == NULL);
1522 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate_rtcp, "sync_src");
1523 fail_if (sinkpad_rtcp == NULL);
1525 gst_pad_set_chain_function (sinkpad_rtcp,
1526 GST_DEBUG_FUNCPTR (sink_chain_muxed_rtcp));
1528 gst_pad_set_active (srcpad_rtcp, TRUE);
1529 gst_pad_set_active (sinkpad_rtcp, TRUE);
1531 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1533 chain_list_func_called = FALSE;
1535 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1536 fail_if (chain_list_func_called == FALSE);
1537 fail_unless (rtcp_packets == 1);
1539 gst_pad_set_active (sinkpad_rtcp, FALSE);
1540 gst_pad_set_active (srcpad_rtcp, FALSE);
1541 gst_pad_set_active (sinkpad, FALSE);
1542 gst_pad_set_active (srcpad, FALSE);
1544 gst_check_teardown_pad_by_name (rtpbin, "sync_src");
1545 gst_check_teardown_pad_by_name (rtpbin, "recv_rtcp_sink");
1546 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1547 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1548 gst_check_teardown_element (rtpbin);
1554 GST_START_TEST (test_bufferlist_recv_muxed_invalid)
1560 GstBufferList *list;
1562 list = create_buffer_list_muxed_invalid ();
1563 fail_unless (list != NULL);
1565 rtpbin = gst_check_setup_element ("rtpsession");
1568 gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "recv_rtp_sink");
1569 fail_if (srcpad == NULL);
1572 gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate, "recv_rtp_src");
1573 fail_if (sinkpad == NULL);
1575 gst_pad_set_chain_list_function (sinkpad,
1576 GST_DEBUG_FUNCPTR (sink_chain_list_muxed_invalid));
1578 gst_pad_set_active (srcpad, TRUE);
1579 gst_pad_set_active (sinkpad, TRUE);
1581 caps = gst_caps_from_string (TEST_CAPS);
1582 gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
1583 gst_caps_unref (caps);
1585 gst_element_set_state (rtpbin, GST_STATE_PLAYING);
1587 chain_list_func_called = FALSE;
1588 fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
1589 fail_if (chain_list_func_called == FALSE);
1591 gst_pad_set_active (sinkpad, FALSE);
1592 gst_pad_set_active (srcpad, FALSE);
1594 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_src");
1595 gst_check_teardown_pad_by_name (rtpbin, "recv_rtp_sink");
1596 gst_check_teardown_element (rtpbin);
1603 bufferlist_suite (void)
1605 Suite *s = suite_create ("BufferList");
1607 TCase *tc_chain = tcase_create ("general");
1609 /* time out after 30s. */
1610 tcase_set_timeout (tc_chain, 10);
1612 suite_add_tcase (s, tc_chain);
1613 tcase_add_test (tc_chain, test_bufferlist);
1614 tcase_add_test (tc_chain, test_bufferlist_recv);
1615 tcase_add_test (tc_chain, test_bufferlist_recv_probation_failed);
1616 tcase_add_test (tc_chain, test_bufferlist_recv_permissible_gap);
1617 tcase_add_test (tc_chain, test_bufferlist_recv_wrapping_seqnums);
1618 tcase_add_test (tc_chain, test_bufferlist_recv_large_jump_discarded);
1619 tcase_add_test (tc_chain, test_bufferlist_recv_large_jump_recovery);
1620 tcase_add_test (tc_chain, test_bufferlist_recv_reordered_packets);
1621 tcase_add_test (tc_chain, test_bufferlist_recv_different_frames);
1622 tcase_add_test (tc_chain, test_bufferlist_recv_muxed_rtcp);
1623 tcase_add_test (tc_chain, test_bufferlist_recv_muxed_invalid);
1628 GST_CHECK_MAIN (bufferlist);