gstreamer/tests/check/elements/avtpcvfpay.c

/*
 * 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_zero_sized_nal)
{
  GstHarness *h;
  GstBuffer *in;
  GstMapInfo map;

  /* 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));

  /* We have the buffer with the nal size (4 bytes) and the nal (4 bytes), but
   * nal size will be zero */
  in = gst_harness_create_buffer (h, 8);
  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] = map.data[3] = 0;    /* Set NAL size to 0 */
  map.data[4] = 1;              /* Some dummy vcl NAL type */
  gst_buffer_unmap (in, &map);

  gst_harness_push (h, in);

  /* No buffer shuld come out */
  fail_unless_equals_int (gst_harness_buffers_received (h), 0);

  gst_harness_teardown (h);
}

GST_END_TEST;

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 "roughly" 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);
  tcase_add_test (tc_chain, test_payloader_zero_sized_nal);

  return s;
}

GST_CHECK_MAIN (avtpcvfpay);