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., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, 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/gstrtcpbuffer.h>
  29 #include <string.h>
  30
  31 #define RTP_HEADER_LEN 12
  32
  33 GST_START_TEST (test_rtp_buffer)
  34 {
  35   GstBuffer *buf;
  36   guint8 *data;
  37   gsize size;
  38   GstRTPBuffer rtp = { NULL, };
  39
  40   /* check GstRTPHeader structure alignment and packing */
  41   buf = gst_rtp_buffer_new_allocate (16, 4, 0);
  42   fail_unless (buf != NULL);
  43   data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
  44   fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4);
  45
  46   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
  47
  48   /* check defaults */
  49   fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
  50   fail_unless (gst_rtp_buffer_get_padding (&rtp) == FALSE);
  51   fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
  52   fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
  53   fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
  54   fail_unless (gst_rtp_buffer_get_payload_type (&rtp) == 0);
  55   fail_unless_equals_int (GST_READ_UINT16_BE (data), 0x8000);
  56
  57   /* check version in bitfield */
  58   gst_rtp_buffer_set_version (&rtp, 3);
  59   fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 3);
  60   fail_unless_equals_int ((data[0] & 0xC0) >> 6, 3);
  61   gst_rtp_buffer_set_version (&rtp, 2);
  62   fail_unless_equals_int (gst_rtp_buffer_get_version (&rtp), 2);
  63   fail_unless_equals_int ((data[0] & 0xC0) >> 6, 2);
  64
  65   /* check padding bit */
  66   gst_rtp_buffer_set_padding (&rtp, TRUE);
  67   fail_unless (gst_rtp_buffer_get_padding (&rtp) == TRUE);
  68   fail_unless_equals_int ((data[0] & 0x20) >> 5, 1);
  69   gst_rtp_buffer_set_padding (&rtp, FALSE);
  70   fail_unless (gst_rtp_buffer_get_padding (&rtp) == FALSE);
  71   fail_unless_equals_int ((data[0] & 0x20) >> 5, 0);
  72
  73   /* check marker bit */
  74   gst_rtp_buffer_set_marker (&rtp, TRUE);
  75   fail_unless (gst_rtp_buffer_get_marker (&rtp) == TRUE);
  76   fail_unless_equals_int ((data[1] & 0x80) >> 7, 1);
  77   gst_rtp_buffer_set_marker (&rtp, FALSE);
  78   fail_unless (gst_rtp_buffer_get_marker (&rtp) == FALSE);
  79   fail_unless_equals_int ((data[1] & 0x80) >> 7, 0);
  80
  81   /* check sequence offset */
  82   gst_rtp_buffer_set_seq (&rtp, 0xF2C9);
  83   fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0xF2C9);
  84   fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0xF2C9);
  85   gst_rtp_buffer_set_seq (&rtp, 0);
  86   fail_unless_equals_int (gst_rtp_buffer_get_seq (&rtp), 0);
  87   fail_unless_equals_int (GST_READ_UINT16_BE (data + 2), 0);
  88
  89   /* check timestamp offset */
  90   gst_rtp_buffer_set_timestamp (&rtp, 432191);
  91   fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 432191);
  92   fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 432191);
  93   gst_rtp_buffer_set_timestamp (&rtp, 0);
  94   fail_unless_equals_int (gst_rtp_buffer_get_timestamp (&rtp), 0);
  95   fail_unless_equals_int (GST_READ_UINT32_BE (data + 4), 0);
  96
  97   /* check ssrc offset */
  98   gst_rtp_buffer_set_ssrc (&rtp, 0xf04043C2);
  99   fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), (gint) 0xf04043c2);
 100   fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), (gint) 0xf04043c2);
 101   gst_rtp_buffer_set_ssrc (&rtp, 0);
 102   fail_unless_equals_int (gst_rtp_buffer_get_ssrc (&rtp), 0);
 103   fail_unless_equals_int (GST_READ_UINT32_BE (data + 4 + 4), 0);
 104
 105   /* check csrc bits */
 106   fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 0);
 107   ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 0));
 108   fail_unless_equals_int (data[0] & 0xf, 0);
 109
 110   gst_rtp_buffer_unmap (&rtp);
 111   gst_buffer_unmap (buf, data, size);
 112   gst_buffer_unref (buf);
 113
 114   /* and again, this time with CSRCs */
 115   buf = gst_rtp_buffer_new_allocate (16, 4, 3);
 116   fail_unless (buf != NULL);
 117   data = gst_buffer_map (buf, &size, NULL, GST_MAP_READWRITE);
 118   fail_unless_equals_int (size, RTP_HEADER_LEN + 16 + 4 + 4 * 3);
 119
 120   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
 121
 122   fail_unless_equals_int (gst_rtp_buffer_get_csrc_count (&rtp), 3);
 123   ASSERT_CRITICAL (gst_rtp_buffer_get_csrc (&rtp, 3));
 124   fail_unless_equals_int (data[0] & 0xf, 3);
 125   fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 0), 0);
 126   fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 1), 0);
 127   fail_unless_equals_int (gst_rtp_buffer_get_csrc (&rtp, 2), 0);
 128
 129   data += RTP_HEADER_LEN;       /* skip the other header stuff */
 130   gst_rtp_buffer_set_csrc (&rtp, 0, 0xf7c0);
 131   fail_unless_equals_int (GST_READ_UINT32_BE (data + 0 * 4), 0xf7c0);
 132   gst_rtp_buffer_set_csrc (&rtp, 1, 0xf7c1);
 133   fail_unless_equals_int (GST_READ_UINT32_BE (data + 1 * 4), 0xf7c1);
 134   gst_rtp_buffer_set_csrc (&rtp, 2, 0xf7c2);
 135   fail_unless_equals_int (GST_READ_UINT32_BE (data + 2 * 4), 0xf7c2);
 136   ASSERT_CRITICAL (gst_rtp_buffer_set_csrc (&rtp, 3, 0xf123));
 137
 138   gst_rtp_buffer_unmap (&rtp);
 139   gst_buffer_unmap (buf, data, size);
 140   gst_buffer_unref (buf);
 141 }
 142
 143 GST_END_TEST;
 144
 145 GST_START_TEST (test_rtp_buffer_validate_corrupt)
 146 {
 147   GstBuffer *buf;
 148   guint8 corrupt_rtp_packet[58] = {
 149     0x90, 0x7a, 0xbf, 0x28, 0x3a, 0x8a, 0x0a, 0xf4, 0x69, 0x6b, 0x76, 0xc0,
 150     0x21, 0xe0, 0xe0, 0x60, 0x81, 0x10, 0x84, 0x30, 0x21, 0x52, 0x06, 0xc2,
 151     0xb8, 0x30, 0x10, 0x4c, 0x08, 0x62, 0x67, 0xc2, 0x6e, 0x1a, 0x53, 0x3f,
 152     0xaf, 0xd6, 0x1b, 0x29, 0x40, 0xe0, 0xa5, 0x83, 0x01, 0x4b, 0x04, 0x02,
 153     0xb0, 0x97, 0x63, 0x08, 0x10, 0x4b, 0x43, 0x85, 0x37, 0x2c
 154   };
 155
 156   buf = gst_buffer_new_and_alloc (sizeof (corrupt_rtp_packet));
 157   gst_buffer_fill (buf, 0, corrupt_rtp_packet, sizeof (corrupt_rtp_packet));
 158   fail_if (gst_rtp_buffer_validate (buf));
 159   gst_buffer_unref (buf);
 160 }
 161
 162 GST_END_TEST;
 163
 164 #if 0
 165 GST_START_TEST (test_rtp_buffer_list)
 166 {
 167   GstBuffer *rtp_header;
 168   GstBuffer *rtp_payload;
 169   GstBufferList *list = NULL;
 170   GstBufferListIterator *it;
 171   guint i;
 172
 173   list = gst_buffer_list_new ();
 174   it = gst_buffer_list_iterate (list);
 175
 176   /* Creating a list of two RTP packages */
 177
 178   /* Create first group to hold the rtp header and the payload */
 179   gst_buffer_list_iterator_add_group (it);
 180   rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
 181   gst_buffer_list_iterator_add (it, rtp_header);
 182   rtp_payload = gst_buffer_new_and_alloc (42);
 183   gst_buffer_list_iterator_add (it, rtp_payload);
 184
 185   /* Create second group to hold an rtp header and a payload */
 186   gst_buffer_list_iterator_add_group (it);
 187   rtp_header = gst_rtp_buffer_new_allocate (0, 0, 0);
 188   gst_buffer_list_iterator_add (it, rtp_header);
 189   rtp_payload = gst_buffer_new_and_alloc (42);
 190   gst_buffer_list_iterator_add (it, rtp_payload);
 191
 192   gst_buffer_list_iterator_free (it);
 193
 194   /* Test SEQ number */
 195   i = gst_rtp_buffer_list_set_seq (list, 1024);
 196   fail_if (1026 != i);
 197   fail_if (!gst_rtp_buffer_list_validate (list));
 198
 199   /* Timestamp */
 200   gst_rtp_buffer_list_set_timestamp (list, 432191);
 201   fail_unless_equals_int (gst_rtp_buffer_list_get_timestamp (list), 432191);
 202
 203   /* SSRC */
 204   gst_rtp_buffer_list_set_ssrc (list, 0xf04043C2);
 205   fail_unless_equals_int (gst_rtp_buffer_list_get_ssrc (list),
 206       (gint) 0xf04043c2);
 207
 208   /* Payload type */
 209   gst_rtp_buffer_list_set_payload_type (list, 127);
 210   fail_unless_equals_int (gst_rtp_buffer_list_get_payload_type (list), 127);
 211
 212   gst_buffer_list_unref (list);
 213 }
 214
 215 GST_END_TEST;
 216 #endif
 217
 218 GST_START_TEST (test_rtp_buffer_set_extension_data)
 219 {
 220   GstBuffer *buf;
 221   guint8 *data;
 222   guint16 bits;
 223   guint size;
 224   guint8 misc_data[4] = { 1, 2, 3, 4 };
 225   gpointer pointer;
 226   guint8 appbits;
 227   gsize bsize;
 228   GstRTPBuffer rtp = { NULL, };
 229
 230   /* check GstRTPHeader structure alignment and packing */
 231   buf = gst_rtp_buffer_new_allocate (4, 0, 0);
 232   data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READWRITE);
 233
 234   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
 235
 236   /* should be impossible to set the extension data */
 237   ASSERT_WARNING (fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 0,
 238               4) == FALSE));
 239   fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
 240
 241   /* should be possible to set the extension data */
 242   fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 270, 0) == TRUE);
 243   fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
 244   gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
 245   fail_unless (bits == 270);
 246   fail_unless (size == 0);
 247   fail_unless (pointer == data + 16);
 248   pointer = gst_rtp_buffer_get_payload (&rtp);
 249   fail_unless (pointer == data + 16);
 250
 251   gst_buffer_unmap (buf, data, bsize);
 252   gst_rtp_buffer_unmap (&rtp);
 253   gst_buffer_unref (buf);
 254
 255   buf = gst_rtp_buffer_new_allocate (20, 0, 0);
 256   data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READWRITE);
 257   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
 258
 259   fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
 260   fail_unless (gst_rtp_buffer_set_extension_data (&rtp, 333, 2) == TRUE);
 261   fail_unless (gst_rtp_buffer_get_extension (&rtp) == TRUE);
 262   gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer, &size);
 263   fail_unless (bits == 333);
 264   fail_unless (size == 2);
 265   fail_unless (pointer == data + 16);
 266   pointer = gst_rtp_buffer_get_payload (&rtp);
 267   fail_unless (pointer == data + 24);
 268
 269   gst_buffer_unmap (buf, data, bsize);
 270   gst_rtp_buffer_unmap (&rtp);
 271   gst_buffer_unref (buf);
 272
 273   /* Test header extensions with a one byte header */
 274   buf = gst_rtp_buffer_new_allocate (20, 0, 0);
 275   data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READWRITE);
 276   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
 277
 278   fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
 279
 280   fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
 281           misc_data, 2) == TRUE);
 282   fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
 283           &size));
 284   fail_unless (bits == 0xBEDE);
 285   fail_unless (size == 1);
 286   data = (guint8 *) pointer;
 287   fail_unless (data[0] == ((5 << 4) | 1));
 288   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
 289           1, &pointer, &size) == FALSE);
 290   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 291           1, &pointer, &size) == FALSE);
 292   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 293           0, &pointer, &size) == TRUE);
 294   fail_unless (size == 2);
 295   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 296
 297   fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 5,
 298           misc_data, 4) == TRUE);
 299   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 300           0, &pointer, &size) == TRUE);
 301   fail_unless (size == 2);
 302   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 303   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 304           1, &pointer, &size) == TRUE);
 305   fail_unless (size == 4);
 306   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 307   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 308           2, &pointer, &size) == FALSE);
 309   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
 310           1, &pointer, &size) == FALSE);
 311
 312   fail_unless (gst_rtp_buffer_add_extension_onebyte_header (&rtp, 6,
 313           misc_data, 2) == TRUE);
 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   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 319           1, &pointer, &size) == TRUE);
 320   fail_unless (size == 4);
 321   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 322   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 323           3, &pointer, &size) == FALSE);
 324   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 2,
 325           1, &pointer, &size) == FALSE);
 326   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 6,
 327           2, &pointer, &size) == FALSE);
 328   fail_unless (gst_rtp_buffer_get_extension_onebyte_header (&rtp, 5,
 329           0, &pointer, &size) == TRUE);
 330   fail_unless (size == 2);
 331   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 332
 333   gst_buffer_unmap (buf, data, bsize);
 334   gst_rtp_buffer_unmap (&rtp);
 335   gst_buffer_unref (buf);
 336
 337   /* Test header extensions with a two bytes header */
 338   buf = gst_rtp_buffer_new_allocate (20, 0, 0);
 339   data = gst_buffer_map (buf, &bsize, NULL, GST_MAP_READWRITE);
 340   gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp);
 341
 342   fail_unless (gst_rtp_buffer_get_extension (&rtp) == FALSE);
 343
 344   fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
 345           misc_data, 2) == TRUE);
 346   fail_unless (gst_rtp_buffer_get_extension_data (&rtp, &bits, &pointer,
 347           &size));
 348   fail_unless (bits == 0x100 << 4);
 349   fail_unless (size == 1);
 350   data = (guint8 *) pointer;
 351   fail_unless (data[0] == 5);
 352   fail_unless (data[1] == 2);
 353   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
 354           0, &pointer, &size) == FALSE);
 355   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 356           1, &pointer, &size) == FALSE);
 357   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 358           0, &pointer, &size) == TRUE);
 359   fail_unless (size == 2);
 360   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 361
 362   fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 5,
 363           misc_data, 4) == TRUE);
 364   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 365           0, &pointer, &size) == TRUE);
 366   fail_unless (size == 2);
 367   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 368   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 369           1, &pointer, &size) == TRUE);
 370   fail_unless (size == 4);
 371   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 372   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 373           2, &pointer, &size) == FALSE);
 374   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
 375           0, &pointer, &size) == FALSE);
 376
 377   fail_unless (gst_rtp_buffer_add_extension_twobytes_header (&rtp, 0, 6,
 378           misc_data, 2) == TRUE);
 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   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 384           1, &pointer, &size) == TRUE);
 385   fail_unless (size == 4);
 386   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 387   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 388           2, &pointer, &size) == FALSE);
 389   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 2,
 390           0, &pointer, &size) == FALSE);
 391   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 6,
 392           1, &pointer, &size) == FALSE);
 393   fail_unless (gst_rtp_buffer_get_extension_twobytes_header (&rtp, &appbits, 5,
 394           0, &pointer, &size) == TRUE);
 395   fail_unless (size == 2);
 396   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 397
 398   gst_buffer_unmap (buf, data, bsize);
 399   gst_rtp_buffer_unmap (&rtp);
 400   gst_buffer_unref (buf);
 401 }
 402
 403 GST_END_TEST;
 404
 405 #if 0
 406 GST_START_TEST (test_rtp_buffer_list_set_extension)
 407 {
 408   GstBufferList *list;
 409   GstBuffer *buf;
 410   guint8 *data;
 411   guint16 bits;
 412   guint size;
 413   guint8 misc_data[4] = { 1, 2, 3, 4 };
 414   gpointer pointer;
 415   guint8 appbits;
 416   GstBufferListIterator *it;
 417
 418   buf = gst_rtp_buffer_new_allocate (20, 0, 0);
 419   list = gst_rtp_buffer_list_from_buffer (buf);
 420   gst_buffer_unref (buf);
 421
 422   it = gst_buffer_list_iterate (list);
 423   fail_unless (gst_buffer_list_iterator_next_group (it));
 424   buf = gst_buffer_list_iterator_next (it);
 425   fail_unless (buf != NULL);
 426   fail_unless (GST_BUFFER_SIZE (buf) == 12);
 427   buf = gst_buffer_list_iterator_next (it);
 428   fail_unless (buf != NULL);
 429   fail_unless (GST_BUFFER_SIZE (buf) == 20);
 430   gst_buffer_list_iterator_free (it);
 431
 432   /* Test header extensions with a one byte header */
 433   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
 434           1, &pointer, &size) == FALSE);
 435
 436   it = gst_buffer_list_iterate (list);
 437   fail_unless (gst_buffer_list_iterator_next_group (it));
 438   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 439   fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
 440           misc_data, 2) == TRUE);
 441   gst_buffer_list_iterator_free (it);
 442   it = gst_buffer_list_iterate (list);
 443   fail_unless (gst_buffer_list_iterator_next_group (it));
 444   buf = gst_buffer_list_iterator_next (it);
 445   fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
 446   fail_unless (bits == 0xBEDE);
 447   fail_unless (size == 1);
 448   data = (guint8 *) pointer;
 449   fail_unless (data[0] == ((5 << 4) | 1));
 450   gst_buffer_list_iterator_free (it);
 451   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
 452           0, &pointer, &size) == FALSE);
 453   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 454           1, &pointer, &size) == FALSE);
 455   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 456           0, &pointer, &size) == TRUE);
 457   fail_unless (size == 2);
 458   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 459
 460   it = gst_buffer_list_iterate (list);
 461   fail_unless (gst_buffer_list_iterator_next_group (it));
 462   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 463   fail_unless (gst_rtp_buffer_list_add_extension_onebyte_header (it, 5,
 464           misc_data, 4) == TRUE);
 465   gst_buffer_list_iterator_free (it);
 466   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 467           0, &pointer, &size) == TRUE);
 468   fail_unless (size == 2);
 469   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 470   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 471           1, &pointer, &size) == TRUE);
 472   fail_unless (size == 4);
 473   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 474   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 475           2, &pointer, &size) == FALSE);
 476   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 2,
 477           0, &pointer, &size) == FALSE);
 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, 6,
 483           misc_data, 2) == 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   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 6,
 498           1, &pointer, &size) == FALSE);
 499   fail_unless (gst_rtp_buffer_list_get_extension_onebyte_header (list, 0, 5,
 500           0, &pointer, &size) == TRUE);
 501   fail_unless (size == 2);
 502   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 503   gst_buffer_list_unref (list);
 504
 505
 506   /* Test header extensions with a two bytes header */
 507   buf = gst_rtp_buffer_new_allocate (20, 0, 0);
 508   list = gst_rtp_buffer_list_from_buffer (buf);
 509   gst_buffer_unref (buf);
 510
 511   it = gst_buffer_list_iterate (list);
 512   fail_unless (gst_buffer_list_iterator_next_group (it));
 513   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 514   fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
 515           misc_data, 2) == TRUE);
 516   gst_buffer_list_iterator_free (it);
 517
 518   it = gst_buffer_list_iterate (list);
 519   fail_unless (gst_buffer_list_iterator_next_group (it));
 520   buf = gst_buffer_list_iterator_next (it);
 521   fail_unless (gst_rtp_buffer_get_extension_data (buf, &bits, &pointer, &size));
 522   fail_unless (bits == 0x100 << 4);
 523   fail_unless (size == 1);
 524   data = (guint8 *) pointer;
 525   fail_unless (data[0] == 5);
 526   fail_unless (data[1] == 2);
 527   gst_buffer_list_iterator_free (it);
 528   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 529           &appbits, 2, 0, &pointer, &size) == FALSE);
 530   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 531           &appbits, 5, 1, &pointer, &size) == FALSE);
 532   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 533           &appbits, 5, 0, &pointer, &size) == TRUE);
 534   fail_unless (size == 2);
 535   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 536
 537   it = gst_buffer_list_iterate (list);
 538   fail_unless (gst_buffer_list_iterator_next_group (it));
 539   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 540   fail_unless (gst_rtp_buffer_list_add_extension_twobytes_header (it, 0, 5,
 541           misc_data, 4) == TRUE);
 542   gst_buffer_list_iterator_free (it);
 543   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 544           &appbits, 5, 0, &pointer, &size) == TRUE);
 545   fail_unless (size == 2);
 546   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 547   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 548           &appbits, 5, 1, &pointer, &size) == TRUE);
 549   fail_unless (size == 4);
 550   fail_unless (memcmp (pointer, misc_data, 4) == 0);
 551   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 552           &appbits, 5, 2, &pointer, &size) == FALSE);
 553   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 554           &appbits, 2, 0, &pointer, &size) == FALSE);
 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, 6,
 560           misc_data, 2) == 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   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 575           &appbits, 6, 1, &pointer, &size) == FALSE);
 576   fail_unless (gst_rtp_buffer_list_get_extension_twobytes_header (list, 0,
 577           &appbits, 5, 0, &pointer, &size) == TRUE);
 578   fail_unless (size == 2);
 579   fail_unless (memcmp (pointer, misc_data, 2) == 0);
 580
 581   gst_buffer_list_unref (list);
 582 }
 583
 584 GST_END_TEST;
 585 #endif
 586
 587 GST_START_TEST (test_rtp_seqnum_compare)
 588 {
 589 #define ASSERT_COMP(a,b,c) fail_unless (gst_rtp_buffer_compare_seqnum ((guint16)a,(guint16)b) == c);
 590   ASSERT_COMP (0xfffe, 0xfffd, -1);
 591   ASSERT_COMP (0xffff, 0xfffe, -1);
 592   ASSERT_COMP (0x0000, 0xffff, -1);
 593   ASSERT_COMP (0x0001, 0x0000, -1);
 594   ASSERT_COMP (0x0002, 0x0001, -1);
 595
 596   ASSERT_COMP (0xffff, 0xfffd, -2);
 597   ASSERT_COMP (0x0000, 0xfffd, -3);
 598   ASSERT_COMP (0x0001, 0xfffd, -4);
 599   ASSERT_COMP (0x0002, 0xfffd, -5);
 600
 601   ASSERT_COMP (0x7ffe, 0x7ffd, -1);
 602   ASSERT_COMP (0x7fff, 0x7ffe, -1);
 603   ASSERT_COMP (0x8000, 0x7fff, -1);
 604   ASSERT_COMP (0x8001, 0x8000, -1);
 605   ASSERT_COMP (0x8002, 0x8001, -1);
 606
 607   ASSERT_COMP (0x7fff, 0x7ffd, -2);
 608   ASSERT_COMP (0x8000, 0x7ffd, -3);
 609   ASSERT_COMP (0x8001, 0x7ffd, -4);
 610   ASSERT_COMP (0x8002, 0x7ffd, -5);
 611
 612   ASSERT_COMP (0x7ffd, 0xffff, -0x7ffe);
 613   ASSERT_COMP (0x7ffe, 0x0000, -0x7ffe);
 614   ASSERT_COMP (0x7fff, 0x0001, -0x7ffe);
 615   ASSERT_COMP (0x7fff, 0x0000, -0x7fff);
 616   ASSERT_COMP (0x8000, 0x0001, -0x7fff);
 617   ASSERT_COMP (0x8001, 0x0002, -0x7fff);
 618
 619   ASSERT_COMP (0xfffd, 0x7ffe, -0x7fff);
 620   ASSERT_COMP (0xfffe, 0x7fff, -0x7fff);
 621   ASSERT_COMP (0xffff, 0x8000, -0x7fff);
 622   ASSERT_COMP (0x0000, 0x8001, -0x7fff);
 623   ASSERT_COMP (0x0001, 0x8002, -0x7fff);
 624
 625   ASSERT_COMP (0xfffe, 0x7ffe, -0x8000);
 626   ASSERT_COMP (0xffff, 0x7fff, -0x8000);
 627   ASSERT_COMP (0x0000, 0x8000, -0x8000);
 628   ASSERT_COMP (0x0001, 0x8001, -0x8000);
 629
 630   ASSERT_COMP (0x7ffe, 0xfffe, -0x8000);
 631   ASSERT_COMP (0x7fff, 0xffff, -0x8000);
 632   ASSERT_COMP (0x8000, 0x0000, -0x8000);
 633   ASSERT_COMP (0x8001, 0x0001, -0x8000);
 634
 635   ASSERT_COMP (0x0001, 0x0002, 1);
 636   ASSERT_COMP (0x0000, 0x0001, 1);
 637   ASSERT_COMP (0xffff, 0x0000, 1);
 638   ASSERT_COMP (0xfffe, 0xffff, 1);
 639   ASSERT_COMP (0xfffd, 0xfffe, 1);
 640
 641   ASSERT_COMP (0x0000, 0x0002, 2);
 642   ASSERT_COMP (0xffff, 0x0002, 3);
 643   ASSERT_COMP (0xfffe, 0x0002, 4);
 644   ASSERT_COMP (0xfffd, 0x0002, 5);
 645
 646   ASSERT_COMP (0x8001, 0x8002, 1);
 647   ASSERT_COMP (0x8000, 0x8001, 1);
 648   ASSERT_COMP (0x7fff, 0x8000, 1);
 649   ASSERT_COMP (0x7ffe, 0x7fff, 1);
 650   ASSERT_COMP (0x7ffd, 0x7ffe, 1);
 651
 652   ASSERT_COMP (0x8000, 0x8002, 2);
 653   ASSERT_COMP (0x7fff, 0x8002, 3);
 654   ASSERT_COMP (0x7ffe, 0x8002, 4);
 655   ASSERT_COMP (0x7ffd, 0x8002, 5);
 656
 657   ASSERT_COMP (0xfffe, 0x7ffd, 0x7fff);
 658   ASSERT_COMP (0xffff, 0x7ffe, 0x7fff);
 659   ASSERT_COMP (0x0000, 0x7fff, 0x7fff);
 660   ASSERT_COMP (0x0001, 0x8000, 0x7fff);
 661   ASSERT_COMP (0x0002, 0x8001, 0x7fff);
 662
 663   ASSERT_COMP (0x7ffe, 0xfffd, 0x7fff);
 664   ASSERT_COMP (0x7fff, 0xfffe, 0x7fff);
 665   ASSERT_COMP (0x8000, 0xffff, 0x7fff);
 666   ASSERT_COMP (0x8001, 0x0000, 0x7fff);
 667   ASSERT_COMP (0x8002, 0x0001, 0x7fff);
 668 #undef ASSERT_COMP
 669 }
 670
 671 GST_END_TEST;
 672
 673 GST_START_TEST (test_rtcp_buffer)
 674 {
 675   GstBuffer *buf;
 676   GstRTCPPacket packet;
 677   GstRTCPBuffer rtcp = { NULL, };
 678
 679   buf = gst_rtcp_buffer_new (1400);
 680   fail_unless (buf != NULL);
 681   fail_unless_equals_int (gst_buffer_get_size (buf), 1400);
 682
 683   gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp);
 684
 685   fail_unless (gst_rtcp_buffer_validate (buf) == FALSE);
 686   fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == FALSE);
 687   fail_unless (gst_rtcp_buffer_get_packet_count (&rtcp) == 0);
 688
 689   /* add an SR packet */
 690   fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SR,
 691           &packet) == TRUE);
 692
 693   fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
 694   fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
 695   fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
 696   fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
 697
 698   gst_rtcp_packet_sr_set_sender_info (&packet, 0x44556677,
 699       G_GUINT64_CONSTANT (1), 0x11111111, 101, 123456);
 700   {
 701     guint32 ssrc;
 702     guint64 ntptime;
 703     guint32 rtptime;
 704     guint32 packet_count;
 705     guint32 octet_count;
 706
 707     gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, &ntptime, &rtptime,
 708         &packet_count, &octet_count);
 709
 710     fail_unless (ssrc == 0x44556677);
 711     fail_unless (ntptime == G_GUINT64_CONSTANT (1));
 712     fail_unless (rtptime == 0x11111111);
 713     fail_unless (packet_count == 101);
 714     fail_unless (octet_count == 123456);
 715   }
 716
 717   /* go to first packet, this should be the packet we just added */
 718   fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
 719
 720   fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
 721   fail_unless (gst_rtcp_packet_get_count (&packet) == 0);
 722   fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SR);
 723   fail_unless (gst_rtcp_packet_get_length (&packet) == 6);
 724
 725   fail_unless (gst_rtcp_packet_move_to_next (&packet) == FALSE);
 726
 727   /* add some SDES */
 728   fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_SDES,
 729           &packet) == TRUE);
 730   fail_unless (gst_rtcp_packet_sdes_add_item (&packet, 0xff658743) == TRUE);
 731   fail_unless (gst_rtcp_packet_sdes_add_entry (&packet, GST_RTCP_SDES_CNAME,
 732           sizeof ("test@foo.bar"), (guint8 *) "test@foo.bar") == TRUE);
 733
 734   /* add some BYE */
 735   fail_unless (gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_BYE,
 736           &packet) == TRUE);
 737   fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x5613212f) == TRUE);
 738   fail_unless (gst_rtcp_packet_bye_add_ssrc (&packet, 0x00112233) == TRUE);
 739   fail_unless (gst_rtcp_packet_bye_get_ssrc_count (&packet) == 2);
 740
 741   fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
 742   fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
 743   fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
 744   fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
 745
 746   /* move to SDES */
 747   fail_unless (gst_rtcp_buffer_get_first_packet (&rtcp, &packet) == TRUE);
 748   fail_unless (gst_rtcp_packet_move_to_next (&packet) == TRUE);
 749
 750   fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
 751   fail_unless (gst_rtcp_packet_get_count (&packet) == 1);
 752   fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_SDES);
 753   fail_unless (gst_rtcp_packet_get_length (&packet) == 5);
 754
 755   /* remove the SDES */
 756   fail_unless (gst_rtcp_packet_remove (&packet) == TRUE);
 757
 758   /* we are now at the BYE packet */
 759   fail_unless (gst_rtcp_packet_get_padding (&packet) == 0);
 760   fail_unless (gst_rtcp_packet_get_count (&packet) == 2);
 761   fail_unless (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_BYE);
 762   fail_unless (gst_rtcp_packet_get_length (&packet) == 2);
 763
 764   /* close and validate */
 765   gst_rtcp_buffer_unmap (&rtcp);
 766   fail_unless (gst_rtcp_buffer_validate (buf) == TRUE);
 767   gst_buffer_unref (buf);
 768 }
 769
 770 GST_END_TEST;
 771
 772 static Suite *
 773 rtp_suite (void)
 774 {
 775   Suite *s = suite_create ("rtp support library");
 776   TCase *tc_chain = tcase_create ("general");
 777
 778   suite_add_tcase (s, tc_chain);
 779   tcase_add_test (tc_chain, test_rtp_buffer);
 780   tcase_add_test (tc_chain, test_rtp_buffer_validate_corrupt);
 781   tcase_add_test (tc_chain, test_rtp_buffer_set_extension_data);
 782   //tcase_add_test (tc_chain, test_rtp_buffer_list_set_extension);
 783   tcase_add_test (tc_chain, test_rtp_seqnum_compare);
 784
 785   tcase_add_test (tc_chain, test_rtcp_buffer);
 786
 787   //tcase_add_test (tc_chain, test_rtp_buffer_list);
 788
 789   return s;
 790 }
 791
 792 int
 793 main (int argc, char **argv)
 794 {
 795   int nf;
 796
 797   Suite *s = rtp_suite ();
 798   SRunner *sr = srunner_create (s);
 799
 800   gst_check_init (&argc, &argv);
 801
 802   srunner_run_all (sr, CK_NORMAL);
 803   nf = srunner_ntests_failed (sr);
 804   srunner_free (sr);
 805
 806   return nf;
 807 }