--- /dev/null
+/*
+ * GStreamer AVTP Plugin
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ */
+
+#include <gst/check/gstcheck.h>
+#include <gst/check/gstharness.h>
+
+#include <avtp.h>
+#include <avtp_cvf.h>
+
+#define AVTP_CVF_H264_HEADER_SIZE (sizeof(struct avtp_stream_pdu) + sizeof(guint32))
+#define STREAM_ID 0xAABBCCDDEEFF0001
+
+/* Simple codec data, with only the NAL size len, no SPS/PPS. */
+static GstCaps *
+generate_caps (guint8 nal_size_len)
+{
+ GstBuffer *codec_data;
+ GstMapInfo map;
+ GstCaps *caps;
+
+ /* 7 is the minimal codec_data size, when no SPS/PPS is sent */
+ codec_data = gst_buffer_new_allocate (NULL, 7, NULL);
+ gst_buffer_map (codec_data, &map, GST_MAP_READWRITE);
+
+ memset (map.data, 0, map.size);
+ map.data[0] = 1; /* version */
+ map.data[4] = (nal_size_len - 1) | 0xfc; /* Other 6 bits are 1 */
+ map.data[5] = 0xe0; /* first 3 bits are 1 */
+
+ gst_buffer_unmap (codec_data, &map);
+
+ caps = gst_caps_new_simple ("video/x-h264",
+ "stream-format", G_TYPE_STRING, "avc",
+ "alignment", G_TYPE_STRING, "au",
+ "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
+ gst_buffer_unref (codec_data);
+
+ return caps;
+}
+
+static void
+fill (guint8 * buf, gsize size)
+{
+ guint8 i = 0;
+
+ while (size--)
+ *buf++ = i++;
+}
+
+static gboolean
+check_nal_filling (GstBuffer * buffer, guint8 first)
+{
+ GstMapInfo map;
+ gint i;
+ gsize offset = AVTP_CVF_H264_HEADER_SIZE + 1;
+ gboolean result = TRUE;
+
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ if ((map.data[AVTP_CVF_H264_HEADER_SIZE] & 0x1f) == 28)
+ offset++; /* Fragmented NALs have 2 bytes header */
+
+ for (i = offset; i < map.size; i++) {
+ if (map.data[i] != first++) {
+ result = FALSE;
+ break;
+ }
+ }
+
+ return result;
+}
+
+static void
+add_nal (GstBuffer * buffer, gsize size, guint type, gsize offset)
+{
+ GstMapInfo map;
+
+ gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
+
+ map.data[offset] = map.data[offset + 1] = 0;
+ map.data[offset + 2] = size >> 8;
+ map.data[offset + 3] = size & 0xff;
+ map.data[offset + 4] = type & 0x1f;
+ fill (&map.data[offset + 5], size - 1);
+
+ gst_buffer_unmap (buffer, &map);
+}
+
+/* This function assumes that NAL size len is 2 */
+static void
+add_nal_2 (GstBuffer * buffer, gsize size, guint type, gsize offset)
+{
+ GstMapInfo map;
+
+ gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
+
+ map.data[offset] = size >> 8;
+ map.data[offset + 1] = size & 0xff;
+ map.data[offset + 2] = type & 0x1f;
+ fill (&map.data[offset + 3], size - 1);
+
+ gst_buffer_unmap (buffer, &map);
+}
+
+static gboolean
+compare_h264_avtpdu (struct avtp_stream_pdu *pdu, GstBuffer * buffer)
+{
+ GstMapInfo map;
+ gboolean result;
+
+ gst_buffer_map (buffer, &map, GST_MAP_READ);
+ /* buffer must have at least the header size */
+ if (map.size < AVTP_CVF_H264_HEADER_SIZE)
+ return FALSE;
+
+ result = memcmp (map.data, pdu, AVTP_CVF_H264_HEADER_SIZE) == 0;
+
+ gst_buffer_unmap (buffer, &map);
+
+ return result;
+}
+
+GST_START_TEST (test_payloader_no_codec_data)
+{
+ GstHarness *h;
+ GstCaps *caps;
+ GstBuffer *in;
+
+ /* Caps without codec_data */
+ caps = gst_caps_new_simple ("video/x-h264",
+ "stream-format", G_TYPE_STRING, "avc",
+ "alignment", G_TYPE_STRING, "au", NULL);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=0");
+ gst_harness_set_src_caps (h, caps);
+
+ /* No buffer should come out when we send input */
+ in = gst_harness_create_buffer (h, 8);
+ add_nal (in, 4, 1, 0);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ gst_harness_push (h, in);
+ fail_unless_equals_int (gst_harness_buffers_received (h), 0);
+
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_invalid_caps)
+{
+ GstBuffer *codec_data;
+ GstElement *element;
+ GstPad *sinkpad;
+ GstMapInfo map;
+ GstCaps *caps;
+ GstHarness *h;
+
+ /* 7 is the minimal codec_data size, when no SPS/PPS is sent */
+ codec_data = gst_buffer_new_allocate (NULL, 7, NULL);
+ gst_buffer_map (codec_data, &map, GST_MAP_READWRITE);
+
+ memset (map.data, 0, map.size);
+ map.data[0] = 0; /* version */
+ map.data[4] = 0x03 | 0xfc; /* Other 6 bits are 1 */
+ map.data[5] = 0xe0; /* first 3 bits are 1 */
+
+ gst_buffer_unmap (codec_data, &map);
+
+ caps = gst_caps_new_simple ("video/x-h264",
+ "stream-format", G_TYPE_STRING, "avc",
+ "alignment", G_TYPE_STRING, "au",
+ "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
+ gst_buffer_unref (codec_data);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000");
+ element = gst_harness_find_element (h, "avtpcvfpay");
+ sinkpad = gst_element_get_static_pad (element, "sink");
+
+ /* 'codec_data' caps has invalid version */
+ gst_harness_push_event (h, gst_event_new_caps (caps));
+ fail_unless (gst_pad_get_current_caps (sinkpad) == NULL);
+ gst_caps_unref (caps);
+
+ /* Send a 'codec_data' too small */
+ codec_data = gst_buffer_new_allocate (NULL, 6, NULL);
+ caps = gst_caps_new_simple ("video/x-h264",
+ "stream-format", G_TYPE_STRING, "avc",
+ "alignment", G_TYPE_STRING, "au",
+ "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
+ gst_buffer_unref (codec_data);
+
+ gst_harness_push_event (h, gst_event_new_caps (caps));
+ fail_unless (gst_pad_get_current_caps (sinkpad) == NULL);
+ gst_caps_unref (caps);
+
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_incomplete_nal)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ GstMapInfo map;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN = sizeof (guint32) + 3;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 4000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=0");
+ gst_harness_set_src_caps (h, generate_caps (4));
+
+ /* Buffer must have the nal len (4 bytes) and the nal (3 bytes) */
+ in = gst_harness_create_buffer (h, 7);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ gst_buffer_map (in, &map, GST_MAP_READWRITE);
+ map.data[0] = map.data[1] = map.data[2] = 0;
+ map.data[3] = 8; /* Lie that NAL size is 8, when buffer is only 7 (so NAL is 3) */
+ map.data[4] = 1; /* Some dummy vcl NAL type */
+ map.data[5] = 0x0;
+ map.data[6] = 0x1;
+
+ out = gst_harness_push_and_pull (h, in);
+
+ /* avtpcvfpay will happily payload the three byte nal. Now, we check it */
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_properties)
+{
+ GstHarness *h;
+ GstElement *element;
+ guint mtu, mtt, tu;
+ guint64 streamid, processing_deadline;
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=2000000 mtu=100 processing-deadline=5000");
+
+ /* Check if all properties were properly set up */
+ element = gst_harness_find_element (h, "avtpcvfpay");
+ g_object_get (G_OBJECT (element), "mtt", &mtt, NULL);
+ fail_unless_equals_uint64 (mtt, 1000000);
+
+ g_object_get (G_OBJECT (element), "mtu", &mtu, NULL);
+ fail_unless_equals_uint64 (mtu, 100);
+
+ g_object_get (G_OBJECT (element), "tu", &tu, NULL);
+ fail_unless_equals_uint64 (tu, 2000000);
+
+ g_object_get (G_OBJECT (element), "streamid", &streamid, NULL);
+ fail_unless_equals_uint64 (streamid, 0xAABBCCDDEEFF0001);
+
+ g_object_get (G_OBJECT (element), "processing-deadline", &processing_deadline,
+ NULL);
+ fail_unless_equals_uint64 (processing_deadline, 5000);
+
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+GST_START_TEST (test_payloader_single_and_fragment_edge)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN_1 = sizeof (guint32) + 100;
+ const gint DATA_LEN_2 = sizeof (guint32) + 100;
+ const gint DATA_LEN_3 = sizeof (guint32) + 4;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 4000000);
+
+ /* Create the harness for the avtpcvfpay. Setting mtu=128 ensures that
+ * NAL units will be broken roughly at 100 bytes. More details below. */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 mtu=128 processing-deadline=0");
+ gst_harness_set_src_caps (h, generate_caps (4));
+
+ /* Create a buffer to contain the multiple NAL units. This buffer
+ * will hold two NAL units, with 100 and 101 bytes, each preceded
+ * by a 4 bytes header */
+ in = gst_harness_create_buffer (h, 100 + 101 + 2 * 4);
+ add_nal (in, 100, 7, 0);
+ add_nal (in, 101, 1, 104);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ /* We now push the buffer, and check if we get three from the avtpcvfpay */
+ gst_harness_push (h, in);
+ fail_unless (gst_harness_buffers_received (h) == 3);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 0);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 0);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ gst_buffer_unref (out);
+
+ /* DATA_LEN_3 is 4 because only 98 bytes from the original NAL unit are
+ * sent on the first buffer (due 2 bytes header), and the two remaining
+ * bytes are preceded by the 2 bytes header. Note that the first byte of
+ * the NAL is stripped before the fragmentation (see comment on
+ * test_payloader_single_and_fragment below for more details). */
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_3);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_single_and_fragment)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN_1 = sizeof (guint32) + 4;
+ const gint DATA_LEN_2 = sizeof (guint32) + 100;
+ const gint DATA_LEN_3 = sizeof (guint32) + 100;
+ const gint DATA_LEN_4 = sizeof (guint32) + 55;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 4000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 5000000);
+
+ /* Create the harness for the avtpcvfpay. Setting mtu=128 ensures that
+ * NAL units will be broken roughly at 100 bytes. More details below. */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=1000000 mtu=128");
+ gst_harness_set_src_caps (h, generate_caps (4));
+
+ /* Create a buffer to contain the multiple NAL units. This buffer
+ * will hold two NAL units, with 4 and 250 bytes, each preceded
+ * by a 4 bytes header */
+ in = gst_harness_create_buffer (h, 4 + 250 + 2 * 4);
+ add_nal (in, 4, 7, 0);
+ add_nal (in, 250, 1, 8);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ /* We now push the buffer, and check if we get four from the avtpcvfpay */
+ gst_harness_push (h, in);
+ fail_unless (gst_harness_buffers_received (h) == 4);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 0);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 0);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_3);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 0);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 0);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 98) == TRUE);
+ gst_buffer_unref (out);
+
+ /* For those wondering why DATA_LEN_4 is 55 and not 50 - or why
+ * comment above states that NAL units are broken "rougly" at 100 bytes:
+ * With mtu=128, there are only 100 bytes left for NAL units, so anything
+ * bigger will be broken. But AVTP NAL units fragments have a header with
+ * two bytes, so NAL units will use only 98 bytes. This leaves the last
+ * fragment with 54 bytes. However, instead of being 56 (54 bytes plus
+ * 2 bytes header), it is 55 (53 bytes plus 2 bytes header) due to the
+ * fact that the first byte of the NAL unit (the NAL unit header) is
+ * in fact stripped from the NAL unit before the fragmentation. */
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_4);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 3);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 4000000);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 196) == TRUE);
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_multiple_single_2)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN_1 = sizeof (guint32) + 32;
+ const gint DATA_LEN_2 = sizeof (guint32) + 16;
+ const gint DATA_LEN_3 = sizeof (guint32) + 8;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 4000000);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=0");
+ gst_harness_set_src_caps (h, generate_caps (2));
+
+ /* Create a buffer to contain the multiple NAL units. This buffer
+ * will hold three NAL units, with 32, 16 and 8 bytes, each preceded
+ * by a 2 bytes header */
+ in = gst_harness_create_buffer (h, 32 + 16 + 8 + 4 * 2);
+ add_nal_2 (in, 32, 7, 0);
+ add_nal_2 (in, 16, 7, 34);
+ add_nal_2 (in, 8, 1, 52);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ /* We now push the buffer, and check if we get three from the avtpcvfpay */
+ gst_harness_push (h, in);
+ fail_unless (gst_harness_buffers_received (h) == 3);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_3);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_multiple_single)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN_1 = sizeof (guint32) + 32;
+ const gint DATA_LEN_2 = sizeof (guint32) + 16;
+ const gint DATA_LEN_3 = sizeof (guint32) + 8;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 4000000);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=0");
+ gst_harness_set_src_caps (h, generate_caps (4));
+
+ /* Create a buffer to contain the multiple NAL units. This buffer
+ * will hold three NAL units, with 32, 16 and 8 bytes, each preceded
+ * by a 4 bytes header */
+ in = gst_harness_create_buffer (h, 32 + 16 + 8 + 4 * 4);
+ add_nal (in, 32, 7, 0);
+ add_nal (in, 16, 7, 36);
+ add_nal (in, 8, 1, 56);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ /* We now push the buffer, and check if we get three from the avtpcvfpay */
+ gst_harness_push (h, in);
+ fail_unless (gst_harness_buffers_received (h) == 3);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+
+ out = gst_harness_pull (h);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN_3);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 2);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_payloader_single)
+{
+ GstHarness *h;
+ GstBuffer *in, *out;
+ struct avtp_stream_pdu *pdu = alloca (AVTP_CVF_H264_HEADER_SIZE);
+ const gint DATA_LEN = sizeof (guint32) + 4;
+
+ /* Create the 'expected' header */
+ avtp_cvf_pdu_init (pdu, AVTP_CVF_FORMAT_SUBTYPE_H264);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_ID, STREAM_ID);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_TIMESTAMP, 3000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_PTV, 1);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_H264_TIMESTAMP, 4000000);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_STREAM_DATA_LEN, DATA_LEN);
+
+ /* Create the harness for the avtpcvfpay */
+ h = gst_harness_new_parse
+ ("avtpcvfpay streamid=0xAABBCCDDEEFF0001 mtt=1000000 tu=1000000 processing-deadline=0");
+ gst_harness_set_src_caps (h, generate_caps (4));
+
+ /* Buffer must have the nal len (4 bytes) and the nal (4 bytes) */
+ in = gst_harness_create_buffer (h, 8);
+ add_nal (in, 4, 1, 0);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ out = gst_harness_push_and_pull (h, in);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ gst_buffer_unref (out);
+
+ /* Now test if, when nal_type is not vcl (not between 1 and 5), M is not set.
+ * Also, as we're using the same element, seqnum should increase by one */
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_M, 0);
+ avtp_cvf_pdu_set (pdu, AVTP_CVF_FIELD_SEQ_NUM, 1);
+
+ in = gst_harness_create_buffer (h, 8);
+ add_nal (in, 4, 6, 0);
+ GST_BUFFER_DTS (in) = 1000000;
+ GST_BUFFER_PTS (in) = 2000000;
+
+ out = gst_harness_push_and_pull (h, in);
+ fail_unless (compare_h264_avtpdu (pdu, out) == TRUE);
+ fail_unless (check_nal_filling (out, 0) == TRUE);
+ gst_buffer_unref (out);
+ gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+static Suite *
+avtpcvfpay_suite (void)
+{
+ Suite *s = suite_create ("avtpcvfpay");
+ TCase *tc_chain = tcase_create ("general");
+
+ suite_add_tcase (s, tc_chain);
+ tcase_add_test (tc_chain, test_payloader_single);
+ tcase_add_test (tc_chain, test_payloader_multiple_single);
+ tcase_add_test (tc_chain, test_payloader_multiple_single_2);
+ tcase_add_test (tc_chain, test_payloader_single_and_fragment);
+ tcase_add_test (tc_chain, test_payloader_single_and_fragment_edge);
+ tcase_add_test (tc_chain, test_payloader_incomplete_nal);
+ tcase_add_test (tc_chain, test_payloader_invalid_caps);
+ tcase_add_test (tc_chain, test_payloader_properties);
+ tcase_add_test (tc_chain, test_payloader_no_codec_data);
+
+ return s;
+}
+
+GST_CHECK_MAIN (avtpcvfpay);
projects / platform / upstream / gstreamer.git / commitdiff