1 /* GStreamer unit tests for the RTP support library
3 * Copyright (C) 2007 Tim-Philipp Müller <tim centricular net>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
25 #include <gst/check/gstcheck.h>
27 #include <gst/rtp/gstrtpbuffer.h>
28 #include <gst/rtp/gstrtphdrext.h>
29 #include <gst/rtp/gstrtcpbuffer.h>
32 #define RTP_HEADER_LEN 12
34 GST_START_TEST (test_rtp_buffer)
40 GstRTPBuffer rtp = { NULL, };
42 /* check GstRTPHeader structure alignment and packing */
43 buf = gst_rtp_buffer_new_allocate (16, 4, 0);
44 fail_unless (buf != NULL);
45 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
48 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4);
50 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
53 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
54 fail_unless (gst_rtp_buffer_get_padding (&rtp) == TRUE);
55 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
56 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
57 fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
58 fail_unless (gst_rtp_buffer_get_payload_type (&rtp) == 0);
59 fail_unless_equals_int (GST_READ_UINT16_BE (data), 0xa000);
61 /* check version in bitfield */
62 gst_rtp_buffer_set_version (&rtp, 3);
63 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 3);
64 fail_unless_equals_int ((data[0] & 0xC0) >> 6, 3);
65 gst_rtp_buffer_set_version (&rtp, 2);
66 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
67 fail_unless_equals_int ((data[0] & 0xC0) >> 6, 2);
69 /* check padding bit */
70 gst_rtp_buffer_set_padding (&rtp, TRUE);
71 fail_unless (gst_rtp_buffer_get_padding (&rtp) == TRUE);
72 fail_unless_equals_int ((data[0] & 0x20) >> 5, 1);
73 gst_rtp_buffer_set_padding (&rtp, FALSE);
74 fail_unless (gst_rtp_buffer_get_padding (&rtp) == FALSE);
75 fail_unless_equals_int ((data[0] & 0x20) >> 5, 0);
77 /* check marker bit */
78 gst_rtp_buffer_set_marker (&rtp, TRUE);
79 fail_unless (gst_rtp_buffer_get_marker (&rtp) == TRUE);
80 fail_unless_equals_int ((data[1] & 0x80) >> 7, 1);
81 gst_rtp_buffer_set_marker (&rtp, FALSE);
82 fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
83 fail_unless_equals_int ((data[1] & 0x80) >> 7, 0);
85 /* check sequence offset */
86 gst_rtp_buffer_set_seq (&rtp, 0xF2C9);
87 fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0xF2C9);
88 fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0xF2C9);
89 gst_rtp_buffer_set_seq (&rtp, 0);
90 fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0);
91 fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0);
93 /* check timestamp offset */
94 gst_rtp_buffer_set_timestamp (&rtp, 432191);
95 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 432191);
96 fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 432191);
97 gst_rtp_buffer_set_timestamp (&rtp, 0);
98 fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 0);
99 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 0);
101 /* check ssrc offset */
102 gst_rtp_buffer_set_ssrc (&rtp, 0xf04043C2);
103 fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), (gint) 0xf04043c2);
104 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), (gint) 0xf04043c2);
105 gst_rtp_buffer_set_ssrc (&rtp, 0);
106 fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), 0);
107 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), 0);
109 /* check csrc bits */
110 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
111 ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 0));
112 fail_unless_equals_int (data[0] & 0xf, 0);
114 gst_rtp_buffer_unmap (&rtp);
115 gst_buffer_unmap (buf, &map);
116 gst_buffer_unref (buf);
118 /* and again, this time with CSRCs */
119 buf = gst_rtp_buffer_new_allocate (16, 4, 3);
120 fail_unless (buf != NULL);
121 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
124 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4 + 4 * 3);
126 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
128 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 3);
129 ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 3));
130 fail_unless_equals_int (data[0] & 0xf, 3);
131 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 0), 0);
132 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 1), 0);
133 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 2), 0);
134 fail_unless_equals_int (gst_rtp_buffer_get_header_len (&rtp),
135 RTP_HEADER_LEN + 4 * 3);
136 fail_unless_equals_int (gst_rtp_buffer_get_payload_len (&rtp), 16);
138 data += RTP_HEADER_LEN; /* skip the other header stuff */
139 gst_rtp_buffer_set_csrc (&rtp, 0, 0xf7c0);
140 fail_unless_equals_int (GST_READ_UINT32_BE (data + 0 * 4), 0xf7c0);
141 gst_rtp_buffer_set_csrc (&rtp, 1, 0xf7c1);
142 fail_unless_equals_int (GST_READ_UINT32_BE (data + 1 * 4), 0xf7c1);
143 gst_rtp_buffer_set_csrc (&rtp, 2, 0xf7c2);
144 fail_unless_equals_int (GST_READ_UINT32_BE (data + 2 * 4), 0xf7c2);
145 ASSERT_CRITICAL (gst_rtp_buffer_set_csrc (&rtp, 3, 0xf123));
147 gst_rtp_buffer_unmap (&rtp);
148 gst_buffer_unmap (buf, &map);
149 gst_buffer_unref (buf);
154 GST_START_TEST (test_rtp_buffer_validate_corrupt)
157 guint8 corrupt_rtp_packet[58] = {
158 0x90, 0x7a, 0xbf, 0x28, 0x3a, 0x8a, 0x0a, 0xf4, 0x69, 0x6b, 0x76, 0xc0,
159 0x21, 0xe0, 0xe0, 0x60, 0x81, 0x10, 0x84, 0x30, 0x21, 0x52, 0x06, 0xc2,
160 0xb8, 0x30, 0x10, 0x4c, 0x08, 0x62, 0x67, 0xc2, 0x6e, 0x1a, 0x53, 0x3f,
161 0xaf, 0xd6, 0x1b, 0x29, 0x40, 0xe0, 0xa5, 0x83, 0x01, 0x4b, 0x04, 0x02,
162 0xb0, 0x97, 0x63, 0x08, 0x10, 0x4b, 0x43, 0x85, 0x37, 0x2c
164 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
166 buf = gst_buffer_new_and_alloc (sizeof (corrupt_rtp_packet));
167 gst_buffer_fill (buf, 0, corrupt_rtp_packet, sizeof (corrupt_rtp_packet));
168 fail_if (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
169 gst_buffer_unref (buf);
174 GST_START_TEST (test_rtp_buffer_validate_padding)
177 guint8 packet_with_padding[] = {
178 0xa0, 0x60, 0x6c, 0x49, 0x58, 0xab, 0xaa, 0x65, 0x65, 0x2e, 0xaf, 0xce,
179 0x68, 0xce, 0x3c, 0x80, 0x00, 0x00, 0x00, 0x04
181 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
183 buf = gst_buffer_new_and_alloc (sizeof (packet_with_padding));
184 gst_buffer_fill (buf, 0, packet_with_padding, sizeof (packet_with_padding));
185 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
186 gst_rtp_buffer_unmap (&rtp);
187 gst_buffer_unref (buf);
189 /* Set the padding to something invalid */
190 buf = gst_buffer_new_and_alloc (sizeof (packet_with_padding));
191 gst_buffer_fill (buf, 0, packet_with_padding, sizeof (packet_with_padding));
192 gst_buffer_memset (buf, gst_buffer_get_size (buf) - 1, 0xff, 1);
193 fail_if (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
195 memset (&rtp, 0, sizeof (rtp));
196 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READ |
197 GST_RTP_BUFFER_MAP_FLAG_SKIP_PADDING, &rtp));
198 gst_rtp_buffer_unmap (&rtp);
199 gst_buffer_unref (buf);
205 GST_START_TEST (test_rtp_buffer_list)
207 GstBuffer *rtp_header;
208 GstBuffer *rtp_payload;
209 GstBufferList *list = NULL;
210 GstBufferListIterator *it;
213 list = gst_buffer_list_new ();
214 it = gst_buffer_list_iterate (list);
216 /* Creating a list of two RTP packages */
218 /* Create first group to hold the rtp header and the payload */
219 gst_buffer_list_iterator_add_group (it);
220 rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
221 gst_buffer_list_iterator_add (it, rtp_header);
222 rtp_payload = gst_buffer_new_and_alloc (42);
223 gst_buffer_list_iterator_add (it, rtp_payload);
225 /* Create second group to hold an rtp header and a payload */
226 gst_buffer_list_iterator_add_group (it);
227 rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
228 gst_buffer_list_iterator_add (it, rtp_header);
229 rtp_payload = gst_buffer_new_and_alloc (42);
230 gst_buffer_list_iterator_add (it, rtp_payload);
232 gst_buffer_list_iterator_free (it);
234 /* Test SEQ number */
235 i = gst_rtp_buffer_list_set_seq (list, 1024);
237 fail_if (!gst_rtp_buffer_list_validate (list));
240 gst_rtp_buffer_list_set_timestamp (list, 432191);
241 fail_unless_equals_int (gst_rtp_buffer_list_get_timestamp (list), 432191);
244 gst_rtp_buffer_list_set_ssrc (list, 0xf04043C2);
245 fail_unless_equals_int (gst_rtp_buffer_list_get_ssrc (list),
249 gst_rtp_buffer_list_set_payload_type (list, 127);
250 fail_unless_equals_int (gst_rtp_buffer_list_get_payload_type (list), 127);
252 gst_buffer_list_unref (list);
258 GST_START_TEST (test_rtp_buffer_set_extension_data)
264 guint8 misc_data[4] = { 1, 2, 3, 4 };
267 GstRTPBuffer rtp = { NULL, };
269 /* check GstRTPHeader structure alignment and packing */
270 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
272 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
274 /* should be possible to set the extension data */
275 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 4) == TRUE);
276 fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
277 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
278 fail_unless (bits == 270);
279 fail_unless (size == 4);
280 gst_rtp_buffer_unmap (&rtp);
281 gst_buffer_unref (buf);
283 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
284 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
286 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
287 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 333, 2) == TRUE);
288 fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
289 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
290 fail_unless (bits == 333);
291 fail_unless (size == 2);
293 gst_rtp_buffer_unmap (&rtp);
294 gst_buffer_unref (buf);
296 /* Test header extensions with a one byte header */
297 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
298 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
300 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
302 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
303 misc_data, 2) == TRUE);
304 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
306 fail_unless (bits == 0xBEDE);
307 fail_unless (size == 1);
308 data = (guint8 *) pointer;
309 fail_unless (data[0] == ((5 << 4) | 1));
310 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
311 1, &pointer, &size) == FALSE);
312 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
313 1, &pointer, &size) == FALSE);
314 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
315 0, &pointer, &size) == TRUE);
316 fail_unless (size == 2);
317 fail_unless (memcmp (pointer, misc_data, 2) == 0);
319 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
320 misc_data, 4) == TRUE);
321 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
322 0, &pointer, &size) == TRUE);
323 fail_unless (size == 2);
324 fail_unless (memcmp (pointer, misc_data, 2) == 0);
325 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
326 1, &pointer, &size) == TRUE);
327 fail_unless (size == 4);
328 fail_unless (memcmp (pointer, misc_data, 4) == 0);
329 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
330 2, &pointer, &size) == FALSE);
331 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
332 1, &pointer, &size) == FALSE);
334 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 6,
335 misc_data, 2) == TRUE);
336 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
337 0, &pointer, &size) == TRUE);
338 fail_unless (size == 2);
339 fail_unless (memcmp (pointer, misc_data, 2) == 0);
340 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
341 1, &pointer, &size) == TRUE);
342 fail_unless (size == 4);
343 fail_unless (memcmp (pointer, misc_data, 4) == 0);
344 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
345 3, &pointer, &size) == FALSE);
346 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
347 1, &pointer, &size) == FALSE);
348 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 6,
349 2, &pointer, &size) == FALSE);
350 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
351 0, &pointer, &size) == TRUE);
352 fail_unless (size == 2);
353 fail_unless (memcmp (pointer, misc_data, 2) == 0);
355 gst_rtp_buffer_unmap (&rtp);
356 gst_buffer_unref (buf);
358 /* Test header extensions with a two bytes header */
359 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
360 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
362 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
364 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
365 misc_data, 2) == TRUE);
366 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
368 fail_unless (bits == 0x100 << 4);
369 fail_unless (size == 1);
370 data = (guint8 *) pointer;
371 fail_unless (data[0] == 5);
372 fail_unless (data[1] == 2);
373 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
374 0, &pointer, &size) == FALSE);
375 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
376 1, &pointer, &size) == FALSE);
377 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
378 0, &pointer, &size) == TRUE);
379 fail_unless (size == 2);
380 fail_unless (memcmp (pointer, misc_data, 2) == 0);
382 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
383 misc_data, 4) == TRUE);
384 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
385 0, &pointer, &size) == TRUE);
386 fail_unless (size == 2);
387 fail_unless (memcmp (pointer, misc_data, 2) == 0);
388 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
389 1, &pointer, &size) == TRUE);
390 fail_unless (size == 4);
391 fail_unless (memcmp (pointer, misc_data, 4) == 0);
392 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
393 2, &pointer, &size) == FALSE);
394 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
395 0, &pointer, &size) == FALSE);
397 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 6,
398 misc_data, 2) == TRUE);
399 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
400 0, &pointer, &size) == TRUE);
401 fail_unless (size == 2);
402 fail_unless (memcmp (pointer, misc_data, 2) == 0);
403 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
404 1, &pointer, &size) == TRUE);
405 fail_unless (size == 4);
406 fail_unless (memcmp (pointer, misc_data, 4) == 0);
407 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
408 2, &pointer, &size) == FALSE);
409 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
410 0, &pointer, &size) == FALSE);
411 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 6,
412 1, &pointer, &size) == FALSE);
413 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
414 0, &pointer, &size) == TRUE);
415 fail_unless (size == 2);
416 fail_unless (memcmp (pointer, misc_data, 2) == 0);
418 gst_rtp_buffer_unmap (&rtp);
419 gst_buffer_unref (buf);
425 GST_START_TEST (test_rtp_buffer_list_set_extension)
432 guint8 misc_data[4] = { 1, 2, 3, 4 };
435 GstBufferListIterator *it;
437 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
438 list = gst_rtp_buffer_list_from_buffer (buf);
439 gst_buffer_unref (buf);
441 it = gst_buffer_list_iterate (list);
442 fail_unless (gst_buffer_list_iterator_next_group (it));
443 buf = gst_buffer_list_iterator_next (it);
444 fail_unless (buf != NULL);
445 fail_unless (GST_BUFFER_SIZE (buf) == 12);
446 buf = gst_buffer_list_iterator_next (it);
447 fail_unless (buf != NULL);
448 fail_unless (GST_BUFFER_SIZE (buf) == 20);
449 gst_buffer_list_iterator_free (it);
451 /* Test header extensions with a one byte header */
452 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
453 1, &pointer, &size) == FALSE);
455 it = gst_buffer_list_iterate (list);
456 fail_unless (gst_buffer_list_iterator_next_group (it));
457 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
458 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
459 misc_data, 2) == TRUE);
460 gst_buffer_list_iterator_free (it);
461 it = gst_buffer_list_iterate (list);
462 fail_unless (gst_buffer_list_iterator_next_group (it));
463 buf = gst_buffer_list_iterator_next (it);
464 fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
465 fail_unless (bits == 0xBEDE);
466 fail_unless (size == 1);
467 data = (guint8 *) pointer;
468 fail_unless (data[0] == ((5 << 4) | 1));
469 gst_buffer_list_iterator_free (it);
470 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
471 0, &pointer, &size) == FALSE);
472 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
473 1, &pointer, &size) == FALSE);
474 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
475 0, &pointer, &size) == TRUE);
476 fail_unless (size == 2);
477 fail_unless (memcmp (pointer, misc_data, 2) == 0);
479 it = gst_buffer_list_iterate (list);
480 fail_unless (gst_buffer_list_iterator_next_group (it));
481 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
482 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
483 misc_data, 4) == TRUE);
484 gst_buffer_list_iterator_free (it);
485 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
486 0, &pointer, &size) == TRUE);
487 fail_unless (size == 2);
488 fail_unless (memcmp (pointer, misc_data, 2) == 0);
489 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
490 1, &pointer, &size) == TRUE);
491 fail_unless (size == 4);
492 fail_unless (memcmp (pointer, misc_data, 4) == 0);
493 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
494 2, &pointer, &size) == FALSE);
495 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
496 0, &pointer, &size) == FALSE);
498 it = gst_buffer_list_iterate (list);
499 fail_unless (gst_buffer_list_iterator_next_group (it));
500 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
501 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 6,
502 misc_data, 2) == TRUE);
503 gst_buffer_list_iterator_free (it);
504 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
505 0, &pointer, &size) == TRUE);
506 fail_unless (size == 2);
507 fail_unless (memcmp (pointer, misc_data, 2) == 0);
508 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
509 1, &pointer, &size) == TRUE);
510 fail_unless (size == 4);
511 fail_unless (memcmp (pointer, misc_data, 4) == 0);
512 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
513 2, &pointer, &size) == FALSE);
514 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
515 0, &pointer, &size) == FALSE);
516 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 6,
517 1, &pointer, &size) == FALSE);
518 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
519 0, &pointer, &size) == TRUE);
520 fail_unless (size == 2);
521 fail_unless (memcmp (pointer, misc_data, 2) == 0);
522 gst_buffer_list_unref (list);
525 /* Test header extensions with a two bytes header */
526 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
527 list = gst_rtp_buffer_list_from_buffer (buf);
528 gst_buffer_unref (buf);
530 it = gst_buffer_list_iterate (list);
531 fail_unless (gst_buffer_list_iterator_next_group (it));
532 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
533 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
534 misc_data, 2) == TRUE);
535 gst_buffer_list_iterator_free (it);
537 it = gst_buffer_list_iterate (list);
538 fail_unless (gst_buffer_list_iterator_next_group (it));
539 buf = gst_buffer_list_iterator_next (it);
540 fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
541 fail_unless (bits == 0x100 << 4);
542 fail_unless (size == 1);
543 data = (guint8 *) pointer;
544 fail_unless (data[0] == 5);
545 fail_unless (data[1] == 2);
546 gst_buffer_list_iterator_free (it);
547 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
548 &appbits, 2, 0, &pointer, &size) == FALSE);
549 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
550 &appbits, 5, 1, &pointer, &size) == FALSE);
551 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
552 &appbits, 5, 0, &pointer, &size) == TRUE);
553 fail_unless (size == 2);
554 fail_unless (memcmp (pointer, misc_data, 2) == 0);
556 it = gst_buffer_list_iterate (list);
557 fail_unless (gst_buffer_list_iterator_next_group (it));
558 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
559 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
560 misc_data, 4) == TRUE);
561 gst_buffer_list_iterator_free (it);
562 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
563 &appbits, 5, 0, &pointer, &size) == TRUE);
564 fail_unless (size == 2);
565 fail_unless (memcmp (pointer, misc_data, 2) == 0);
566 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
567 &appbits, 5, 1, &pointer, &size) == TRUE);
568 fail_unless (size == 4);
569 fail_unless (memcmp (pointer, misc_data, 4) == 0);
570 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
571 &appbits, 5, 2, &pointer, &size) == FALSE);
572 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
573 &appbits, 2, 0, &pointer, &size) == FALSE);
575 it = gst_buffer_list_iterate (list);
576 fail_unless (gst_buffer_list_iterator_next_group (it));
577 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
578 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 6,
579 misc_data, 2) == TRUE);
580 gst_buffer_list_iterator_free (it);
581 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
582 &appbits, 5, 0, &pointer, &size) == TRUE);
583 fail_unless (size == 2);
584 fail_unless (memcmp (pointer, misc_data, 2) == 0);
585 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
586 &appbits, 5, 1, &pointer, &size) == TRUE);
587 fail_unless (size == 4);
588 fail_unless (memcmp (pointer, misc_data, 4) == 0);
589 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
590 &appbits, 5, 2, &pointer, &size) == FALSE);
591 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
592 &appbits, 2, 0, &pointer, &size) == FALSE);
593 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
594 &appbits, 6, 1, &pointer, &size) == FALSE);
595 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
596 &appbits, 5, 0, &pointer, &size) == TRUE);
597 fail_unless (size == 2);
598 fail_unless (memcmp (pointer, misc_data, 2) == 0);
600 gst_buffer_list_unref (list);
606 GST_START_TEST (test_rtp_seqnum_compare)
608 #define ASSERT_COMP(a,b,c) fail_unless (gst_rtp_buffer_compare_seqnum ((guint16)a,(guint16)b) == c);
609 ASSERT_COMP (0xfffe, 0xfffd, -1);
610 ASSERT_COMP (0xffff, 0xfffe, -1);
611 ASSERT_COMP (0x0000, 0xffff, -1);
612 ASSERT_COMP (0x0001, 0x0000, -1);
613 ASSERT_COMP (0x0002, 0x0001, -1);
615 ASSERT_COMP (0xffff, 0xfffd, -2);
616 ASSERT_COMP (0x0000, 0xfffd, -3);
617 ASSERT_COMP (0x0001, 0xfffd, -4);
618 ASSERT_COMP (0x0002, 0xfffd, -5);
620 ASSERT_COMP (0x7ffe, 0x7ffd, -1);
621 ASSERT_COMP (0x7fff, 0x7ffe, -1);
622 ASSERT_COMP (0x8000, 0x7fff, -1);
623 ASSERT_COMP (0x8001, 0x8000, -1);
624 ASSERT_COMP (0x8002, 0x8001, -1);
626 ASSERT_COMP (0x7fff, 0x7ffd, -2);
627 ASSERT_COMP (0x8000, 0x7ffd, -3);
628 ASSERT_COMP (0x8001, 0x7ffd, -4);
629 ASSERT_COMP (0x8002, 0x7ffd, -5);
631 ASSERT_COMP (0x7ffd, 0xffff, -0x7ffe);
632 ASSERT_COMP (0x7ffe, 0x0000, -0x7ffe);
633 ASSERT_COMP (0x7fff, 0x0001, -0x7ffe);
634 ASSERT_COMP (0x7fff, 0x0000, -0x7fff);
635 ASSERT_COMP (0x8000, 0x0001, -0x7fff);
636 ASSERT_COMP (0x8001, 0x0002, -0x7fff);
638 ASSERT_COMP (0xfffd, 0x7ffe, -0x7fff);
639 ASSERT_COMP (0xfffe, 0x7fff, -0x7fff);
640 ASSERT_COMP (0xffff, 0x8000, -0x7fff);
641 ASSERT_COMP (0x0000, 0x8001, -0x7fff);
642 ASSERT_COMP (0x0001, 0x8002, -0x7fff);
644 ASSERT_COMP (0xfffe, 0x7ffe, -0x8000);
645 ASSERT_COMP (0xffff, 0x7fff, -0x8000);
646 ASSERT_COMP (0x0000, 0x8000, -0x8000);
647 ASSERT_COMP (0x0001, 0x8001, -0x8000);
649 ASSERT_COMP (0x7ffe, 0xfffe, -0x8000);
650 ASSERT_COMP (0x7fff, 0xffff, -0x8000);
651 ASSERT_COMP (0x8000, 0x0000, -0x8000);
652 ASSERT_COMP (0x8001, 0x0001, -0x8000);
654 ASSERT_COMP (0x0001, 0x0002, 1);
655 ASSERT_COMP (0x0000, 0x0001, 1);
656 ASSERT_COMP (0xffff, 0x0000, 1);
657 ASSERT_COMP (0xfffe, 0xffff, 1);
658 ASSERT_COMP (0xfffd, 0xfffe, 1);
660 ASSERT_COMP (0x0000, 0x0002, 2);
661 ASSERT_COMP (0xffff, 0x0002, 3);
662 ASSERT_COMP (0xfffe, 0x0002, 4);
663 ASSERT_COMP (0xfffd, 0x0002, 5);
665 ASSERT_COMP (0x8001, 0x8002, 1);
666 ASSERT_COMP (0x8000, 0x8001, 1);
667 ASSERT_COMP (0x7fff, 0x8000, 1);
668 ASSERT_COMP (0x7ffe, 0x7fff, 1);
669 ASSERT_COMP (0x7ffd, 0x7ffe, 1);
671 ASSERT_COMP (0x8000, 0x8002, 2);
672 ASSERT_COMP (0x7fff, 0x8002, 3);
673 ASSERT_COMP (0x7ffe, 0x8002, 4);
674 ASSERT_COMP (0x7ffd, 0x8002, 5);
676 ASSERT_COMP (0xfffe, 0x7ffd, 0x7fff);
677 ASSERT_COMP (0xffff, 0x7ffe, 0x7fff);
678 ASSERT_COMP (0x0000, 0x7fff, 0x7fff);
679 ASSERT_COMP (0x0001, 0x8000, 0x7fff);
680 ASSERT_COMP (0x0002, 0x8001, 0x7fff);
682 ASSERT_COMP (0x7ffe, 0xfffd, 0x7fff);
683 ASSERT_COMP (0x7fff, 0xfffe, 0x7fff);
684 ASSERT_COMP (0x8000, 0xffff, 0x7fff);
685 ASSERT_COMP (0x8001, 0x0000, 0x7fff);
686 ASSERT_COMP (0x8002, 0x0001, 0x7fff);
692 GST_START_TEST (test_rtcp_buffer)
695 GstRTCPPacket packet;
696 GstRTCPBuffer rtcp = { NULL, };
700 buf = gst_rtcp_buffer_new (1400);
701 fail_unless (buf != NULL);
702 fail_unless_equals_int (gst_buffer_get_sizes (buf, &offset, &maxsize), 0);
703 fail_unless_equals_int (offset, 0);
704 fail_unless_equals_int (maxsize, 1400);
706 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
708 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
709 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
710 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
712 /* add an SR packet */
713 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR,
716 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
717 fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
718 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
719 fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
721 gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
722 G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
727 guint32 packet_count;
730 gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, &ntptime, &rtptime,
731 &packet_count, &octet_count);
733 fail_unless (ssrc == 0x44556677);
734 fail_unless (ntptime == G_GUINT64_CONSTANT (1));
735 fail_unless (rtptime == 0x11111111);
736 fail_unless (packet_count == 101);
737 fail_unless (octet_count == 123456);
740 /* go to first packet, this should be the packet we just added */
741 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
743 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
744 fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
745 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
746 fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
748 fail_unless (gst_rtcp_packet_move_to_next (&packet) == FALSE);
751 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SDES,
753 fail_unless (gst_rtcp_packet_sdes_add_item (&packet, 0xff658743) == TRUE);
754 fail_unless (gst_rtcp_packet_sdes_add_entry (&packet, GST_RTCP_SDES_CNAME,
755 sizeof ("test@foo.bar"), (guint8 *) "test@foo.bar") == TRUE);
758 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_BYE,
760 fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x5613212f) == TRUE);
761 fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x00112233) == TRUE);
762 fail_unless (gst_rtcp_packet_bye_get_ssrc_count (&packet) == 2);
764 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
765 fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
766 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
767 fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
770 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
771 fail_unless (gst_rtcp_packet_move_to_next (&packet) == TRUE);
773 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
774 fail_unless (gst_rtcp_packet_get_count (&packet) == 1);
775 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SDES);
776 fail_unless (gst_rtcp_packet_get_length (&packet) == 5);
778 /* remove the SDES */
779 fail_unless (gst_rtcp_packet_remove (&packet) == TRUE);
781 /* we are now at the BYE packet */
782 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
783 fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
784 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
785 fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
787 /* close and validate */
788 gst_rtcp_buffer_unmap (&rtcp);
789 fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
790 fail_unless (gst_rtcp_buffer_validate_reduced (buf) == TRUE);
791 gst_buffer_unref (buf);
796 GST_START_TEST (test_rtcp_reduced_buffer)
799 GstRTCPPacket packet;
800 GstRTCPBuffer rtcp = { NULL, };
804 buf = gst_rtcp_buffer_new (1400);
805 fail_unless (buf != NULL);
806 fail_unless_equals_int (gst_buffer_get_sizes (buf, &offset, &maxsize), 0);
807 fail_unless_equals_int (offset, 0);
808 fail_unless_equals_int (maxsize, 1400);
810 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
812 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
813 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
814 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
816 /* add an SR packet */
817 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_PSFB,
820 /* close and validate */
821 gst_rtcp_buffer_unmap (&rtcp);
822 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
823 fail_unless (gst_rtcp_buffer_validate_reduced (buf) == TRUE);
824 gst_buffer_unref (buf);
830 GST_START_TEST (test_rtcp_validate_with_padding)
832 /* Compound packet with padding in the last packet. Padding is included in
833 * the length of the last packet. */
834 guint8 rtcp_pkt[] = {
835 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
836 0x97, 0x6d, 0x21, 0x6a,
837 0x4d, 0x16, 0xaf, 0x14,
838 0x10, 0x1f, 0xd9, 0x91,
839 0x0f, 0xb7, 0x50, 0x88,
840 0x3b, 0x79, 0x31, 0x50,
841 0xbe, 0x19, 0x12, 0xa8,
842 0xbb, 0xce, 0x9e, 0x3e,
843 0xA0, 0xCA, 0x00, 0x0A, /* P=1, Type SDES, length = 10 (includes padding) */
844 0x97, 0x6d, 0x21, 0x6a,
845 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
846 0x00, 0x00, 0x00, 0x00,
847 0x00, 0x00, 0x00, 0x00,
848 0x00, 0x00, 0x00, 0x00,
849 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
850 0x00, 0x00, 0x00, 0x00,
851 0x00, 0x00, 0x00, 0x00,
852 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
853 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
856 fail_unless (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
861 GST_START_TEST (test_rtcp_validate_with_padding_wrong_padlength)
863 /* Compound packet with padding in the last packet. Padding is included in
864 * the length of the last packet. */
865 guint8 rtcp_pkt[] = {
866 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
867 0x97, 0x6d, 0x21, 0x6a,
868 0x4d, 0x16, 0xaf, 0x14,
869 0x10, 0x1f, 0xd9, 0x91,
870 0x0f, 0xb7, 0x50, 0x88,
871 0x3b, 0x79, 0x31, 0x50,
872 0xbe, 0x19, 0x12, 0xa8,
873 0xbb, 0xce, 0x9e, 0x3e,
874 0xA0, 0xCA, 0x00, 0x0A, /* P=1, Type SDES, length = 10 (includes padding) */
875 0x97, 0x6d, 0x21, 0x6a,
876 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
877 0x00, 0x00, 0x00, 0x00,
878 0x00, 0x00, 0x00, 0x00,
879 0x00, 0x00, 0x00, 0x00,
880 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
881 0x00, 0x00, 0x00, 0x00,
882 0x00, 0x00, 0x00, 0x00,
883 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
884 0x00, 0x00, 0x00, 0x03 /* RTCP padding (wrong length) */
887 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
892 GST_START_TEST (test_rtcp_validate_with_padding_excluded_from_length)
894 /* Compound packet with padding in the last packet. Padding is not included
896 guint8 rtcp_pkt[] = {
897 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
898 0x97, 0x6d, 0x21, 0x6a,
899 0x4d, 0x16, 0xaf, 0x14,
900 0x10, 0x1f, 0xd9, 0x91,
901 0x0f, 0xb7, 0x50, 0x88,
902 0x3b, 0x79, 0x31, 0x50,
903 0xbe, 0x19, 0x12, 0xa8,
904 0xbb, 0xce, 0x9e, 0x3e,
905 0xA0, 0xCA, 0x00, 0x09, /* P=1, Type SDES, length = 9 (excludes padding) */
906 0x97, 0x6d, 0x21, 0x6a,
907 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
908 0x00, 0x00, 0x00, 0x00,
909 0x00, 0x00, 0x00, 0x00,
910 0x00, 0x00, 0x00, 0x00,
911 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
912 0x00, 0x00, 0x00, 0x00,
913 0x00, 0x00, 0x00, 0x00,
914 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
915 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
918 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
923 GST_START_TEST (test_rtcp_validate_with_padding_set_in_first_packet)
925 /* Compound packet with padding in the last packet but with the pad
926 bit set on first packet */
927 guint8 rtcp_pkt[] = {
928 0xA0, 0xC9, 0x00, 0x07, /* P=1, Type RR, length = 7 */
929 0x97, 0x6d, 0x21, 0x6a,
930 0x4d, 0x16, 0xaf, 0x14,
931 0x10, 0x1f, 0xd9, 0x91,
932 0x0f, 0xb7, 0x50, 0x88,
933 0x3b, 0x79, 0x31, 0x50,
934 0xbe, 0x19, 0x12, 0xa8,
935 0xbb, 0xce, 0x9e, 0x3e,
936 0x80, 0xCA, 0x00, 0x0a, /* Type SDES, length = 10 (include padding) */
937 0x97, 0x6d, 0x21, 0x6a,
938 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
939 0x00, 0x00, 0x00, 0x00,
940 0x00, 0x00, 0x00, 0x00,
941 0x00, 0x00, 0x00, 0x00,
942 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
943 0x00, 0x00, 0x00, 0x00,
944 0x00, 0x00, 0x00, 0x00,
945 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
946 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
949 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
954 GST_START_TEST (test_rtcp_validate_reduced_without_padding)
956 /* Reduced size packet without padding */
957 guint8 rtcp_pkt[] = {
958 0x80, 0xcd, 0x00, 0x07, /* Type FB, length = 8 */
959 0x97, 0x6d, 0x21, 0x6a,
960 0x4d, 0x16, 0xaf, 0x14,
961 0x10, 0x1f, 0xd9, 0x91,
962 0x0f, 0xb7, 0x50, 0x88,
963 0x3b, 0x79, 0x31, 0x50,
964 0xbe, 0x19, 0x12, 0xa8,
965 0xbb, 0xce, 0x9e, 0x3e,
968 fail_unless (gst_rtcp_buffer_validate_data_reduced (rtcp_pkt,
974 GST_START_TEST (test_rtcp_validate_reduced_with_padding)
976 /* Reduced size packet with padding. */
977 guint8 rtcp_pkt[] = {
978 0xA0, 0xcd, 0x00, 0x08, /* P=1, Type FB, length = 8 */
979 0x97, 0x6d, 0x21, 0x6a,
980 0x4d, 0x16, 0xaf, 0x14,
981 0x10, 0x1f, 0xd9, 0x91,
982 0x0f, 0xb7, 0x50, 0x88,
983 0x3b, 0x79, 0x31, 0x50,
984 0xbe, 0x19, 0x12, 0xa8,
985 0xbb, 0xce, 0x9e, 0x3e,
986 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
989 fail_if (gst_rtcp_buffer_validate_data_reduced (rtcp_pkt, sizeof (rtcp_pkt)));
994 GST_START_TEST (test_rtcp_buffer_profile_specific_extension)
997 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
998 GstRTCPPacket packet;
999 const guint8 pse[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1000 const guint8 pse2[] = { 0x01, 0x23, 0x45, 0x67 };
1002 fail_unless ((buf = gst_rtcp_buffer_new (1400)) != NULL);
1003 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1005 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
1006 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
1007 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
1009 /* add an SR packet with sender info */
1010 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR, &packet));
1011 gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
1012 G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
1013 fail_unless_equals_int (0,
1014 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1015 fail_unless_equals_int (6, gst_rtcp_packet_get_length (&packet));
1017 /* add profile-specific extension */
1018 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1019 pse, sizeof (pse)));
1021 guint8 *data = NULL;
1024 fail_unless_equals_int (8, gst_rtcp_packet_get_length (&packet));
1025 fail_unless_equals_int (sizeof (pse) / 4,
1026 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1028 /* gst_rtcp_packet_get_profile_specific_ext */
1029 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1031 fail_unless_equals_int (sizeof (pse), len);
1032 fail_unless (data != NULL);
1033 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1035 /* gst_rtcp_packet_copy_profile_specific_ext */
1036 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1038 fail_unless_equals_int (sizeof (pse), len);
1039 fail_unless (data != NULL);
1040 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1044 /* append more profile-specific extension */
1045 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1046 pse2, sizeof (pse2)));
1048 guint8 *data = NULL;
1053 /* Expect the second extension to be appended to the first */
1054 concat_len = sizeof (pse) + sizeof (pse2);
1055 concat_pse = g_malloc (concat_len);
1056 memcpy (concat_pse, pse, sizeof (pse));
1057 memcpy (concat_pse + sizeof (pse), pse2, sizeof (pse2));
1059 fail_unless_equals_int (9, gst_rtcp_packet_get_length (&packet));
1060 fail_unless_equals_int (concat_len / 4,
1061 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1063 /* gst_rtcp_packet_get_profile_specific_ext */
1064 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1066 fail_unless_equals_int (concat_len, len);
1067 fail_unless (data != NULL);
1068 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1070 /* gst_rtcp_packet_copy_profile_specific_ext */
1071 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1073 fail_unless_equals_int (concat_len, len);
1074 fail_unless (data != NULL);
1075 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1077 g_free (concat_pse);
1080 /* close and validate */
1081 gst_rtcp_buffer_unmap (&rtcp);
1082 fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
1083 gst_buffer_unref (buf);
1088 GST_START_TEST (test_rtcp_buffer_app)
1091 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1092 GstRTCPPacket packet;
1094 const guint8 data[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1095 guint max_data_length = (mtu - 12) / 4;
1098 fail_unless ((buf = gst_rtcp_buffer_new (mtu)) != NULL);
1099 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1101 /* Not a valid packet yet */
1102 fail_if (gst_rtcp_buffer_validate (buf));
1103 fail_if (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1104 fail_unless_equals_int (gst_rtcp_buffer_get_packet_count (&rtcp), 0);
1106 /* Add APP packet */
1107 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_APP, &packet));
1108 gst_rtcp_packet_app_set_subtype (&packet, 0x15);
1109 gst_rtcp_packet_app_set_ssrc (&packet, 0x01234567);
1110 gst_rtcp_packet_app_set_name (&packet, "Test");
1112 /* Check maximum allowed data */
1113 fail_if (gst_rtcp_packet_app_set_data_length (&packet, max_data_length + 1));
1114 fail_unless (gst_rtcp_packet_app_set_data_length (&packet, max_data_length));
1117 fail_unless (gst_rtcp_packet_app_set_data_length (&packet,
1118 (sizeof (data) + 3) / 4));
1119 fail_unless_equals_int (gst_rtcp_packet_app_get_data_length (&packet), 2);
1120 fail_unless ((data_ptr = gst_rtcp_packet_app_get_data (&packet)));
1121 memcpy (data_ptr, data, sizeof (data));
1123 gst_rtcp_buffer_unmap (&rtcp);
1125 /* Map again with only the READ flag and check fields */
1126 gst_rtcp_buffer_map (buf, GST_MAP_READ, &rtcp);
1127 fail_unless_equals_int (gst_rtcp_packet_app_get_subtype (&packet), 0x15);
1128 fail_unless_equals_int (gst_rtcp_packet_app_get_ssrc (&packet), 0x01234567);
1129 fail_unless (memcmp (gst_rtcp_packet_app_get_name (&packet), "Test", 4) == 0);
1130 fail_unless_equals_int (gst_rtcp_packet_app_get_data_length (&packet), 2);
1131 fail_unless ((data_ptr = gst_rtcp_packet_app_get_data (&packet)));
1132 fail_unless (memcmp (data_ptr, data, sizeof (data)) == 0);
1133 gst_rtcp_buffer_unmap (&rtcp);
1135 gst_buffer_unref (buf);
1140 GST_START_TEST (test_rtcp_buffer_xr)
1143 GstRTCPPacket packet;
1144 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1145 guint8 rtcp_pkt[] = {
1146 0x80, 0xCF, 0x00, 0x0e, /* Type XR, length = 14 */
1147 0x97, 0x6d, 0x21, 0x6a,
1148 0x01, 0x00, 0x00, 0x03, /* Loss RLE, No thining, length = 3 */
1149 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1150 0x00, 0x01, 0x00, 0x02,
1151 0xcf, 0xb7, 0x8f, 0xb7,
1152 0x02, 0x00, 0x00, 0x03, /* Dup RLE, No thining, length = 3 */
1153 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1154 0x00, 0x01, 0x00, 0x02,
1155 0xcf, 0xb7, 0x8f, 0xb7,
1156 0x03, 0x00, 0x00, 0x04, /* Packet Receipt Times, No thining, length = 4 */
1157 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1158 0x00, 0x01, 0x00, 0x02,
1159 0x59, 0xf9, 0xdd, 0x7e,
1160 0x59, 0xf9, 0xdd, 0x7e,
1163 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1164 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1166 fail_unless (gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp));
1168 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1169 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_XR);
1170 fail_unless (gst_rtcp_packet_xr_get_ssrc (&packet) ==
1171 GST_READ_UINT32_BE (rtcp_pkt + 12));
1172 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1173 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1174 GST_RTCP_XR_TYPE_LRLE);
1175 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1176 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1177 GST_RTCP_XR_TYPE_DRLE);
1178 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1179 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1180 GST_RTCP_XR_TYPE_PRT);
1182 fail_if (gst_rtcp_packet_xr_next_rb (&packet));
1184 gst_rtcp_buffer_unmap (&rtcp);
1185 gst_buffer_unref (buffer);
1190 GST_START_TEST (test_rtcp_buffer_xr_rle)
1193 GstRTCPPacket packet;
1194 guint32 ssrc, chunk_count;
1196 guint16 begin_seq, end_seq, chunk;
1197 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1198 guint8 rtcp_pkt[] = {
1199 0x80, 0xCF, 0x00, 0x0a, /* Type XR, length = 10 */
1200 0x97, 0x6d, 0x21, 0x6a,
1201 0x01, 0x00, 0x00, 0x03, /* Loss RLE, No thining, length = 3 */
1202 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1203 0x00, 0x01, 0x00, 0x02,
1204 0x80, 0x12, 0x00, 0x00,
1205 0x02, 0x00, 0x00, 0x04, /* Dup RLE, No thining, length = 4 */
1206 0x97, 0x6d, 0x21, 0x7b, /* SSRC of source */
1207 0x00, 0x01, 0x00, 0x04,
1208 0x8f, 0x21, 0x8f, 0x22,
1209 0x8f, 0x23, 0x8f, 0x24
1211 guint8 rtcp_pkt_invalid_pkt_length[] = {
1212 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1213 0x97, 0x6d, 0x21, 0x6a,
1214 0x01, 0x00, 0x00, 0x02, /* Loss RLE, No thining, length = 1 (but really 3) */
1215 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1216 0x00, 0x01, 0x00, 0x02,
1219 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1220 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1221 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1223 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1226 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1227 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1228 GST_RTCP_XR_TYPE_LRLE);
1229 fail_unless (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1230 &begin_seq, &end_seq, &chunk_count));
1231 fail_unless_equals_int (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1232 fail_unless_equals_int (thining, 0);
1233 fail_unless_equals_int (begin_seq, 0x0001);
1234 fail_unless_equals_int (end_seq, 0x0002);
1235 fail_unless_equals_int (chunk_count, 2);
1237 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 0, &chunk);
1238 fail_unless_equals_int (chunk, 0x8012);
1240 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1241 fail_unless_equals_int (chunk, 0x0);
1244 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1245 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1246 GST_RTCP_XR_TYPE_DRLE);
1247 fail_unless (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1248 &begin_seq, &end_seq, &chunk_count));
1249 fail_unless_equals_int (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 28));
1250 fail_unless_equals_int (thining, 0);
1251 fail_unless_equals_int (begin_seq, 0x0001);
1252 fail_unless_equals_int (end_seq, 0x0004);
1253 fail_unless_equals_int (chunk_count, 4);
1255 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1256 fail_unless_equals_int (chunk, 0x8f22);
1258 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 2, &chunk);
1259 fail_unless_equals_int (chunk, 0x8f23);
1261 gst_rtcp_buffer_unmap (&rtcp);
1262 gst_buffer_unref (buffer);
1264 /* Test invalid length */
1265 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1266 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1267 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1268 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1269 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1271 /* check LRLE (should fail because length is too short) */
1272 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1273 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1274 GST_RTCP_XR_TYPE_LRLE);
1275 fail_if (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1276 &begin_seq, &end_seq, &chunk_count));
1277 gst_rtcp_buffer_unmap (&rtcp);
1278 gst_buffer_unref (buffer);
1283 GST_START_TEST (test_rtcp_buffer_xr_prt)
1286 GstRTCPPacket packet;
1287 guint32 ssrc, receipt_time;
1289 guint16 begin_seq, end_seq;
1290 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1291 guint8 rtcp_pkt[] = {
1292 0x80, 0xCF, 0x00, 0x06, /* Type XR, length = 6 */
1293 0x97, 0x6d, 0x21, 0x6a,
1294 0x03, 0x00, 0x00, 0x04, /* Packet Receipt Times, No thining, length = 4 */
1295 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1296 0x00, 0x01, 0x00, 0x03,
1297 0x59, 0xf9, 0xdd, 0x7e,
1298 0x59, 0xf9, 0xde, 0x00,
1300 guint8 rtcp_pkt_invalid_pkt_length[] = {
1301 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1302 0x97, 0x6d, 0x21, 0x6a,
1303 0x03, 0x00, 0x00, 0x02, /* Packet Receipt Times, No thining, length = 2 (but should be 4) */
1304 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1305 0x00, 0x01, 0x00, 0x03,
1307 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1308 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1309 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1311 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1313 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1314 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1315 GST_RTCP_XR_TYPE_PRT);
1317 fail_unless (gst_rtcp_packet_xr_get_prt_info (&packet, &ssrc, &thining,
1318 &begin_seq, &end_seq));
1319 fail_unless (gst_rtcp_packet_xr_get_prt_by_seq (&packet, 2, &receipt_time));
1320 fail_unless_equals_int_hex (receipt_time, 0x59f9de00L);
1322 gst_rtcp_buffer_unmap (&rtcp);
1323 gst_buffer_unref (buffer);
1325 /* Test for invalid length */
1326 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1327 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1328 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1329 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1331 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1333 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1334 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1335 GST_RTCP_XR_TYPE_PRT);
1337 fail_if (gst_rtcp_packet_xr_get_prt_info (&packet, &ssrc, &thining,
1338 &begin_seq, &end_seq));
1339 gst_rtcp_buffer_unmap (&rtcp);
1340 gst_buffer_unref (buffer);
1346 GST_START_TEST (test_rtcp_buffer_xr_rrt)
1349 GstRTCPPacket packet;
1351 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1352 guint8 rtcp_pkt[] = {
1353 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1354 0x97, 0x6d, 0x21, 0x6a,
1355 0x04, 0x00, 0x00, 0x02, /* Receiver Reference Time, length = 2 */
1356 0x01, 0x23, 0x45, 0x67,
1357 0x89, 0x01, 0x23, 0x45
1359 guint8 rtcp_pkt_invalid_pkt_length[] = {
1360 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1361 0x97, 0x6d, 0x21, 0x6a,
1362 0x04, 0x00, 0x00, 0x01, /* Receiver Reference Time, length = 1 */
1363 0x01, 0x23, 0x45, 0x67,
1364 0x89, 0x01, 0x23, 0x45
1367 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1368 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1369 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1371 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1373 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1374 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1375 GST_RTCP_XR_TYPE_RRT);
1377 fail_unless (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1378 fail_unless_equals_uint64_hex (ntptime, 0x0123456789012345LL);
1380 gst_rtcp_buffer_unmap (&rtcp);
1381 gst_buffer_unref (buffer);
1383 /* Test invalid length */
1384 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1385 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1386 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1387 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1389 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1391 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1392 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1393 GST_RTCP_XR_TYPE_RRT);
1395 fail_if (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1397 gst_rtcp_buffer_unmap (&rtcp);
1398 gst_buffer_unref (buffer);
1403 GST_START_TEST (test_rtcp_buffer_xr_dlrr)
1406 GstRTCPPacket packet;
1407 guint32 ssrc, last_rr, delay;
1408 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1409 guint8 rtcp_pkt[] = {
1410 0x80, 0xCF, 0x00, 0x08, /* Type XR, length = 8 */
1411 0x97, 0x6d, 0x21, 0x6a,
1412 0x05, 0x00, 0x00, 0x06, /* DLRR, length = 6 */
1413 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1414 0x01, 0x23, 0x45, 0x67,
1415 0x89, 0x01, 0x23, 0x45,
1416 0x97, 0x6d, 0x21, 0x6b, /* SSRC of source */
1417 0x01, 0x23, 0x45, 0x67,
1418 0x89, 0x01, 0x23, 0x45
1421 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1422 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1423 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1425 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1427 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1428 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1429 GST_RTCP_XR_TYPE_DLRR);
1431 fail_unless (gst_rtcp_packet_xr_get_dlrr_block (&packet, 0, &ssrc, &last_rr,
1433 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1434 fail_unless (gst_rtcp_packet_xr_get_dlrr_block (&packet, 1, &ssrc, &last_rr,
1436 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 24));
1438 /* it has only two sub-blocks. */
1439 fail_if (gst_rtcp_packet_xr_get_dlrr_block (&packet, 2, &ssrc, &last_rr,
1442 gst_rtcp_buffer_unmap (&rtcp);
1443 gst_buffer_unref (buffer);
1448 GST_START_TEST (test_rtcp_buffer_xr_ssumm)
1451 GstRTCPPacket packet;
1452 guint32 ssrc, lost_packets, dup_packets;
1453 guint16 begin_seq, end_seq;
1454 guint32 min_jitter, max_jitter, mean_jitter, dev_jitter;
1455 guint8 min_ttl, max_ttl, mean_ttl, dev_ttl;
1457 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1458 guint8 rtcp_pkt[] = {
1459 0x80, 0xCF, 0x00, 0x0b, /* Type XR, length = 11 */
1460 0x97, 0x6d, 0x21, 0x6a,
1461 0x06, 0xe8, 0x00, 0x09, /* Statistics summary, length = 9 */
1462 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1463 0x00, 0x01, 0x00, 0x02,
1464 0x00, 0x00, 0x00, 0x01,
1465 0x00, 0x00, 0x00, 0x02,
1466 0x00, 0x00, 0x00, 0x03,
1467 0x00, 0x00, 0x00, 0x04,
1468 0x00, 0x00, 0x00, 0x05,
1469 0x00, 0x00, 0x00, 0x06,
1470 0x01, 0x80, 0x0f, 0x8f
1473 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1474 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1475 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1477 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1479 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1480 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1481 GST_RTCP_XR_TYPE_SSUMM);
1483 fail_unless (gst_rtcp_packet_xr_get_summary_info (&packet, &ssrc, &begin_seq,
1485 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1486 fail_unless_equals_int (begin_seq, GST_READ_UINT16_BE (rtcp_pkt + 16));
1487 fail_unless_equals_int (end_seq, GST_READ_UINT16_BE (rtcp_pkt + 18));
1489 fail_unless (gst_rtcp_packet_xr_get_summary_pkt (&packet, &lost_packets,
1491 fail_unless_equals_int (lost_packets, GST_READ_UINT32_BE (rtcp_pkt + 20));
1492 fail_unless_equals_int (dup_packets, GST_READ_UINT32_BE (rtcp_pkt + 24));
1494 fail_unless (gst_rtcp_packet_xr_get_summary_jitter (&packet, &min_jitter,
1495 &max_jitter, &mean_jitter, &dev_jitter));
1496 fail_unless_equals_int (min_jitter, GST_READ_UINT32_BE (rtcp_pkt + 28));
1497 fail_unless_equals_int (max_jitter, GST_READ_UINT32_BE (rtcp_pkt + 32));
1498 fail_unless_equals_int (mean_jitter, GST_READ_UINT32_BE (rtcp_pkt + 36));
1499 fail_unless_equals_int (dev_jitter, GST_READ_UINT32_BE (rtcp_pkt + 40));
1501 fail_unless (gst_rtcp_packet_xr_get_summary_ttl (&packet, &ipv4, &min_ttl,
1502 &max_ttl, &mean_ttl, &dev_ttl));
1504 fail_unless_equals_int (min_ttl, rtcp_pkt[44]);
1505 fail_unless_equals_int (max_ttl, rtcp_pkt[45]);
1506 fail_unless_equals_int (mean_ttl, rtcp_pkt[46]);
1507 fail_unless_equals_int (dev_ttl, rtcp_pkt[47]);
1509 gst_rtcp_buffer_unmap (&rtcp);
1510 gst_buffer_unref (buffer);
1515 GST_START_TEST (test_rtcp_buffer_xr_voipmtrx)
1518 GstRTCPPacket packet;
1520 guint8 loss_rate, discard_rate, burst_density, gap_density;
1521 guint8 signal_level, noise_level, rerl, gmin;
1522 guint8 r_factor, ext_r_factor, mos_lq, mos_cq, rx_config;
1523 guint16 burst_duration, gap_duration;
1524 guint16 roundtrip_delay, end_system_delay;
1525 guint16 jb_nominal, jb_maximum, jb_abs_max;
1526 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1527 guint8 rtcp_pkt[] = {
1528 0x80, 0xCF, 0x00, 0x0a, /* Type XR, length = 10 */
1529 0x97, 0x6d, 0x21, 0x6a,
1530 0x07, 0x00, 0x00, 0x08, /* VoIP Metrics, length = 8 */
1531 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1532 0x01, 0x02, 0x03, 0x04,
1533 0x05, 0x06, 0x07, 0x08,
1534 0x09, 0x0a, 0x0b, 0x0c,
1535 0x0d, 0x0e, 0x0f, 0x10,
1536 0x11, 0x12, 0x13, 0x14,
1537 0x15, 0x00, 0x16, 0x17,
1538 0x18, 0x19, 0x1a, 0x1b
1541 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1542 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1543 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1545 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1547 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1548 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1549 GST_RTCP_XR_TYPE_VOIP_METRICS);
1550 fail_unless (gst_rtcp_packet_xr_get_voip_metrics_ssrc (&packet, &ssrc));
1551 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1553 fail_unless (gst_rtcp_packet_xr_get_voip_packet_metrics (&packet, &loss_rate,
1555 fail_unless_equals_int (loss_rate, rtcp_pkt[16]);
1556 fail_unless_equals_int (discard_rate, rtcp_pkt[17]);
1558 fail_unless (gst_rtcp_packet_xr_get_voip_burst_metrics (&packet,
1559 &burst_density, &gap_density, &burst_duration, &gap_duration));
1560 fail_unless_equals_int (burst_density, rtcp_pkt[18]);
1561 fail_unless_equals_int (gap_density, rtcp_pkt[19]);
1562 fail_unless_equals_int (burst_duration, GST_READ_UINT16_BE (rtcp_pkt + 20));
1563 fail_unless_equals_int (gap_duration, GST_READ_UINT16_BE (rtcp_pkt + 22));
1565 fail_unless (gst_rtcp_packet_xr_get_voip_delay_metrics (&packet,
1566 &roundtrip_delay, &end_system_delay));
1567 fail_unless_equals_int (roundtrip_delay, GST_READ_UINT16_BE (rtcp_pkt + 24));
1568 fail_unless_equals_int (end_system_delay, GST_READ_UINT16_BE (rtcp_pkt + 26));
1570 fail_unless (gst_rtcp_packet_xr_get_voip_signal_metrics (&packet,
1571 &signal_level, &noise_level, &rerl, &gmin));
1572 fail_unless_equals_int (signal_level, rtcp_pkt[28]);
1573 fail_unless_equals_int (noise_level, rtcp_pkt[29]);
1574 fail_unless_equals_int (rerl, rtcp_pkt[30]);
1575 fail_unless_equals_int (gmin, rtcp_pkt[31]);
1577 fail_unless (gst_rtcp_packet_xr_get_voip_quality_metrics (&packet, &r_factor,
1578 &ext_r_factor, &mos_lq, &mos_cq));
1579 fail_unless_equals_int (r_factor, rtcp_pkt[32]);
1580 fail_unless_equals_int (ext_r_factor, rtcp_pkt[33]);
1581 fail_unless_equals_int (mos_lq, rtcp_pkt[34]);
1582 fail_unless_equals_int (mos_cq, rtcp_pkt[35]);
1584 fail_unless (gst_rtcp_packet_xr_get_voip_configuration_params (&packet, &gmin,
1586 fail_unless_equals_int (gmin, rtcp_pkt[31]);
1587 fail_unless_equals_int (rx_config, rtcp_pkt[36]);
1589 fail_unless (gst_rtcp_packet_xr_get_voip_jitter_buffer_params (&packet,
1590 &jb_nominal, &jb_maximum, &jb_abs_max));
1591 fail_unless_equals_int (jb_nominal, GST_READ_UINT16_BE (rtcp_pkt + 38));
1592 fail_unless_equals_int (jb_maximum, GST_READ_UINT16_BE (rtcp_pkt + 40));
1593 fail_unless_equals_int (jb_abs_max, GST_READ_UINT16_BE (rtcp_pkt + 42));
1595 gst_rtcp_buffer_unmap (&rtcp);
1596 gst_buffer_unref (buffer);
1601 GST_START_TEST (test_rtp_ntp64_extension)
1606 GstRTPBuffer rtp = { NULL, };
1607 guint8 bytes[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1609 guint8 hdrext_ntp64[GST_RTP_HDREXT_NTP_64_SIZE];
1611 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1613 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1615 /* format extension data */
1616 gst_rtp_hdrext_set_ntp_64 (hdrext_ntp64, GST_RTP_HDREXT_NTP_64_SIZE,
1617 0x0123456789012345LL);
1618 fail_unless (memcmp (bytes, hdrext_ntp64, sizeof (bytes)) == 0);
1620 /* add as 1byte header */
1621 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp64,
1622 GST_RTP_HDREXT_NTP_64_SIZE);
1624 /* get extension again */
1625 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1628 fail_unless (size == GST_RTP_HDREXT_NTP_64_SIZE);
1629 fail_unless (memcmp (data, hdrext_ntp64, size) == 0);
1631 gst_rtp_hdrext_get_ntp_64 (data, size, &ntptime);
1632 fail_unless (ntptime == 0x0123456789012345LL);
1634 gst_rtp_buffer_unmap (&rtp);
1635 gst_buffer_unref (buf);
1640 GST_START_TEST (test_rtp_ntp56_extension)
1645 GstRTPBuffer rtp = { NULL, };
1646 guint8 bytes[] = { 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1648 guint8 hdrext_ntp56[GST_RTP_HDREXT_NTP_56_SIZE];
1650 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1652 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1654 /* format extension data */
1655 gst_rtp_hdrext_set_ntp_56 (hdrext_ntp56, GST_RTP_HDREXT_NTP_56_SIZE,
1656 0x0123456789012345LL);
1657 /* truncates top bits */
1658 fail_unless (memcmp (bytes, hdrext_ntp56, sizeof (bytes)) == 0);
1660 /* add as 1byte header */
1661 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp56,
1662 GST_RTP_HDREXT_NTP_56_SIZE);
1664 /* get extension again */
1665 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1668 fail_unless (size == GST_RTP_HDREXT_NTP_56_SIZE);
1669 fail_unless (memcmp (data, hdrext_ntp56, size) == 0);
1671 gst_rtp_hdrext_get_ntp_56 (data, size, &ntptime);
1672 fail_unless (ntptime == 0x23456789012345LL);
1674 gst_rtp_buffer_unmap (&rtp);
1675 gst_buffer_unref (buf);
1680 GST_START_TEST (test_rtp_buffer_get_extension_bytes)
1685 guint8 misc_data[4] = { 1, 2, 3, 4 };
1687 GstRTPBuffer rtp = { NULL, };
1691 /* create RTP buffer without extension header */
1692 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
1693 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1694 fail_if (gst_rtp_buffer_get_extension (&rtp));
1696 /* verify that obtaining extension data returns NULL and bits are unchanged */
1698 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1699 fail_unless (gb == NULL);
1700 fail_unless (bits == 0xabcd);
1704 /* add extension header without data and verify that
1705 * an empty GBytes is returned */
1706 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 0));
1707 fail_unless (gst_rtp_buffer_get_extension (&rtp));
1708 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1709 fail_unless (gb != NULL);
1710 fail_unless_equals_int (g_bytes_get_size (gb), 0);
1713 gst_rtp_buffer_unmap (&rtp);
1714 gst_buffer_unref (buf);
1716 /* create RTP buffer with extension header and extension data */
1717 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
1718 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1719 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
1721 fail_unless (gst_rtp_buffer_get_extension (&rtp));
1723 /* verify that gst_rtp_buffer_get_extension_bytes returns the same
1724 * header bits and data as does gst_rtp_buffer_get_extension_data */
1725 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
1727 fail_unless (bits == 0xBEDE);
1728 fail_unless (size == 1);
1729 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1730 fail_unless (gb != NULL);
1731 fail_unless (bits == 0xBEDE);
1732 fail_unless_equals_int (g_bytes_get_size (gb), size * 4);
1733 fail_unless (memcmp (pointer, g_bytes_get_data (gb, &gb_size),
1735 fail_unless_equals_int (gb_size, size * 4);
1738 gst_rtp_buffer_unmap (&rtp);
1739 gst_buffer_unref (buf);
1744 GST_START_TEST (test_rtp_buffer_get_payload_bytes)
1746 guint8 rtppacket[] = {
1747 0x80, 0xe0, 0xdf, 0xd7, 0xef, 0x84, 0xbe, 0xed, 0x9b, 0xc5, 0x29, 0x14,
1748 'H', 'e', 'l', 'l', 'o', '\0'
1755 GstRTPBuffer rtp = { NULL, };
1758 /* create empty RTP buffer, i.e. no payload */
1759 buf = gst_rtp_buffer_new_allocate (0, 4, 0);
1760 fail_unless (buf != NULL);
1761 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
1762 fail_unless_equals_int (map.size, RTP_HEADER_LEN + 4);
1763 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp));
1765 /* verify that requesting payload data returns an empty GBytes */
1766 gb = gst_rtp_buffer_get_payload_bytes (&rtp);
1767 fail_unless (gb != NULL);
1768 fail_unless_equals_int (g_bytes_get_size (gb), 0);
1770 gst_rtp_buffer_unmap (&rtp);
1771 gst_buffer_unmap (buf, &map);
1772 gst_buffer_unref (buf);
1775 /* create RTP buffer containing RTP packet */
1776 buf = gst_buffer_new_and_alloc (sizeof (rtppacket));
1777 fail_unless (buf != NULL);
1778 gst_buffer_fill (buf, 0, rtppacket, sizeof (rtppacket));
1779 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
1780 fail_unless_equals_int (map.size, sizeof (rtppacket));
1781 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp));
1783 /* verify that the returned GBytes contains the correct payload data */
1784 gb = gst_rtp_buffer_get_payload_bytes (&rtp);
1785 fail_unless (gb != NULL);
1786 data = g_bytes_get_data (gb, &size);
1787 fail_unless (data != NULL);
1788 fail_unless (size == (sizeof (rtppacket) - RTP_HEADER_LEN));
1789 fail_unless_equals_string ("Hello", data);
1792 gst_rtp_buffer_unmap (&rtp);
1793 gst_buffer_unmap (buf, &map);
1794 gst_buffer_unref (buf);
1800 GST_START_TEST (test_rtp_buffer_empty_payload)
1802 GstRTPBuffer rtp = { NULL };
1803 GstBuffer *paybuf, *outbuf;
1805 paybuf = gst_rtp_buffer_new_allocate (0, 0, 0);
1807 gst_rtp_buffer_map (paybuf, GST_MAP_READ, &rtp);
1808 outbuf = gst_rtp_buffer_get_payload_buffer (&rtp);
1809 gst_rtp_buffer_unmap (&rtp);
1811 gst_buffer_unref (paybuf);
1812 gst_buffer_unref (outbuf);
1817 GST_START_TEST (test_rtp_buffer_extension_onebyte_header_full_padding)
1820 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1827 guint8 hdr_buffer_1[2] = { 0x1, 0x1 };
1829 guint8 rtp_test_buffer[] = {
1830 0x90, 0x7c, 0x18, 0xa6, /* |V=2|P|X|CC|M|PT|sequence number| */
1831 0x7a, 0x62, 0x17, 0x0f, /* |timestamp| */
1832 0x70, 0x23, 0x91, 0x38, /* |synchronization source (SSRC) identifier| */
1833 0xbe, 0xde, 0x00, 0x02, /* |0xBE|0xDE|length=2| */
1834 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1835 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1836 0xff, 0xff, 0xff, 0xff /* |dummy payload| */
1839 mem = malloc (sizeof (rtp_test_buffer));
1840 fail_unless (mem != NULL);
1841 memcpy (mem, rtp_test_buffer, sizeof (rtp_test_buffer));
1842 fail_unless_equals_int (memcmp (mem, rtp_test_buffer,
1843 sizeof (rtp_test_buffer)), 0);
1845 buffer = gst_buffer_new_wrapped (mem, sizeof (rtp_test_buffer));
1847 fail_unless (gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp));
1849 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1850 (gpointer) & pdata, &wordlen));
1851 fail_unless_equals_int (bits, 0xBEDE);
1852 fail_unless_equals_int (wordlen, 2);
1853 fail_unless_equals_int (pdata[0], 0x0);
1854 fail_unless_equals_int (pdata[1], 0x0);
1855 fail_unless_equals_int (pdata[2], 0x0);
1856 fail_unless_equals_int (pdata[3], 0x0);
1857 fail_unless_equals_int (pdata[4], 0x0);
1858 fail_unless_equals_int (pdata[5], 0x0);
1859 fail_unless_equals_int (pdata[6], 0x0);
1860 fail_unless_equals_int (pdata[7], 0x0);
1862 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1,
1864 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0,
1865 (gpointer *) & data_out, &size));
1866 fail_unless_equals_int (size, 2);
1867 fail_unless_equals_int (data_out[0], 0x1);
1868 fail_unless_equals_int (data_out[1], 0x1);
1869 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1870 (gpointer) & pdata, &wordlen));
1871 fail_unless_equals_int (bits, 0xBEDE);
1872 fail_unless_equals_int (wordlen, 2);
1873 fail_unless_equals_int (pdata[0], 0x11);
1874 fail_unless_equals_int (pdata[1], 0x1);
1875 fail_unless_equals_int (pdata[2], 0x1);
1876 fail_unless_equals_int (pdata[3], 0x0);
1877 fail_unless_equals_int (pdata[4], 0x0);
1878 fail_unless_equals_int (pdata[5], 0x0);
1879 fail_unless_equals_int (pdata[6], 0x0);
1880 fail_unless_equals_int (pdata[7], 0x0);
1882 gst_rtp_buffer_unmap (&rtp);
1884 gst_buffer_unref (buffer);
1890 GST_START_TEST (test_ext_timestamp_basic)
1892 guint64 exttimestamp = -1;
1895 /* no wraparound when timestamps are increasing */
1896 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 0);
1897 fail_unless_equals_uint64 (result, 0);
1898 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1899 fail_unless_equals_uint64 (result, 10);
1900 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1901 fail_unless_equals_uint64 (result, 10);
1902 result = gst_rtp_buffer_ext_timestamp (&exttimestamp,
1903 G_GUINT64_CONSTANT (1) + G_MAXINT32);
1904 fail_unless_equals_uint64 (result, G_GUINT64_CONSTANT (1) + G_MAXINT32);
1906 /* Even big bumps under G_MAXINT32 don't result in wrap-around */
1908 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 1087500);
1909 fail_unless_equals_uint64 (result, 1087500);
1910 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 24);
1911 fail_unless_equals_uint64 (result, 24);
1916 GST_START_TEST (test_ext_timestamp_wraparound)
1918 guint64 ext_ts = -1;
1920 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts,
1921 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)),
1922 (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1924 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 0),
1925 G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1927 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000),
1928 (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1934 GST_START_TEST (test_ext_timestamp_wraparound_disordered)
1936 guint64 ext_ts = -1;
1938 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1939 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1940 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1942 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 0)
1943 == G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1945 /* Unwrapping around */
1946 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1947 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1948 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1950 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1951 == (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1956 GST_START_TEST (test_ext_timestamp_wraparound_disordered_cannot_unwrap)
1958 guint64 ext_ts = -1;
1960 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1963 /* Cannot unwrapping around */
1964 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1965 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)) == 0);
1967 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1976 Suite *s = suite_create ("rtp support library");
1977 TCase *tc_chain = tcase_create ("general");
1979 suite_add_tcase (s, tc_chain);
1980 tcase_add_test (tc_chain, test_rtp_buffer);
1981 tcase_add_test (tc_chain, test_rtp_buffer_validate_corrupt);
1982 tcase_add_test (tc_chain, test_rtp_buffer_validate_padding);
1983 tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data);
1984 //tcase_add_test (tc_chain, test_rtp_buffer_list_set_extension);
1985 tcase_add_test (tc_chain, test_rtp_seqnum_compare);
1987 tcase_add_test (tc_chain, test_rtcp_buffer);
1988 tcase_add_test (tc_chain, test_rtcp_reduced_buffer);
1989 tcase_add_test (tc_chain, test_rtcp_validate_with_padding);
1990 tcase_add_test (tc_chain, test_rtcp_validate_with_padding_wrong_padlength);
1991 tcase_add_test (tc_chain,
1992 test_rtcp_validate_with_padding_excluded_from_length);
1993 tcase_add_test (tc_chain,
1994 test_rtcp_validate_with_padding_set_in_first_packet);
1995 tcase_add_test (tc_chain, test_rtcp_validate_reduced_without_padding);
1996 tcase_add_test (tc_chain, test_rtcp_validate_reduced_with_padding);
1997 tcase_add_test (tc_chain, test_rtcp_buffer_profile_specific_extension);
1998 tcase_add_test (tc_chain, test_rtcp_buffer_app);
1999 tcase_add_test (tc_chain, test_rtcp_buffer_xr);
2000 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rle);
2001 tcase_add_test (tc_chain, test_rtcp_buffer_xr_prt);
2002 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rrt);
2003 tcase_add_test (tc_chain, test_rtcp_buffer_xr_dlrr);
2004 tcase_add_test (tc_chain, test_rtcp_buffer_xr_ssumm);
2005 tcase_add_test (tc_chain, test_rtcp_buffer_xr_voipmtrx);
2007 tcase_add_test (tc_chain, test_rtp_ntp64_extension);
2008 tcase_add_test (tc_chain, test_rtp_ntp56_extension);
2010 tcase_add_test (tc_chain, test_rtp_buffer_get_payload_bytes);
2011 tcase_add_test (tc_chain, test_rtp_buffer_get_extension_bytes);
2012 tcase_add_test (tc_chain, test_rtp_buffer_empty_payload);
2014 tcase_add_test (tc_chain,
2015 test_rtp_buffer_extension_onebyte_header_full_padding);
2017 //tcase_add_test (tc_chain, test_rtp_buffer_list);
2019 tcase_add_test (tc_chain, test_ext_timestamp_basic);
2020 tcase_add_test (tc_chain, test_ext_timestamp_wraparound);
2021 tcase_add_test (tc_chain, test_ext_timestamp_wraparound_disordered);
2022 tcase_add_test (tc_chain,
2023 test_ext_timestamp_wraparound_disordered_cannot_unwrap);
2028 GST_CHECK_MAIN (rtp);