tests/check/libs/rtp.c

   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 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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
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
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
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
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
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
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_rtp_buffer_extension_onebyte_header_full_padding)
1818 {
1819   GstBuffer *buffer;
1820   GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
1821   guint8 *mem;
1822   guint size;
1823   guint8 *data_out;
1824   guint16 bits;
1825   guint8 *pdata;
1826   guint wordlen = 0;
1827   guint8 hdr_buffer_1[2] = { 0x1, 0x1 };
1828
1829   guint8 rtp_test_buffer[] = {
1830     0x90, 0x7c, 0x18, 0xa6,     /* |V=2|P|X|CC|M|PT|sequence number| */
1831     0x7a, 0x62, 0x17, 0x0f,     /* |timestamp| */
1832     0x70, 0x23, 0x91, 0x38,     /* |synchronization source (SSRC) identifier| */
1833     0xbe, 0xde, 0x00, 0x02,     /* |0xBE|0xDE|length=2| */
1834     0x00, 0x00, 0x00, 0x00,     /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1835     0x00, 0x00, 0x00, 0x00,     /* |0 (pad)|0 (pad)|0 (pad)|0 (pad)| */
1836     0xff, 0xff, 0xff, 0xff      /* |dummy payload| */
1837   };
1838
1839   mem = malloc (sizeof (rtp_test_buffer));
1840   fail_unless (mem != NULL);
1841   memcpy (mem, rtp_test_buffer, sizeof (rtp_test_buffer));
1842   fail_unless_equals_int (memcmp (mem, rtp_test_buffer,
1843           sizeof (rtp_test_buffer)), 0);
1844
1845   buffer = gst_buffer_new_wrapped (mem, sizeof (rtp_test_buffer));
1846
1847   fail_unless (gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp));
1848
1849   fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1850           (gpointer) & pdata, &wordlen));
1851   fail_unless_equals_int (bits, 0xBEDE);
1852   fail_unless_equals_int (wordlen, 2);
1853   fail_unless_equals_int (pdata[0], 0x0);
1854   fail_unless_equals_int (pdata[1], 0x0);
1855   fail_unless_equals_int (pdata[2], 0x0);
1856   fail_unless_equals_int (pdata[3], 0x0);
1857   fail_unless_equals_int (pdata[4], 0x0);
1858   fail_unless_equals_int (pdata[5], 0x0);
1859   fail_unless_equals_int (pdata[6], 0x0);
1860   fail_unless_equals_int (pdata[7], 0x0);
1861
1862   fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 1,
1863           hdr_buffer_1, 2));
1864   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 1, 0,
1865           (gpointer *) & data_out, &size));
1866   fail_unless_equals_int (size, 2);
1867   fail_unless_equals_int (data_out[0], 0x1);
1868   fail_unless_equals_int (data_out[1], 0x1);
1869   fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits,
1870           (gpointer) & pdata, &wordlen));
1871   fail_unless_equals_int (bits, 0xBEDE);
1872   fail_unless_equals_int (wordlen, 2);
1873   fail_unless_equals_int (pdata[0], 0x11);
1874   fail_unless_equals_int (pdata[1], 0x1);
1875   fail_unless_equals_int (pdata[2], 0x1);
1876   fail_unless_equals_int (pdata[3], 0x0);
1877   fail_unless_equals_int (pdata[4], 0x0);
1878   fail_unless_equals_int (pdata[5], 0x0);
1879   fail_unless_equals_int (pdata[6], 0x0);
1880   fail_unless_equals_int (pdata[7], 0x0);
1881
1882   gst_rtp_buffer_unmap (&rtp);
1883
1884   gst_buffer_unref (buffer);
1885 }
1886
1887 GST_END_TEST;
1888
1889
1890 GST_START_TEST (test_ext_timestamp_basic)
1891 {
1892   guint64 exttimestamp = -1;
1893   guint64 result = 0;
1894
1895   /* no wraparound when timestamps are increasing */
1896   result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 0);
1897   fail_unless_equals_uint64 (result, 0);
1898   result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1899   fail_unless_equals_uint64 (result, 10);
1900   result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 10);
1901   fail_unless_equals_uint64 (result, 10);
1902   result = gst_rtp_buffer_ext_timestamp (&exttimestamp,
1903       G_GUINT64_CONSTANT (1) + G_MAXINT32);
1904   fail_unless_equals_uint64 (result, G_GUINT64_CONSTANT (1) + G_MAXINT32);
1905
1906   /* Even big bumps under G_MAXINT32 don't result in wrap-around */
1907   exttimestamp = -1;
1908   result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 1087500);
1909   fail_unless_equals_uint64 (result, 1087500);
1910   result = gst_rtp_buffer_ext_timestamp (&exttimestamp, 24);
1911   fail_unless_equals_uint64 (result, 24);
1912 }
1913
1914 GST_END_TEST;
1915
1916 GST_START_TEST (test_ext_timestamp_wraparound)
1917 {
1918   guint64 ext_ts = -1;
1919
1920   fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts,
1921           G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)),
1922       (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1923
1924   fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 0),
1925       G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1926
1927   fail_unless_equals_uint64 (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000),
1928       (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1929 }
1930
1931 GST_END_TEST;
1932
1933
1934 GST_START_TEST (test_ext_timestamp_wraparound_disordered)
1935 {
1936   guint64 ext_ts = -1;
1937
1938   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1939           G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1940       == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1941
1942   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 0)
1943       == G_MAXUINT32 + G_GUINT64_CONSTANT (1));
1944
1945   /* Unwrapping around */
1946   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1947           G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1))
1948       == (G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)));
1949
1950   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1951       == (G_MAXUINT32 + G_GUINT64_CONSTANT (1) + 90000));
1952 }
1953
1954 GST_END_TEST;
1955
1956 GST_START_TEST (test_ext_timestamp_wraparound_disordered_cannot_unwrap)
1957 {
1958   guint64 ext_ts = -1;
1959
1960   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1961       == 90000);
1962
1963   /* Cannot unwrapping around */
1964   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts,
1965           G_MAXUINT32 - 90000 + G_GUINT64_CONSTANT (1)) == 0);
1966
1967   fail_unless (gst_rtp_buffer_ext_timestamp (&ext_ts, 90000)
1968       == 90000);
1969 }
1970
1971 GST_END_TEST;
1972
1973 static gboolean
1974 set_rtcp_packet (GstBuffer * buffer, GstRTCPPacket * packet)
1975 {
1976   GstMapInfo map = GST_MAP_INFO_INIT;
1977   gboolean ret = FALSE;
1978   gssize fci_length;
1979
1980   if (!gst_buffer_map (buffer, &map, GST_MAP_READ)) {
1981     GST_WARNING_OBJECT (buffer, "Cannot map feedback buffer");
1982     return FALSE;
1983   }
1984
1985   fci_length = (map.size / 4) /* words of 4 bytes */ -3 /* skip RCTP header */ ;
1986   if (fci_length <= 0) {
1987     GST_WARNING ("Unexpected FCI length");
1988     goto end;
1989   }
1990
1991   if (!gst_rtcp_packet_fb_set_fci_length (packet, fci_length)) {
1992     /* No enough space in rtcp packet to add this report */
1993     GST_WARNING ("Could not set transport feedback FCI length");
1994     goto end;
1995   }
1996   // Copy the rtcp feedback message here
1997   memcpy (packet->rtcp->map.data + packet->offset, map.data, map.size);
1998
1999   ret = TRUE;
2000
2001 end:
2002   gst_buffer_unmap (buffer, &map);
2003
2004   return ret;
2005 }
2006
2007 static gboolean
2008 add_rtcp_packet (GstBuffer * rtcp_buffer, GstBuffer * buffer, GstRTCPType type)
2009 {
2010   GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
2011   gboolean rtcp_mapped = FALSE;
2012   GstRTCPPacket packet;
2013   gboolean ret = FALSE;
2014
2015   rtcp_mapped = gst_rtcp_buffer_map (rtcp_buffer, GST_MAP_READWRITE, &rtcp);
2016   if (!rtcp_mapped) {
2017     GST_WARNING_OBJECT (rtcp_buffer, "Cannot map buffer to RTCP");
2018     return FALSE;
2019   }
2020
2021   if (!gst_rtcp_buffer_add_packet (&rtcp, type, &packet)) {
2022     GST_DEBUG ("Cannot add RTCP packet");
2023     goto end;
2024   }
2025
2026   ret = set_rtcp_packet (buffer, &packet);
2027
2028 end:
2029   if (rtcp_mapped) {
2030     gst_rtcp_buffer_unmap (&rtcp);
2031   }
2032
2033   return ret;
2034 }
2035
2036 static GstBuffer *
2037 create_feedback_buffer (gboolean with_padding)
2038 {
2039   if (with_padding) {
2040     guint8 transport_wide_cc_padding_buffer[72] = {
2041       0xaf, 0xcd, 0x00, 0x11,
2042       0x7c, 0xbf, 0x7b, 0x00,
2043       0x4c, 0xc1, 0xe4, 0x69,
2044       0x00, 0x24, 0x00, 0x30,
2045       0x00, 0x00, 0x2c, 0x01,
2046       0x20, 0x30, 0x65, 0x0c,
2047       0x09, 0x0c, 0x0d, 0x08,
2048       0x2a, 0x16, 0x14, 0x14,
2049       0x16, 0x14, 0xcc, 0x00,
2050       0x14, 0x14, 0xcc, 0x8e,
2051       0x01, 0xa3, 0x02, 0x14,
2052       0x16, 0x50, 0x00, 0x16,
2053       0x7b, 0x01, 0x17, 0x14,
2054       0x94, 0x01, 0x15, 0x11,
2055       0x18, 0x16, 0x15, 0x90,
2056       0x01, 0x13, 0x15, 0x2a,
2057       0x00, 0x17, 0x17, 0x4f,
2058       0x00, 0x14, 0x00, 0x02,
2059     };
2060
2061     return gst_buffer_new_wrapped (g_memdup (transport_wide_cc_padding_buffer,
2062             sizeof (transport_wide_cc_padding_buffer)),
2063         sizeof (transport_wide_cc_padding_buffer));
2064   } else {
2065     guint8 transport_wide_cc_buffer[36] = {
2066       0x8f, 0xcd, 0x00, 0x08,
2067       0x7c, 0xbf, 0x7b, 0x00,
2068       0x4c, 0xc1, 0xe4, 0x69,
2069       0x19, 0xbc, 0x00, 0x0e,
2070       0x00, 0x02, 0x3c, 0x33,
2071       0x20, 0x0e, 0x02, 0x28,
2072       0x15, 0x15, 0x14, 0x17,
2073       0x14, 0x14, 0x15, 0x29,
2074       0x18, 0x12, 0x15, 0x16,
2075     };
2076     return gst_buffer_new_wrapped (g_memdup (transport_wide_cc_buffer,
2077             sizeof (transport_wide_cc_buffer)),
2078         sizeof (transport_wide_cc_buffer));
2079   }
2080 }
2081
2082 static GstBuffer *
2083 create_remb_buffer ()
2084 {
2085   guint8 remb_buffer[20] = {
2086     0x8f, 0xce, 0x00, 0x04,
2087     0x00, 0x00, 0x00, 0x01,
2088     0x00, 0x00, 0x00, 0x00,
2089     0x52, 0x45, 0x4d, 0x42,
2090     0x00, 0x0b, 0xd0, 0x90,
2091   };
2092
2093   return gst_buffer_new_wrapped (g_memdup (remb_buffer, sizeof (remb_buffer)),
2094       sizeof (remb_buffer));
2095 }
2096
2097 static gboolean
2098 add_transport_wide_cc (GstBuffer * buffer, gboolean with_padding)
2099 {
2100   GstBuffer *feedback;
2101   gboolean ret;
2102
2103   feedback = create_feedback_buffer (with_padding);
2104   ret = add_rtcp_packet (buffer, feedback, GST_RTCP_TYPE_RTPFB);
2105   gst_buffer_unref (feedback);
2106
2107   return ret;
2108 }
2109
2110 static gboolean
2111 add_remb (GstBuffer * buffer)
2112 {
2113   GstBuffer *remb;
2114   gboolean ret;
2115
2116   remb = create_remb_buffer ();
2117   ret = add_rtcp_packet (buffer, remb, GST_RTCP_TYPE_PSFB);
2118   gst_buffer_unref (remb);
2119
2120   return ret;
2121 }
2122
2123 GST_START_TEST (test_rtcp_compound_padding)
2124 {
2125   GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
2126   GstRTCPPacket *rtcp_packet = NULL;
2127   GstBuffer *rtcp_buffer;
2128
2129   rtcp_buffer = gst_rtcp_buffer_new (1400);
2130
2131   fail_unless (gst_rtcp_buffer_map (rtcp_buffer, GST_MAP_READWRITE, &rtcp));
2132   rtcp_packet = g_slice_new0 (GstRTCPPacket);
2133   fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_RR,
2134           rtcp_packet));
2135   gst_rtcp_packet_rr_set_ssrc (rtcp_packet, 1);
2136   g_slice_free (GstRTCPPacket, rtcp_packet);
2137   gst_rtcp_buffer_unmap (&rtcp);
2138
2139   fail_unless (gst_rtcp_buffer_validate (rtcp_buffer));
2140
2141   fail_unless (add_remb (rtcp_buffer));
2142   fail_unless (add_transport_wide_cc (rtcp_buffer, FALSE));
2143   /* Last packet did not have padding so we can add more packets */
2144   fail_unless (add_remb (rtcp_buffer));
2145
2146   fail_unless (add_transport_wide_cc (rtcp_buffer, TRUE));
2147   /* Last packet has padding so we are not allow to add more */
2148   fail_if (add_remb (rtcp_buffer));
2149
2150   gst_buffer_unref (rtcp_buffer);
2151 }
2152
2153 GST_END_TEST;
2154
2155 static Suite *
2156 rtp_suite (void)
2157 {
2158   Suite *s = suite_create ("rtp support library");
2159   TCase *tc_chain = tcase_create ("general");
2160
2161   suite_add_tcase (s, tc_chain);
2162   tcase_add_test (tc_chain, test_rtp_buffer);
2163   tcase_add_test (tc_chain, test_rtp_buffer_validate_corrupt);
2164   tcase_add_test (tc_chain, test_rtp_buffer_validate_padding);
2165   tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data);
2166   //tcase_add_test (tc_chain, test_rtp_buffer_list_set_extension);
2167   tcase_add_test (tc_chain, test_rtp_seqnum_compare);
2168
2169   tcase_add_test (tc_chain, test_rtcp_buffer);
2170   tcase_add_test (tc_chain, test_rtcp_reduced_buffer);
2171   tcase_add_test (tc_chain, test_rtcp_validate_with_padding);
2172   tcase_add_test (tc_chain, test_rtcp_validate_with_padding_wrong_padlength);
2173   tcase_add_test (tc_chain,
2174       test_rtcp_validate_with_padding_excluded_from_length);
2175   tcase_add_test (tc_chain,
2176       test_rtcp_validate_with_padding_set_in_first_packet);
2177   tcase_add_test (tc_chain, test_rtcp_validate_reduced_without_padding);
2178   tcase_add_test (tc_chain, test_rtcp_validate_reduced_with_padding);
2179   tcase_add_test (tc_chain, test_rtcp_buffer_profile_specific_extension);
2180   tcase_add_test (tc_chain, test_rtcp_buffer_app);
2181   tcase_add_test (tc_chain, test_rtcp_buffer_xr);
2182   tcase_add_test (tc_chain, test_rtcp_buffer_xr_rle);
2183   tcase_add_test (tc_chain, test_rtcp_buffer_xr_prt);
2184   tcase_add_test (tc_chain, test_rtcp_buffer_xr_rrt);
2185   tcase_add_test (tc_chain, test_rtcp_buffer_xr_dlrr);
2186   tcase_add_test (tc_chain, test_rtcp_buffer_xr_ssumm);
2187   tcase_add_test (tc_chain, test_rtcp_buffer_xr_voipmtrx);
2188
2189   tcase_add_test (tc_chain, test_rtp_ntp64_extension);
2190   tcase_add_test (tc_chain, test_rtp_ntp56_extension);
2191
2192   tcase_add_test (tc_chain, test_rtp_buffer_get_payload_bytes);
2193   tcase_add_test (tc_chain, test_rtp_buffer_get_extension_bytes);
2194   tcase_add_test (tc_chain, test_rtp_buffer_empty_payload);
2195
2196   tcase_add_test (tc_chain,
2197       test_rtp_buffer_extension_onebyte_header_full_padding);
2198
2199   //tcase_add_test (tc_chain, test_rtp_buffer_list);
2200
2201   tcase_add_test (tc_chain, test_ext_timestamp_basic);
2202   tcase_add_test (tc_chain, test_ext_timestamp_wraparound);
2203   tcase_add_test (tc_chain, test_ext_timestamp_wraparound_disordered);
2204   tcase_add_test (tc_chain,
2205       test_ext_timestamp_wraparound_disordered_cannot_unwrap);
2206
2207   tcase_add_test (tc_chain, test_rtcp_compound_padding);
2208
2209   return s;
2210 }
2211
2212 GST_CHECK_MAIN (rtp);