tests/check/elements/rtpbin_buffer_list.c

   1 /* GStreamer
   2  *
   3  * Unit test for gstrtpbin sending rtp packets using GstBufferList.
   4  * Copyright (C) 2009 Branko Subasic <branko dot subasic at axis dot com>
   5  * Copyright 2019, Collabora Ltd.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include <gst/check/gstcheck.h>
  24
  25 #include <gst/rtp/gstrtpbuffer.h>
  26
  27
  28 /* This test makes sure that RTP packets sent as buffer lists are sent through
  29  * the rtpbin as they are supposed to, and not corrupted in any way.
  30  */
  31
  32
  33 #define TEST_CAPS \
  34   "application/x-rtp, "                \
  35   "media=(string)video, "              \
  36   "clock-rate=(int)90000, "            \
  37   "encoding-name=(string)H264, "       \
  38   "profile-level-id=(string)4d4015, "  \
  39   "payload=(int)96, "                  \
  40   "ssrc=(guint)2633237432, "           \
  41   "clock-base=(guint)1868267015, "     \
  42   "seqnum-base=(guint)54229"
  43
  44
  45 /* RTP headers and the first 2 bytes of the payload (FU indicator and FU header)
  46  */
  47 static const guint8 rtp_header[2][14] = {
  48   {0x80, 0x60, 0xbb, 0xb7, 0x5c, 0xe9, 0x09,
  49       0x0d, 0xf5, 0x9c, 0x43, 0x55, 0x1c, 0x86},
  50   {0x80, 0x60, 0xbb, 0xb8, 0x5c, 0xe9, 0x09,
  51       0x0d, 0xf5, 0x9c, 0x43, 0x55, 0x1c, 0x46}
  52 };
  53
  54 static const guint rtp_header_len[] = {
  55   sizeof rtp_header[0],
  56   sizeof rtp_header[1]
  57 };
  58
  59 /* Some payload.
  60  */
  61 static const char *payload =
  62     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  63     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  64     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  65     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  66     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  67     "0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF0123456789ABSDEF"
  68     "0123456789ABSDEF0123456";
  69
  70 static const guint payload_offset[] = {
  71   0, 498
  72 };
  73
  74 static const guint payload_len[] = {
  75   498, 5
  76 };
  77
  78
  79 static GstBuffer *original_buffer = NULL;
  80
  81 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  82     GST_PAD_SINK,
  83     GST_PAD_ALWAYS,
  84     GST_STATIC_CAPS ("application/x-rtp"));
  85
  86 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  87     GST_PAD_SRC,
  88     GST_PAD_ALWAYS,
  89     GST_STATIC_CAPS ("application/x-rtp"));
  90
  91
  92 static GstBuffer *
  93 create_original_buffer (void)
  94 {
  95   if (original_buffer != NULL)
  96     return original_buffer;
  97
  98   original_buffer =
  99       gst_buffer_new_wrapped ((guint8 *) payload, strlen (payload));
 100   fail_unless (original_buffer != NULL);
 101
 102   GST_BUFFER_TIMESTAMP (original_buffer) =
 103       gst_clock_get_internal_time (gst_system_clock_obtain ());
 104
 105   return original_buffer;
 106 }
 107
 108 static GstBuffer *
 109 create_rtp_packet_buffer (gconstpointer header, gint header_size,
 110     GstBuffer * payload_buffer, gint payload_offset, gint payload_size)
 111 {
 112   GstBuffer *buffer;
 113   GstBuffer *sub_buffer;
 114
 115   /* Create buffer with RTP header. */
 116   buffer = gst_buffer_new_allocate (NULL, header_size, NULL);
 117   gst_buffer_fill (buffer, 0, header, header_size);
 118   gst_buffer_copy_into (buffer, payload_buffer, GST_BUFFER_COPY_METADATA, 0,
 119       -1);
 120
 121   /* Create the payload buffer and add it to the current buffer. */
 122   sub_buffer =
 123       gst_buffer_copy_region (payload_buffer, GST_BUFFER_COPY_MEMORY,
 124       payload_offset, payload_size);
 125
 126   buffer = gst_buffer_append (buffer, sub_buffer);
 127   fail_if (buffer == NULL);
 128
 129   return buffer;
 130 }
 131
 132 static void
 133 check_header (GstBuffer * buffer, guint index)
 134 {
 135   GstMemory *memory;
 136   GstMapInfo info;
 137   gboolean ret;
 138
 139   fail_if (buffer == NULL);
 140   fail_unless (index < 2);
 141
 142   memory = gst_buffer_get_memory (buffer, 0);
 143   ret = gst_memory_map (memory, &info, GST_MAP_READ);
 144   fail_if (ret == FALSE);
 145
 146   fail_unless (info.size == rtp_header_len[index]);
 147
 148   /* Can't do a memcmp() on the whole header, cause the SSRC (bytes 8-11) will
 149    * most likely be changed in gstrtpbin.
 150    */
 151   fail_unless (info.data != NULL);
 152   fail_unless_equals_uint64 (*(guint64 *) info.data,
 153       *(guint64 *) rtp_header[index]);
 154   fail_unless (*(guint16 *) (info.data + 12) ==
 155       *(guint16 *) (rtp_header[index] + 12));
 156
 157   gst_memory_unmap (memory, &info);
 158   gst_memory_unref (memory);
 159 }
 160
 161 static void
 162 check_payload (GstBuffer * buffer, guint index)
 163 {
 164   GstMemory *memory;
 165   GstMapInfo info;
 166   gboolean ret;
 167
 168   fail_if (buffer == NULL);
 169   fail_unless (index < 2);
 170
 171   memory = gst_buffer_get_memory (buffer, 1);
 172   ret = gst_memory_map (memory, &info, GST_MAP_READ);
 173   fail_if (ret == FALSE);
 174
 175   fail_unless (info.size == payload_len[index]);
 176   fail_if (info.data != (gpointer) (payload + payload_offset[index]));
 177   fail_if (memcmp (info.data, payload + payload_offset[index],
 178           payload_len[index]));
 179
 180   gst_memory_unmap (memory, &info);
 181   gst_memory_unref (memory);
 182 }
 183
 184 static void
 185 check_packet (GstBufferList * list, guint list_index, guint packet_index)
 186 {
 187   GstBuffer *buffer;
 188
 189   fail_unless (list != NULL);
 190
 191   fail_unless ((buffer = gst_buffer_list_get (list, list_index)) != NULL);
 192   fail_unless (gst_buffer_n_memory (buffer) == 2);
 193
 194   fail_unless (GST_BUFFER_TIMESTAMP (buffer) ==
 195       GST_BUFFER_TIMESTAMP (original_buffer));
 196
 197   check_header (buffer, packet_index);
 198   check_payload (buffer, packet_index);
 199 }
 200
 201 /*
 202  * Used to verify that the chain_list function is actually implemented by the
 203  * element and called when executing the pipeline. This is needed because pads
 204  * always have a default chain_list handler which handle buffers in a buffer
 205  * list individually, and pushing a list to a pad can succeed even if no
 206  * chain_list handler has been set.
 207  */
 208 static gboolean chain_list_func_called;
 209
 210 /* Create two packets with different payloads. */
 211 static GstBufferList *
 212 create_buffer_list (void)
 213 {
 214   GstBufferList *list;
 215   GstBuffer *orig_buffer;
 216   GstBuffer *buffer;
 217
 218   orig_buffer = create_original_buffer ();
 219   fail_if (orig_buffer == NULL);
 220
 221   list = gst_buffer_list_new ();
 222   fail_if (list == NULL);
 223
 224   /*** First packet. **/
 225   buffer =
 226       create_rtp_packet_buffer (&rtp_header[0], rtp_header_len[0], orig_buffer,
 227       payload_offset[0], payload_len[0]);
 228   gst_buffer_list_add (list, buffer);
 229
 230   /***  Second packet. ***/
 231   buffer =
 232       create_rtp_packet_buffer (&rtp_header[1], rtp_header_len[1], orig_buffer,
 233       payload_offset[1], payload_len[1]);
 234   gst_buffer_list_add (list, buffer);
 235
 236   return list;
 237 }
 238
 239 /* Check that the correct packets have been pushed out of the element. */
 240 static GstFlowReturn
 241 sink_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list)
 242 {
 243   GstCaps *current_caps;
 244   GstCaps *caps;
 245
 246   chain_list_func_called = TRUE;
 247
 248   current_caps = gst_pad_get_current_caps (pad);
 249   fail_unless (current_caps != NULL);
 250
 251   caps = gst_caps_from_string (TEST_CAPS);
 252   fail_unless (caps != NULL);
 253
 254   fail_unless (gst_caps_is_equal (caps, current_caps));
 255   gst_caps_unref (caps);
 256   gst_caps_unref (current_caps);
 257
 258   fail_unless (GST_IS_BUFFER_LIST (list));
 259   fail_unless (gst_buffer_list_length (list) == 2);
 260
 261   fail_unless (gst_buffer_list_get (list, 0));
 262   check_packet (list, 0, 0);
 263
 264   fail_unless (gst_buffer_list_get (list, 1));
 265   check_packet (list, 1, 1);
 266
 267   gst_buffer_list_unref (list);
 268
 269   return GST_FLOW_OK;
 270 }
 271
 272
 273 GST_START_TEST (test_bufferlist)
 274 {
 275   GstElement *rtpbin;
 276   GstPad *srcpad;
 277   GstPad *sinkpad;
 278   GstCaps *caps;
 279   GstBufferList *list;
 280
 281   list = create_buffer_list ();
 282   fail_unless (list != NULL);
 283
 284   rtpbin = gst_check_setup_element ("rtpbin");
 285
 286   srcpad =
 287       gst_check_setup_src_pad_by_name (rtpbin, &srctemplate, "send_rtp_sink_0");
 288   fail_if (srcpad == NULL);
 289   sinkpad =
 290       gst_check_setup_sink_pad_by_name (rtpbin, &sinktemplate,
 291       "send_rtp_src_0");
 292   fail_if (sinkpad == NULL);
 293
 294   gst_pad_set_chain_list_function (sinkpad,
 295       GST_DEBUG_FUNCPTR (sink_chain_list));
 296
 297   gst_pad_set_active (srcpad, TRUE);
 298   gst_pad_set_active (sinkpad, TRUE);
 299
 300   caps = gst_caps_from_string (TEST_CAPS);
 301   gst_check_setup_events (srcpad, rtpbin, caps, GST_FORMAT_TIME);
 302   gst_caps_unref (caps);
 303
 304   gst_element_set_state (rtpbin, GST_STATE_PLAYING);
 305
 306   chain_list_func_called = FALSE;
 307   fail_unless (gst_pad_push_list (srcpad, list) == GST_FLOW_OK);
 308   fail_if (chain_list_func_called == FALSE);
 309
 310   gst_pad_set_active (sinkpad, FALSE);
 311   gst_pad_set_active (srcpad, FALSE);
 312
 313   gst_check_teardown_pad_by_name (rtpbin, "send_rtp_src_0");
 314   gst_check_teardown_pad_by_name (rtpbin, "send_rtp_sink_0");
 315   gst_check_teardown_element (rtpbin);
 316 }
 317
 318 GST_END_TEST;
 319
 320 static Suite *
 321 bufferlist_suite (void)
 322 {
 323   Suite *s = suite_create ("BufferList");
 324
 325   TCase *tc_chain = tcase_create ("general");
 326
 327   /* time out after 30s. */
 328   tcase_set_timeout (tc_chain, 10);
 329
 330   suite_add_tcase (s, tc_chain);
 331   tcase_add_test (tc_chain, test_bufferlist);
 332
 333   return s;
 334 }
 335
 336 GST_CHECK_MAIN (bufferlist);