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