1 /* GStreamer unit tests for the RTP support library
2 *
3 * Copyright (C) 2007 Tim-Philipp Müller <tim centricular net>
4 *
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.
9 *
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.
14 *
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.
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include <gst/check/gstcheck.h>
26
27 #include <gst/rtp/gstrtpbuffer.h>
28 #include <gst/rtp/gstrtphdrext.h>
29 #include <gst/rtp/gstrtcpbuffer.h>
30 #include <string.h>
31
32 #define RTP_HEADER_LEN 12
33
GST_START_TEST(test_rtp_buffer)34 GST_START_TEST (test_rtp_buffer)
35 {
36 GstBuffer *buf;
37 GstMapInfo map;
38 guint8 *data;
39 gsize size;
40 GstRTPBuffer rtp = { NULL, };
41
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);
46 data = map.data;
47 size = map.size;
48 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4);
49
50 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
51
52 /* check defaults */
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);
60
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);
68
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);
76
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);
84
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);
92
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);
100
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);
108
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);
113
114 gst_rtp_buffer_unmap (&rtp);
115 gst_buffer_unmap (buf, &map);
116 gst_buffer_unref (buf);
117
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);
122 data = map.data;
123 size = map.size;
124 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4 + 4 * 3);
125
126 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
127
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);
137
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));
146
147 gst_rtp_buffer_unmap (&rtp);
148 gst_buffer_unmap (buf, &map);
149 gst_buffer_unref (buf);
150 }
151
152 GST_END_TEST;
153
GST_START_TEST(test_rtp_buffer_validate_corrupt)154 GST_START_TEST (test_rtp_buffer_validate_corrupt)
155 {
156 GstBuffer *buf;
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
163 };
164 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
165
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);
170 }
171
172 GST_END_TEST;
173
GST_START_TEST(test_rtp_buffer_validate_padding)174 GST_START_TEST (test_rtp_buffer_validate_padding)
175 {
176 GstBuffer *buf;
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
180 };
181 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
182
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);
188
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));
194
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);
200 }
201
202 GST_END_TEST;
203
204 #if 0
205 GST_START_TEST (test_rtp_buffer_list)
206 {
207 GstBuffer *rtp_header;
208 GstBuffer *rtp_payload;
209 GstBufferList *list = NULL;
210 GstBufferListIterator *it;
211 guint i;
212
213 list = gst_buffer_list_new ();
214 it = gst_buffer_list_iterate (list);
215
216 /* Creating a list of two RTP packages */
217
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);
224
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);
231
232 gst_buffer_list_iterator_free (it);
233
234 /* Test SEQ number */
235 i = gst_rtp_buffer_list_set_seq (list, 1024);
236 fail_if (1026 != i);
237 fail_if (!gst_rtp_buffer_list_validate (list));
238
239 /* Timestamp */
240 gst_rtp_buffer_list_set_timestamp (list, 432191);
241 fail_unless_equals_int (gst_rtp_buffer_list_get_timestamp (list), 432191);
242
243 /* SSRC */
244 gst_rtp_buffer_list_set_ssrc (list, 0xf04043C2);
245 fail_unless_equals_int (gst_rtp_buffer_list_get_ssrc (list),
246 (gint) 0xf04043c2);
247
248 /* Payload type */
249 gst_rtp_buffer_list_set_payload_type (list, 127);
250 fail_unless_equals_int (gst_rtp_buffer_list_get_payload_type (list), 127);
251
252 gst_buffer_list_unref (list);
253 }
254
255 GST_END_TEST;
256 #endif
257
GST_START_TEST(test_rtp_buffer_set_extension_data)258 GST_START_TEST (test_rtp_buffer_set_extension_data)
259 {
260 GstBuffer *buf;
261 guint8 *data;
262 guint16 bits;
263 guint size;
264 guint8 misc_data[4] = { 1, 2, 3, 4 };
265 gpointer pointer;
266 guint8 appbits;
267 GstRTPBuffer rtp = { NULL, };
268
269 /* check GstRTPHeader structure alignment and packing */
270 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
271
272 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
273
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);
282
283 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
284 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
285
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);
292
293 gst_rtp_buffer_unmap (&rtp);
294 gst_buffer_unref (buf);
295
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);
299
300 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
301
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,
305 &size));
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);
318
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);
333
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);
354
355 gst_rtp_buffer_unmap (&rtp);
356 gst_buffer_unref (buf);
357
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);
361
362 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
363
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,
367 &size));
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);
381
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);
396
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);
417
418 gst_rtp_buffer_unmap (&rtp);
419 gst_buffer_unref (buf);
420 }
421
422 GST_END_TEST;
423
424 #if 0
425 GST_START_TEST (test_rtp_buffer_list_set_extension)
426 {
427 GstBufferList *list;
428 GstBuffer *buf;
429 guint8 *data;
430 guint16 bits;
431 guint size;
432 guint8 misc_data[4] = { 1, 2, 3, 4 };
433 gpointer pointer;
434 guint8 appbits;
435 GstBufferListIterator *it;
436
437 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
438 list = gst_rtp_buffer_list_from_buffer (buf);
439 gst_buffer_unref (buf);
440
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);
450
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);
454
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);
478
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);
497
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);
523
524
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);
529
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);
536
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);
555
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);
574
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);
599
600 gst_buffer_list_unref (list);
601 }
602
603 GST_END_TEST;
604 #endif
605
GST_START_TEST(test_rtp_seqnum_compare)606 GST_START_TEST (test_rtp_seqnum_compare)
607 {
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);
614
615 ASSERT_COMP (0xffff, 0xfffd, -2);
616 ASSERT_COMP (0x0000, 0xfffd, -3);
617 ASSERT_COMP (0x0001, 0xfffd, -4);
618 ASSERT_COMP (0x0002, 0xfffd, -5);
619
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);
625
626 ASSERT_COMP (0x7fff, 0x7ffd, -2);
627 ASSERT_COMP (0x8000, 0x7ffd, -3);
628 ASSERT_COMP (0x8001, 0x7ffd, -4);
629 ASSERT_COMP (0x8002, 0x7ffd, -5);
630
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);
637
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);
643
644 ASSERT_COMP (0xfffe, 0x7ffe, -0x8000);
645 ASSERT_COMP (0xffff, 0x7fff, -0x8000);
646 ASSERT_COMP (0x0000, 0x8000, -0x8000);
647 ASSERT_COMP (0x0001, 0x8001, -0x8000);
648
649 ASSERT_COMP (0x7ffe, 0xfffe, -0x8000);
650 ASSERT_COMP (0x7fff, 0xffff, -0x8000);
651 ASSERT_COMP (0x8000, 0x0000, -0x8000);
652 ASSERT_COMP (0x8001, 0x0001, -0x8000);
653
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);
659
660 ASSERT_COMP (0x0000, 0x0002, 2);
661 ASSERT_COMP (0xffff, 0x0002, 3);
662 ASSERT_COMP (0xfffe, 0x0002, 4);
663 ASSERT_COMP (0xfffd, 0x0002, 5);
664
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);
670
671 ASSERT_COMP (0x8000, 0x8002, 2);
672 ASSERT_COMP (0x7fff, 0x8002, 3);
673 ASSERT_COMP (0x7ffe, 0x8002, 4);
674 ASSERT_COMP (0x7ffd, 0x8002, 5);
675
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);
681
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);
687 #undef ASSERT_COMP
688 }
689
690 GST_END_TEST;
691
GST_START_TEST(test_rtcp_buffer)692 GST_START_TEST (test_rtcp_buffer)
693 {
694 GstBuffer *buf;
695 GstRTCPPacket packet;
696 GstRTCPBuffer rtcp = { NULL, };
697 gsize offset;
698 gsize maxsize;
699
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);
705
706 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
707
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);
711
712 /* add an SR packet */
713 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR,
714 &packet) == TRUE);
715
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);
720
721 gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
722 G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
723 {
724 guint32 ssrc;
725 guint64 ntptime;
726 guint32 rtptime;
727 guint32 packet_count;
728 guint32 octet_count;
729
730 gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, &ntptime, &rtptime,
731 &packet_count, &octet_count);
732
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);
738 }
739
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);
742
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);
747
748 fail_unless (gst_rtcp_packet_move_to_next (&packet) == FALSE);
749
750 /* add some SDES */
751 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SDES,
752 &packet) == TRUE);
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);
756
757 /* add some BYE */
758 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_BYE,
759 &packet) == TRUE);
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);
763
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);
768
769 /* move to SDES */
770 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
771 fail_unless (gst_rtcp_packet_move_to_next (&packet) == TRUE);
772
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);
777
778 /* remove the SDES */
779 fail_unless (gst_rtcp_packet_remove (&packet) == TRUE);
780
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);
786
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);
792 }
793
794 GST_END_TEST;
795
GST_START_TEST(test_rtcp_reduced_buffer)796 GST_START_TEST (test_rtcp_reduced_buffer)
797 {
798 GstBuffer *buf;
799 GstRTCPPacket packet;
800 GstRTCPBuffer rtcp = { NULL, };
801 gsize offset;
802 gsize maxsize;
803
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);
809
810 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
811
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);
815
816 /* add an SR packet */
817 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_PSFB,
818 &packet) == TRUE);
819
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);
825 }
826
827 GST_END_TEST;
828
829
GST_START_TEST(test_rtcp_validate_with_padding)830 GST_START_TEST (test_rtcp_validate_with_padding)
831 {
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 */
854 };
855
856 fail_unless (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
857 }
858
859 GST_END_TEST;
860
GST_START_TEST(test_rtcp_validate_with_padding_wrong_padlength)861 GST_START_TEST (test_rtcp_validate_with_padding_wrong_padlength)
862 {
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) */
885 };
886
887 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
888 }
889
890 GST_END_TEST;
891
GST_START_TEST(test_rtcp_validate_with_padding_excluded_from_length)892 GST_START_TEST (test_rtcp_validate_with_padding_excluded_from_length)
893 {
894 /* Compound packet with padding in the last packet. Padding is not included
895 * in the length. */
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 */
916 };
917
918 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
919 }
920
921 GST_END_TEST;
922
GST_START_TEST(test_rtcp_validate_with_padding_set_in_first_packet)923 GST_START_TEST (test_rtcp_validate_with_padding_set_in_first_packet)
924 {
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 */
947 };
948
949 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
950 }
951
952 GST_END_TEST;
953
GST_START_TEST(test_rtcp_validate_reduced_without_padding)954 GST_START_TEST (test_rtcp_validate_reduced_without_padding)
955 {
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,
966 };
967
968 fail_unless (gst_rtcp_buffer_validate_data_reduced (rtcp_pkt,
969 sizeof (rtcp_pkt)));
970 }
971
972 GST_END_TEST;
973
GST_START_TEST(test_rtcp_validate_reduced_with_padding)974 GST_START_TEST (test_rtcp_validate_reduced_with_padding)
975 {
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 */
987 };
988
989 fail_if (gst_rtcp_buffer_validate_data_reduced (rtcp_pkt, sizeof (rtcp_pkt)));
990 }
991
992 GST_END_TEST;
993
GST_START_TEST(test_rtcp_buffer_profile_specific_extension)994 GST_START_TEST (test_rtcp_buffer_profile_specific_extension)
995 {
996 GstBuffer *buf;
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 };
1001
1002 fail_unless ((buf = gst_rtcp_buffer_new (1400)) != NULL);
1003 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1004
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);
1008
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));
1016
1017 /* add profile-specific extension */
1018 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1019 pse, sizeof (pse)));
1020 {
1021 guint8 *data = NULL;
1022 guint len = 0;
1023
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));
1027
1028 /* gst_rtcp_packet_get_profile_specific_ext */
1029 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1030 &len));
1031 fail_unless_equals_int (sizeof (pse), len);
1032 fail_unless (data != NULL);
1033 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1034
1035 /* gst_rtcp_packet_copy_profile_specific_ext */
1036 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1037 &len));
1038 fail_unless_equals_int (sizeof (pse), len);
1039 fail_unless (data != NULL);
1040 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1041 g_free (data);
1042 }
1043
1044 /* append more profile-specific extension */
1045 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1046 pse2, sizeof (pse2)));
1047 {
1048 guint8 *data = NULL;
1049 guint len = 0;
1050 guint concat_len;
1051 guint8 *concat_pse;
1052
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));
1058
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));
1062
1063 /* gst_rtcp_packet_get_profile_specific_ext */
1064 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1065 &len));
1066 fail_unless_equals_int (concat_len, len);
1067 fail_unless (data != NULL);
1068 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1069
1070 /* gst_rtcp_packet_copy_profile_specific_ext */
1071 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1072 &len));
1073 fail_unless_equals_int (concat_len, len);
1074 fail_unless (data != NULL);
1075 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1076 g_free (data);
1077 g_free (concat_pse);
1078 }
1079
1080 /* close and validate */
1081 gst_rtcp_buffer_unmap (&rtcp);
1082 fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
1083 gst_buffer_unref (buf);
1084 }
1085
1086 GST_END_TEST;
1087
GST_START_TEST(test_rtcp_buffer_app)1088 GST_START_TEST (test_rtcp_buffer_app)
1089 {
1090 GstBuffer *buf;
1091 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1092 GstRTCPPacket packet;
1093 guint mtu = 1000;
1094 const guint8 data[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1095 guint max_data_length = (mtu - 12) / 4;
1096 guint8 *data_ptr;
1097
1098 fail_unless ((buf = gst_rtcp_buffer_new (mtu)) != NULL);
1099 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1100
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);
1105
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");
1111
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));
1115
1116 /* Add data */
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));
1122
1123 gst_rtcp_buffer_unmap (&rtcp);
1124
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);
1134
1135 gst_buffer_unref (buf);
1136 }
1137
1138 GST_END_TEST;
1139
GST_START_TEST(test_rtcp_buffer_xr)1140 GST_START_TEST (test_rtcp_buffer_xr)
1141 {
1142 GstBuffer *buffer;
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,
1161 };
1162
1163 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1164 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1165
1166 fail_unless (gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp));
1167
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);
1181
1182 fail_if (gst_rtcp_packet_xr_next_rb (&packet));
1183
1184 gst_rtcp_buffer_unmap (&rtcp);
1185 gst_buffer_unref (buffer);
1186 }
1187
1188 GST_END_TEST;
1189
GST_START_TEST(test_rtcp_buffer_xr_rle)1190 GST_START_TEST (test_rtcp_buffer_xr_rle)
1191 {
1192 GstBuffer *buffer;
1193 GstRTCPPacket packet;
1194 guint32 ssrc, chunk_count;
1195 guint8 thining;
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
1210 };
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,
1217 };
1218
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);
1222
1223 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1224
1225 /* check LRLE */
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);
1236
1237 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 0, &chunk);
1238 fail_unless_equals_int (chunk, 0x8012);
1239
1240 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1241 fail_unless_equals_int (chunk, 0x0);
1242
1243 /* check DRLE */
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);
1254
1255 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1256 fail_unless_equals_int (chunk, 0x8f22);
1257
1258 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 2, &chunk);
1259 fail_unless_equals_int (chunk, 0x8f23);
1260
1261 gst_rtcp_buffer_unmap (&rtcp);
1262 gst_buffer_unref (buffer);
1263
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));
1270
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);
1279 }
1280
1281 GST_END_TEST;
1282
GST_START_TEST(test_rtcp_buffer_xr_prt)1283 GST_START_TEST (test_rtcp_buffer_xr_prt)
1284 {
1285 GstBuffer *buffer;
1286 GstRTCPPacket packet;
1287 guint32 ssrc, receipt_time;
1288 guint8 thining;
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,
1299 };
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,
1306 };
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);
1310
1311 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1312
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);
1316
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);
1321
1322 gst_rtcp_buffer_unmap (&rtcp);
1323 gst_buffer_unref (buffer);
1324
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);
1330
1331 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1332
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);
1336
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);
1341
1342 }
1343
1344 GST_END_TEST;
1345
GST_START_TEST(test_rtcp_buffer_xr_rrt)1346 GST_START_TEST (test_rtcp_buffer_xr_rrt)
1347 {
1348 GstBuffer *buffer;
1349 GstRTCPPacket packet;
1350 guint64 ntptime;
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
1358 };
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
1365 };
1366
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);
1370
1371 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1372
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);
1376
1377 fail_unless (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1378 fail_unless_equals_uint64_hex (ntptime, 0x0123456789012345LL);
1379
1380 gst_rtcp_buffer_unmap (&rtcp);
1381 gst_buffer_unref (buffer);
1382
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);
1388
1389 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1390
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);
1394
1395 fail_if (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1396
1397 gst_rtcp_buffer_unmap (&rtcp);
1398 gst_buffer_unref (buffer);
1399 }
1400
1401 GST_END_TEST;
1402
GST_START_TEST(test_rtcp_buffer_xr_dlrr)1403 GST_START_TEST (test_rtcp_buffer_xr_dlrr)
1404 {
1405 GstBuffer *buffer;
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
1419 };
1420
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);
1424
1425 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1426
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);
1430
1431 fail_unless (gst_rtcp_packet_xr_get_dlrr_block (&packet, 0, &ssrc, &last_rr,
1432 &delay));
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,
1435 &delay));
1436 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 24));
1437
1438 /* it has only two sub-blocks. */
1439 fail_if (gst_rtcp_packet_xr_get_dlrr_block (&packet, 2, &ssrc, &last_rr,
1440 &delay));
1441
1442 gst_rtcp_buffer_unmap (&rtcp);
1443 gst_buffer_unref (buffer);
1444 }
1445
1446 GST_END_TEST;
1447
GST_START_TEST(test_rtcp_buffer_xr_ssumm)1448 GST_START_TEST (test_rtcp_buffer_xr_ssumm)
1449 {
1450 GstBuffer *buffer;
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;
1456 gboolean ipv4;
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
1471 };
1472
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);
1476
1477 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1478
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);
1482
1483 fail_unless (gst_rtcp_packet_xr_get_summary_info (&packet, &ssrc, &begin_seq,
1484 &end_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));
1488
1489 fail_unless (gst_rtcp_packet_xr_get_summary_pkt (&packet, &lost_packets,
1490 &dup_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));
1493
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));
1500
1501 fail_unless (gst_rtcp_packet_xr_get_summary_ttl (&packet, &ipv4, &min_ttl,
1502 &max_ttl, &mean_ttl, &dev_ttl));
1503 fail_unless (ipv4);
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]);
1508
1509 gst_rtcp_buffer_unmap (&rtcp);
1510 gst_buffer_unref (buffer);
1511 }
1512
1513 GST_END_TEST;
1514
GST_START_TEST(test_rtcp_buffer_xr_voipmtrx)1515 GST_START_TEST (test_rtcp_buffer_xr_voipmtrx)
1516 {
1517 GstBuffer *buffer;
1518 GstRTCPPacket packet;
1519 guint32 ssrc;
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
1539 };
1540
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);
1544
1545 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1546
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));
1552
1553 fail_unless (gst_rtcp_packet_xr_get_voip_packet_metrics (&packet, &loss_rate,
1554 &discard_rate));
1555 fail_unless_equals_int (loss_rate, rtcp_pkt[16]);
1556 fail_unless_equals_int (discard_rate, rtcp_pkt[17]);
1557
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));
1564
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));
1569
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]);
1576
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]);
1583
1584 fail_unless (gst_rtcp_packet_xr_get_voip_configuration_params (&packet, &gmin,
1585 &rx_config));
1586 fail_unless_equals_int (gmin, rtcp_pkt[31]);
1587 fail_unless_equals_int (rx_config, rtcp_pkt[36]);
1588
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));
1594
1595 gst_rtcp_buffer_unmap (&rtcp);
1596 gst_buffer_unref (buffer);
1597 }
1598
1599 GST_END_TEST;
1600
GST_START_TEST(test_rtp_ntp64_extension)1601 GST_START_TEST (test_rtp_ntp64_extension)
1602 {
1603 GstBuffer *buf;
1604 gpointer data;
1605 guint size;
1606 GstRTPBuffer rtp = { NULL, };
1607 guint8 bytes[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1608 guint64 ntptime;
1609 guint8 hdrext_ntp64[GST_RTP_HDREXT_NTP_64_SIZE];
1610
1611 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1612
1613 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1614
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);
1619
1620 /* add as 1byte header */
1621 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp64,
1622 GST_RTP_HDREXT_NTP_64_SIZE);
1623
1624 /* get extension again */
1625 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1626
1627 /* and check */
1628 fail_unless (size == GST_RTP_HDREXT_NTP_64_SIZE);
1629 fail_unless (memcmp (data, hdrext_ntp64, size) == 0);
1630
1631 gst_rtp_hdrext_get_ntp_64 (data, size, &ntptime);
1632 fail_unless (ntptime == 0x0123456789012345LL);
1633
1634 gst_rtp_buffer_unmap (&rtp);
1635 gst_buffer_unref (buf);
1636 }
1637
1638 GST_END_TEST;
1639
GST_START_TEST(test_rtp_ntp56_extension)1640 GST_START_TEST (test_rtp_ntp56_extension)
1641 {
1642 GstBuffer *buf;
1643 gpointer data;
1644 guint size;
1645 GstRTPBuffer rtp = { NULL, };
1646 guint8 bytes[] = { 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1647 guint64 ntptime;
1648 guint8 hdrext_ntp56[GST_RTP_HDREXT_NTP_56_SIZE];
1649
1650 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1651
1652 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1653
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);
1659
1660 /* add as 1byte header */
1661 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp56,
1662 GST_RTP_HDREXT_NTP_56_SIZE);
1663
1664 /* get extension again */
1665 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1666
1667 /* and check */
1668 fail_unless (size == GST_RTP_HDREXT_NTP_56_SIZE);
1669 fail_unless (memcmp (data, hdrext_ntp56, size) == 0);
1670
1671 gst_rtp_hdrext_get_ntp_56 (data, size, &ntptime);
1672 fail_unless (ntptime == 0x23456789012345LL);
1673
1674 gst_rtp_buffer_unmap (&rtp);
1675 gst_buffer_unref (buf);
1676 }
1677
1678 GST_END_TEST;
1679
GST_START_TEST(test_rtp_buffer_get_extension_bytes)1680 GST_START_TEST (test_rtp_buffer_get_extension_bytes)
1681 {
1682 GstBuffer *buf;
1683 guint16 bits;
1684 guint size;
1685 guint8 misc_data[4] = { 1, 2, 3, 4 };
1686 gpointer pointer;
1687 GstRTPBuffer rtp = { NULL, };
1688 GBytes *gb;
1689 gsize gb_size;
1690
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));
1695
1696 /* verify that obtaining extension data returns NULL and bits are unchanged */
1697 bits = 0xabcd;
1698 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1699 fail_unless (gb == NULL);
1700 fail_unless (bits == 0xabcd);
1701
1702 g_bytes_unref (gb);
1703
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);
1711
1712 g_bytes_unref (gb);
1713 gst_rtp_buffer_unmap (&rtp);
1714 gst_buffer_unref (buf);
1715
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,
1720 misc_data, 2));
1721 fail_unless (gst_rtp_buffer_get_extension (&rtp));
1722
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,
1726 &size));
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),
1734 size * 4) == 0);
1735 fail_unless_equals_int (gb_size, size * 4);
1736
1737 g_bytes_unref (gb);
1738 gst_rtp_buffer_unmap (&rtp);
1739 gst_buffer_unref (buf);
1740 }
1741
1742 GST_END_TEST;
1743
GST_START_TEST(test_rtp_buffer_get_payload_bytes)1744 GST_START_TEST (test_rtp_buffer_get_payload_bytes)
1745 {
1746 guint8 rtppacket[] = {
1747 0x80, 0xe0, 0xdf, 0xd7, 0xef, 0x84, 0xbe, 0xed, 0x9b, 0xc5, 0x29, 0x14,
1748 'H', 'e', 'l', 'l', 'o', '\0'
1749 };
1750
1751 GstBuffer *buf;
1752 GstMapInfo map;
1753 gconstpointer data;
1754 gsize size;
1755 GstRTPBuffer rtp = { NULL, };
1756 GBytes *gb;
1757
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));
1764
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);
1769
1770 gst_rtp_buffer_unmap (&rtp);
1771 gst_buffer_unmap (buf, &map);
1772 gst_buffer_unref (buf);
1773 g_bytes_unref (gb);
1774
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));
1782
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);
1790 g_bytes_unref (gb);
1791
1792 gst_rtp_buffer_unmap (&rtp);
1793 gst_buffer_unmap (buf, &map);
1794 gst_buffer_unref (buf);
1795 }
1796
1797 GST_END_TEST;
1798
1799
GST_START_TEST(test_rtp_buffer_empty_payload)1800 GST_START_TEST (test_rtp_buffer_empty_payload)
1801 {
1802 GstRTPBuffer rtp = { NULL };
1803 GstBuffer *paybuf, *outbuf;
1804
1805 paybuf = gst_rtp_buffer_new_allocate (0, 0, 0);
1806
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);
1810
1811 gst_buffer_unref (paybuf);
1812 gst_buffer_unref (outbuf);
1813 }
1814
1815 GST_END_TEST;
1816
1817
GST_START_TEST(test_ext_timestamp_basic)1818 GST_START_TEST (test_ext_timestamp_basic)
1819 {
1820 guint64 exttimestamp = -1;
1821 guint64 result = 0;
1822
1823 /* no wraparound when timestamps are increasing */
1824 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 0);
1825 fail_unless_equals_uint64 (result, 0);
1826 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1827 fail_unless_equals_uint64 (result, 10);
1828 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1829 fail_unless_equals_uint64 (result, 10);
1830 result = gst_rtp_buffer_ext_timestamp (&exttimestamp,
1831 G_GUINT64_CONSTANT (1) + G_MAXINT32);
1832 fail_unless_equals_uint64 (result, G_GUINT64_CONSTANT (1) + G_MAXINT32);
1833
1834 /* Even big bumps under G_MAXINT32 don't result in wrap-around */
1835 exttimestamp = -1;
1836 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 1087500);
1837 fail_unless_equals_uint64 (result, 1087500);
1838 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 24);
1839 fail_unless_equals_uint64 (result, 24);
1840 }
1841
1842 GST_END_TEST;
1843
GST_START_TEST(test_ext_timestamp_wraparound)1844 GST_START_TEST (test_ext_timestamp_wraparound)
1845 {
1846 guint64 ext_ts = -1;
1847
1848 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts,
1849 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)),
1850 (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1851
1852 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 0),
1853 G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1854
1855 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000),
1856 (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1857 }
1858
1859 GST_END_TEST;
1860
1861
GST_START_TEST(test_ext_timestamp_wraparound_disordered)1862 GST_START_TEST (test_ext_timestamp_wraparound_disordered)
1863 {
1864 guint64 ext_ts = -1;
1865
1866 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1867 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1868 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1869
1870 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 0)
1871 == G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1872
1873 /* Unwrapping around */
1874 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1875 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1876 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1877
1878 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1879 == (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1880 }
1881
1882 GST_END_TEST;
1883
GST_START_TEST(test_ext_timestamp_wraparound_disordered_cannot_unwrap)1884 GST_START_TEST (test_ext_timestamp_wraparound_disordered_cannot_unwrap)
1885 {
1886 guint64 ext_ts = -1;
1887
1888 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1889 == 90000);
1890
1891 /* Cannot unwrapping around */
1892 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1893 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)) == 0);
1894
1895 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1896 == 90000);
1897 }
1898
1899 GST_END_TEST;
1900
1901 static Suite *
rtp_suite(void)1902 rtp_suite (void)
1903 {
1904 Suite *s = suite_create ("rtp support library");
1905 TCase *tc_chain = tcase_create ("general");
1906
1907 suite_add_tcase (s, tc_chain);
1908 tcase_add_test (tc_chain, test_rtp_buffer);
1909 tcase_add_test (tc_chain, test_rtp_buffer_validate_corrupt);
1910 tcase_add_test (tc_chain, test_rtp_buffer_validate_padding);
1911 tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data);
1912 //tcase_add_test (tc_chain, test_rtp_buffer_list_set_extension);
1913 tcase_add_test (tc_chain, test_rtp_seqnum_compare);
1914
1915 tcase_add_test (tc_chain, test_rtcp_buffer);
1916 tcase_add_test (tc_chain, test_rtcp_reduced_buffer);
1917 tcase_add_test (tc_chain, test_rtcp_validate_with_padding);
1918 tcase_add_test (tc_chain, test_rtcp_validate_with_padding_wrong_padlength);
1919 tcase_add_test (tc_chain,
1920 test_rtcp_validate_with_padding_excluded_from_length);
1921 tcase_add_test (tc_chain,
1922 test_rtcp_validate_with_padding_set_in_first_packet);
1923 tcase_add_test (tc_chain, test_rtcp_validate_reduced_without_padding);
1924 tcase_add_test (tc_chain, test_rtcp_validate_reduced_with_padding);
1925 tcase_add_test (tc_chain, test_rtcp_buffer_profile_specific_extension);
1926 tcase_add_test (tc_chain, test_rtcp_buffer_app);
1927 tcase_add_test (tc_chain, test_rtcp_buffer_xr);
1928 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rle);
1929 tcase_add_test (tc_chain, test_rtcp_buffer_xr_prt);
1930 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rrt);
1931 tcase_add_test (tc_chain, test_rtcp_buffer_xr_dlrr);
1932 tcase_add_test (tc_chain, test_rtcp_buffer_xr_ssumm);
1933 tcase_add_test (tc_chain, test_rtcp_buffer_xr_voipmtrx);
1934
1935 tcase_add_test (tc_chain, test_rtp_ntp64_extension);
1936 tcase_add_test (tc_chain, test_rtp_ntp56_extension);
1937
1938 tcase_add_test (tc_chain, test_rtp_buffer_get_payload_bytes);
1939 tcase_add_test (tc_chain, test_rtp_buffer_get_extension_bytes);
1940 tcase_add_test (tc_chain, test_rtp_buffer_empty_payload);
1941
1942 //tcase_add_test (tc_chain, test_rtp_buffer_list);
1943
1944 tcase_add_test (tc_chain, test_ext_timestamp_basic);
1945 tcase_add_test (tc_chain, test_ext_timestamp_wraparound);
1946 tcase_add_test (tc_chain, test_ext_timestamp_wraparound_disordered);
1947 tcase_add_test (tc_chain,
1948 test_ext_timestamp_wraparound_disordered_cannot_unwrap);
1949
1950 return s;
1951 }
1952
1953 GST_CHECK_MAIN (rtp);
1954