tests/check/elements/rtp-payloading.c

   1 /* GStreamer RTP payloader unit tests
   2  * Copyright (C) 2008 Nokia Corporation and its subsidary(-ies)
   3  *               contact: <stefan.kost@nokia.com>
   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 #include <gst/check/gstcheck.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23
  24 #define RELEASE_ELEMENT(x) if(x) {gst_object_unref(x); x = NULL;}
  25
  26 #define LOOP_COUNT 1
  27
  28 /*
  29  * RTP pipeline structure to store the required elements.
  30  */
  31 typedef struct
  32 {
  33   GstElement *pipeline;
  34   GstElement *appsrc;
  35   GstElement *rtppay;
  36   GstElement *rtpdepay;
  37   GstElement *fakesink;
  38   const guint8 *frame_data;
  39   int frame_data_size;
  40   int frame_count;
  41 } rtp_pipeline;
  42
  43 /*
  44  * Number of bytes received in the chain list function when using buffer lists
  45  */
  46 static guint chain_list_bytes_received;
  47
  48 /*
  49  * Chain list function for testing buffer lists
  50  */
  51 static GstFlowReturn
  52 rtp_pipeline_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list)
  53 {
  54   guint i, len;
  55
  56   fail_if (!list);
  57   /*
  58    * Count the size of the payload in the buffer list.
  59    */
  60   len = gst_buffer_list_length (list);
  61
  62   /* Loop through all groups */
  63   for (i = 0; i < len; i++) {
  64     GstBuffer *paybuf;
  65     GstMemory *mem;
  66     gint size;
  67
  68     paybuf = gst_buffer_list_get (list, i);
  69     /* only count real data which is expected in last memory block */
  70     fail_unless (gst_buffer_n_memory (paybuf) > 1);
  71     mem = gst_buffer_get_memory_range (paybuf, gst_buffer_n_memory (paybuf) - 1,
  72         1);
  73     size = gst_memory_get_sizes (mem, NULL, NULL);
  74     gst_memory_unref (mem);
  75     chain_list_bytes_received += size;
  76   }
  77   gst_buffer_list_unref (list);
  78
  79   return GST_FLOW_OK;
  80 }
  81
  82 /*
  83  * RTP bus callback.
  84  */
  85 static gboolean
  86 rtp_bus_callback (GstBus * bus, GstMessage * message, gpointer data)
  87 {
  88   GMainLoop *mainloop = (GMainLoop *) data;
  89
  90   switch (GST_MESSAGE_TYPE (message)) {
  91     case GST_MESSAGE_ERROR:
  92     {
  93       GError *err;
  94
  95       gchar *debug;
  96
  97       gchar *element_name;
  98
  99       element_name = (message->src) ? gst_object_get_name (message->src) : NULL;
 100       gst_message_parse_error (message, &err, &debug);
 101       /* FIXME: should we fail the test here? */
 102       g_print ("\nError from element %s: %s\n%s\n\n",
 103           GST_STR_NULL (element_name), err->message, (debug) ? debug : "");
 104       g_error_free (err);
 105       g_free (debug);
 106       g_free (element_name);
 107
 108       g_main_loop_quit (mainloop);
 109     }
 110       break;
 111
 112     case GST_MESSAGE_EOS:
 113     {
 114       g_main_loop_quit (mainloop);
 115     }
 116       break;
 117       break;
 118
 119     default:
 120     {
 121     }
 122       break;
 123   }
 124
 125   return TRUE;
 126 }
 127
 128 /*
 129  * Creates a RTP pipeline for one test.
 130  * @param frame_data Pointer to the frame data which is used to pass thru pay/depayloaders.
 131  * @param frame_data_size Frame data size in bytes.
 132  * @param frame_count Frame count.
 133  * @param filtercaps Caps filters.
 134  * @param pay Payloader name.
 135  * @param depay Depayloader name.
 136  * @return
 137  * Returns pointer to the RTP pipeline.
 138  * The user must free the RTP pipeline when it's not used anymore.
 139  */
 140 static rtp_pipeline *
 141 rtp_pipeline_create (const guint8 * frame_data, int frame_data_size,
 142     int frame_count, const char *filtercaps, const char *pay, const char *depay)
 143 {
 144   gchar *pipeline_name;
 145   rtp_pipeline *p;
 146   GstCaps *caps;
 147
 148   /* Check parameters. */
 149   if (!frame_data || !pay || !depay) {
 150     return NULL;
 151   }
 152
 153   /* Allocate memory for the RTP pipeline. */
 154   p = (rtp_pipeline *) malloc (sizeof (rtp_pipeline));
 155
 156   p->frame_data = frame_data;
 157   p->frame_data_size = frame_data_size;
 158   p->frame_count = frame_count;
 159
 160   /* Create elements. */
 161   pipeline_name = g_strdup_printf ("%s-%s-pipeline", pay, depay);
 162   p->pipeline = gst_pipeline_new (pipeline_name);
 163   g_free (pipeline_name);
 164   p->appsrc = gst_element_factory_make ("appsrc", NULL);
 165   p->rtppay = gst_element_factory_make (pay, NULL);
 166   p->rtpdepay = gst_element_factory_make (depay, NULL);
 167   p->fakesink = gst_element_factory_make ("fakesink", NULL);
 168
 169   /* One or more elements are not created successfully or failed to create p? */
 170   if (!p->pipeline || !p->appsrc || !p->rtppay || !p->rtpdepay || !p->fakesink) {
 171     /* Release created elements. */
 172     RELEASE_ELEMENT (p->pipeline);
 173     RELEASE_ELEMENT (p->appsrc);
 174     RELEASE_ELEMENT (p->rtppay);
 175     RELEASE_ELEMENT (p->rtpdepay);
 176     RELEASE_ELEMENT (p->fakesink);
 177
 178     /* Release allocated memory. */
 179     free (p);
 180
 181     return NULL;
 182   }
 183
 184   /* Set src properties. */
 185   caps = gst_caps_from_string (filtercaps);
 186   g_object_set (p->appsrc, "do-timestamp", TRUE, "caps", caps,
 187       "format", GST_FORMAT_TIME, NULL);
 188   gst_caps_unref (caps);
 189
 190   /* Add elements to the pipeline. */
 191   gst_bin_add (GST_BIN (p->pipeline), p->appsrc);
 192   gst_bin_add (GST_BIN (p->pipeline), p->rtppay);
 193   gst_bin_add (GST_BIN (p->pipeline), p->rtpdepay);
 194   gst_bin_add (GST_BIN (p->pipeline), p->fakesink);
 195
 196   /* Link elements. */
 197   gst_element_link (p->appsrc, p->rtppay);
 198   gst_element_link (p->rtppay, p->rtpdepay);
 199   gst_element_link (p->rtpdepay, p->fakesink);
 200
 201   return p;
 202 }
 203
 204 /*
 205  * Destroys the RTP pipeline.
 206  * @param p Pointer to the RTP pipeline.
 207  */
 208 static void
 209 rtp_pipeline_destroy (rtp_pipeline * p)
 210 {
 211   /* Check parameters. */
 212   if (p == NULL) {
 213     return;
 214   }
 215
 216   /* Release pipeline. */
 217   RELEASE_ELEMENT (p->pipeline);
 218
 219   /* Release allocated memory. */
 220   free (p);
 221 }
 222
 223 /*
 224  * Runs the RTP pipeline.
 225  * @param p Pointer to the RTP pipeline.
 226  */
 227 static void
 228 rtp_pipeline_run (rtp_pipeline * p)
 229 {
 230   GstFlowReturn flow_ret;
 231   GMainLoop *mainloop = NULL;
 232   GstBus *bus;
 233   gint i, j;
 234
 235   /* Check parameters. */
 236   if (p == NULL) {
 237     return;
 238   }
 239
 240   /* Create mainloop. */
 241   mainloop = g_main_loop_new (NULL, FALSE);
 242   if (!mainloop) {
 243     return;
 244   }
 245
 246   /* Add bus callback. */
 247   bus = gst_pipeline_get_bus (GST_PIPELINE (p->pipeline));
 248
 249   gst_bus_add_watch (bus, rtp_bus_callback, (gpointer) mainloop);
 250   gst_object_unref (bus);
 251
 252   /* Set pipeline to PLAYING. */
 253   gst_element_set_state (p->pipeline, GST_STATE_PLAYING);
 254
 255   /* Push data into the pipeline */
 256   for (i = 0; i < LOOP_COUNT; i++) {
 257     const guint8 *data = p->frame_data;
 258
 259     for (j = 0; j < p->frame_count; j++) {
 260       GstBuffer *buf;
 261
 262       buf =
 263           gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
 264           (guint8 *) data, p->frame_data_size, 0, p->frame_data_size, NULL,
 265           NULL);
 266
 267       g_signal_emit_by_name (p->appsrc, "push-buffer", buf, &flow_ret);
 268       fail_unless_equals_int (flow_ret, GST_FLOW_OK);
 269       data += p->frame_data_size;
 270
 271       gst_buffer_unref (buf);
 272     }
 273   }
 274
 275   g_signal_emit_by_name (p->appsrc, "end-of-stream", &flow_ret);
 276
 277   /* Run mainloop. */
 278   g_main_loop_run (mainloop);
 279
 280   /* Set pipeline to NULL. */
 281   gst_element_set_state (p->pipeline, GST_STATE_NULL);
 282
 283   /* Release mainloop. */
 284   g_main_loop_unref (mainloop);
 285 }
 286
 287 /*
 288  * Enables buffer lists and adds a chain_list_function to the depayloader.
 289  * @param p Pointer to the RTP pipeline.
 290  */
 291 static void
 292 rtp_pipeline_enable_lists (rtp_pipeline * p, guint mtu_size)
 293 {
 294   GstPad *pad;
 295
 296   /* set mtu size if needed */
 297   if (mtu_size) {
 298     g_object_set (p->rtppay, "mtu", mtu_size, NULL);
 299   }
 300
 301   /* Add chain list function for the buffer list tests */
 302   pad = gst_element_get_static_pad (p->rtpdepay, "sink");
 303   gst_pad_set_chain_list_function (pad,
 304       GST_DEBUG_FUNCPTR (rtp_pipeline_chain_list));
 305   gst_object_unref (pad);
 306 }
 307
 308 /*
 309  * Creates the RTP pipeline and runs the test using the pipeline.
 310  * @param frame_data Pointer to the frame data which is used to pass thru pay/depayloaders.
 311  * @param frame_data_size Frame data size in bytes.
 312  * @param frame_count Frame count.
 313  * @param filtercaps Caps filters.
 314  * @param pay Payloader name.
 315  * @param depay Depayloader name.
 316  * @bytes_sent bytes that will be sent, used when testing buffer lists
 317  * @mtu_size set mtu size when testing lists
 318  * @use_lists enable buffer lists
 319  */
 320 static void
 321 rtp_pipeline_test (const guint8 * frame_data, int frame_data_size,
 322     int frame_count, const char *filtercaps, const char *pay, const char *depay,
 323     guint bytes_sent, guint mtu_size, gboolean use_lists)
 324 {
 325   /* Create RTP pipeline. */
 326   rtp_pipeline *p =
 327       rtp_pipeline_create (frame_data, frame_data_size, frame_count, filtercaps,
 328       pay, depay);
 329
 330   if (p == NULL) {
 331     return;
 332   }
 333
 334   if (use_lists) {
 335     rtp_pipeline_enable_lists (p, mtu_size);
 336     chain_list_bytes_received = 0;
 337   }
 338
 339   /* Run RTP pipeline. */
 340   rtp_pipeline_run (p);
 341
 342   /* Destroy RTP pipeline. */
 343   rtp_pipeline_destroy (p);
 344
 345   if (use_lists) {
 346     /* 'next NAL' indicator is 4 bytes */
 347     fail_if (chain_list_bytes_received != bytes_sent * LOOP_COUNT);
 348   }
 349 }
 350
 351 static const guint8 rtp_ilbc_frame_data[] =
 352     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 353   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 354 };
 355
 356 static int rtp_ilbc_frame_data_size = 20;
 357
 358 static int rtp_ilbc_frame_count = 1;
 359
 360 GST_START_TEST (rtp_ilbc)
 361 {
 362   rtp_pipeline_test (rtp_ilbc_frame_data, rtp_ilbc_frame_data_size,
 363       rtp_ilbc_frame_count, "audio/x-iLBC,mode=20", "rtpilbcpay",
 364       "rtpilbcdepay", 0, 0, FALSE);
 365 }
 366
 367 GST_END_TEST;
 368 static const guint8 rtp_gsm_frame_data[] =
 369     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 370   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 371 };
 372
 373 static int rtp_gsm_frame_data_size = 20;
 374
 375 static int rtp_gsm_frame_count = 1;
 376
 377 GST_START_TEST (rtp_gsm)
 378 {
 379   rtp_pipeline_test (rtp_gsm_frame_data, rtp_gsm_frame_data_size,
 380       rtp_gsm_frame_count, "audio/x-gsm,rate=8000,channels=1", "rtpgsmpay",
 381       "rtpgsmdepay", 0, 0, FALSE);
 382 }
 383
 384 GST_END_TEST;
 385 static const guint8 rtp_amr_frame_data[] =
 386     { 0x3c, 0x24, 0x03, 0xb3, 0x48, 0x10, 0x68, 0x46, 0x6c, 0xec, 0x03,
 387   0x7a, 0x37, 0x16, 0x41, 0x41, 0xc0, 0x00, 0x0d, 0xcd, 0x12, 0xed,
 388   0xad, 0x80, 0x00, 0x00, 0x11, 0x31, 0x00, 0x00, 0x0d, 0xa0
 389 };
 390
 391 static int rtp_amr_frame_data_size = 32;
 392
 393 static int rtp_amr_frame_count = 1;
 394
 395 GST_START_TEST (rtp_amr)
 396 {
 397   rtp_pipeline_test (rtp_amr_frame_data, rtp_amr_frame_data_size,
 398       rtp_amr_frame_count, "audio/AMR,channels=1,rate=8000", "rtpamrpay",
 399       "rtpamrdepay", 0, 0, FALSE);
 400 }
 401
 402 GST_END_TEST;
 403 static const guint8 rtp_pcma_frame_data[] =
 404     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 405   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 406 };
 407
 408 static int rtp_pcma_frame_data_size = 20;
 409
 410 static int rtp_pcma_frame_count = 1;
 411
 412 GST_START_TEST (rtp_pcma)
 413 {
 414   rtp_pipeline_test (rtp_pcma_frame_data, rtp_pcma_frame_data_size,
 415       rtp_pcma_frame_count, "audio/x-alaw,channels=1,rate=8000", "rtppcmapay",
 416       "rtppcmadepay", 0, 0, FALSE);
 417 }
 418
 419 GST_END_TEST;
 420 static const guint8 rtp_pcmu_frame_data[] =
 421     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 422   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 423 };
 424
 425 static int rtp_pcmu_frame_data_size = 20;
 426
 427 static int rtp_pcmu_frame_count = 1;
 428
 429 GST_START_TEST (rtp_pcmu)
 430 {
 431   rtp_pipeline_test (rtp_pcmu_frame_data, rtp_pcmu_frame_data_size,
 432       rtp_pcmu_frame_count, "audio/x-mulaw,channels=1,rate=8000", "rtppcmupay",
 433       "rtppcmudepay", 0, 0, FALSE);
 434 }
 435
 436 GST_END_TEST;
 437 static const guint8 rtp_mpa_frame_data[] =
 438     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 439   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 440 };
 441
 442 static int rtp_mpa_frame_data_size = 20;
 443
 444 static int rtp_mpa_frame_count = 1;
 445
 446 GST_START_TEST (rtp_mpa)
 447 {
 448   rtp_pipeline_test (rtp_mpa_frame_data, rtp_mpa_frame_data_size,
 449       rtp_mpa_frame_count, "audio/mpeg,mpegversion=1", "rtpmpapay",
 450       "rtpmpadepay", 0, 0, FALSE);
 451 }
 452
 453 GST_END_TEST;
 454 static const guint8 rtp_h263_frame_data[] =
 455     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 456   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 457 };
 458
 459 static int rtp_h263_frame_data_size = 20;
 460
 461 static int rtp_h263_frame_count = 1;
 462
 463 GST_START_TEST (rtp_h263)
 464 {
 465   rtp_pipeline_test (rtp_h263_frame_data, rtp_h263_frame_data_size,
 466       rtp_h263_frame_count, "video/x-h263,variant=(string)itu,h263version=h263",
 467       "rtph263pay", "rtph263depay", 0, 0, FALSE);
 468 }
 469
 470 GST_END_TEST;
 471 static const guint8 rtp_h263p_frame_data[] =
 472     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 473   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 474 };
 475
 476 static int rtp_h263p_frame_data_size = 20;
 477
 478 static int rtp_h263p_frame_count = 1;
 479
 480 GST_START_TEST (rtp_h263p)
 481 {
 482   rtp_pipeline_test (rtp_h263p_frame_data, rtp_h263p_frame_data_size,
 483       rtp_h263p_frame_count, "video/x-h263,variant=(string)itu,"
 484       "h263version=(string)h263", "rtph263ppay", "rtph263pdepay", 0, 0, FALSE);
 485
 486   /* payloader should accept any input that matches the template caps
 487    * if there's just a udpsink or fakesink downstream */
 488   rtp_pipeline_test (rtp_h263p_frame_data, rtp_h263p_frame_data_size,
 489       rtp_h263p_frame_count, "video/x-h263,variant=(string)itu,"
 490       "h263version=(string)h263", "rtph263ppay", "identity", 0, 0, FALSE);
 491
 492   /* default output of avenc_h263p */
 493   rtp_pipeline_test (rtp_h263p_frame_data, rtp_h263p_frame_data_size,
 494       rtp_h263p_frame_count, "video/x-h263,variant=(string)itu,"
 495       "h263version=(string)h263p, annex-f=(boolean)true, "
 496       "annex-j=(boolean)true, annex-i=(boolean)true, annex-t=(boolean)true",
 497       "rtph263ppay", "identity", 0, 0, FALSE);
 498
 499   /* pay ! depay should also work with any input */
 500   rtp_pipeline_test (rtp_h263p_frame_data, rtp_h263p_frame_data_size,
 501       rtp_h263p_frame_count, "video/x-h263,variant=(string)itu,"
 502       "h263version=(string)h263p, annex-f=(boolean)true, "
 503       "annex-j=(boolean)true, annex-i=(boolean)true, annex-t=(boolean)true",
 504       "rtph263ppay", "rtph263pdepay", 0, 0, FALSE);
 505 }
 506
 507 GST_END_TEST;
 508 static const guint8 rtp_h264_frame_data[] =
 509     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 510   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 511 };
 512
 513 static int rtp_h264_frame_data_size = 20;
 514
 515 static int rtp_h264_frame_count = 1;
 516
 517 GST_START_TEST (rtp_h264)
 518 {
 519   /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
 520   rtp_pipeline_test (rtp_h264_frame_data, rtp_h264_frame_data_size,
 521       rtp_h264_frame_count,
 522       "video/x-h264,stream-format=(string)byte-stream,alignment=(string)nal",
 523       "rtph264pay", "rtph264depay", 0, 0, FALSE);
 524 }
 525
 526 GST_END_TEST;
 527 static const guint8 rtp_h264_list_lt_mtu_frame_data[] =
 528     /* not packetized, next NAL starts with 0001 */
 529 { 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
 530   0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 531   0xad, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00
 532 };
 533
 534 static int rtp_h264_list_lt_mtu_frame_data_size = 16;
 535
 536 static int rtp_h264_list_lt_mtu_frame_count = 2;
 537
 538 /* NAL = 4 bytes */
 539 /* also 2 bytes FU-A header each time */
 540 static int rtp_h264_list_lt_mtu_bytes_sent = 2 * (16 - 4);
 541
 542 static int rtp_h264_list_lt_mtu_mtu_size = 1024;
 543
 544 GST_START_TEST (rtp_h264_list_lt_mtu)
 545 {
 546   /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
 547   rtp_pipeline_test (rtp_h264_list_lt_mtu_frame_data,
 548       rtp_h264_list_lt_mtu_frame_data_size, rtp_h264_list_lt_mtu_frame_count,
 549       "video/x-h264,stream-format=(string)byte-stream,alignment=(string)nal",
 550       "rtph264pay", "rtph264depay",
 551       rtp_h264_list_lt_mtu_bytes_sent, rtp_h264_list_lt_mtu_mtu_size, TRUE);
 552 }
 553
 554 GST_END_TEST;
 555 static const guint8 rtp_h264_list_lt_mtu_frame_data_avc[] =
 556     /* packetized data */
 557 { 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
 558   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
 559   0xad, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x0d, 0x00
 560 };
 561
 562 /* NAL = 4 bytes */
 563 static int rtp_h264_list_lt_mtu_bytes_sent_avc = 2 * (16 - 2 * 4);
 564
 565 //static int rtp_h264_list_lt_mtu_mtu_size = 1024;
 566
 567 GST_START_TEST (rtp_h264_list_lt_mtu_avc)
 568 {
 569   /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
 570   rtp_pipeline_test (rtp_h264_list_lt_mtu_frame_data_avc,
 571       rtp_h264_list_lt_mtu_frame_data_size, rtp_h264_list_lt_mtu_frame_count,
 572       "video/x-h264,stream-format=(string)avc,alignment=(string)au,"
 573       "codec_data=(buffer)01640014ffe1001867640014acd94141fb0110000003001773594000f142996001000568ebecb22c",
 574       "rtph264pay", "rtph264depay",
 575       rtp_h264_list_lt_mtu_bytes_sent_avc, rtp_h264_list_lt_mtu_mtu_size, TRUE);
 576 }
 577
 578 GST_END_TEST;
 579 static const guint8 rtp_h264_list_gt_mtu_frame_data[] =
 580     /* not packetized, next NAL starts with 0001 */
 581 { 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 582   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 583   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 584   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 585   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 586   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 587 };
 588
 589 static int rtp_h264_list_gt_mtu_frame_data_size = 64;
 590
 591 static int rtp_h264_list_gt_mtu_frame_count = 1;
 592
 593 /* NAL = 4 bytes. When data does not fit into 1 mtu, 1 byte will be skipped */
 594 static int rtp_h264_list_gt_mtu_bytes_sent = 1 * (64 - 4) - 1;
 595
 596 static int rtp_h264_list_gt_mtu_mty_size = 28;
 597
 598 GST_START_TEST (rtp_h264_list_gt_mtu)
 599 {
 600   /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
 601   rtp_pipeline_test (rtp_h264_list_gt_mtu_frame_data,
 602       rtp_h264_list_gt_mtu_frame_data_size, rtp_h264_list_gt_mtu_frame_count,
 603       "video/x-h264,stream-format=(string)byte-stream,alignment=(string)nal",
 604       "rtph264pay", "rtph264depay",
 605       rtp_h264_list_gt_mtu_bytes_sent, rtp_h264_list_gt_mtu_mty_size, TRUE);
 606 }
 607
 608 GST_END_TEST;
 609 static const guint8 rtp_h264_list_gt_mtu_frame_data_avc[] =
 610     /* packetized data */
 611 { 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 612   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 613   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 614   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
 615   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 616   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 617 };
 618
 619 /* NAL = 4 bytes. When data does not fit into 1 mtu, 1 byte will be skipped */
 620 static int rtp_h264_list_gt_mtu_bytes_sent_avc = 1 * (64 - 2 * 4 - 2 * 1);
 621
 622 GST_START_TEST (rtp_h264_list_gt_mtu_avc)
 623 {
 624   /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
 625   rtp_pipeline_test (rtp_h264_list_gt_mtu_frame_data_avc,
 626       rtp_h264_list_gt_mtu_frame_data_size, rtp_h264_list_gt_mtu_frame_count,
 627       "video/x-h264,stream-format=(string)avc,alignment=(string)au,"
 628       "codec_data=(buffer)01640014ffe1001867640014acd94141fb0110000003001773594000f142996001000568ebecb22c",
 629       "rtph264pay", "rtph264depay",
 630       rtp_h264_list_gt_mtu_bytes_sent_avc, rtp_h264_list_gt_mtu_mty_size, TRUE);
 631 }
 632
 633 GST_END_TEST;
 634
 635 static const guint8 rtp_L16_frame_data[] =
 636     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 637   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 638 };
 639
 640 static int rtp_L16_frame_data_size = 20;
 641
 642 static int rtp_L16_frame_count = 1;
 643
 644 GST_START_TEST (rtp_L16)
 645 {
 646   rtp_pipeline_test (rtp_L16_frame_data, rtp_L16_frame_data_size,
 647       rtp_L16_frame_count,
 648       "audio/x-raw,format=S16BE,rate=1,channels=1,layout=(string)interleaved",
 649       "rtpL16pay", "rtpL16depay", 0, 0, FALSE);
 650 }
 651
 652 GST_END_TEST;
 653 static const guint8 rtp_mp2t_frame_data[] =
 654     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 655   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 656 };
 657
 658 static int rtp_mp2t_frame_data_size = 20;
 659
 660 static int rtp_mp2t_frame_count = 1;
 661
 662 GST_START_TEST (rtp_mp2t)
 663 {
 664   rtp_pipeline_test (rtp_mp2t_frame_data, rtp_mp2t_frame_data_size,
 665       rtp_mp2t_frame_count, "video/mpegts,packetsize=188,systemstream=true",
 666       "rtpmp2tpay", "rtpmp2tdepay", 0, 0, FALSE);
 667 }
 668
 669 GST_END_TEST;
 670 static const guint8 rtp_mp4v_frame_data[] =
 671     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 672   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 673 };
 674
 675 static int rtp_mp4v_frame_data_size = 20;
 676
 677 static int rtp_mp4v_frame_count = 1;
 678
 679 GST_START_TEST (rtp_mp4v)
 680 {
 681   rtp_pipeline_test (rtp_mp4v_frame_data, rtp_mp4v_frame_data_size,
 682       rtp_mp4v_frame_count, "video/mpeg,mpegversion=4,systemstream=false",
 683       "rtpmp4vpay", "rtpmp4vdepay", 0, 0, FALSE);
 684 }
 685
 686 GST_END_TEST;
 687 static const guint8 rtp_mp4v_list_frame_data[] =
 688     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 689   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 690 };
 691
 692 static int rtp_mp4v_list_frame_data_size = 20;
 693
 694 static int rtp_mp4v_list_frame_count = 1;
 695
 696 static int rtp_mp4v_list_bytes_sent = 1 * 20;
 697
 698 GST_START_TEST (rtp_mp4v_list)
 699 {
 700   rtp_pipeline_test (rtp_mp4v_list_frame_data, rtp_mp4v_list_frame_data_size,
 701       rtp_mp4v_list_frame_count,
 702       "video/mpeg,mpegversion=4,systemstream=false,codec_data=(buffer)000001b001",
 703       "rtpmp4vpay", "rtpmp4vdepay", rtp_mp4v_list_bytes_sent, 0, TRUE);
 704 }
 705
 706 GST_END_TEST;
 707 static const guint8 rtp_mp4g_frame_data[] =
 708     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 709   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 710 };
 711
 712 static int rtp_mp4g_frame_data_size = 20;
 713
 714 static int rtp_mp4g_frame_count = 1;
 715
 716 GST_START_TEST (rtp_mp4g)
 717 {
 718   rtp_pipeline_test (rtp_mp4g_frame_data, rtp_mp4g_frame_data_size,
 719       rtp_mp4g_frame_count,
 720       "video/mpeg,mpegversion=4,systemstream=false,codec_data=(buffer)000001b001",
 721       "rtpmp4gpay", "rtpmp4gdepay", 0, 0, FALSE);
 722 }
 723
 724 GST_END_TEST;
 725 static const guint8 rtp_theora_frame_data[] =
 726     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 727   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 728 };
 729
 730 static int rtp_theora_frame_data_size = 20;
 731
 732 static int rtp_theora_frame_count = 1;
 733
 734 GST_START_TEST (rtp_theora)
 735 {
 736   rtp_pipeline_test (rtp_theora_frame_data, rtp_theora_frame_data_size,
 737       rtp_theora_frame_count, "video/x-theora", "rtptheorapay",
 738       "rtptheoradepay", 0, 0, FALSE);
 739 }
 740
 741 GST_END_TEST;
 742 static const guint8 rtp_vorbis_frame_data[] =
 743     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 744   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 745 };
 746
 747 static int rtp_vorbis_frame_data_size = 20;
 748
 749 static int rtp_vorbis_frame_count = 1;
 750
 751 GST_START_TEST (rtp_vorbis)
 752 {
 753   rtp_pipeline_test (rtp_vorbis_frame_data, rtp_vorbis_frame_data_size,
 754       rtp_vorbis_frame_count, "audio/x-vorbis", "rtpvorbispay",
 755       "rtpvorbisdepay", 0, 0, FALSE);
 756 }
 757
 758 GST_END_TEST;
 759 static const guint8 rtp_jpeg_frame_data[] =
 760     { /* SOF */ 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08,
 761   0x03, 0x00, 0x21, 0x08, 0x01, 0x11, 0x08, 0x02, 0x11, 0x08,
 762   /* DQT */ 0xFF, 0xDB, 0x00, 0x43, 0x08,
 763   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 764   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 765   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 766   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 767   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 768   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 769   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 770   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 771   /* DATA */ 0x00, 0x00, 0x00, 0x00, 0x00
 772 };
 773
 774 static int rtp_jpeg_frame_data_size = sizeof (rtp_jpeg_frame_data);
 775
 776 static int rtp_jpeg_frame_count = 1;
 777
 778 GST_START_TEST (rtp_jpeg)
 779 {
 780   rtp_pipeline_test (rtp_jpeg_frame_data, rtp_jpeg_frame_data_size,
 781       rtp_jpeg_frame_count, "video/x-jpeg,height=640,width=480", "rtpjpegpay",
 782       "rtpjpegdepay", 0, 0, FALSE);
 783 }
 784
 785 GST_END_TEST;
 786
 787 GST_START_TEST (rtp_jpeg_width_greater_than_2040)
 788 {
 789   rtp_pipeline_test (rtp_jpeg_frame_data, rtp_jpeg_frame_data_size,
 790       rtp_jpeg_frame_count, "video/x-jpeg,height=2048,width=480", "rtpjpegpay",
 791       "rtpjpegdepay", 0, 0, FALSE);
 792 }
 793
 794 GST_END_TEST;
 795
 796 GST_START_TEST (rtp_jpeg_height_greater_than_2040)
 797 {
 798   rtp_pipeline_test (rtp_jpeg_frame_data, rtp_jpeg_frame_data_size,
 799       rtp_jpeg_frame_count, "video/x-jpeg,height=640,width=2048", "rtpjpegpay",
 800       "rtpjpegdepay", 0, 0, FALSE);
 801 }
 802
 803 GST_END_TEST;
 804
 805 GST_START_TEST (rtp_jpeg_width_and_height_greater_than_2040)
 806 {
 807   rtp_pipeline_test (rtp_jpeg_frame_data, rtp_jpeg_frame_data_size,
 808       rtp_jpeg_frame_count, "video/x-jpeg,height=2048,width=2048", "rtpjpegpay",
 809       "rtpjpegdepay", 0, 0, FALSE);
 810 }
 811
 812 GST_END_TEST;
 813
 814 static const guint8 rtp_jpeg_list_frame_data[] =
 815     { /* SOF */ 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08,
 816   0x03, 0x00, 0x21, 0x08, 0x01, 0x11, 0x08, 0x02, 0x11, 0x08,
 817   /* DQT */ 0xFF, 0xDB, 0x00, 0x43, 0x08,
 818   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 819   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 820   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 821   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 822   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 823   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 824   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 825   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 826   /* DATA */ 0x00, 0x00, 0x00, 0x00, 0x00
 827 };
 828
 829 static int rtp_jpeg_list_frame_data_size = sizeof (rtp_jpeg_list_frame_data);
 830
 831 static int rtp_jpeg_list_frame_count = 1;
 832
 833 static int rtp_jpeg_list_bytes_sent = 1 * sizeof (rtp_jpeg_list_frame_data);
 834
 835 GST_START_TEST (rtp_jpeg_list)
 836 {
 837   rtp_pipeline_test (rtp_jpeg_list_frame_data, rtp_jpeg_list_frame_data_size,
 838       rtp_jpeg_list_frame_count, "video/x-jpeg,height=640,width=480",
 839       "rtpjpegpay", "rtpjpegdepay", rtp_jpeg_list_bytes_sent, 0, TRUE);
 840 }
 841
 842 GST_END_TEST;
 843
 844 GST_START_TEST (rtp_jpeg_list_width_greater_than_2040)
 845 {
 846   rtp_pipeline_test (rtp_jpeg_list_frame_data, rtp_jpeg_list_frame_data_size,
 847       rtp_jpeg_list_frame_count, "video/x-jpeg,height=2048,width=480",
 848       "rtpjpegpay", "rtpjpegdepay", rtp_jpeg_list_bytes_sent, 0, TRUE);
 849 }
 850
 851 GST_END_TEST;
 852
 853 GST_START_TEST (rtp_jpeg_list_height_greater_than_2040)
 854 {
 855   rtp_pipeline_test (rtp_jpeg_list_frame_data, rtp_jpeg_list_frame_data_size,
 856       rtp_jpeg_list_frame_count, "video/x-jpeg,height=640,width=2048",
 857       "rtpjpegpay", "rtpjpegdepay", rtp_jpeg_list_bytes_sent, 0, TRUE);
 858 }
 859
 860 GST_END_TEST;
 861
 862 GST_START_TEST (rtp_jpeg_list_width_and_height_greater_than_2040)
 863 {
 864   rtp_pipeline_test (rtp_jpeg_list_frame_data, rtp_jpeg_list_frame_data_size,
 865       rtp_jpeg_list_frame_count, "video/x-jpeg,height=2048,width=2048",
 866       "rtpjpegpay", "rtpjpegdepay", rtp_jpeg_list_bytes_sent, 0, TRUE);
 867 }
 868
 869 GST_END_TEST;
 870
 871 static const guint8 rtp_g729_frame_data[] =
 872     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 873   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 874 };
 875
 876 static int rtp_g729_frame_data_size = 22;
 877
 878 static int rtp_g729_frame_count = 1;
 879
 880 GST_START_TEST (rtp_g729)
 881 {
 882   rtp_pipeline_test (rtp_g729_frame_data, rtp_g729_frame_data_size,
 883       rtp_g729_frame_count, "audio/G729,rate=8000,channels=1", "rtpg729pay",
 884       "rtpg729depay", 0, 0, FALSE);
 885 }
 886
 887 GST_END_TEST;
 888
 889 /*
 890  * Creates the test suite.
 891  *
 892  * Returns: pointer to the test suite.
 893  */
 894 static Suite *
 895 rtp_payloading_suite (void)
 896 {
 897   Suite *s = suite_create ("rtp_data_test");
 898
 899   TCase *tc_chain = tcase_create ("linear");
 900
 901   /* Set timeout to 60 seconds. */
 902   tcase_set_timeout (tc_chain, 60);
 903
 904   suite_add_tcase (s, tc_chain);
 905   tcase_add_test (tc_chain, rtp_ilbc);
 906   tcase_add_test (tc_chain, rtp_gsm);
 907   tcase_add_test (tc_chain, rtp_amr);
 908   tcase_add_test (tc_chain, rtp_pcma);
 909   tcase_add_test (tc_chain, rtp_pcmu);
 910   tcase_add_test (tc_chain, rtp_mpa);
 911   tcase_add_test (tc_chain, rtp_h263);
 912   tcase_add_test (tc_chain, rtp_h263p);
 913   tcase_add_test (tc_chain, rtp_h264);
 914   tcase_add_test (tc_chain, rtp_h264_list_lt_mtu);
 915   tcase_add_test (tc_chain, rtp_h264_list_lt_mtu_avc);
 916   tcase_add_test (tc_chain, rtp_h264_list_gt_mtu);
 917   tcase_add_test (tc_chain, rtp_h264_list_gt_mtu_avc);
 918   tcase_add_test (tc_chain, rtp_L16);
 919   tcase_add_test (tc_chain, rtp_mp2t);
 920   tcase_add_test (tc_chain, rtp_mp4v);
 921   tcase_add_test (tc_chain, rtp_mp4v_list);
 922   tcase_add_test (tc_chain, rtp_mp4g);
 923   tcase_add_test (tc_chain, rtp_theora);
 924   tcase_add_test (tc_chain, rtp_vorbis);
 925   tcase_add_test (tc_chain, rtp_jpeg);
 926   tcase_add_test (tc_chain, rtp_jpeg_width_greater_than_2040);
 927   tcase_add_test (tc_chain, rtp_jpeg_height_greater_than_2040);
 928   tcase_add_test (tc_chain, rtp_jpeg_width_and_height_greater_than_2040);
 929   tcase_add_test (tc_chain, rtp_jpeg_list);
 930   tcase_add_test (tc_chain, rtp_jpeg_list_width_greater_than_2040);
 931   tcase_add_test (tc_chain, rtp_jpeg_list_height_greater_than_2040);
 932   tcase_add_test (tc_chain, rtp_jpeg_list_width_and_height_greater_than_2040);
 933   tcase_add_test (tc_chain, rtp_g729);
 934   return s;
 935 }
 936
 937 GST_CHECK_MAIN (rtp_payloading)