rtp-payloading.c 22.9 KB
Newer Older
1
/* GStreamer RTP payloader unit tests
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 * Copyright (C) 2008 Nokia Corporation and its subsidary(-ies)
 *               contact: <stefan.kost@nokia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
#include <gst/check/gstcheck.h>
#include <stdlib.h>
#include <unistd.h>

#define RELEASE_ELEMENT(x) if(x) {gst_object_unref(x); x = NULL;}

#define LOOP_COUNT 1

/*
 * RTP pipeline structure to store the required elements.
 */
typedef struct
{
  GstElement *pipeline;
34
  GstElement *appsrc;
35
36
37
  GstElement *rtppay;
  GstElement *rtpdepay;
  GstElement *fakesink;
38
  const guint8 *frame_data;
39
40
41
42
  int frame_data_size;
  int frame_count;
} rtp_pipeline;

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*
 * Number of bytes received in the chain list function when using buffer lists
 */
static guint chain_list_bytes_received;

/*
 * Chain list function for testing buffer lists
 */
static GstFlowReturn
rtp_pipeline_chain_list (GstPad * pad, GstBufferList * list)
{
  GstBufferListIterator *it;

  fail_if (!list);
  it = gst_buffer_list_iterate (list);

  /*
   * Count the size of the payload in the buffer list.
   */

  /* Loop through all groups */
  while (gst_buffer_list_iterator_next_group (it)) {
    GstBuffer *paybuf;

    /* Skip the first buffer in the group, its the RTP header */
    fail_if (!gst_buffer_list_iterator_next (it));

    /* Loop through all payload buffers in the current group */
    while ((paybuf = gst_buffer_list_iterator_next (it))) {
      chain_list_bytes_received += GST_BUFFER_SIZE (paybuf);
    }
  }

  gst_buffer_list_iterator_free (it);
  gst_buffer_list_unref (list);

  return GST_FLOW_OK;
}

82
83
84
/*
 * RTP bus callback.
 */
85
static gboolean
86
87
88
89
90
91
92
93
rtp_bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
  GMainLoop *mainloop = (GMainLoop *) data;

  switch (GST_MESSAGE_TYPE (message)) {
    case GST_MESSAGE_ERROR:
    {
      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
102
103
      /* FIXME: should we fail the test here? */
      g_print ("\nError from element %s: %s\n%s\n\n",
          GST_STR_NULL (element_name), err->message, (debug) ? debug : "");
104
105
      g_error_free (err);
      g_free (debug);
106
      g_free (element_name);
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

      g_main_loop_quit (mainloop);
    }
      break;

    case GST_MESSAGE_EOS:
    {
      g_main_loop_quit (mainloop);
    }
      break;
      break;

    default:
    {
    }
      break;
  }

  return TRUE;
}

/*
 * Creates a RTP pipeline for one test.
 * @param frame_data Pointer to the frame data which is used to pass thru pay/depayloaders.
 * @param frame_data_size Frame data size in bytes.
 * @param frame_count Frame count.
 * @param filtercaps Caps filters.
 * @param pay Payloader name.
 * @param depay Depayloader name.
 * @return
 * Returns pointer to the RTP pipeline.
 * The user must free the RTP pipeline when it's not used anymore.
 */
140
static rtp_pipeline *
141
rtp_pipeline_create (const guint8 * frame_data, int frame_data_size,
142
143
    int frame_count, const char *filtercaps, const char *pay, const char *depay)
{
144
  gchar *pipeline_name;
145
146
147
  rtp_pipeline *p;
  GstCaps *caps;

148
149
150
151
152
153
  /* Check parameters. */
  if (!frame_data || !pay || !depay) {
    return NULL;
  }

  /* Allocate memory for the RTP pipeline. */
154
  p = (rtp_pipeline *) malloc (sizeof (rtp_pipeline));
155
156
157
158
159
160

  p->frame_data = frame_data;
  p->frame_data_size = frame_data_size;
  p->frame_count = frame_count;

  /* Create elements. */
161
162
163
  pipeline_name = g_strdup_printf ("%s-%s-pipeline", pay, depay);
  p->pipeline = gst_pipeline_new (pipeline_name);
  g_free (pipeline_name);
164
  p->appsrc = gst_element_factory_make ("appsrc", NULL);
165
166
167
168
169
  p->rtppay = gst_element_factory_make (pay, NULL);
  p->rtpdepay = gst_element_factory_make (depay, NULL);
  p->fakesink = gst_element_factory_make ("fakesink", NULL);

  /* 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
172
    /* Release created elements. */
    RELEASE_ELEMENT (p->pipeline);
173
    RELEASE_ELEMENT (p->appsrc);
174
175
176
177
178
179
180
181
182
183
    RELEASE_ELEMENT (p->rtppay);
    RELEASE_ELEMENT (p->rtpdepay);
    RELEASE_ELEMENT (p->fakesink);

    /* Release allocated memory. */
    free (p);

    return NULL;
  }

184
  /* Set src properties. */
185
  caps = gst_caps_from_string (filtercaps);
186
  g_object_set (p->appsrc, "do-timestamp", TRUE, "caps", caps, NULL);
187
188
189
  gst_caps_unref (caps);

  /* Add elements to the pipeline. */
190
  gst_bin_add (GST_BIN (p->pipeline), p->appsrc);
191
192
193
194
195
  gst_bin_add (GST_BIN (p->pipeline), p->rtppay);
  gst_bin_add (GST_BIN (p->pipeline), p->rtpdepay);
  gst_bin_add (GST_BIN (p->pipeline), p->fakesink);

  /* Link elements. */
196
  gst_element_link (p->appsrc, p->rtppay);
197
198
199
200
201
202
203
204
205
206
  gst_element_link (p->rtppay, p->rtpdepay);
  gst_element_link (p->rtpdepay, p->fakesink);

  return p;
}

/*
 * Destroys the RTP pipeline.
 * @param p Pointer to the RTP pipeline.
 */
207
static void
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
rtp_pipeline_destroy (rtp_pipeline * p)
{
  /* Check parameters. */
  if (p == NULL) {
    return;
  }

  /* Release pipeline. */
  RELEASE_ELEMENT (p->pipeline);

  /* Release allocated memory. */
  free (p);
}

/*
 * Runs the RTP pipeline.
 * @param p Pointer to the RTP pipeline.
 */
226
static void
227
228
rtp_pipeline_run (rtp_pipeline * p)
{
229
  GstFlowReturn flow_ret;
230
  GMainLoop *mainloop = NULL;
231
  GstBus *bus;
232
  gint i, j;
233

234
235
236
237
238
239
240
241
242
243
244
245
  /* Check parameters. */
  if (p == NULL) {
    return;
  }

  /* Create mainloop. */
  mainloop = g_main_loop_new (NULL, FALSE);
  if (!mainloop) {
    return;
  }

  /* Add bus callback. */
246
  bus = gst_pipeline_get_bus (GST_PIPELINE (p->pipeline));
247
248
249
250
251
252
253

  gst_bus_add_watch (bus, rtp_bus_callback, (gpointer) mainloop);
  gst_object_unref (bus);

  /* Set pipeline to PLAYING. */
  gst_element_set_state (p->pipeline, GST_STATE_PLAYING);

254
  /* Push data into the pipeline */
255
  for (i = 0; i < LOOP_COUNT; i++) {
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
    const guint8 *data = p->frame_data;

    for (j = 0; j < p->frame_count; j++) {
      GstBuffer *buf;

      buf = gst_buffer_new ();
      GST_BUFFER_DATA (buf) = (guint8 *) data;
      GST_BUFFER_SIZE (buf) = p->frame_data_size;
      GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);

      g_signal_emit_by_name (p->appsrc, "push-buffer", buf, &flow_ret);
      fail_unless_equals_int (flow_ret, GST_FLOW_OK);
      data += p->frame_data_size;

      gst_buffer_unref (buf);
271
272
273
    }
  }

274
275
  g_signal_emit_by_name (p->appsrc, "end-of-stream", &flow_ret);

276
277
278
279
280
281
282
283
284
285
  /* Run mainloop. */
  g_main_loop_run (mainloop);

  /* Set pipeline to NULL. */
  gst_element_set_state (p->pipeline, GST_STATE_NULL);

  /* Release mainloop. */
  g_main_loop_unref (mainloop);
}

286
287
288
289
290
291
292
293
/*
 * Enables buffer lists. Sets the buffer-list property of the payloader
 * and adds a chain_list_function to the depayloader.
 * @param p Pointer to the RTP pipeline.
 */
static void
rtp_pipeline_enable_lists (rtp_pipeline * p, guint mtu_size)
{
294
295
  GstPad *pad;

296
297
298
299
300
301
302
303
304
  /* use buffer lists */
  g_object_set (p->rtppay, "buffer-list", TRUE, NULL);

  /* set mtu size if needed */
  if (mtu_size) {
    g_object_set (p->rtppay, "mtu", mtu_size, NULL);
  }

  /* Add chain list function for the buffer list tests */
305
306
307
308
  pad = gst_element_get_static_pad (p->rtpdepay, "sink");
  gst_pad_set_chain_list_function (pad,
      GST_DEBUG_FUNCPTR (rtp_pipeline_chain_list));
  gst_object_unref (pad);
309
310
}

311
312
313
314
315
316
317
318
/*
 * Creates the RTP pipeline and runs the test using the pipeline.
 * @param frame_data Pointer to the frame data which is used to pass thru pay/depayloaders.
 * @param frame_data_size Frame data size in bytes.
 * @param frame_count Frame count.
 * @param filtercaps Caps filters.
 * @param pay Payloader name.
 * @param depay Depayloader name.
319
320
321
 * @bytes_sent bytes that will be sent, used when testing buffer lists
 * @mtu_size set mtu size when testing lists
 * @use_lists enable buffer lists
322
 */
323
static void
324
325
rtp_pipeline_test (const guint8 * frame_data, int frame_data_size,
    int frame_count, const char *filtercaps, const char *pay, const char *depay,
326
    guint bytes_sent, guint mtu_size, gboolean use_lists)
327
328
329
330
331
{
  /* Create RTP pipeline. */
  rtp_pipeline *p =
      rtp_pipeline_create (frame_data, frame_data_size, frame_count, filtercaps,
      pay, depay);
332

333
334
335
336
  if (p == NULL) {
    return;
  }

337
338
339
340
341
  if (use_lists) {
    rtp_pipeline_enable_lists (p, mtu_size);
    chain_list_bytes_received = 0;
  }

342
343
344
345
346
  /* Run RTP pipeline. */
  rtp_pipeline_run (p);

  /* Destroy RTP pipeline. */
  rtp_pipeline_destroy (p);
347
348
349
350
351

  if (use_lists) {
    /* 'next NAL' indicator is 4 bytes */
    fail_if (chain_list_bytes_received != bytes_sent * LOOP_COUNT);
  }
352
353
}

354
static const guint8 rtp_ilbc_frame_data[] =
355
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356
357
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
358

359
static int rtp_ilbc_frame_data_size = 20;
360

361
362
363
364
365
366
static int rtp_ilbc_frame_count = 1;

GST_START_TEST (rtp_ilbc)
{
  rtp_pipeline_test (rtp_ilbc_frame_data, rtp_ilbc_frame_data_size,
      rtp_ilbc_frame_count, "audio/x-iLBC,mode=20", "rtpilbcpay",
367
      "rtpilbcdepay", 0, 0, FALSE);
368
}
369
370

GST_END_TEST;
371
static const guint8 rtp_gsm_frame_data[] =
372
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373
374
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
375

376
static int rtp_gsm_frame_data_size = 20;
377

378
379
380
381
382
383
static int rtp_gsm_frame_count = 1;

GST_START_TEST (rtp_gsm)
{
  rtp_pipeline_test (rtp_gsm_frame_data, rtp_gsm_frame_data_size,
      rtp_gsm_frame_count, "audio/x-gsm,rate=8000,channels=1", "rtpgsmpay",
384
      "rtpgsmdepay", 0, 0, FALSE);
385
}
386
387

GST_END_TEST;
388
static const guint8 rtp_amr_frame_data[] =
Wim Taymans's avatar
Wim Taymans committed
389
390
391
    { 0x3c, 0x24, 0x03, 0xb3, 0x48, 0x10, 0x68, 0x46, 0x6c, 0xec, 0x03,
  0x7a, 0x37, 0x16, 0x41, 0x41, 0xc0, 0x00, 0x0d, 0xcd, 0x12, 0xed,
  0xad, 0x80, 0x00, 0x00, 0x11, 0x31, 0x00, 0x00, 0x0d, 0xa0
392
};
393

Wim Taymans's avatar
Wim Taymans committed
394
static int rtp_amr_frame_data_size = 32;
395

396
397
398
399
400
401
static int rtp_amr_frame_count = 1;

GST_START_TEST (rtp_amr)
{
  rtp_pipeline_test (rtp_amr_frame_data, rtp_amr_frame_data_size,
      rtp_amr_frame_count, "audio/AMR,channels=1,rate=8000", "rtpamrpay",
402
      "rtpamrdepay", 0, 0, FALSE);
403
}
404
405

GST_END_TEST;
406
static const guint8 rtp_pcma_frame_data[] =
407
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
408
409
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
410

411
static int rtp_pcma_frame_data_size = 20;
412

413
414
415
416
417
418
static int rtp_pcma_frame_count = 1;

GST_START_TEST (rtp_pcma)
{
  rtp_pipeline_test (rtp_pcma_frame_data, rtp_pcma_frame_data_size,
      rtp_pcma_frame_count, "audio/x-alaw,channels=1,rate=8000", "rtppcmapay",
419
      "rtppcmadepay", 0, 0, FALSE);
420
}
421
422

GST_END_TEST;
423
static const guint8 rtp_pcmu_frame_data[] =
424
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
425
426
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
427

428
static int rtp_pcmu_frame_data_size = 20;
429

430
431
432
433
434
435
static int rtp_pcmu_frame_count = 1;

GST_START_TEST (rtp_pcmu)
{
  rtp_pipeline_test (rtp_pcmu_frame_data, rtp_pcmu_frame_data_size,
      rtp_pcmu_frame_count, "audio/x-mulaw,channels=1,rate=8000", "rtppcmupay",
436
      "rtppcmudepay", 0, 0, FALSE);
437
}
438
439

GST_END_TEST;
440
static const guint8 rtp_mpa_frame_data[] =
441
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
442
443
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
444

445
static int rtp_mpa_frame_data_size = 20;
446

447
448
449
450
451
static int rtp_mpa_frame_count = 1;

GST_START_TEST (rtp_mpa)
{
  rtp_pipeline_test (rtp_mpa_frame_data, rtp_mpa_frame_data_size,
452
453
      rtp_mpa_frame_count, "audio/mpeg", "rtpmpapay", "rtpmpadepay", 0, 0,
      FALSE);
454
}
455
456

GST_END_TEST;
457
static const guint8 rtp_h263_frame_data[] =
458
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
459
460
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
461

462
static int rtp_h263_frame_data_size = 20;
463

464
465
466
467
468
static int rtp_h263_frame_count = 1;

GST_START_TEST (rtp_h263)
{
  rtp_pipeline_test (rtp_h263_frame_data, rtp_h263_frame_data_size,
469
      rtp_h263_frame_count, "video/x-h263,variant=(string)itu,h263version=h263",
470
      "rtph263pay", "rtph263depay", 0, 0, FALSE);
471
}
472
473

GST_END_TEST;
474
static const guint8 rtp_h263p_frame_data[] =
475
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
476
477
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
478

479
static int rtp_h263p_frame_data_size = 20;
480

481
482
483
484
485
static int rtp_h263p_frame_count = 1;

GST_START_TEST (rtp_h263p)
{
  rtp_pipeline_test (rtp_h263p_frame_data, rtp_h263p_frame_data_size,
486
      rtp_h263p_frame_count, "video/x-h263,variant=(string)itu", "rtph263ppay",
487
      "rtph263pdepay", 0, 0, FALSE);
488
}
489
490

GST_END_TEST;
491
static const guint8 rtp_h264_frame_data[] =
492
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
493
494
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
495

496
static int rtp_h264_frame_data_size = 20;
497

498
499
500
501
static int rtp_h264_frame_count = 1;

GST_START_TEST (rtp_h264)
{
502
  /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
503
  rtp_pipeline_test (rtp_h264_frame_data, rtp_h264_frame_data_size,
504
505
506
507
508
      rtp_h264_frame_count, "video/x-h264", "rtph264pay", "rtph264depay",
      0, 0, FALSE);
}

GST_END_TEST;
509
static const guint8 rtp_h264_list_lt_mtu_frame_data[] =
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
    /* not packetized, next NAL starts with 0001 */
{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
  0xad, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00
};

static int rtp_h264_list_lt_mtu_frame_data_size = 16;

static int rtp_h264_list_lt_mtu_frame_count = 2;

/* NAL = 4 bytes */
static int rtp_h264_list_lt_mtu_bytes_sent = 2 * (16 - 4);

static int rtp_h264_list_lt_mtu_mtu_size = 1024;

GST_START_TEST (rtp_h264_list_lt_mtu)
{
527
  /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
528
529
530
531
532
533
534
  rtp_pipeline_test (rtp_h264_list_lt_mtu_frame_data,
      rtp_h264_list_lt_mtu_frame_data_size, rtp_h264_list_lt_mtu_frame_count,
      "video/x-h264", "rtph264pay", "rtph264depay",
      rtp_h264_list_lt_mtu_bytes_sent, rtp_h264_list_lt_mtu_mtu_size, TRUE);
}

GST_END_TEST;
535
static const guint8 rtp_h264_list_gt_mtu_frame_data[] =
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
    /* not packetized, next NAL starts with 0001 */
{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

static int rtp_h264_list_gt_mtu_frame_data_size = 64;

static int rtp_h264_list_gt_mtu_frame_count = 1;

/* NAL = 4 bytes. When data does not fit into 1 mtu, 1 byte will be skipped */
static int rtp_h264_list_gt_mtu_bytes_sent = 1 * (64 - 4) - 1;

static int rtp_h264_list_gt_mtu_mty_size = 28;

GST_START_TEST (rtp_h264_list_gt_mtu)
{
556
  /* FIXME 0.11: fully specify h264 caps (and make payloader check) */
557
558
559
560
  rtp_pipeline_test (rtp_h264_list_gt_mtu_frame_data,
      rtp_h264_list_gt_mtu_frame_data_size, rtp_h264_list_gt_mtu_frame_count,
      "video/x-h264", "rtph264pay", "rtph264depay",
      rtp_h264_list_gt_mtu_bytes_sent, rtp_h264_list_gt_mtu_mty_size, TRUE);
561
}
562
563

GST_END_TEST;
564
static const guint8 rtp_L16_frame_data[] =
565
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
566
567
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
568

569
static int rtp_L16_frame_data_size = 20;
570

571
572
573
574
575
576
577
static int rtp_L16_frame_count = 1;

GST_START_TEST (rtp_L16)
{
  rtp_pipeline_test (rtp_L16_frame_data, rtp_L16_frame_data_size,
      rtp_L16_frame_count,
      "audio/x-raw-int,endianess=4321,signed=true,width=16,depth=16,rate=1,channels=1",
578
      "rtpL16pay", "rtpL16depay", 0, 0, FALSE);
579
}
580
581

GST_END_TEST;
582
static const guint8 rtp_mp2t_frame_data[] =
583
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
584
585
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
586

587
static int rtp_mp2t_frame_data_size = 20;
588

589
590
591
592
593
594
static int rtp_mp2t_frame_count = 1;

GST_START_TEST (rtp_mp2t)
{
  rtp_pipeline_test (rtp_mp2t_frame_data, rtp_mp2t_frame_data_size,
      rtp_mp2t_frame_count, "video/mpegts,packetsize=188,systemstream=true",
595
      "rtpmp2tpay", "rtpmp2tdepay", 0, 0, FALSE);
596
}
597
598

GST_END_TEST;
599
static const guint8 rtp_mp4v_frame_data[] =
600
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
601
602
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
603

604
static int rtp_mp4v_frame_data_size = 20;
605

606
607
608
609
610
611
static int rtp_mp4v_frame_count = 1;

GST_START_TEST (rtp_mp4v)
{
  rtp_pipeline_test (rtp_mp4v_frame_data, rtp_mp4v_frame_data_size,
      rtp_mp4v_frame_count, "video/mpeg,mpegversion=4,systemstream=false",
612
613
614
615
      "rtpmp4vpay", "rtpmp4vdepay", 0, 0, FALSE);
}

GST_END_TEST;
616
static const guint8 rtp_mp4v_list_frame_data[] =
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

static int rtp_mp4v_list_frame_data_size = 20;

static int rtp_mp4v_list_frame_count = 1;

static int rtp_mp4v_list_bytes_sent = 1 * 20;

GST_START_TEST (rtp_mp4v_list)
{
  rtp_pipeline_test (rtp_mp4v_list_frame_data, rtp_mp4v_list_frame_data_size,
      rtp_mp4v_list_frame_count,
      "video/mpeg,mpegversion=4,codec_data=(buffer)000001b001",
      "rtpmp4vpay", "rtpmp4vdepay", rtp_mp4v_list_bytes_sent, 0, TRUE);
633
}
634
635

GST_END_TEST;
636
static const guint8 rtp_mp4g_frame_data[] =
637
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
638
639
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
640

641
static int rtp_mp4g_frame_data_size = 20;
642

643
644
645
646
647
static int rtp_mp4g_frame_count = 1;

GST_START_TEST (rtp_mp4g)
{
  rtp_pipeline_test (rtp_mp4g_frame_data, rtp_mp4g_frame_data_size,
Wim Taymans's avatar
Wim Taymans committed
648
649
      rtp_mp4g_frame_count,
      "video/mpeg,mpegversion=4,codec_data=(buffer)000001b001", "rtpmp4gpay",
650
      "rtpmp4gdepay", 0, 0, FALSE);
651
}
652
653

GST_END_TEST;
654
static const guint8 rtp_theora_frame_data[] =
655
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
656
657
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
658

659
static int rtp_theora_frame_data_size = 20;
660

661
662
663
664
665
666
static int rtp_theora_frame_count = 1;

GST_START_TEST (rtp_theora)
{
  rtp_pipeline_test (rtp_theora_frame_data, rtp_theora_frame_data_size,
      rtp_theora_frame_count, "video/x-theora", "rtptheorapay",
667
      "rtptheoradepay", 0, 0, FALSE);
668
}
669
670

GST_END_TEST;
671
static const guint8 rtp_vorbis_frame_data[] =
672
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
673
674
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
675

676
static int rtp_vorbis_frame_data_size = 20;
677

678
679
680
681
682
683
static int rtp_vorbis_frame_count = 1;

GST_START_TEST (rtp_vorbis)
{
  rtp_pipeline_test (rtp_vorbis_frame_data, rtp_vorbis_frame_data_size,
      rtp_vorbis_frame_count, "audio/x-vorbis", "rtpvorbispay",
684
685
686
687
      "rtpvorbisdepay", 0, 0, FALSE);
}

GST_END_TEST;
688
static const guint8 rtp_jpeg_frame_data[] =
689
    { /* SOF */ 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08,
Wim Taymans's avatar
Wim Taymans committed
690
691
692
693
694
695
696
697
698
699
  0x03, 0x00, 0x21, 0x08, 0x01, 0x11, 0x08, 0x02, 0x11, 0x08,
  /* DQT */ 0xFF, 0xDB, 0x00, 0x43, 0x08,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
700
701
702
  /* DATA */ 0x00, 0x00, 0x00, 0x00, 0x00
};

Wim Taymans's avatar
Wim Taymans committed
703
static int rtp_jpeg_frame_data_size = sizeof (rtp_jpeg_frame_data);
704
705
706
707
708
709
710
711
712
713
714

static int rtp_jpeg_frame_count = 1;

GST_START_TEST (rtp_jpeg)
{
  rtp_pipeline_test (rtp_jpeg_frame_data, rtp_jpeg_frame_data_size,
      rtp_jpeg_frame_count, "video/x-jpeg,height=640,width=480", "rtpjpegpay",
      "rtpjpegdepay", 0, 0, FALSE);
}

GST_END_TEST;
715
static const guint8 rtp_jpeg_list_frame_data[] =
716
    { /* SOF */ 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08,
Wim Taymans's avatar
Wim Taymans committed
717
718
719
720
721
722
723
724
725
726
  0x03, 0x00, 0x21, 0x08, 0x01, 0x11, 0x08, 0x02, 0x11, 0x08,
  /* DQT */ 0xFF, 0xDB, 0x00, 0x43, 0x08,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
727
728
729
  /* DATA */ 0x00, 0x00, 0x00, 0x00, 0x00
};

Wim Taymans's avatar
Wim Taymans committed
730
static int rtp_jpeg_list_frame_data_size = sizeof (rtp_jpeg_list_frame_data);
731
732
733

static int rtp_jpeg_list_frame_count = 1;

Wim Taymans's avatar
Wim Taymans committed
734
static int rtp_jpeg_list_bytes_sent = 1 * sizeof (rtp_jpeg_list_frame_data);
735
736
737
738
739
740

GST_START_TEST (rtp_jpeg_list)
{
  rtp_pipeline_test (rtp_jpeg_list_frame_data, rtp_jpeg_list_frame_data_size,
      rtp_jpeg_list_frame_count, "video/x-jpeg,height=640,width=480",
      "rtpjpegpay", "rtpjpegdepay", rtp_jpeg_list_bytes_sent, 0, TRUE);
741
742
}

743
GST_END_TEST;
744
static const guint8 rtp_g729_frame_data[] =
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

static int rtp_g729_frame_data_size = 22;

static int rtp_g729_frame_count = 1;

GST_START_TEST (rtp_g729)
{
  rtp_pipeline_test (rtp_g729_frame_data, rtp_g729_frame_data_size,
      rtp_g729_frame_count, "audio/G729", "rtpg729pay",
      "rtpg729depay", 0, 0, FALSE);
}

GST_END_TEST;

762
763
764
765
766
/*
 * Creates the test suite.
 *
 * Returns: pointer to the test suite.
 */
767
static Suite *
768
rtp_payloading_suite (void)
769
770
{
  Suite *s = suite_create ("rtp_data_test");
771

772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
  TCase *tc_chain = tcase_create ("linear");

  /* Set timeout to 60 seconds. */
  tcase_set_timeout (tc_chain, 60);

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, rtp_ilbc);
  tcase_add_test (tc_chain, rtp_gsm);
  tcase_add_test (tc_chain, rtp_amr);
  tcase_add_test (tc_chain, rtp_pcma);
  tcase_add_test (tc_chain, rtp_pcmu);
  tcase_add_test (tc_chain, rtp_mpa);
  tcase_add_test (tc_chain, rtp_h263);
  tcase_add_test (tc_chain, rtp_h263p);
  tcase_add_test (tc_chain, rtp_h264);
787
788
  tcase_add_test (tc_chain, rtp_h264_list_lt_mtu);
  tcase_add_test (tc_chain, rtp_h264_list_gt_mtu);
789
790
791
  tcase_add_test (tc_chain, rtp_L16);
  tcase_add_test (tc_chain, rtp_mp2t);
  tcase_add_test (tc_chain, rtp_mp4v);
792
  tcase_add_test (tc_chain, rtp_mp4v_list);
793
794
795
  tcase_add_test (tc_chain, rtp_mp4g);
  tcase_add_test (tc_chain, rtp_theora);
  tcase_add_test (tc_chain, rtp_vorbis);
796
797
  tcase_add_test (tc_chain, rtp_jpeg);
  tcase_add_test (tc_chain, rtp_jpeg_list);
798
  tcase_add_test (tc_chain, rtp_g729);
799
800
801
  return s;
}

802
GST_CHECK_MAIN (rtp_payloading)