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
34 static GstBuffer *create_feedback_buffer (gboolean with_padding);
35
GST_START_TEST(test_rtp_buffer)36 GST_START_TEST (test_rtp_buffer)
37 {
38 GstBuffer *buf;
39 GstMapInfo map;
40 guint8 *data;
41 gsize size;
42 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
43
44 /* check GstRTPHeader structure alignment and packing */
45 buf = gst_rtp_buffer_new_allocate (16, 4, 0);
46 fail_unless (buf != NULL);
47 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
48 data = map.data;
49 size = map.size;
50 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4);
51
52 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
53
54 /* check defaults */
55 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
56 fail_unless (gst_rtp_buffer_get_padding (&rtp) == TRUE);
57 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
58 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
59 fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
60 fail_unless (gst_rtp_buffer_get_payload_type (&rtp) == 0);
61 fail_unless_equals_int (GST_READ_UINT16_BE (data), 0xa000);
62
63 /* check version in bitfield */
64 gst_rtp_buffer_set_version (&rtp, 3);
65 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 3);
66 fail_unless_equals_int ((data[0] & 0xC0) >> 6, 3);
67 gst_rtp_buffer_set_version (&rtp, 2);
68 fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
69 fail_unless_equals_int ((data[0] & 0xC0) >> 6, 2);
70
71 /* check padding bit */
72 gst_rtp_buffer_set_padding (&rtp, TRUE);
73 fail_unless (gst_rtp_buffer_get_padding (&rtp) == TRUE);
74 fail_unless_equals_int ((data[0] & 0x20) >> 5, 1);
75 gst_rtp_buffer_set_padding (&rtp, FALSE);
76 fail_unless (gst_rtp_buffer_get_padding (&rtp) == FALSE);
77 fail_unless_equals_int ((data[0] & 0x20) >> 5, 0);
78
79 /* check marker bit */
80 gst_rtp_buffer_set_marker (&rtp, TRUE);
81 fail_unless (gst_rtp_buffer_get_marker (&rtp) == TRUE);
82 fail_unless_equals_int ((data[1] & 0x80) >> 7, 1);
83 gst_rtp_buffer_set_marker (&rtp, FALSE);
84 fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
85 fail_unless_equals_int ((data[1] & 0x80) >> 7, 0);
86
87 /* check sequence offset */
88 gst_rtp_buffer_set_seq (&rtp, 0xF2C9);
89 fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0xF2C9);
90 fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0xF2C9);
91 gst_rtp_buffer_set_seq (&rtp, 0);
92 fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0);
93 fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0);
94
95 /* check timestamp offset */
96 gst_rtp_buffer_set_timestamp (&rtp, 432191);
97 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 432191);
98 fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 432191);
99 gst_rtp_buffer_set_timestamp (&rtp, 0);
100 fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 0);
101 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 0);
102
103 /* check ssrc offset */
104 gst_rtp_buffer_set_ssrc (&rtp, 0xf04043C2);
105 fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), (gint) 0xf04043c2);
106 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), (gint) 0xf04043c2);
107 gst_rtp_buffer_set_ssrc (&rtp, 0);
108 fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), 0);
109 fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), 0);
110
111 /* check csrc bits */
112 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
113 ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 0));
114 fail_unless_equals_int (data[0] & 0xf, 0);
115
116 gst_rtp_buffer_unmap (&rtp);
117 gst_buffer_unmap (buf, &map);
118 gst_buffer_unref (buf);
119
120 /* and again, this time with CSRCs */
121 buf = gst_rtp_buffer_new_allocate (16, 4, 3);
122 fail_unless (buf != NULL);
123 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
124 data = map.data;
125 size = map.size;
126 fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4 + 4 * 3);
127
128 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
129
130 fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 3);
131 ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 3));
132 fail_unless_equals_int (data[0] & 0xf, 3);
133 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 0), 0);
134 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 1), 0);
135 fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 2), 0);
136 fail_unless_equals_int (gst_rtp_buffer_get_header_len (&rtp),
137 RTP_HEADER_LEN + 4 * 3);
138 fail_unless_equals_int (gst_rtp_buffer_get_payload_len (&rtp), 16);
139
140 data += RTP_HEADER_LEN; /* skip the other header stuff */
141 gst_rtp_buffer_set_csrc (&rtp, 0, 0xf7c0);
142 fail_unless_equals_int (GST_READ_UINT32_BE (data + 0 * 4), 0xf7c0);
143 gst_rtp_buffer_set_csrc (&rtp, 1, 0xf7c1);
144 fail_unless_equals_int (GST_READ_UINT32_BE (data + 1 * 4), 0xf7c1);
145 gst_rtp_buffer_set_csrc (&rtp, 2, 0xf7c2);
146 fail_unless_equals_int (GST_READ_UINT32_BE (data + 2 * 4), 0xf7c2);
147 ASSERT_CRITICAL (gst_rtp_buffer_set_csrc (&rtp, 3, 0xf123));
148
149 gst_rtp_buffer_unmap (&rtp);
150 gst_buffer_unmap (buf, &map);
151 gst_buffer_unref (buf);
152 }
153
154 GST_END_TEST;
155
GST_START_TEST(test_rtp_buffer_validate_corrupt)156 GST_START_TEST (test_rtp_buffer_validate_corrupt)
157 {
158 GstBuffer *buf;
159 guint8 corrupt_rtp_packet[58] = {
160 0x90, 0x7a, 0xbf, 0x28, 0x3a, 0x8a, 0x0a, 0xf4, 0x69, 0x6b, 0x76, 0xc0,
161 0x21, 0xe0, 0xe0, 0x60, 0x81, 0x10, 0x84, 0x30, 0x21, 0x52, 0x06, 0xc2,
162 0xb8, 0x30, 0x10, 0x4c, 0x08, 0x62, 0x67, 0xc2, 0x6e, 0x1a, 0x53, 0x3f,
163 0xaf, 0xd6, 0x1b, 0x29, 0x40, 0xe0, 0xa5, 0x83, 0x01, 0x4b, 0x04, 0x02,
164 0xb0, 0x97, 0x63, 0x08, 0x10, 0x4b, 0x43, 0x85, 0x37, 0x2c
165 };
166 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
167
168 buf = gst_buffer_new_and_alloc (sizeof (corrupt_rtp_packet));
169 gst_buffer_fill (buf, 0, corrupt_rtp_packet, sizeof (corrupt_rtp_packet));
170 fail_if (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
171 gst_buffer_unref (buf);
172 }
173
174 GST_END_TEST;
175
GST_START_TEST(test_rtp_buffer_validate_padding)176 GST_START_TEST (test_rtp_buffer_validate_padding)
177 {
178 GstBuffer *buf;
179 guint8 packet_with_padding[] = {
180 0xa0, 0x60, 0x6c, 0x49, 0x58, 0xab, 0xaa, 0x65, 0x65, 0x2e, 0xaf, 0xce,
181 0x68, 0xce, 0x3c, 0x80, 0x00, 0x00, 0x00, 0x04
182 };
183 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
184
185 buf = gst_buffer_new_and_alloc (sizeof (packet_with_padding));
186 gst_buffer_fill (buf, 0, packet_with_padding, sizeof (packet_with_padding));
187 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
188 gst_rtp_buffer_unmap (&rtp);
189 gst_buffer_unref (buf);
190
191 /* Set the padding to something invalid */
192 buf = gst_buffer_new_and_alloc (sizeof (packet_with_padding));
193 gst_buffer_fill (buf, 0, packet_with_padding, sizeof (packet_with_padding));
194 gst_buffer_memset (buf, gst_buffer_get_size (buf) - 1, 0xff, 1);
195 fail_if (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
196
197 memset (&rtp, 0, sizeof (rtp));
198 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READ |
199 GST_RTP_BUFFER_MAP_FLAG_SKIP_PADDING, &rtp));
200 gst_rtp_buffer_unmap (&rtp);
201 gst_buffer_unref (buf);
202 }
203
204 GST_END_TEST;
205
206 #if 0
207 GST_START_TEST (test_rtp_buffer_list)
208 {
209 GstBuffer *rtp_header;
210 GstBuffer *rtp_payload;
211 GstBufferList *list = NULL;
212 GstBufferListIterator *it;
213 guint i;
214
215 list = gst_buffer_list_new ();
216 it = gst_buffer_list_iterate (list);
217
218 /* Creating a list of two RTP packages */
219
220 /* Create first group to hold the rtp header and the payload */
221 gst_buffer_list_iterator_add_group (it);
222 rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
223 gst_buffer_list_iterator_add (it, rtp_header);
224 rtp_payload = gst_buffer_new_and_alloc (42);
225 gst_buffer_list_iterator_add (it, rtp_payload);
226
227 /* Create second group to hold an rtp header and a payload */
228 gst_buffer_list_iterator_add_group (it);
229 rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
230 gst_buffer_list_iterator_add (it, rtp_header);
231 rtp_payload = gst_buffer_new_and_alloc (42);
232 gst_buffer_list_iterator_add (it, rtp_payload);
233
234 gst_buffer_list_iterator_free (it);
235
236 /* Test SEQ number */
237 i = gst_rtp_buffer_list_set_seq (list, 1024);
238 fail_if (1026 != i);
239 fail_if (!gst_rtp_buffer_list_validate (list));
240
241 /* Timestamp */
242 gst_rtp_buffer_list_set_timestamp (list, 432191);
243 fail_unless_equals_int (gst_rtp_buffer_list_get_timestamp (list), 432191);
244
245 /* SSRC */
246 gst_rtp_buffer_list_set_ssrc (list, 0xf04043C2);
247 fail_unless_equals_int (gst_rtp_buffer_list_get_ssrc (list),
248 (gint) 0xf04043c2);
249
250 /* Payload type */
251 gst_rtp_buffer_list_set_payload_type (list, 127);
252 fail_unless_equals_int (gst_rtp_buffer_list_get_payload_type (list), 127);
253
254 gst_buffer_list_unref (list);
255 }
256
257 GST_END_TEST;
258 #endif
259
GST_START_TEST(test_rtp_buffer_set_extension_data)260 GST_START_TEST (test_rtp_buffer_set_extension_data)
261 {
262 GstBuffer *buf;
263 guint8 *data;
264 guint16 bits;
265 guint size;
266 guint8 misc_data[4] = { 1, 2, 3, 4 };
267 gpointer pointer;
268 guint8 appbits;
269 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
270
271 /* check GstRTPHeader structure alignment and packing */
272 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
273
274 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
275
276 /* should be possible to set the extension data */
277 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 4) == TRUE);
278 fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
279 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
280 fail_unless (bits == 270);
281 fail_unless (size == 4);
282 gst_rtp_buffer_unmap (&rtp);
283 gst_buffer_unref (buf);
284
285 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
286 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
287
288 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
289 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 333, 2) == TRUE);
290 fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
291 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
292 fail_unless (bits == 333);
293 fail_unless (size == 2);
294
295 gst_rtp_buffer_unmap (&rtp);
296 gst_buffer_unref (buf);
297
298 /* Test header extensions with a one byte header */
299 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
300 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
301
302 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
303
304 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
305 misc_data, 2) == TRUE);
306 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
307 &size));
308 fail_unless (bits == 0xBEDE);
309 fail_unless (size == 1);
310 data = (guint8 *) pointer;
311 fail_unless (data[0] == ((5 << 4) | 1));
312 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
313 1, &pointer, &size) == FALSE);
314 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
315 1, &pointer, &size) == FALSE);
316 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
317 0, &pointer, &size) == TRUE);
318 fail_unless (size == 2);
319 fail_unless (memcmp (pointer, misc_data, 2) == 0);
320
321 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
322 misc_data, 4) == TRUE);
323 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
324 0, &pointer, &size) == TRUE);
325 fail_unless (size == 2);
326 fail_unless (memcmp (pointer, misc_data, 2) == 0);
327 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
328 1, &pointer, &size) == TRUE);
329 fail_unless (size == 4);
330 fail_unless (memcmp (pointer, misc_data, 4) == 0);
331 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
332 2, &pointer, &size) == FALSE);
333 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
334 1, &pointer, &size) == FALSE);
335
336 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 6,
337 misc_data, 2) == TRUE);
338 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
339 0, &pointer, &size) == TRUE);
340 fail_unless (size == 2);
341 fail_unless (memcmp (pointer, misc_data, 2) == 0);
342 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
343 1, &pointer, &size) == TRUE);
344 fail_unless (size == 4);
345 fail_unless (memcmp (pointer, misc_data, 4) == 0);
346 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
347 3, &pointer, &size) == FALSE);
348 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
349 1, &pointer, &size) == FALSE);
350 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 6,
351 2, &pointer, &size) == FALSE);
352 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
353 0, &pointer, &size) == TRUE);
354 fail_unless (size == 2);
355 fail_unless (memcmp (pointer, misc_data, 2) == 0);
356
357 gst_rtp_buffer_unmap (&rtp);
358 gst_buffer_unref (buf);
359
360 /* Test header extensions with a two bytes header */
361 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
362 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
363
364 fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
365
366 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
367 misc_data, 2) == TRUE);
368 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
369 &size));
370 fail_unless (bits == 0x100 << 4);
371 fail_unless (size == 1);
372 data = (guint8 *) pointer;
373 fail_unless (data[0] == 5);
374 fail_unless (data[1] == 2);
375 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
376 0, &pointer, &size) == FALSE);
377 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
378 1, &pointer, &size) == FALSE);
379 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
380 0, &pointer, &size) == TRUE);
381 fail_unless (size == 2);
382 fail_unless (memcmp (pointer, misc_data, 2) == 0);
383
384 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
385 misc_data, 4) == TRUE);
386 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
387 0, &pointer, &size) == TRUE);
388 fail_unless (size == 2);
389 fail_unless (memcmp (pointer, misc_data, 2) == 0);
390 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
391 1, &pointer, &size) == TRUE);
392 fail_unless (size == 4);
393 fail_unless (memcmp (pointer, misc_data, 4) == 0);
394 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
395 2, &pointer, &size) == FALSE);
396 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
397 0, &pointer, &size) == FALSE);
398
399 fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 6,
400 misc_data, 2) == TRUE);
401 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
402 0, &pointer, &size) == TRUE);
403 fail_unless (size == 2);
404 fail_unless (memcmp (pointer, misc_data, 2) == 0);
405 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
406 1, &pointer, &size) == TRUE);
407 fail_unless (size == 4);
408 fail_unless (memcmp (pointer, misc_data, 4) == 0);
409 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
410 2, &pointer, &size) == FALSE);
411 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
412 0, &pointer, &size) == FALSE);
413 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 6,
414 1, &pointer, &size) == FALSE);
415 fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
416 0, &pointer, &size) == TRUE);
417 fail_unless (size == 2);
418 fail_unless (memcmp (pointer, misc_data, 2) == 0);
419
420 gst_rtp_buffer_unmap (&rtp);
421 gst_buffer_unref (buf);
422 }
423
424 GST_END_TEST;
425
GST_START_TEST(test_rtp_buffer_set_extension_data_shrink_data)426 GST_START_TEST (test_rtp_buffer_set_extension_data_shrink_data)
427 {
428 GstBuffer *buf;
429 guint16 bits;
430 guint size;
431 gpointer pointer;
432 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
433 guint8 scratch_cmp[4 * 4] = { 0, };
434 GstMapInfo info = GST_MAP_INFO_INIT;
435 gsize i;
436
437 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
438 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
439
440 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 4) == TRUE);
441 fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
442 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
443 GST_MEMDUMP ("", pointer, size * 4);
444 fail_unless (bits == 270);
445 fail_unless (size == 4);
446 for (i = 0; i < size * 4; i++) {
447 guint8 *bytes = pointer;
448 bytes[i] = i;
449 }
450 memcpy (scratch_cmp, pointer, size * 4);
451 fail_unless_equals_int64 ((guint64) gst_buffer_get_size (buf), 52);
452 gst_rtp_buffer_unmap (&rtp);
453
454 /* ensure that the mapped buffer size matches */
455 gst_buffer_map (buf, &info, GST_MAP_READ);
456 GST_MEMDUMP ("", info.data, info.size);
457 fail_unless_equals_int64 ((guint64) info.size, 52);
458 gst_buffer_unmap (buf, &info);
459
460 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
461 /* shrinking the extension data should still succeed and only output the
462 * relevant data */
463 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 180, 2) == TRUE);
464 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
465 GST_MEMDUMP ("", pointer, size * 4);
466 fail_unless (bits == 180);
467 fail_unless (size == 2);
468 fail_unless_equals_int64 ((guint64) gst_buffer_get_size (buf), 44);
469 for (i = 0; i < 8; i++) {
470 guint8 *ext_data = pointer;
471 fail_unless_equals_int_hex (ext_data[i], scratch_cmp[i]);
472 }
473 gst_rtp_buffer_unmap (&rtp);
474
475 gst_buffer_map (buf, &info, GST_MAP_READ);
476 GST_MEMDUMP ("", info.data, info.size);
477 fail_unless_equals_int64 ((guint64) info.size, 44);
478 gst_buffer_unmap (buf, &info);
479
480 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
481 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 308, 3) == TRUE);
482 gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
483 GST_MEMDUMP ("", pointer, size * 4);
484 fail_unless (bits == 308);
485 fail_unless (size == 3);
486 for (i = 0; i < 8; i++) {
487 guint8 *ext_data = pointer;
488 fail_unless_equals_int_hex (ext_data[i], scratch_cmp[i]);
489 }
490 /* new data will be zero-initialized */
491 for (i = 8; i < size * 4; i++) {
492 guint8 *ext_data = pointer;
493 fail_unless_equals_int_hex (ext_data[i], 0);
494 }
495 fail_unless_equals_int64 ((guint64) gst_buffer_get_size (buf), 48);
496 gst_rtp_buffer_unmap (&rtp);
497
498 gst_buffer_map (buf, &info, GST_MAP_READ);
499 GST_MEMDUMP ("", info.data, info.size);
500 fail_unless_equals_int64 ((guint64) info.size, 48);
501 gst_buffer_unmap (buf, &info);
502 gst_buffer_unref (buf);
503 }
504
505 GST_END_TEST;
506
507 #if 0
508 GST_START_TEST (test_rtp_buffer_list_set_extension)
509 {
510 GstBufferList *list;
511 GstBuffer *buf;
512 guint8 *data;
513 guint16 bits;
514 guint size;
515 guint8 misc_data[4] = { 1, 2, 3, 4 };
516 gpointer pointer;
517 guint8 appbits;
518 GstBufferListIterator *it;
519
520 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
521 list = gst_rtp_buffer_list_from_buffer (buf);
522 gst_buffer_unref (buf);
523
524 it = gst_buffer_list_iterate (list);
525 fail_unless (gst_buffer_list_iterator_next_group (it));
526 buf = gst_buffer_list_iterator_next (it);
527 fail_unless (buf != NULL);
528 fail_unless (GST_BUFFER_SIZE (buf) == 12);
529 buf = gst_buffer_list_iterator_next (it);
530 fail_unless (buf != NULL);
531 fail_unless (GST_BUFFER_SIZE (buf) == 20);
532 gst_buffer_list_iterator_free (it);
533
534 /* Test header extensions with a one byte header */
535 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
536 1, &pointer, &size) == FALSE);
537
538 it = gst_buffer_list_iterate (list);
539 fail_unless (gst_buffer_list_iterator_next_group (it));
540 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
541 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
542 misc_data, 2) == TRUE);
543 gst_buffer_list_iterator_free (it);
544 it = gst_buffer_list_iterate (list);
545 fail_unless (gst_buffer_list_iterator_next_group (it));
546 buf = gst_buffer_list_iterator_next (it);
547 fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
548 fail_unless (bits == 0xBEDE);
549 fail_unless (size == 1);
550 data = (guint8 *) pointer;
551 fail_unless (data[0] == ((5 << 4) | 1));
552 gst_buffer_list_iterator_free (it);
553 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
554 0, &pointer, &size) == FALSE);
555 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
556 1, &pointer, &size) == FALSE);
557 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
558 0, &pointer, &size) == TRUE);
559 fail_unless (size == 2);
560 fail_unless (memcmp (pointer, misc_data, 2) == 0);
561
562 it = gst_buffer_list_iterate (list);
563 fail_unless (gst_buffer_list_iterator_next_group (it));
564 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
565 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
566 misc_data, 4) == TRUE);
567 gst_buffer_list_iterator_free (it);
568 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
569 0, &pointer, &size) == TRUE);
570 fail_unless (size == 2);
571 fail_unless (memcmp (pointer, misc_data, 2) == 0);
572 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
573 1, &pointer, &size) == TRUE);
574 fail_unless (size == 4);
575 fail_unless (memcmp (pointer, misc_data, 4) == 0);
576 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
577 2, &pointer, &size) == FALSE);
578 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
579 0, &pointer, &size) == FALSE);
580
581 it = gst_buffer_list_iterate (list);
582 fail_unless (gst_buffer_list_iterator_next_group (it));
583 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
584 fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 6,
585 misc_data, 2) == TRUE);
586 gst_buffer_list_iterator_free (it);
587 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
588 0, &pointer, &size) == TRUE);
589 fail_unless (size == 2);
590 fail_unless (memcmp (pointer, misc_data, 2) == 0);
591 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
592 1, &pointer, &size) == TRUE);
593 fail_unless (size == 4);
594 fail_unless (memcmp (pointer, misc_data, 4) == 0);
595 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
596 2, &pointer, &size) == FALSE);
597 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
598 0, &pointer, &size) == FALSE);
599 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 6,
600 1, &pointer, &size) == FALSE);
601 fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
602 0, &pointer, &size) == TRUE);
603 fail_unless (size == 2);
604 fail_unless (memcmp (pointer, misc_data, 2) == 0);
605 gst_buffer_list_unref (list);
606
607
608 /* Test header extensions with a two bytes header */
609 buf = gst_rtp_buffer_new_allocate (20, 0, 0);
610 list = gst_rtp_buffer_list_from_buffer (buf);
611 gst_buffer_unref (buf);
612
613 it = gst_buffer_list_iterate (list);
614 fail_unless (gst_buffer_list_iterator_next_group (it));
615 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
616 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
617 misc_data, 2) == TRUE);
618 gst_buffer_list_iterator_free (it);
619
620 it = gst_buffer_list_iterate (list);
621 fail_unless (gst_buffer_list_iterator_next_group (it));
622 buf = gst_buffer_list_iterator_next (it);
623 fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
624 fail_unless (bits == 0x100 << 4);
625 fail_unless (size == 1);
626 data = (guint8 *) pointer;
627 fail_unless (data[0] == 5);
628 fail_unless (data[1] == 2);
629 gst_buffer_list_iterator_free (it);
630 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
631 &appbits, 2, 0, &pointer, &size) == FALSE);
632 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
633 &appbits, 5, 1, &pointer, &size) == FALSE);
634 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
635 &appbits, 5, 0, &pointer, &size) == TRUE);
636 fail_unless (size == 2);
637 fail_unless (memcmp (pointer, misc_data, 2) == 0);
638
639 it = gst_buffer_list_iterate (list);
640 fail_unless (gst_buffer_list_iterator_next_group (it));
641 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
642 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
643 misc_data, 4) == TRUE);
644 gst_buffer_list_iterator_free (it);
645 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
646 &appbits, 5, 0, &pointer, &size) == TRUE);
647 fail_unless (size == 2);
648 fail_unless (memcmp (pointer, misc_data, 2) == 0);
649 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
650 &appbits, 5, 1, &pointer, &size) == TRUE);
651 fail_unless (size == 4);
652 fail_unless (memcmp (pointer, misc_data, 4) == 0);
653 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
654 &appbits, 5, 2, &pointer, &size) == FALSE);
655 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
656 &appbits, 2, 0, &pointer, &size) == FALSE);
657
658 it = gst_buffer_list_iterate (list);
659 fail_unless (gst_buffer_list_iterator_next_group (it));
660 fail_unless (gst_buffer_list_iterator_next (it) != NULL);
661 fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 6,
662 misc_data, 2) == TRUE);
663 gst_buffer_list_iterator_free (it);
664 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
665 &appbits, 5, 0, &pointer, &size) == TRUE);
666 fail_unless (size == 2);
667 fail_unless (memcmp (pointer, misc_data, 2) == 0);
668 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
669 &appbits, 5, 1, &pointer, &size) == TRUE);
670 fail_unless (size == 4);
671 fail_unless (memcmp (pointer, misc_data, 4) == 0);
672 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
673 &appbits, 5, 2, &pointer, &size) == FALSE);
674 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
675 &appbits, 2, 0, &pointer, &size) == FALSE);
676 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
677 &appbits, 6, 1, &pointer, &size) == FALSE);
678 fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
679 &appbits, 5, 0, &pointer, &size) == TRUE);
680 fail_unless (size == 2);
681 fail_unless (memcmp (pointer, misc_data, 2) == 0);
682
683 gst_buffer_list_unref (list);
684 }
685
686 GST_END_TEST;
687 #endif
688
GST_START_TEST(test_rtp_seqnum_compare)689 GST_START_TEST (test_rtp_seqnum_compare)
690 {
691 #define ASSERT_COMP(a,b,c) fail_unless (gst_rtp_buffer_compare_seqnum ((guint16)a,(guint16)b) == c);
692 ASSERT_COMP (0xfffe, 0xfffd, -1);
693 ASSERT_COMP (0xffff, 0xfffe, -1);
694 ASSERT_COMP (0x0000, 0xffff, -1);
695 ASSERT_COMP (0x0001, 0x0000, -1);
696 ASSERT_COMP (0x0002, 0x0001, -1);
697
698 ASSERT_COMP (0xffff, 0xfffd, -2);
699 ASSERT_COMP (0x0000, 0xfffd, -3);
700 ASSERT_COMP (0x0001, 0xfffd, -4);
701 ASSERT_COMP (0x0002, 0xfffd, -5);
702
703 ASSERT_COMP (0x7ffe, 0x7ffd, -1);
704 ASSERT_COMP (0x7fff, 0x7ffe, -1);
705 ASSERT_COMP (0x8000, 0x7fff, -1);
706 ASSERT_COMP (0x8001, 0x8000, -1);
707 ASSERT_COMP (0x8002, 0x8001, -1);
708
709 ASSERT_COMP (0x7fff, 0x7ffd, -2);
710 ASSERT_COMP (0x8000, 0x7ffd, -3);
711 ASSERT_COMP (0x8001, 0x7ffd, -4);
712 ASSERT_COMP (0x8002, 0x7ffd, -5);
713
714 ASSERT_COMP (0x7ffd, 0xffff, -0x7ffe);
715 ASSERT_COMP (0x7ffe, 0x0000, -0x7ffe);
716 ASSERT_COMP (0x7fff, 0x0001, -0x7ffe);
717 ASSERT_COMP (0x7fff, 0x0000, -0x7fff);
718 ASSERT_COMP (0x8000, 0x0001, -0x7fff);
719 ASSERT_COMP (0x8001, 0x0002, -0x7fff);
720
721 ASSERT_COMP (0xfffd, 0x7ffe, -0x7fff);
722 ASSERT_COMP (0xfffe, 0x7fff, -0x7fff);
723 ASSERT_COMP (0xffff, 0x8000, -0x7fff);
724 ASSERT_COMP (0x0000, 0x8001, -0x7fff);
725 ASSERT_COMP (0x0001, 0x8002, -0x7fff);
726
727 ASSERT_COMP (0xfffe, 0x7ffe, -0x8000);
728 ASSERT_COMP (0xffff, 0x7fff, -0x8000);
729 ASSERT_COMP (0x0000, 0x8000, -0x8000);
730 ASSERT_COMP (0x0001, 0x8001, -0x8000);
731
732 ASSERT_COMP (0x7ffe, 0xfffe, -0x8000);
733 ASSERT_COMP (0x7fff, 0xffff, -0x8000);
734 ASSERT_COMP (0x8000, 0x0000, -0x8000);
735 ASSERT_COMP (0x8001, 0x0001, -0x8000);
736
737 ASSERT_COMP (0x0001, 0x0002, 1);
738 ASSERT_COMP (0x0000, 0x0001, 1);
739 ASSERT_COMP (0xffff, 0x0000, 1);
740 ASSERT_COMP (0xfffe, 0xffff, 1);
741 ASSERT_COMP (0xfffd, 0xfffe, 1);
742
743 ASSERT_COMP (0x0000, 0x0002, 2);
744 ASSERT_COMP (0xffff, 0x0002, 3);
745 ASSERT_COMP (0xfffe, 0x0002, 4);
746 ASSERT_COMP (0xfffd, 0x0002, 5);
747
748 ASSERT_COMP (0x8001, 0x8002, 1);
749 ASSERT_COMP (0x8000, 0x8001, 1);
750 ASSERT_COMP (0x7fff, 0x8000, 1);
751 ASSERT_COMP (0x7ffe, 0x7fff, 1);
752 ASSERT_COMP (0x7ffd, 0x7ffe, 1);
753
754 ASSERT_COMP (0x8000, 0x8002, 2);
755 ASSERT_COMP (0x7fff, 0x8002, 3);
756 ASSERT_COMP (0x7ffe, 0x8002, 4);
757 ASSERT_COMP (0x7ffd, 0x8002, 5);
758
759 ASSERT_COMP (0xfffe, 0x7ffd, 0x7fff);
760 ASSERT_COMP (0xffff, 0x7ffe, 0x7fff);
761 ASSERT_COMP (0x0000, 0x7fff, 0x7fff);
762 ASSERT_COMP (0x0001, 0x8000, 0x7fff);
763 ASSERT_COMP (0x0002, 0x8001, 0x7fff);
764
765 ASSERT_COMP (0x7ffe, 0xfffd, 0x7fff);
766 ASSERT_COMP (0x7fff, 0xfffe, 0x7fff);
767 ASSERT_COMP (0x8000, 0xffff, 0x7fff);
768 ASSERT_COMP (0x8001, 0x0000, 0x7fff);
769 ASSERT_COMP (0x8002, 0x0001, 0x7fff);
770 #undef ASSERT_COMP
771 }
772
773 GST_END_TEST;
774
GST_START_TEST(test_rtcp_sdes_type)775 GST_START_TEST (test_rtcp_sdes_type)
776 {
777 GstRTCPSDESType i;
778
779 for (i = 1; i < GST_RTCP_SDES_MID; i++) {
780 GstRTCPSDESType sdes_type;
781 const char *sdes_name;
782
783 sdes_name = gst_rtcp_sdes_type_to_name (i);
784 GST_DEBUG ("%u (0x%x) -> \'%s\'", i, i, sdes_name);
785 fail_unless (sdes_name != NULL);
786 sdes_type = gst_rtcp_sdes_name_to_type (sdes_name);
787
788 fail_unless_equals_int (sdes_type, i);
789 }
790 }
791
792 GST_END_TEST;
793
GST_START_TEST(test_rtcp_buffer)794 GST_START_TEST (test_rtcp_buffer)
795 {
796 GstBuffer *buf;
797 GstRTCPPacket packet;
798 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
799 gsize offset;
800 gsize maxsize;
801
802 buf = gst_rtcp_buffer_new (1400);
803 fail_unless (buf != NULL);
804 fail_unless_equals_int (gst_buffer_get_sizes (buf, &offset, &maxsize), 0);
805 fail_unless_equals_int (offset, 0);
806 fail_unless_equals_int (maxsize, 1400);
807
808 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
809
810 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
811 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
812 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
813
814 /* add an SR packet */
815 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR,
816 &packet) == TRUE);
817
818 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
819 fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
820 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
821 fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
822
823 gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
824 G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
825 {
826 guint32 ssrc;
827 guint64 ntptime;
828 guint32 rtptime;
829 guint32 packet_count;
830 guint32 octet_count;
831
832 gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, &ntptime, &rtptime,
833 &packet_count, &octet_count);
834
835 fail_unless (ssrc == 0x44556677);
836 fail_unless (ntptime == G_GUINT64_CONSTANT (1));
837 fail_unless (rtptime == 0x11111111);
838 fail_unless (packet_count == 101);
839 fail_unless (octet_count == 123456);
840 }
841
842 /* go to first packet, this should be the packet we just added */
843 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
844
845 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
846 fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
847 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
848 fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
849
850 fail_unless (gst_rtcp_packet_move_to_next (&packet) == FALSE);
851
852 /* add some SDES */
853 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SDES,
854 &packet) == TRUE);
855 fail_unless (gst_rtcp_packet_sdes_add_item (&packet, 0xff658743) == TRUE);
856 fail_unless (gst_rtcp_packet_sdes_add_entry (&packet, GST_RTCP_SDES_CNAME,
857 sizeof ("test@foo.bar"), (guint8 *) "test@foo.bar") == TRUE);
858
859 /* add some BYE */
860 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_BYE,
861 &packet) == TRUE);
862 fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x5613212f) == TRUE);
863 fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x00112233) == TRUE);
864 fail_unless (gst_rtcp_packet_bye_get_ssrc_count (&packet) == 2);
865
866 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
867 fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
868 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
869 fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
870
871 /* move to SDES */
872 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
873 fail_unless (gst_rtcp_packet_move_to_next (&packet) == TRUE);
874
875 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
876 fail_unless (gst_rtcp_packet_get_count (&packet) == 1);
877 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SDES);
878 fail_unless (gst_rtcp_packet_get_length (&packet) == 5);
879
880 /* remove the SDES */
881 fail_unless (gst_rtcp_packet_remove (&packet) == TRUE);
882
883 /* we are now at the BYE packet */
884 fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
885 fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
886 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
887 fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
888
889 /* close and validate */
890 gst_rtcp_buffer_unmap (&rtcp);
891 fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
892 fail_unless (gst_rtcp_buffer_validate_reduced (buf) == TRUE);
893 gst_buffer_unref (buf);
894 }
895
896 GST_END_TEST;
897
GST_START_TEST(test_rtcp_reduced_buffer)898 GST_START_TEST (test_rtcp_reduced_buffer)
899 {
900 GstBuffer *buf;
901 GstRTCPPacket packet;
902 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
903 gsize offset;
904 gsize maxsize;
905
906 buf = gst_rtcp_buffer_new (1400);
907 fail_unless (buf != NULL);
908 fail_unless_equals_int (gst_buffer_get_sizes (buf, &offset, &maxsize), 0);
909 fail_unless_equals_int (offset, 0);
910 fail_unless_equals_int (maxsize, 1400);
911
912 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
913
914 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
915 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
916 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
917
918 /* add an SR packet */
919 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_PSFB,
920 &packet) == TRUE);
921
922 /* close and validate */
923 gst_rtcp_buffer_unmap (&rtcp);
924 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
925 fail_unless (gst_rtcp_buffer_validate_reduced (buf) == TRUE);
926 gst_buffer_unref (buf);
927 }
928
929 GST_END_TEST;
930
931
GST_START_TEST(test_rtcp_validate_with_padding)932 GST_START_TEST (test_rtcp_validate_with_padding)
933 {
934 /* Compound packet with padding in the last packet. Padding is included in
935 * the length of the last packet. */
936 guint8 rtcp_pkt[] = {
937 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
938 0x97, 0x6d, 0x21, 0x6a,
939 0x4d, 0x16, 0xaf, 0x14,
940 0x10, 0x1f, 0xd9, 0x91,
941 0x0f, 0xb7, 0x50, 0x88,
942 0x3b, 0x79, 0x31, 0x50,
943 0xbe, 0x19, 0x12, 0xa8,
944 0xbb, 0xce, 0x9e, 0x3e,
945 0xA0, 0xCA, 0x00, 0x0A, /* P=1, Type SDES, length = 10 (includes padding) */
946 0x97, 0x6d, 0x21, 0x6a,
947 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
948 0x00, 0x00, 0x00, 0x00,
949 0x00, 0x00, 0x00, 0x00,
950 0x00, 0x00, 0x00, 0x00,
951 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
952 0x00, 0x00, 0x00, 0x00,
953 0x00, 0x00, 0x00, 0x00,
954 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
955 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
956 };
957
958 fail_unless (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
959 }
960
961 GST_END_TEST;
962
GST_START_TEST(test_rtcp_validate_with_padding_wrong_padlength)963 GST_START_TEST (test_rtcp_validate_with_padding_wrong_padlength)
964 {
965 /* Compound packet with padding in the last packet. Padding is included in
966 * the length of the last packet. */
967 guint8 rtcp_pkt[] = {
968 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
969 0x97, 0x6d, 0x21, 0x6a,
970 0x4d, 0x16, 0xaf, 0x14,
971 0x10, 0x1f, 0xd9, 0x91,
972 0x0f, 0xb7, 0x50, 0x88,
973 0x3b, 0x79, 0x31, 0x50,
974 0xbe, 0x19, 0x12, 0xa8,
975 0xbb, 0xce, 0x9e, 0x3e,
976 0xA0, 0xCA, 0x00, 0x0A, /* P=1, Type SDES, length = 10 (includes padding) */
977 0x97, 0x6d, 0x21, 0x6a,
978 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
979 0x00, 0x00, 0x00, 0x00,
980 0x00, 0x00, 0x00, 0x00,
981 0x00, 0x00, 0x00, 0x00,
982 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
983 0x00, 0x00, 0x00, 0x00,
984 0x00, 0x00, 0x00, 0x00,
985 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
986 0x00, 0x00, 0x00, 0x03 /* RTCP padding (wrong length) */
987 };
988
989 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
990 }
991
992 GST_END_TEST;
993
GST_START_TEST(test_rtcp_validate_with_padding_excluded_from_length)994 GST_START_TEST (test_rtcp_validate_with_padding_excluded_from_length)
995 {
996 /* Compound packet with padding in the last packet. Padding is not included
997 * in the length. */
998 guint8 rtcp_pkt[] = {
999 0x80, 0xC9, 0x00, 0x07, /* Type RR, length = 7 */
1000 0x97, 0x6d, 0x21, 0x6a,
1001 0x4d, 0x16, 0xaf, 0x14,
1002 0x10, 0x1f, 0xd9, 0x91,
1003 0x0f, 0xb7, 0x50, 0x88,
1004 0x3b, 0x79, 0x31, 0x50,
1005 0xbe, 0x19, 0x12, 0xa8,
1006 0xbb, 0xce, 0x9e, 0x3e,
1007 0xA0, 0xCA, 0x00, 0x09, /* P=1, Type SDES, length = 9 (excludes padding) */
1008 0x97, 0x6d, 0x21, 0x6a,
1009 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
1010 0x00, 0x00, 0x00, 0x00,
1011 0x00, 0x00, 0x00, 0x00,
1012 0x00, 0x00, 0x00, 0x00,
1013 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
1014 0x00, 0x00, 0x00, 0x00,
1015 0x00, 0x00, 0x00, 0x00,
1016 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
1017 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
1018 };
1019
1020 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
1021 }
1022
1023 GST_END_TEST;
1024
GST_START_TEST(test_rtcp_validate_with_padding_set_in_first_packet)1025 GST_START_TEST (test_rtcp_validate_with_padding_set_in_first_packet)
1026 {
1027 /* Compound packet with padding in the last packet but with the pad
1028 bit set on first packet */
1029 guint8 rtcp_pkt[] = {
1030 0xA0, 0xC9, 0x00, 0x07, /* P=1, Type RR, length = 7 */
1031 0x97, 0x6d, 0x21, 0x6a,
1032 0x4d, 0x16, 0xaf, 0x14,
1033 0x10, 0x1f, 0xd9, 0x91,
1034 0x0f, 0xb7, 0x50, 0x88,
1035 0x3b, 0x79, 0x31, 0x50,
1036 0xbe, 0x19, 0x12, 0xa8,
1037 0xbb, 0xce, 0x9e, 0x3e,
1038 0x80, 0xCA, 0x00, 0x0a, /* Type SDES, length = 10 (include padding) */
1039 0x97, 0x6d, 0x21, 0x6a,
1040 0x01, 0x0F, 0x00, 0x00, /* Type 1 (CNAME), length 15 */
1041 0x00, 0x00, 0x00, 0x00,
1042 0x00, 0x00, 0x00, 0x00,
1043 0x00, 0x00, 0x00, 0x00,
1044 0x00, 0x02, 0x09, 0x00, /* Type 2 (NAME), length 9 */
1045 0x00, 0x00, 0x00, 0x00,
1046 0x00, 0x00, 0x00, 0x00,
1047 0x00, 0x00, 0x00, 0x00, /* Type 0 (no length, 2 unused bytes) */
1048 0x00, 0x00, 0x00, 0x04 /* RTCP padding */
1049 };
1050
1051 fail_if (gst_rtcp_buffer_validate_data (rtcp_pkt, sizeof (rtcp_pkt)));
1052 }
1053
1054 GST_END_TEST;
1055
GST_START_TEST(test_rtcp_validate_reduced_without_padding)1056 GST_START_TEST (test_rtcp_validate_reduced_without_padding)
1057 {
1058 /* Reduced size packet without padding */
1059 guint8 rtcp_pkt[] = {
1060 0x80, 0xcd, 0x00, 0x07, /* Type FB, length = 8 */
1061 0x97, 0x6d, 0x21, 0x6a,
1062 0x4d, 0x16, 0xaf, 0x14,
1063 0x10, 0x1f, 0xd9, 0x91,
1064 0x0f, 0xb7, 0x50, 0x88,
1065 0x3b, 0x79, 0x31, 0x50,
1066 0xbe, 0x19, 0x12, 0xa8,
1067 0xbb, 0xce, 0x9e, 0x3e,
1068 };
1069
1070 fail_unless (gst_rtcp_buffer_validate_data_reduced (rtcp_pkt,
1071 sizeof (rtcp_pkt)));
1072 }
1073
1074 GST_END_TEST;
1075
GST_START_TEST(test_rtcp_validate_reduced_with_padding)1076 GST_START_TEST (test_rtcp_validate_reduced_with_padding)
1077 {
1078 GstRTCPPacket packet;
1079 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1080 GstBuffer *buffer = create_feedback_buffer (TRUE);
1081
1082 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1083 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1084 fail_unless (gst_rtcp_packet_get_padding (&packet));
1085 gst_rtcp_buffer_unmap (&rtcp);
1086
1087 fail_unless (gst_rtcp_buffer_validate_reduced (buffer));
1088 fail_if (gst_rtcp_buffer_validate (buffer));
1089
1090 gst_buffer_unref (buffer);
1091 }
1092
1093 GST_END_TEST;
1094
GST_START_TEST(test_rtcp_buffer_profile_specific_extension)1095 GST_START_TEST (test_rtcp_buffer_profile_specific_extension)
1096 {
1097 GstBuffer *buf;
1098 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1099 GstRTCPPacket packet;
1100 const guint8 pse[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1101 const guint8 pse2[] = { 0x01, 0x23, 0x45, 0x67 };
1102
1103 fail_unless ((buf = gst_rtcp_buffer_new (1400)) != NULL);
1104 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1105
1106 fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
1107 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
1108 fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
1109
1110 /* add an SR packet with sender info */
1111 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR, &packet));
1112 gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
1113 G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
1114 fail_unless_equals_int (0,
1115 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1116 fail_unless_equals_int (6, gst_rtcp_packet_get_length (&packet));
1117
1118 /* add profile-specific extension */
1119 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1120 pse, sizeof (pse)));
1121 {
1122 guint8 *data = NULL;
1123 guint len = 0;
1124
1125 fail_unless_equals_int (8, gst_rtcp_packet_get_length (&packet));
1126 fail_unless_equals_int (sizeof (pse) / 4,
1127 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1128
1129 /* gst_rtcp_packet_get_profile_specific_ext */
1130 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1131 &len));
1132 fail_unless_equals_int (sizeof (pse), len);
1133 fail_unless (data != NULL);
1134 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1135
1136 /* gst_rtcp_packet_copy_profile_specific_ext */
1137 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1138 &len));
1139 fail_unless_equals_int (sizeof (pse), len);
1140 fail_unless (data != NULL);
1141 fail_unless_equals_int (0, memcmp (pse, data, sizeof (pse)));
1142 g_free (data);
1143 }
1144
1145 /* append more profile-specific extension */
1146 fail_unless (gst_rtcp_packet_add_profile_specific_ext (&packet,
1147 pse2, sizeof (pse2)));
1148 {
1149 guint8 *data = NULL;
1150 guint len = 0;
1151 guint concat_len;
1152 guint8 *concat_pse;
1153
1154 /* Expect the second extension to be appended to the first */
1155 concat_len = sizeof (pse) + sizeof (pse2);
1156 concat_pse = g_malloc (concat_len);
1157 memcpy (concat_pse, pse, sizeof (pse));
1158 memcpy (concat_pse + sizeof (pse), pse2, sizeof (pse2));
1159
1160 fail_unless_equals_int (9, gst_rtcp_packet_get_length (&packet));
1161 fail_unless_equals_int (concat_len / 4,
1162 gst_rtcp_packet_get_profile_specific_ext_length (&packet));
1163
1164 /* gst_rtcp_packet_get_profile_specific_ext */
1165 fail_unless (gst_rtcp_packet_get_profile_specific_ext (&packet, &data,
1166 &len));
1167 fail_unless_equals_int (concat_len, len);
1168 fail_unless (data != NULL);
1169 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1170
1171 /* gst_rtcp_packet_copy_profile_specific_ext */
1172 fail_unless (gst_rtcp_packet_copy_profile_specific_ext (&packet, &data,
1173 &len));
1174 fail_unless_equals_int (concat_len, len);
1175 fail_unless (data != NULL);
1176 fail_unless_equals_int (0, memcmp (concat_pse, data, len));
1177 g_free (data);
1178 g_free (concat_pse);
1179 }
1180
1181 /* close and validate */
1182 gst_rtcp_buffer_unmap (&rtcp);
1183 fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
1184 gst_buffer_unref (buf);
1185 }
1186
1187 GST_END_TEST;
1188
GST_START_TEST(test_rtcp_buffer_app)1189 GST_START_TEST (test_rtcp_buffer_app)
1190 {
1191 GstBuffer *buf;
1192 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1193 GstRTCPPacket packet;
1194 guint mtu = 1000;
1195 const guint8 data[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1196 guint max_data_length = (mtu - 12) / 4;
1197 guint8 *data_ptr;
1198
1199 fail_unless ((buf = gst_rtcp_buffer_new (mtu)) != NULL);
1200 gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
1201
1202 /* Not a valid packet yet */
1203 fail_if (gst_rtcp_buffer_validate (buf));
1204 fail_if (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1205 fail_unless_equals_int (gst_rtcp_buffer_get_packet_count (&rtcp), 0);
1206
1207 /* Add APP packet */
1208 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_APP, &packet));
1209 gst_rtcp_packet_app_set_subtype (&packet, 0x15);
1210 gst_rtcp_packet_app_set_ssrc (&packet, 0x01234567);
1211 gst_rtcp_packet_app_set_name (&packet, "Test");
1212
1213 /* Check maximum allowed data */
1214 fail_if (gst_rtcp_packet_app_set_data_length (&packet, max_data_length + 1));
1215 fail_unless (gst_rtcp_packet_app_set_data_length (&packet, max_data_length));
1216
1217 /* Add data */
1218 fail_unless (gst_rtcp_packet_app_set_data_length (&packet,
1219 (sizeof (data) + 3) / 4));
1220 fail_unless_equals_int (gst_rtcp_packet_app_get_data_length (&packet), 2);
1221 fail_unless ((data_ptr = gst_rtcp_packet_app_get_data (&packet)));
1222 memcpy (data_ptr, data, sizeof (data));
1223
1224 gst_rtcp_buffer_unmap (&rtcp);
1225
1226 /* Map again with only the READ flag and check fields */
1227 gst_rtcp_buffer_map (buf, GST_MAP_READ, &rtcp);
1228 fail_unless_equals_int (gst_rtcp_packet_app_get_subtype (&packet), 0x15);
1229 fail_unless_equals_int (gst_rtcp_packet_app_get_ssrc (&packet), 0x01234567);
1230 fail_unless (memcmp (gst_rtcp_packet_app_get_name (&packet), "Test", 4) == 0);
1231 fail_unless_equals_int (gst_rtcp_packet_app_get_data_length (&packet), 2);
1232 fail_unless ((data_ptr = gst_rtcp_packet_app_get_data (&packet)));
1233 fail_unless (memcmp (data_ptr, data, sizeof (data)) == 0);
1234 gst_rtcp_buffer_unmap (&rtcp);
1235
1236 gst_buffer_unref (buf);
1237 }
1238
1239 GST_END_TEST;
1240
GST_START_TEST(test_rtcp_buffer_xr)1241 GST_START_TEST (test_rtcp_buffer_xr)
1242 {
1243 GstBuffer *buffer;
1244 GstRTCPPacket packet;
1245 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1246 guint8 rtcp_pkt[] = {
1247 0x80, 0xCF, 0x00, 0x0e, /* Type XR, length = 14 */
1248 0x97, 0x6d, 0x21, 0x6a,
1249 0x01, 0x00, 0x00, 0x03, /* Loss RLE, No thining, length = 3 */
1250 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1251 0x00, 0x01, 0x00, 0x02,
1252 0xcf, 0xb7, 0x8f, 0xb7,
1253 0x02, 0x00, 0x00, 0x03, /* Dup RLE, No thining, length = 3 */
1254 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1255 0x00, 0x01, 0x00, 0x02,
1256 0xcf, 0xb7, 0x8f, 0xb7,
1257 0x03, 0x00, 0x00, 0x04, /* Packet Receipt Times, No thining, length = 4 */
1258 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1259 0x00, 0x01, 0x00, 0x02,
1260 0x59, 0xf9, 0xdd, 0x7e,
1261 0x59, 0xf9, 0xdd, 0x7e,
1262 };
1263
1264 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1265 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1266
1267 fail_unless (gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp));
1268
1269 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1270 fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_XR);
1271 fail_unless (gst_rtcp_packet_xr_get_ssrc (&packet) ==
1272 GST_READ_UINT32_BE (rtcp_pkt + 12));
1273 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1274 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1275 GST_RTCP_XR_TYPE_LRLE);
1276 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1277 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1278 GST_RTCP_XR_TYPE_DRLE);
1279 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1280 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1281 GST_RTCP_XR_TYPE_PRT);
1282
1283 fail_if (gst_rtcp_packet_xr_next_rb (&packet));
1284
1285 gst_rtcp_buffer_unmap (&rtcp);
1286 gst_buffer_unref (buffer);
1287 }
1288
1289 GST_END_TEST;
1290
GST_START_TEST(test_rtcp_buffer_xr_rle)1291 GST_START_TEST (test_rtcp_buffer_xr_rle)
1292 {
1293 GstBuffer *buffer;
1294 GstRTCPPacket packet;
1295 guint32 ssrc, chunk_count;
1296 guint8 thining;
1297 guint16 begin_seq, end_seq, chunk;
1298 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1299 guint8 rtcp_pkt[] = {
1300 0x80, 0xCF, 0x00, 0x0a, /* Type XR, length = 10 */
1301 0x97, 0x6d, 0x21, 0x6a,
1302 0x01, 0x00, 0x00, 0x03, /* Loss RLE, No thining, length = 3 */
1303 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1304 0x00, 0x01, 0x00, 0x02,
1305 0x80, 0x12, 0x00, 0x00,
1306 0x02, 0x00, 0x00, 0x04, /* Dup RLE, No thining, length = 4 */
1307 0x97, 0x6d, 0x21, 0x7b, /* SSRC of source */
1308 0x00, 0x01, 0x00, 0x04,
1309 0x8f, 0x21, 0x8f, 0x22,
1310 0x8f, 0x23, 0x8f, 0x24
1311 };
1312 guint8 rtcp_pkt_invalid_pkt_length[] = {
1313 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1314 0x97, 0x6d, 0x21, 0x6a,
1315 0x01, 0x00, 0x00, 0x02, /* Loss RLE, No thining, length = 1 (but really 3) */
1316 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1317 0x00, 0x01, 0x00, 0x02,
1318 };
1319
1320 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1321 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1322 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1323
1324 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1325
1326 /* check LRLE */
1327 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1328 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1329 GST_RTCP_XR_TYPE_LRLE);
1330 fail_unless (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1331 &begin_seq, &end_seq, &chunk_count));
1332 fail_unless_equals_int (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1333 fail_unless_equals_int (thining, 0);
1334 fail_unless_equals_int (begin_seq, 0x0001);
1335 fail_unless_equals_int (end_seq, 0x0002);
1336 fail_unless_equals_int (chunk_count, 2);
1337
1338 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 0, &chunk);
1339 fail_unless_equals_int (chunk, 0x8012);
1340
1341 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1342 fail_unless_equals_int (chunk, 0x0);
1343
1344 /* check DRLE */
1345 fail_unless (gst_rtcp_packet_xr_next_rb (&packet));
1346 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1347 GST_RTCP_XR_TYPE_DRLE);
1348 fail_unless (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1349 &begin_seq, &end_seq, &chunk_count));
1350 fail_unless_equals_int (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 28));
1351 fail_unless_equals_int (thining, 0);
1352 fail_unless_equals_int (begin_seq, 0x0001);
1353 fail_unless_equals_int (end_seq, 0x0004);
1354 fail_unless_equals_int (chunk_count, 4);
1355
1356 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 1, &chunk);
1357 fail_unless_equals_int (chunk, 0x8f22);
1358
1359 gst_rtcp_packet_xr_get_rle_nth_chunk (&packet, 2, &chunk);
1360 fail_unless_equals_int (chunk, 0x8f23);
1361
1362 gst_rtcp_buffer_unmap (&rtcp);
1363 gst_buffer_unref (buffer);
1364
1365 /* Test invalid length */
1366 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1367 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1368 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1369 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1370 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1371
1372 /* check LRLE (should fail because length is too short) */
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_LRLE);
1376 fail_if (gst_rtcp_packet_xr_get_rle_info (&packet, &ssrc, &thining,
1377 &begin_seq, &end_seq, &chunk_count));
1378 gst_rtcp_buffer_unmap (&rtcp);
1379 gst_buffer_unref (buffer);
1380 }
1381
1382 GST_END_TEST;
1383
GST_START_TEST(test_rtcp_buffer_xr_prt)1384 GST_START_TEST (test_rtcp_buffer_xr_prt)
1385 {
1386 GstBuffer *buffer;
1387 GstRTCPPacket packet;
1388 guint32 ssrc, receipt_time;
1389 guint8 thining;
1390 guint16 begin_seq, end_seq;
1391 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1392 guint8 rtcp_pkt[] = {
1393 0x80, 0xCF, 0x00, 0x06, /* Type XR, length = 6 */
1394 0x97, 0x6d, 0x21, 0x6a,
1395 0x03, 0x00, 0x00, 0x04, /* Packet Receipt Times, No thining, length = 4 */
1396 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1397 0x00, 0x01, 0x00, 0x03,
1398 0x59, 0xf9, 0xdd, 0x7e,
1399 0x59, 0xf9, 0xde, 0x00,
1400 };
1401 guint8 rtcp_pkt_invalid_pkt_length[] = {
1402 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1403 0x97, 0x6d, 0x21, 0x6a,
1404 0x03, 0x00, 0x00, 0x02, /* Packet Receipt Times, No thining, length = 2 (but should be 4) */
1405 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1406 0x00, 0x01, 0x00, 0x03,
1407 };
1408 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1409 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1410 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1411
1412 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1413
1414 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1415 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1416 GST_RTCP_XR_TYPE_PRT);
1417
1418 fail_unless (gst_rtcp_packet_xr_get_prt_info (&packet, &ssrc, &thining,
1419 &begin_seq, &end_seq));
1420 fail_unless (gst_rtcp_packet_xr_get_prt_by_seq (&packet, 2, &receipt_time));
1421 fail_unless_equals_int_hex (receipt_time, 0x59f9de00L);
1422
1423 gst_rtcp_buffer_unmap (&rtcp);
1424 gst_buffer_unref (buffer);
1425
1426 /* Test for invalid length */
1427 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1428 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1429 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1430 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1431
1432 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1433
1434 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1435 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1436 GST_RTCP_XR_TYPE_PRT);
1437
1438 fail_if (gst_rtcp_packet_xr_get_prt_info (&packet, &ssrc, &thining,
1439 &begin_seq, &end_seq));
1440 gst_rtcp_buffer_unmap (&rtcp);
1441 gst_buffer_unref (buffer);
1442
1443 }
1444
1445 GST_END_TEST;
1446
GST_START_TEST(test_rtcp_buffer_xr_rrt)1447 GST_START_TEST (test_rtcp_buffer_xr_rrt)
1448 {
1449 GstBuffer *buffer;
1450 GstRTCPPacket packet;
1451 guint64 ntptime;
1452 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1453 guint8 rtcp_pkt[] = {
1454 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1455 0x97, 0x6d, 0x21, 0x6a,
1456 0x04, 0x00, 0x00, 0x02, /* Receiver Reference Time, length = 2 */
1457 0x01, 0x23, 0x45, 0x67,
1458 0x89, 0x01, 0x23, 0x45
1459 };
1460 guint8 rtcp_pkt_invalid_pkt_length[] = {
1461 0x80, 0xCF, 0x00, 0x04, /* Type XR, length = 4 */
1462 0x97, 0x6d, 0x21, 0x6a,
1463 0x04, 0x00, 0x00, 0x01, /* Receiver Reference Time, length = 1 */
1464 0x01, 0x23, 0x45, 0x67,
1465 0x89, 0x01, 0x23, 0x45
1466 };
1467
1468 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1469 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1470 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1471
1472 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1473
1474 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1475 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1476 GST_RTCP_XR_TYPE_RRT);
1477
1478 fail_unless (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1479 fail_unless_equals_uint64_hex (ntptime, 0x0123456789012345LL);
1480
1481 gst_rtcp_buffer_unmap (&rtcp);
1482 gst_buffer_unref (buffer);
1483
1484 /* Test invalid length */
1485 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1486 rtcp_pkt_invalid_pkt_length, sizeof (rtcp_pkt_invalid_pkt_length), 0,
1487 sizeof (rtcp_pkt_invalid_pkt_length), NULL, NULL);
1488 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1489
1490 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1491
1492 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1493 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1494 GST_RTCP_XR_TYPE_RRT);
1495
1496 fail_if (gst_rtcp_packet_xr_get_rrt (&packet, &ntptime));
1497
1498 gst_rtcp_buffer_unmap (&rtcp);
1499 gst_buffer_unref (buffer);
1500 }
1501
1502 GST_END_TEST;
1503
GST_START_TEST(test_rtcp_buffer_xr_dlrr)1504 GST_START_TEST (test_rtcp_buffer_xr_dlrr)
1505 {
1506 GstBuffer *buffer;
1507 GstRTCPPacket packet;
1508 guint32 ssrc, last_rr, delay;
1509 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1510 guint8 rtcp_pkt[] = {
1511 0x80, 0xCF, 0x00, 0x08, /* Type XR, length = 8 */
1512 0x97, 0x6d, 0x21, 0x6a,
1513 0x05, 0x00, 0x00, 0x06, /* DLRR, length = 6 */
1514 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1515 0x01, 0x23, 0x45, 0x67,
1516 0x89, 0x01, 0x23, 0x45,
1517 0x97, 0x6d, 0x21, 0x6b, /* SSRC of source */
1518 0x01, 0x23, 0x45, 0x67,
1519 0x89, 0x01, 0x23, 0x45
1520 };
1521
1522 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1523 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1524 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1525
1526 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1527
1528 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1529 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1530 GST_RTCP_XR_TYPE_DLRR);
1531
1532 fail_unless (gst_rtcp_packet_xr_get_dlrr_block (&packet, 0, &ssrc, &last_rr,
1533 &delay));
1534 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1535 fail_unless (gst_rtcp_packet_xr_get_dlrr_block (&packet, 1, &ssrc, &last_rr,
1536 &delay));
1537 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 24));
1538
1539 /* it has only two sub-blocks. */
1540 fail_if (gst_rtcp_packet_xr_get_dlrr_block (&packet, 2, &ssrc, &last_rr,
1541 &delay));
1542
1543 gst_rtcp_buffer_unmap (&rtcp);
1544 gst_buffer_unref (buffer);
1545 }
1546
1547 GST_END_TEST;
1548
GST_START_TEST(test_rtcp_buffer_xr_ssumm)1549 GST_START_TEST (test_rtcp_buffer_xr_ssumm)
1550 {
1551 GstBuffer *buffer;
1552 GstRTCPPacket packet;
1553 guint32 ssrc, lost_packets, dup_packets;
1554 guint16 begin_seq, end_seq;
1555 guint32 min_jitter, max_jitter, mean_jitter, dev_jitter;
1556 guint8 min_ttl, max_ttl, mean_ttl, dev_ttl;
1557 gboolean ipv4;
1558 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1559 guint8 rtcp_pkt[] = {
1560 0x80, 0xCF, 0x00, 0x0b, /* Type XR, length = 11 */
1561 0x97, 0x6d, 0x21, 0x6a,
1562 0x06, 0xe8, 0x00, 0x09, /* Statistics summary, length = 9 */
1563 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1564 0x00, 0x01, 0x00, 0x02,
1565 0x00, 0x00, 0x00, 0x01,
1566 0x00, 0x00, 0x00, 0x02,
1567 0x00, 0x00, 0x00, 0x03,
1568 0x00, 0x00, 0x00, 0x04,
1569 0x00, 0x00, 0x00, 0x05,
1570 0x00, 0x00, 0x00, 0x06,
1571 0x01, 0x80, 0x0f, 0x8f
1572 };
1573
1574 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1575 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1576 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1577
1578 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1579
1580 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1581 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1582 GST_RTCP_XR_TYPE_SSUMM);
1583
1584 fail_unless (gst_rtcp_packet_xr_get_summary_info (&packet, &ssrc, &begin_seq,
1585 &end_seq));
1586 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1587 fail_unless_equals_int (begin_seq, GST_READ_UINT16_BE (rtcp_pkt + 16));
1588 fail_unless_equals_int (end_seq, GST_READ_UINT16_BE (rtcp_pkt + 18));
1589
1590 fail_unless (gst_rtcp_packet_xr_get_summary_pkt (&packet, &lost_packets,
1591 &dup_packets));
1592 fail_unless_equals_int (lost_packets, GST_READ_UINT32_BE (rtcp_pkt + 20));
1593 fail_unless_equals_int (dup_packets, GST_READ_UINT32_BE (rtcp_pkt + 24));
1594
1595 fail_unless (gst_rtcp_packet_xr_get_summary_jitter (&packet, &min_jitter,
1596 &max_jitter, &mean_jitter, &dev_jitter));
1597 fail_unless_equals_int (min_jitter, GST_READ_UINT32_BE (rtcp_pkt + 28));
1598 fail_unless_equals_int (max_jitter, GST_READ_UINT32_BE (rtcp_pkt + 32));
1599 fail_unless_equals_int (mean_jitter, GST_READ_UINT32_BE (rtcp_pkt + 36));
1600 fail_unless_equals_int (dev_jitter, GST_READ_UINT32_BE (rtcp_pkt + 40));
1601
1602 fail_unless (gst_rtcp_packet_xr_get_summary_ttl (&packet, &ipv4, &min_ttl,
1603 &max_ttl, &mean_ttl, &dev_ttl));
1604 fail_unless (ipv4);
1605 fail_unless_equals_int (min_ttl, rtcp_pkt[44]);
1606 fail_unless_equals_int (max_ttl, rtcp_pkt[45]);
1607 fail_unless_equals_int (mean_ttl, rtcp_pkt[46]);
1608 fail_unless_equals_int (dev_ttl, rtcp_pkt[47]);
1609
1610 gst_rtcp_buffer_unmap (&rtcp);
1611 gst_buffer_unref (buffer);
1612 }
1613
1614 GST_END_TEST;
1615
GST_START_TEST(test_rtcp_buffer_xr_voipmtrx)1616 GST_START_TEST (test_rtcp_buffer_xr_voipmtrx)
1617 {
1618 GstBuffer *buffer;
1619 GstRTCPPacket packet;
1620 guint32 ssrc;
1621 guint8 loss_rate, discard_rate, burst_density, gap_density;
1622 guint8 signal_level, noise_level, rerl, gmin;
1623 guint8 r_factor, ext_r_factor, mos_lq, mos_cq, rx_config;
1624 guint16 burst_duration, gap_duration;
1625 guint16 roundtrip_delay, end_system_delay;
1626 guint16 jb_nominal, jb_maximum, jb_abs_max;
1627 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
1628 guint8 rtcp_pkt[] = {
1629 0x80, 0xCF, 0x00, 0x0a, /* Type XR, length = 10 */
1630 0x97, 0x6d, 0x21, 0x6a,
1631 0x07, 0x00, 0x00, 0x08, /* VoIP Metrics, length = 8 */
1632 0x97, 0x6d, 0x21, 0x6a, /* SSRC of source */
1633 0x01, 0x02, 0x03, 0x04,
1634 0x05, 0x06, 0x07, 0x08,
1635 0x09, 0x0a, 0x0b, 0x0c,
1636 0x0d, 0x0e, 0x0f, 0x10,
1637 0x11, 0x12, 0x13, 0x14,
1638 0x15, 0x00, 0x16, 0x17,
1639 0x18, 0x19, 0x1a, 0x1b
1640 };
1641
1642 buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
1643 rtcp_pkt, sizeof (rtcp_pkt), 0, sizeof (rtcp_pkt), NULL, NULL);
1644 gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp);
1645
1646 fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet));
1647
1648 fail_unless (gst_rtcp_packet_xr_first_rb (&packet));
1649 fail_unless (gst_rtcp_packet_xr_get_block_type (&packet) ==
1650 GST_RTCP_XR_TYPE_VOIP_METRICS);
1651 fail_unless (gst_rtcp_packet_xr_get_voip_metrics_ssrc (&packet, &ssrc));
1652 fail_unless_equals_int_hex (ssrc, GST_READ_UINT32_BE (rtcp_pkt + 12));
1653
1654 fail_unless (gst_rtcp_packet_xr_get_voip_packet_metrics (&packet, &loss_rate,
1655 &discard_rate));
1656 fail_unless_equals_int (loss_rate, rtcp_pkt[16]);
1657 fail_unless_equals_int (discard_rate, rtcp_pkt[17]);
1658
1659 fail_unless (gst_rtcp_packet_xr_get_voip_burst_metrics (&packet,
1660 &burst_density, &gap_density, &burst_duration, &gap_duration));
1661 fail_unless_equals_int (burst_density, rtcp_pkt[18]);
1662 fail_unless_equals_int (gap_density, rtcp_pkt[19]);
1663 fail_unless_equals_int (burst_duration, GST_READ_UINT16_BE (rtcp_pkt + 20));
1664 fail_unless_equals_int (gap_duration, GST_READ_UINT16_BE (rtcp_pkt + 22));
1665
1666 fail_unless (gst_rtcp_packet_xr_get_voip_delay_metrics (&packet,
1667 &roundtrip_delay, &end_system_delay));
1668 fail_unless_equals_int (roundtrip_delay, GST_READ_UINT16_BE (rtcp_pkt + 24));
1669 fail_unless_equals_int (end_system_delay, GST_READ_UINT16_BE (rtcp_pkt + 26));
1670
1671 fail_unless (gst_rtcp_packet_xr_get_voip_signal_metrics (&packet,
1672 &signal_level, &noise_level, &rerl, &gmin));
1673 fail_unless_equals_int (signal_level, rtcp_pkt[28]);
1674 fail_unless_equals_int (noise_level, rtcp_pkt[29]);
1675 fail_unless_equals_int (rerl, rtcp_pkt[30]);
1676 fail_unless_equals_int (gmin, rtcp_pkt[31]);
1677
1678 fail_unless (gst_rtcp_packet_xr_get_voip_quality_metrics (&packet, &r_factor,
1679 &ext_r_factor, &mos_lq, &mos_cq));
1680 fail_unless_equals_int (r_factor, rtcp_pkt[32]);
1681 fail_unless_equals_int (ext_r_factor, rtcp_pkt[33]);
1682 fail_unless_equals_int (mos_lq, rtcp_pkt[34]);
1683 fail_unless_equals_int (mos_cq, rtcp_pkt[35]);
1684
1685 fail_unless (gst_rtcp_packet_xr_get_voip_configuration_params (&packet, &gmin,
1686 &rx_config));
1687 fail_unless_equals_int (gmin, rtcp_pkt[31]);
1688 fail_unless_equals_int (rx_config, rtcp_pkt[36]);
1689
1690 fail_unless (gst_rtcp_packet_xr_get_voip_jitter_buffer_params (&packet,
1691 &jb_nominal, &jb_maximum, &jb_abs_max));
1692 fail_unless_equals_int (jb_nominal, GST_READ_UINT16_BE (rtcp_pkt + 38));
1693 fail_unless_equals_int (jb_maximum, GST_READ_UINT16_BE (rtcp_pkt + 40));
1694 fail_unless_equals_int (jb_abs_max, GST_READ_UINT16_BE (rtcp_pkt + 42));
1695
1696 gst_rtcp_buffer_unmap (&rtcp);
1697 gst_buffer_unref (buffer);
1698 }
1699
1700 GST_END_TEST;
1701
GST_START_TEST(test_rtp_ntp64_extension)1702 GST_START_TEST (test_rtp_ntp64_extension)
1703 {
1704 GstBuffer *buf;
1705 gpointer data;
1706 guint size;
1707 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1708 guint8 bytes[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1709 guint64 ntptime;
1710 guint8 hdrext_ntp64[GST_RTP_HDREXT_NTP_64_SIZE];
1711
1712 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1713
1714 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1715
1716 /* format extension data */
1717 gst_rtp_hdrext_set_ntp_64 (hdrext_ntp64, GST_RTP_HDREXT_NTP_64_SIZE,
1718 0x0123456789012345LL);
1719 fail_unless (memcmp (bytes, hdrext_ntp64, sizeof (bytes)) == 0);
1720
1721 /* add as 1byte header */
1722 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp64,
1723 GST_RTP_HDREXT_NTP_64_SIZE);
1724
1725 /* get extension again */
1726 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1727
1728 /* and check */
1729 fail_unless (size == GST_RTP_HDREXT_NTP_64_SIZE);
1730 fail_unless (memcmp (data, hdrext_ntp64, size) == 0);
1731
1732 gst_rtp_hdrext_get_ntp_64 (data, size, &ntptime);
1733 fail_unless (ntptime == 0x0123456789012345LL);
1734
1735 gst_rtp_buffer_unmap (&rtp);
1736 gst_buffer_unref (buf);
1737 }
1738
1739 GST_END_TEST;
1740
GST_START_TEST(test_rtp_ntp56_extension)1741 GST_START_TEST (test_rtp_ntp56_extension)
1742 {
1743 GstBuffer *buf;
1744 gpointer data;
1745 guint size;
1746 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1747 guint8 bytes[] = { 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45 };
1748 guint64 ntptime;
1749 guint8 hdrext_ntp56[GST_RTP_HDREXT_NTP_56_SIZE];
1750
1751 buf = gst_rtp_buffer_new_allocate (0, 0, 0);
1752
1753 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1754
1755 /* format extension data */
1756 gst_rtp_hdrext_set_ntp_56 (hdrext_ntp56, GST_RTP_HDREXT_NTP_56_SIZE,
1757 0x0123456789012345LL);
1758 /* truncates top bits */
1759 fail_unless (memcmp (bytes, hdrext_ntp56, sizeof (bytes)) == 0);
1760
1761 /* add as 1byte header */
1762 gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1, hdrext_ntp56,
1763 GST_RTP_HDREXT_NTP_56_SIZE);
1764
1765 /* get extension again */
1766 gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0, &data, &size);
1767
1768 /* and check */
1769 fail_unless (size == GST_RTP_HDREXT_NTP_56_SIZE);
1770 fail_unless (memcmp (data, hdrext_ntp56, size) == 0);
1771
1772 gst_rtp_hdrext_get_ntp_56 (data, size, &ntptime);
1773 fail_unless (ntptime == 0x23456789012345LL);
1774
1775 gst_rtp_buffer_unmap (&rtp);
1776 gst_buffer_unref (buf);
1777 }
1778
1779 GST_END_TEST;
1780
GST_START_TEST(test_rtp_buffer_get_extension_bytes)1781 GST_START_TEST (test_rtp_buffer_get_extension_bytes)
1782 {
1783 GstBuffer *buf;
1784 guint16 bits;
1785 guint size;
1786 guint8 misc_data[4] = { 1, 2, 3, 4 };
1787 gpointer pointer;
1788 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1789 GBytes *gb;
1790 gsize gb_size;
1791
1792 /* create RTP buffer without extension header */
1793 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
1794 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1795 fail_if (gst_rtp_buffer_get_extension (&rtp));
1796
1797 /* verify that obtaining extension data returns NULL and bits are unchanged */
1798 bits = 0xabcd;
1799 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1800 fail_unless (gb == NULL);
1801 fail_unless (bits == 0xabcd);
1802
1803 g_bytes_unref (gb);
1804
1805 /* add extension header without data and verify that
1806 * an empty GBytes is returned */
1807 fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 0));
1808 fail_unless (gst_rtp_buffer_get_extension (&rtp));
1809 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1810 fail_unless (gb != NULL);
1811 fail_unless_equals_int (g_bytes_get_size (gb), 0);
1812
1813 g_bytes_unref (gb);
1814 gst_rtp_buffer_unmap (&rtp);
1815 gst_buffer_unref (buf);
1816
1817 /* create RTP buffer with extension header and extension data */
1818 buf = gst_rtp_buffer_new_allocate (4, 0, 0);
1819 gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
1820 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
1821 misc_data, 2));
1822 fail_unless (gst_rtp_buffer_get_extension (&rtp));
1823
1824 /* verify that gst_rtp_buffer_get_extension_bytes returns the same
1825 * header bits and data as does gst_rtp_buffer_get_extension_data */
1826 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
1827 &size));
1828 fail_unless (bits == 0xBEDE);
1829 fail_unless (size == 1);
1830 gb = gst_rtp_buffer_get_extension_bytes (&rtp, &bits);
1831 fail_unless (gb != NULL);
1832 fail_unless (bits == 0xBEDE);
1833 fail_unless_equals_int (g_bytes_get_size (gb), size * 4);
1834 fail_unless (memcmp (pointer, g_bytes_get_data (gb, &gb_size),
1835 size * 4) == 0);
1836 fail_unless_equals_int (gb_size, size * 4);
1837
1838 g_bytes_unref (gb);
1839 gst_rtp_buffer_unmap (&rtp);
1840 gst_buffer_unref (buf);
1841 }
1842
1843 GST_END_TEST;
1844
GST_START_TEST(test_rtp_buffer_get_payload_bytes)1845 GST_START_TEST (test_rtp_buffer_get_payload_bytes)
1846 {
1847 guint8 rtppacket[] = {
1848 0x80, 0xe0, 0xdf, 0xd7, 0xef, 0x84, 0xbe, 0xed, 0x9b, 0xc5, 0x29, 0x14,
1849 'H', 'e', 'l', 'l', 'o', '\0'
1850 };
1851
1852 GstBuffer *buf;
1853 GstMapInfo map;
1854 gconstpointer data;
1855 gsize size;
1856 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1857 GBytes *gb;
1858
1859 /* create empty RTP buffer, i.e. no payload */
1860 buf = gst_rtp_buffer_new_allocate (0, 4, 0);
1861 fail_unless (buf != NULL);
1862 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
1863 fail_unless_equals_int (map.size, RTP_HEADER_LEN + 4);
1864 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp));
1865
1866 /* verify that requesting payload data returns an empty GBytes */
1867 gb = gst_rtp_buffer_get_payload_bytes (&rtp);
1868 fail_unless (gb != NULL);
1869 fail_unless_equals_int (g_bytes_get_size (gb), 0);
1870
1871 gst_rtp_buffer_unmap (&rtp);
1872 gst_buffer_unmap (buf, &map);
1873 gst_buffer_unref (buf);
1874 g_bytes_unref (gb);
1875
1876 /* create RTP buffer containing RTP packet */
1877 buf = gst_buffer_new_and_alloc (sizeof (rtppacket));
1878 fail_unless (buf != NULL);
1879 gst_buffer_fill (buf, 0, rtppacket, sizeof (rtppacket));
1880 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
1881 fail_unless_equals_int (map.size, sizeof (rtppacket));
1882 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp));
1883
1884 /* verify that the returned GBytes contains the correct payload data */
1885 gb = gst_rtp_buffer_get_payload_bytes (&rtp);
1886 fail_unless (gb != NULL);
1887 data = g_bytes_get_data (gb, &size);
1888 fail_unless (data != NULL);
1889 fail_unless (size == (sizeof (rtppacket) - RTP_HEADER_LEN));
1890 fail_unless_equals_string ("Hello", data);
1891 g_bytes_unref (gb);
1892
1893 gst_rtp_buffer_unmap (&rtp);
1894 gst_buffer_unmap (buf, &map);
1895 gst_buffer_unref (buf);
1896 }
1897
1898 GST_END_TEST;
1899
1900
GST_START_TEST(test_rtp_buffer_empty_payload)1901 GST_START_TEST (test_rtp_buffer_empty_payload)
1902 {
1903 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1904 GstBuffer *paybuf, *outbuf;
1905
1906 paybuf = gst_rtp_buffer_new_allocate (0, 0, 0);
1907
1908 gst_rtp_buffer_map (paybuf, GST_MAP_READ, &rtp);
1909 outbuf = gst_rtp_buffer_get_payload_buffer (&rtp);
1910 gst_rtp_buffer_unmap (&rtp);
1911
1912 gst_buffer_unref (paybuf);
1913 gst_buffer_unref (outbuf);
1914 }
1915
1916 GST_END_TEST;
1917
GST_START_TEST(test_rtp_buffer_extension_onebyte_header_full_padding)1918 GST_START_TEST (test_rtp_buffer_extension_onebyte_header_full_padding)
1919 {
1920 GstBuffer *buffer;
1921 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1922 guint8 *mem;
1923 guint size;
1924 guint8 *data_out;
1925 guint16 bits;
1926 guint8 *pdata;
1927 guint wordlen = 0;
1928 guint8 hdr_buffer_1[2] = { 0x1, 0x1 };
1929
1930 guint8 rtp_test_buffer[] = {
1931 0x90, 0x7c, 0x18, 0xa6, /* |V=2|P|X|CC|M|PT|sequence number| */
1932 0x7a, 0x62, 0x17, 0x0f, /* |timestamp| */
1933 0x70, 0x23, 0x91, 0x38, /* |synchronization source (SSRC) identifier| */
1934 0xbe, 0xde, 0x00, 0x02, /* |0xBE|0xDE|length=2| */
1935 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1936 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1937 0xff, 0xff, 0xff, 0xff /* |dummy payload| */
1938 };
1939
1940 mem = malloc (sizeof (rtp_test_buffer));
1941 fail_unless (mem != NULL);
1942 memcpy (mem, rtp_test_buffer, sizeof (rtp_test_buffer));
1943 fail_unless_equals_int (memcmp (mem, rtp_test_buffer,
1944 sizeof (rtp_test_buffer)), 0);
1945
1946 buffer = gst_buffer_new_wrapped (mem, sizeof (rtp_test_buffer));
1947
1948 fail_unless (gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp));
1949
1950 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1951 (gpointer) & pdata, &wordlen));
1952 fail_unless_equals_int (bits, 0xBEDE);
1953 fail_unless_equals_int (wordlen, 2);
1954 fail_unless_equals_int (pdata[0], 0x0);
1955 fail_unless_equals_int (pdata[1], 0x0);
1956 fail_unless_equals_int (pdata[2], 0x0);
1957 fail_unless_equals_int (pdata[3], 0x0);
1958 fail_unless_equals_int (pdata[4], 0x0);
1959 fail_unless_equals_int (pdata[5], 0x0);
1960 fail_unless_equals_int (pdata[6], 0x0);
1961 fail_unless_equals_int (pdata[7], 0x0);
1962
1963 fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1,
1964 hdr_buffer_1, 2));
1965 fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0,
1966 (gpointer *) & data_out, &size));
1967 fail_unless_equals_int (size, 2);
1968 fail_unless_equals_int (data_out[0], 0x1);
1969 fail_unless_equals_int (data_out[1], 0x1);
1970 fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1971 (gpointer) & pdata, &wordlen));
1972 fail_unless_equals_int (bits, 0xBEDE);
1973 fail_unless_equals_int (wordlen, 2);
1974 fail_unless_equals_int (pdata[0], 0x11);
1975 fail_unless_equals_int (pdata[1], 0x1);
1976 fail_unless_equals_int (pdata[2], 0x1);
1977 fail_unless_equals_int (pdata[3], 0x0);
1978 fail_unless_equals_int (pdata[4], 0x0);
1979 fail_unless_equals_int (pdata[5], 0x0);
1980 fail_unless_equals_int (pdata[6], 0x0);
1981 fail_unless_equals_int (pdata[7], 0x0);
1982
1983 gst_rtp_buffer_unmap (&rtp);
1984
1985 gst_buffer_unref (buffer);
1986 }
1987
1988 GST_END_TEST;
1989
1990
GST_START_TEST(test_ext_timestamp_basic)1991 GST_START_TEST (test_ext_timestamp_basic)
1992 {
1993 guint64 exttimestamp = -1;
1994 guint64 result = 0;
1995
1996 /* no wraparound when timestamps are increasing */
1997 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 0);
1998 fail_unless_equals_uint64 (result, 0);
1999 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
2000 fail_unless_equals_uint64 (result, 10);
2001 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
2002 fail_unless_equals_uint64 (result, 10);
2003 result = gst_rtp_buffer_ext_timestamp (&exttimestamp,
2004 G_GUINT64_CONSTANT (1) + G_MAXINT32);
2005 fail_unless_equals_uint64 (result, G_GUINT64_CONSTANT (1) + G_MAXINT32);
2006
2007 /* Even big bumps under G_MAXINT32 don't result in wrap-around */
2008 exttimestamp = -1;
2009 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 1087500);
2010 fail_unless_equals_uint64 (result, 1087500);
2011 result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 24);
2012 fail_unless_equals_uint64 (result, 24);
2013 }
2014
2015 GST_END_TEST;
2016
GST_START_TEST(test_ext_timestamp_wraparound)2017 GST_START_TEST (test_ext_timestamp_wraparound)
2018 {
2019 guint64 ext_ts = -1;
2020
2021 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts,
2022 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)),
2023 (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
2024
2025 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 0),
2026 G_MAXUINT32 + G_GUINT64_CONSTANT (1));
2027
2028 fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000),
2029 (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
2030 }
2031
2032 GST_END_TEST;
2033
2034
GST_START_TEST(test_ext_timestamp_wraparound_disordered)2035 GST_START_TEST (test_ext_timestamp_wraparound_disordered)
2036 {
2037 guint64 ext_ts = -1;
2038
2039 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
2040 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
2041 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
2042
2043 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 0)
2044 == G_MAXUINT32 + G_GUINT64_CONSTANT (1));
2045
2046 /* Unwrapping around */
2047 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
2048 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
2049 == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
2050
2051 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
2052 == (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
2053 }
2054
2055 GST_END_TEST;
2056
GST_START_TEST(test_ext_timestamp_wraparound_disordered_cannot_unwrap)2057 GST_START_TEST (test_ext_timestamp_wraparound_disordered_cannot_unwrap)
2058 {
2059 guint64 ext_ts = -1;
2060
2061 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
2062 == 90000);
2063
2064 /* Cannot unwrapping around */
2065 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
2066 G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)) == 0);
2067
2068 fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
2069 == 90000);
2070 }
2071
2072 GST_END_TEST;
2073
2074 static gboolean
set_rtcp_packet(GstBuffer * buffer,GstRTCPPacket * packet)2075 set_rtcp_packet (GstBuffer * buffer, GstRTCPPacket * packet)
2076 {
2077 GstMapInfo map = GST_MAP_INFO_INIT;
2078 gboolean ret = FALSE;
2079 gssize fci_length;
2080
2081 if (!gst_buffer_map (buffer, &map, GST_MAP_READ)) {
2082 GST_WARNING_OBJECT (buffer, "Cannot map feedback buffer");
2083 return FALSE;
2084 }
2085
2086 fci_length = (map.size / 4) /* words of 4 bytes */ -3 /* skip RCTP header */ ;
2087 if (fci_length <= 0) {
2088 GST_WARNING ("Unexpected FCI length");
2089 goto end;
2090 }
2091
2092 if (!gst_rtcp_packet_fb_set_fci_length (packet, fci_length)) {
2093 /* No enough space in rtcp packet to add this report */
2094 GST_WARNING ("Could not set transport feedback FCI length");
2095 goto end;
2096 }
2097 // Copy the rtcp feedback message here
2098 memcpy (packet->rtcp->map.data + packet->offset, map.data, map.size);
2099
2100 ret = TRUE;
2101
2102 end:
2103 gst_buffer_unmap (buffer, &map);
2104
2105 return ret;
2106 }
2107
2108 static gboolean
add_rtcp_packet(GstBuffer * rtcp_buffer,GstBuffer * buffer,GstRTCPType type)2109 add_rtcp_packet (GstBuffer * rtcp_buffer, GstBuffer * buffer, GstRTCPType type)
2110 {
2111 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
2112 gboolean rtcp_mapped = FALSE;
2113 GstRTCPPacket packet;
2114 gboolean ret = FALSE;
2115
2116 rtcp_mapped = gst_rtcp_buffer_map (rtcp_buffer, GST_MAP_READWRITE, &rtcp);
2117 if (!rtcp_mapped) {
2118 GST_WARNING_OBJECT (rtcp_buffer, "Cannot map buffer to RTCP");
2119 return FALSE;
2120 }
2121
2122 if (!gst_rtcp_buffer_add_packet (&rtcp, type, &packet)) {
2123 GST_DEBUG ("Cannot add RTCP packet");
2124 goto end;
2125 }
2126
2127 ret = set_rtcp_packet (buffer, &packet);
2128
2129 end:
2130 if (rtcp_mapped) {
2131 gst_rtcp_buffer_unmap (&rtcp);
2132 }
2133
2134 return ret;
2135 }
2136
2137 static GstBuffer *
create_feedback_buffer(gboolean with_padding)2138 create_feedback_buffer (gboolean with_padding)
2139 {
2140 if (with_padding) {
2141 guint8 transport_wide_cc_padding_buffer[72] = {
2142 0xaf, 0xcd, 0x00, 0x11,
2143 0x7c, 0xbf, 0x7b, 0x00,
2144 0x4c, 0xc1, 0xe4, 0x69,
2145 0x00, 0x24, 0x00, 0x30,
2146 0x00, 0x00, 0x2c, 0x01,
2147 0x20, 0x30, 0x65, 0x0c,
2148 0x09, 0x0c, 0x0d, 0x08,
2149 0x2a, 0x16, 0x14, 0x14,
2150 0x16, 0x14, 0xcc, 0x00,
2151 0x14, 0x14, 0xcc, 0x8e,
2152 0x01, 0xa3, 0x02, 0x14,
2153 0x16, 0x50, 0x00, 0x16,
2154 0x7b, 0x01, 0x17, 0x14,
2155 0x94, 0x01, 0x15, 0x11,
2156 0x18, 0x16, 0x15, 0x90,
2157 0x01, 0x13, 0x15, 0x2a,
2158 0x00, 0x17, 0x17, 0x4f,
2159 0x00, 0x14, 0x00, 0x02,
2160 };
2161
2162 return gst_buffer_new_memdup (transport_wide_cc_padding_buffer,
2163 sizeof (transport_wide_cc_padding_buffer));
2164 } else {
2165 guint8 transport_wide_cc_buffer[36] = {
2166 0x8f, 0xcd, 0x00, 0x08,
2167 0x7c, 0xbf, 0x7b, 0x00,
2168 0x4c, 0xc1, 0xe4, 0x69,
2169 0x19, 0xbc, 0x00, 0x0e,
2170 0x00, 0x02, 0x3c, 0x33,
2171 0x20, 0x0e, 0x02, 0x28,
2172 0x15, 0x15, 0x14, 0x17,
2173 0x14, 0x14, 0x15, 0x29,
2174 0x18, 0x12, 0x15, 0x16,
2175 };
2176 return gst_buffer_new_memdup (transport_wide_cc_buffer,
2177 sizeof (transport_wide_cc_buffer));
2178 }
2179 }
2180
2181 static GstBuffer *
create_remb_buffer()2182 create_remb_buffer ()
2183 {
2184 guint8 remb_buffer[20] = {
2185 0x8f, 0xce, 0x00, 0x04,
2186 0x00, 0x00, 0x00, 0x01,
2187 0x00, 0x00, 0x00, 0x00,
2188 0x52, 0x45, 0x4d, 0x42,
2189 0x00, 0x0b, 0xd0, 0x90,
2190 };
2191
2192 return gst_buffer_new_memdup (remb_buffer, sizeof (remb_buffer));
2193 }
2194
2195 static gboolean
add_transport_wide_cc(GstBuffer * buffer,gboolean with_padding)2196 add_transport_wide_cc (GstBuffer * buffer, gboolean with_padding)
2197 {
2198 GstBuffer *feedback;
2199 gboolean ret;
2200
2201 feedback = create_feedback_buffer (with_padding);
2202 ret = add_rtcp_packet (buffer, feedback, GST_RTCP_TYPE_RTPFB);
2203 gst_buffer_unref (feedback);
2204
2205 return ret;
2206 }
2207
2208 static gboolean
add_remb(GstBuffer * buffer)2209 add_remb (GstBuffer * buffer)
2210 {
2211 GstBuffer *remb;
2212 gboolean ret;
2213
2214 remb = create_remb_buffer ();
2215 ret = add_rtcp_packet (buffer, remb, GST_RTCP_TYPE_PSFB);
2216 gst_buffer_unref (remb);
2217
2218 return ret;
2219 }
2220
GST_START_TEST(test_rtcp_compound_padding)2221 GST_START_TEST (test_rtcp_compound_padding)
2222 {
2223 GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
2224 GstRTCPPacket *rtcp_packet = NULL;
2225 GstBuffer *rtcp_buffer;
2226
2227 rtcp_buffer = gst_rtcp_buffer_new (1400);
2228
2229 fail_unless (gst_rtcp_buffer_map (rtcp_buffer, GST_MAP_READWRITE, &rtcp));
2230 rtcp_packet = g_slice_new0 (GstRTCPPacket);
2231 fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_RR,
2232 rtcp_packet));
2233 gst_rtcp_packet_rr_set_ssrc (rtcp_packet, 1);
2234 g_slice_free (GstRTCPPacket, rtcp_packet);
2235 gst_rtcp_buffer_unmap (&rtcp);
2236
2237 fail_unless (gst_rtcp_buffer_validate (rtcp_buffer));
2238
2239 fail_unless (add_remb (rtcp_buffer));
2240 fail_unless (add_transport_wide_cc (rtcp_buffer, FALSE));
2241 /* Last packet did not have padding so we can add more packets */
2242 fail_unless (add_remb (rtcp_buffer));
2243
2244 fail_unless (add_transport_wide_cc (rtcp_buffer, TRUE));
2245 /* Last packet has padding so we are not allow to add more */
2246 fail_if (add_remb (rtcp_buffer));
2247
2248 gst_buffer_unref (rtcp_buffer);
2249 }
2250
2251 GST_END_TEST;
2252
GST_START_TEST(test_rtp_buffer_extlen_wraparound)2253 GST_START_TEST (test_rtp_buffer_extlen_wraparound)
2254 {
2255 GstBuffer *buf;
2256 guint8 rtp_test_buffer[] = {
2257 0x90, 0x7c, 0x18, 0xa6, /* |V=2|P|X|CC|M|PT|sequence number| */
2258 0x7a, 0x62, 0x17, 0x0f, /* |timestamp| */
2259 0x70, 0x23, 0x91, 0x38, /* |synchronization source (SSRC) identifier| */
2260 0xbe, 0xde, 0x40, 0x01, /* |0xBE|0xDE|length=16385| */
2261 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
2262 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
2263 0xff, 0xff, 0xff, 0xff /* |dummy payload| */
2264 };
2265
2266 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
2267
2268 buf = gst_buffer_new_and_alloc (sizeof (rtp_test_buffer));
2269 gst_buffer_fill (buf, 0, rtp_test_buffer, sizeof (rtp_test_buffer));
2270 fail_if (gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp));
2271 gst_buffer_unref (buf);
2272 }
2273
2274 GST_END_TEST;
2275
GST_START_TEST(test_rtp_buffer_remove_extension_data)2276 GST_START_TEST (test_rtp_buffer_remove_extension_data)
2277 {
2278 GstBuffer *buf;
2279 GstMapInfo info;
2280 guint8 rtp_test_buffer[] = {
2281 0x90, 0x7c, 0x18, 0xa6, /* |V=2|P|X|CC|M|PT|sequence number| */
2282 0x7a, 0x62, 0x17, 0x0f, /* |timestamp| */
2283 0x70, 0x23, 0x91, 0x38, /* |synchronization source (SSRC) identifier| */
2284 0xbe, 0xde, 0x00, 0x02, /* |0xBE|0xDE|length=2| */
2285 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
2286 0x00, 0x00, 0x00, 0x00, /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
2287 0xff, 0xff, 0xff, 0xff /* |dummy payload| */
2288 };
2289
2290 guint8 expected_result[] = {
2291 0x80, 0x7c, 0x18, 0xa6, /* |V=2|P|X|CC|M|PT|sequence number| */
2292 0x7a, 0x62, 0x17, 0x0f, /* |timestamp| */
2293 0x70, 0x23, 0x91, 0x38, /* |synchronization source (SSRC) identifier| */
2294 0xff, 0xff, 0xff, 0xff /* |dummy payload| */
2295 };
2296
2297 GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
2298
2299 buf = gst_buffer_new_and_alloc (sizeof (rtp_test_buffer));
2300 gst_buffer_fill (buf, 0, rtp_test_buffer, sizeof (rtp_test_buffer));
2301
2302 fail_unless (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp));
2303
2304 gst_rtp_buffer_remove_extension_data (&rtp);
2305 gst_rtp_buffer_unmap (&rtp);
2306
2307 gst_buffer_map (buf, &info, GST_MAP_READ);
2308
2309 fail_unless_equals_int (info.size, sizeof (expected_result));
2310 fail_unless_equals_int
2311 (memcmp (info.data, expected_result, sizeof (expected_result)), 0);
2312
2313 gst_buffer_unmap (buf, &info);
2314 gst_buffer_unref (buf);
2315 }
2316
2317 GST_END_TEST;
2318
2319 static Suite *
rtp_suite(void)2320 rtp_suite (void)
2321 {
2322 Suite *s = suite_create ("rtp support library");
2323 TCase *tc_chain = tcase_create ("general");
2324
2325 suite_add_tcase (s, tc_chain);
2326 tcase_add_test (tc_chain, test_rtp_buffer);
2327 tcase_add_test (tc_chain, test_rtp_buffer_validate_corrupt);
2328 tcase_add_test (tc_chain, test_rtp_buffer_validate_padding);
2329 tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data);
2330 //tcase_add_test (tc_chain, test_rtp_buffer_list_set_extension);
2331 tcase_add_test (tc_chain, test_rtp_seqnum_compare);
2332
2333 tcase_add_test (tc_chain, test_rtcp_sdes_type);
2334 tcase_add_test (tc_chain, test_rtcp_buffer);
2335 tcase_add_test (tc_chain, test_rtcp_reduced_buffer);
2336 tcase_add_test (tc_chain, test_rtcp_validate_with_padding);
2337 tcase_add_test (tc_chain, test_rtcp_validate_with_padding_wrong_padlength);
2338 tcase_add_test (tc_chain,
2339 test_rtcp_validate_with_padding_excluded_from_length);
2340 tcase_add_test (tc_chain,
2341 test_rtcp_validate_with_padding_set_in_first_packet);
2342 tcase_add_test (tc_chain, test_rtcp_validate_reduced_without_padding);
2343 tcase_add_test (tc_chain, test_rtcp_validate_reduced_with_padding);
2344 tcase_add_test (tc_chain, test_rtcp_buffer_profile_specific_extension);
2345 tcase_add_test (tc_chain, test_rtcp_buffer_app);
2346 tcase_add_test (tc_chain, test_rtcp_buffer_xr);
2347 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rle);
2348 tcase_add_test (tc_chain, test_rtcp_buffer_xr_prt);
2349 tcase_add_test (tc_chain, test_rtcp_buffer_xr_rrt);
2350 tcase_add_test (tc_chain, test_rtcp_buffer_xr_dlrr);
2351 tcase_add_test (tc_chain, test_rtcp_buffer_xr_ssumm);
2352 tcase_add_test (tc_chain, test_rtcp_buffer_xr_voipmtrx);
2353
2354 tcase_add_test (tc_chain, test_rtp_ntp64_extension);
2355 tcase_add_test (tc_chain, test_rtp_ntp56_extension);
2356
2357 tcase_add_test (tc_chain, test_rtp_buffer_get_payload_bytes);
2358 tcase_add_test (tc_chain, test_rtp_buffer_get_extension_bytes);
2359 tcase_add_test (tc_chain, test_rtp_buffer_empty_payload);
2360
2361 tcase_add_test (tc_chain,
2362 test_rtp_buffer_extension_onebyte_header_full_padding);
2363
2364 //tcase_add_test (tc_chain, test_rtp_buffer_list);
2365
2366 tcase_add_test (tc_chain, test_ext_timestamp_basic);
2367 tcase_add_test (tc_chain, test_ext_timestamp_wraparound);
2368 tcase_add_test (tc_chain, test_ext_timestamp_wraparound_disordered);
2369 tcase_add_test (tc_chain,
2370 test_ext_timestamp_wraparound_disordered_cannot_unwrap);
2371
2372 tcase_add_test (tc_chain, test_rtcp_compound_padding);
2373 tcase_add_test (tc_chain, test_rtp_buffer_extlen_wraparound);
2374 tcase_add_test (tc_chain, test_rtp_buffer_remove_extension_data);
2375 tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data_shrink_data);
2376
2377 return s;
2378 }
2379
2380 GST_CHECK_MAIN (rtp);
2381