mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
79d2af5626
Add missing markers. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1335>
711 lines
21 KiB
C
711 lines
21 KiB
C
/*
|
|
* GStreamer AVTP Plugin
|
|
* Copyright (c) 2021, Fastree3D
|
|
* Adrian Fiergolski <Adrian.Fiergolski@fastree3d.com>
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
/**
|
|
* SECTION:element-avtprvfdepay
|
|
* @see_also: avtprvfpay
|
|
*
|
|
* De-payload RVF AVTPDUs into x-raw video according
|
|
* to IEEE 1722-2016. For detailed information see
|
|
* https://standards.ieee.org/standard/1722-2016.html.
|
|
*
|
|
* <refsect2>
|
|
* <title>Example pipeline</title>
|
|
* |[
|
|
* gst-launch-1.0 avtpsrc ! avtprvfdepay ! videoconvert ! autovideosink
|
|
* ]| This example pipeline will de-payload raw video from the AVTPDUs
|
|
* and play them. Refer to the avtprvfpay example to payload raw video and send the
|
|
* AVTP stream.
|
|
* </refsect2>
|
|
* Since: 1.24
|
|
*/
|
|
|
|
#include <avtp.h>
|
|
#include <avtp_rvf.h>
|
|
|
|
#include <gst/video/video.h>
|
|
#include "gstavtprvfdepay.h"
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (avtprvfdepay_debug);
|
|
#define GST_CAT_DEFAULT avtprvfdepay_debug
|
|
|
|
/* prototypes */
|
|
|
|
static GstFlowReturn gst_avtp_rvf_depay_chain (GstPad * pad, GstObject * parent,
|
|
GstBuffer * buffer);
|
|
|
|
static gboolean gst_avtp_rvf_depay_push_caps (GstAvtpVfDepayBase * avtpvfdepay);
|
|
|
|
gboolean is_first_fragment (GstAvtpRvfDepay * avtprvfdepay, GstMapInfo * map);
|
|
gboolean is_last_fragment (GstAvtpRvfDepay * avtprvfdepay, GstMapInfo * map);
|
|
|
|
#define AVTP_RVF_HEADER_SIZE (sizeof(struct avtp_stream_pdu) + sizeof(uint64_t))
|
|
|
|
/* pad templates */
|
|
|
|
static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{GRAY16_LE}"))
|
|
);
|
|
|
|
#define gst_avtp_rvf_depay_parent_class parent_class
|
|
G_DEFINE_TYPE (GstAvtpRvfDepay, gst_avtp_rvf_depay,
|
|
GST_TYPE_AVTP_VF_DEPAY_BASE);
|
|
GST_ELEMENT_REGISTER_DEFINE (avtprvfdepay, "avtprvfdepay", GST_RANK_NONE,
|
|
GST_TYPE_AVTP_RVF_DEPAY);
|
|
|
|
static void
|
|
gst_avtp_rvf_depay_class_init (GstAvtpRvfDepayClass * klass)
|
|
{
|
|
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
|
|
GstAvtpBaseDepayloadClass *avtpbasedepayload_class =
|
|
GST_AVTP_BASE_DEPAYLOAD_CLASS (klass);
|
|
GstAvtpVfDepayBaseClass *avtpvfdepaybase_class =
|
|
GST_AVTP_VF_DEPAY_BASE_CLASS (klass);
|
|
|
|
gst_element_class_add_static_pad_template (element_class, &src_template);
|
|
|
|
gst_element_class_set_static_metadata (element_class,
|
|
"AVTP Raw Video Format (RVF) depayloader",
|
|
"Codec/Depayloader/Network/AVTP",
|
|
"Extracts raw video from RVF AVTPDUs",
|
|
"Adrian Fiergolski <Adrian.Fiergolski@fastree3d.com>");
|
|
|
|
avtpbasedepayload_class->chain = GST_DEBUG_FUNCPTR (gst_avtp_rvf_depay_chain);
|
|
|
|
avtpvfdepaybase_class->depay_push_caps =
|
|
GST_DEBUG_FUNCPTR (gst_avtp_rvf_depay_push_caps);
|
|
|
|
GST_DEBUG_CATEGORY_INIT (avtprvfdepay_debug, "avtprvfdepay",
|
|
0, "debug category for avtprvfdepay element");
|
|
}
|
|
|
|
static void
|
|
gst_avtp_rvf_depay_init (GstAvtpRvfDepay * avtprvfdepay)
|
|
{
|
|
avtprvfdepay->seqnum = 0;
|
|
avtprvfdepay->format_fixed = FALSE;
|
|
}
|
|
|
|
static guint
|
|
translate_pixel_depth (guint8 pixel_depth)
|
|
{
|
|
switch (pixel_depth) {
|
|
case AVTP_RVF_PIXEL_DEPTH_8:
|
|
return 8;
|
|
case AVTP_RVF_PIXEL_DEPTH_10:
|
|
return 10;
|
|
case AVTP_RVF_PIXEL_DEPTH_12:
|
|
return 12;
|
|
case AVTP_RVF_PIXEL_DEPTH_16:
|
|
return 16;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static guint
|
|
translate_frame_rate (guint8 frame_rate)
|
|
{
|
|
switch (frame_rate) {
|
|
case AVTP_RVF_FRAME_RATE_1:
|
|
return 1;
|
|
case AVTP_RVF_FRAME_RATE_2:
|
|
return 2;
|
|
case AVTP_RVF_FRAME_RATE_5:
|
|
return 5;
|
|
case AVTP_RVF_FRAME_RATE_10:
|
|
return 10;
|
|
case AVTP_RVF_FRAME_RATE_15:
|
|
return 15;
|
|
case AVTP_RVF_FRAME_RATE_20:
|
|
return 20;
|
|
case AVTP_RVF_FRAME_RATE_24:
|
|
return 24;
|
|
case AVTP_RVF_FRAME_RATE_25:
|
|
return 25;
|
|
case AVTP_RVF_FRAME_RATE_30:
|
|
return 30;
|
|
case AVTP_RVF_FRAME_RATE_48:
|
|
return 48;
|
|
case AVTP_RVF_FRAME_RATE_50:
|
|
return 50;
|
|
case AVTP_RVF_FRAME_RATE_60:
|
|
return 60;
|
|
case AVTP_RVF_FRAME_RATE_72:
|
|
return 72;
|
|
case AVTP_RVF_FRAME_RATE_85:
|
|
return 85;
|
|
case AVTP_RVF_FRAME_RATE_100:
|
|
return 100;
|
|
case AVTP_RVF_FRAME_RATE_120:
|
|
return 120;
|
|
case AVTP_RVF_FRAME_RATE_150:
|
|
return 150;
|
|
case AVTP_RVF_FRAME_RATE_200:
|
|
return 200;
|
|
case AVTP_RVF_FRAME_RATE_240:
|
|
return 240;
|
|
case AVTP_RVF_FRAME_RATE_300:
|
|
return 300;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_avtp_rvf_depay_push_caps (GstAvtpVfDepayBase * avtpvfdepay)
|
|
{
|
|
GstAvtpBaseDepayload *avtpbasedepayload =
|
|
GST_AVTP_BASE_DEPAYLOAD (avtpvfdepay);
|
|
GstAvtpRvfDepay *avtprvfdepay = GST_AVTP_RVF_DEPAY (avtpvfdepay);
|
|
GstEvent *event;
|
|
GstCaps *caps;
|
|
GstVideoInfo info;
|
|
GstVideoFormat format;
|
|
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Setting src pad caps");
|
|
|
|
format = GST_VIDEO_FORMAT_UNKNOWN;
|
|
if (avtprvfdepay->pixel_depth == AVTP_RVF_PIXEL_DEPTH_16 &&
|
|
avtprvfdepay->pixel_format == AVTP_RVF_PIXEL_FORMAT_MONO &&
|
|
avtprvfdepay->colorspace == AVTP_RVF_COLORSPACE_GRAY) {
|
|
format = GST_VIDEO_FORMAT_GRAY16_LE;
|
|
}
|
|
|
|
/* Unsupported format */
|
|
if (format == GST_VIDEO_FORMAT_UNKNOWN) {
|
|
GST_ERROR_OBJECT (avtprvfdepay, "Unsupported raw video format");
|
|
return FALSE;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Selected source format: %s", gst_video_format_to_string (format));
|
|
|
|
gst_video_info_set_interlaced_format (&info, format,
|
|
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE, avtprvfdepay->active_pixels,
|
|
avtprvfdepay->total_lines);
|
|
|
|
info.fps_n = translate_frame_rate (avtprvfdepay->frame_rate);
|
|
info.fps_d = 1;
|
|
if (avtprvfdepay->pd) {
|
|
info.fps_n *= 1000;
|
|
info.fps_d = 1001;
|
|
}
|
|
|
|
caps = gst_video_info_to_caps (&info);
|
|
event = gst_event_new_caps (caps);
|
|
|
|
gst_caps_unref (caps);
|
|
|
|
return gst_pad_push_event (avtpbasedepayload->srcpad, event);
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_avtp_rvf_depay_discard (GstAvtpRvfDepay * avtprvfdepay)
|
|
{
|
|
GstAvtpVfDepayBase *avtpvfdepaybase = GST_AVTP_VF_DEPAY_BASE (avtprvfdepay);
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
|
|
/* Discard any incomplete frame */
|
|
if (avtpvfdepaybase->out_buffer != NULL) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Discarding incomplete frame");
|
|
gst_buffer_unref (avtpvfdepaybase->out_buffer);
|
|
avtpvfdepaybase->out_buffer = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avtp_rvf_depay_validate_avtpdu (GstAvtpRvfDepay * avtprvfdepay,
|
|
GstMapInfo * map, gboolean * lost_packet)
|
|
{
|
|
GstAvtpBaseDepayload *avtpbasedepayload =
|
|
GST_AVTP_BASE_DEPAYLOAD (avtprvfdepay);
|
|
struct avtp_stream_pdu *pdu;
|
|
gboolean result = FALSE;
|
|
guint64 val;
|
|
guint val32;
|
|
gint r;
|
|
|
|
if (G_UNLIKELY (map->size < AVTP_RVF_HEADER_SIZE)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Incomplete AVTP header, expected it to have size of %zd, got %zd",
|
|
AVTP_RVF_HEADER_SIZE, map->size);
|
|
goto end;
|
|
}
|
|
|
|
pdu = (struct avtp_stream_pdu *) map->data;
|
|
|
|
r = avtp_pdu_get ((struct avtp_common_pdu *) pdu, AVTP_FIELD_SUBTYPE, &val32);
|
|
g_assert (r == 0);
|
|
if (val32 != AVTP_SUBTYPE_RVF) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header subtype %d, expected %d", val32,
|
|
AVTP_SUBTYPE_RVF);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_pdu_get ((struct avtp_common_pdu *) pdu, AVTP_FIELD_VERSION, &val32);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val32 != 0)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header version %d, expected %d", val32, 0);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_SV, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != 1)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header stream valid %" G_GUINT64_FORMAT
|
|
", expected %d", val, 1);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_STREAM_ID, &val);
|
|
g_assert (r == 0);
|
|
if (val != avtpbasedepayload->streamid) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header stream id 0x%" G_GINT64_MODIFIER
|
|
"x, expected 0x%" G_GINT64_MODIFIER "x", val,
|
|
avtpbasedepayload->streamid);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_STREAM_DATA_LEN, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->stream_data_length)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
if (G_UNLIKELY (map->size < sizeof (*pdu) + val)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"AVTP packet size %" G_GSIZE_FORMAT
|
|
" too small, expected at least %" G_GUINT64_FORMAT,
|
|
map->size - AVTP_RVF_HEADER_SIZE, sizeof (*pdu) + val);
|
|
goto end;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Data length of the video format %" G_GSIZE_FORMAT, val);
|
|
avtprvfdepay->stream_data_length = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header data_length %" G_GSIZE_FORMAT
|
|
", should be fixed for a given stream (expected %d)", val,
|
|
avtprvfdepay->stream_data_length);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_AP, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != 1)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header AP field %" G_GUINT64_FORMAT ", expected %d",
|
|
val, 1);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_F, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != 0)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header F field %" G_GUINT64_FORMAT ", expected %d",
|
|
val, 0);
|
|
goto end;
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_ACTIVE_PIXELS, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->active_pixels)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Active pixels of the AVTP raw video stream %" G_GUINT64_FORMAT, val);
|
|
avtprvfdepay->active_pixels = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header active_pixels %" G_GUINT64_FORMAT
|
|
", expected %u", val, avtprvfdepay->active_pixels);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_TOTAL_LINES, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->total_lines)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Total lines of the AVTP raw video stream %" G_GUINT64_FORMAT, val);
|
|
avtprvfdepay->total_lines = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header total_lines %" G_GUINT64_FORMAT
|
|
", expected %d", val, avtprvfdepay->active_pixels);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_PD, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->pd)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Pull-down (PD) filed of the of the AVTP raw video stream %"
|
|
G_GUINT64_FORMAT, val);
|
|
avtprvfdepay->pd = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header PD filed %" G_GUINT64_FORMAT ", expected %d",
|
|
val, avtprvfdepay->pd);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_PIXEL_DEPTH, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->pixel_depth)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Pixel depth of the AVTP raw video stream %" G_GUINT64_FORMAT, val);
|
|
avtprvfdepay->pixel_depth = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header pixel_depth %" G_GUINT64_FORMAT
|
|
", expected %d", val, avtprvfdepay->pixel_depth);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_PIXEL_FORMAT, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->pixel_format)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Pixel format of the of the AVTP raw video stream 0x%"
|
|
G_GINT64_MODIFIER "x", val);
|
|
avtprvfdepay->pixel_format = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header pixel_format filed 0x%" G_GINT64_MODIFIER
|
|
"x, expected %x", val, avtprvfdepay->pixel_format);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_FRAME_RATE, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->frame_rate)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Frame_rate of the AVTP raw video stream 0x%" G_GINT64_MODIFIER "x",
|
|
val);
|
|
avtprvfdepay->frame_rate = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header frame_rate filed 0x%" G_GINT64_MODIFIER
|
|
"x, expected %x", val, avtprvfdepay->frame_rate);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_COLORSPACE, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->colorspace)) {
|
|
if (!avtprvfdepay->format_fixed) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Colorspace of the AVTP raw video stream 0x%" G_GINT64_MODIFIER "x",
|
|
val);
|
|
avtprvfdepay->colorspace = (guint) val;
|
|
} else {
|
|
GST_DEBUG_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header colorspace filed 0x%" G_GINT64_MODIFIER
|
|
"x, expected %x", val, avtprvfdepay->colorspace);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
if (G_UNLIKELY (!avtprvfdepay->format_fixed)) {
|
|
guint8 pixelDepth;
|
|
guint8 samplesPerPixels;
|
|
const guint8 samplesPerPixelsFactor = 4; //multiplied by 4 to avoid floating numbers
|
|
|
|
pixelDepth = translate_pixel_depth (avtprvfdepay->pixel_depth);
|
|
if (!pixelDepth) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Unsupported pixel depth");
|
|
goto end;
|
|
}
|
|
|
|
switch (avtprvfdepay->pixel_format) {
|
|
case AVTP_RVF_PIXEL_FORMAT_MONO:
|
|
samplesPerPixels = 1 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_411:
|
|
samplesPerPixels = 1.5 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_420:
|
|
samplesPerPixels = 1.5 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_422:
|
|
samplesPerPixels = 2 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_444:
|
|
samplesPerPixels = 3 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_4224:
|
|
samplesPerPixels = 2.25 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_4444:
|
|
samplesPerPixels = 4 * samplesPerPixelsFactor;
|
|
break;
|
|
case AVTP_RVF_PIXEL_FORMAT_BAYER_GRBG:
|
|
case AVTP_RVF_PIXEL_FORMAT_BAYER_RGGB:
|
|
case AVTP_RVF_PIXEL_FORMAT_BAYER_BGGR:
|
|
case AVTP_RVF_PIXEL_FORMAT_BAYER_GBRG:
|
|
samplesPerPixels = 2 * samplesPerPixelsFactor;
|
|
break;
|
|
default:
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Unsupported colorspace");
|
|
goto end;
|
|
}
|
|
|
|
avtprvfdepay->line_size =
|
|
(avtprvfdepay->active_pixels * samplesPerPixels * pixelDepth +
|
|
(samplesPerPixelsFactor * 8 - 1)) / (samplesPerPixelsFactor * 8);
|
|
|
|
/* Take into account AVTP raw header which is considered to be part of the payload too */
|
|
avtprvfdepay->fragment_size =
|
|
avtprvfdepay->stream_data_length - sizeof (uint64_t);
|
|
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_NUM_LINES, &val);
|
|
g_assert (r == 0);
|
|
|
|
if (val == 0) { //large raster
|
|
avtprvfdepay->fragment_eol_size =
|
|
avtprvfdepay->line_size % avtprvfdepay->fragment_size;
|
|
avtprvfdepay->i_seq_max =
|
|
avtprvfdepay->line_size / avtprvfdepay->fragment_size;
|
|
}
|
|
|
|
/* Video format paramaters fixed */
|
|
avtprvfdepay->format_fixed = TRUE;
|
|
}
|
|
|
|
*lost_packet = FALSE;
|
|
r = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_SEQ_NUM, &val);
|
|
g_assert (r == 0);
|
|
if (G_UNLIKELY (val != avtprvfdepay->seqnum)) {
|
|
GST_INFO_OBJECT (avtprvfdepay,
|
|
"Unexpected AVTP header seq num %" G_GUINT64_FORMAT ", expected %u",
|
|
val, avtprvfdepay->seqnum);
|
|
|
|
avtprvfdepay->seqnum = val;
|
|
|
|
*lost_packet = TRUE;
|
|
}
|
|
avtprvfdepay->seqnum++;
|
|
|
|
result = TRUE;
|
|
|
|
end:
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
gst_avtp_rvf_depay_get_avtp_timestamp (GstAvtpRvfDepay * avtprvfdepay,
|
|
GstMapInfo * map, GstClockTime * ts)
|
|
{
|
|
struct avtp_stream_pdu *pdu;
|
|
guint64 avtp_time, tv;
|
|
gint res;
|
|
|
|
pdu = (struct avtp_stream_pdu *) map->data;
|
|
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_TV, &tv);
|
|
g_assert (res == 0);
|
|
|
|
if (tv == 1) {
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_TIMESTAMP, &avtp_time);
|
|
g_assert (res == 0);
|
|
|
|
*ts = avtp_time;
|
|
} else {
|
|
*ts = GST_CLOCK_TIME_NONE;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
is_first_fragment (GstAvtpRvfDepay * avtprvfdepay, GstMapInfo * map)
|
|
{
|
|
struct avtp_stream_pdu *pdu;
|
|
guint64 num_lines, line_number, i_seq_num;
|
|
gint res;
|
|
|
|
pdu = (struct avtp_stream_pdu *) map->data;
|
|
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_NUM_LINES, &num_lines);
|
|
g_assert (res == 0);
|
|
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_LINE_NUMBER, &line_number);
|
|
g_assert (res == 0);
|
|
|
|
|
|
if (line_number == 1) {
|
|
if (num_lines == 0) { //large raster
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_I_SEQ_NUM, &i_seq_num);
|
|
g_assert (res == 0);
|
|
|
|
if (i_seq_num == 0)
|
|
return TRUE;
|
|
} else
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
is_last_fragment (GstAvtpRvfDepay * avtprvfdepay, GstMapInfo * map)
|
|
{
|
|
struct avtp_stream_pdu *pdu;
|
|
guint64 val;
|
|
gint res;
|
|
|
|
pdu = (struct avtp_stream_pdu *) map->data;
|
|
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_EF, &val);
|
|
g_assert (res == 0);
|
|
|
|
return (gboolean) val;
|
|
}
|
|
|
|
static void
|
|
gst_avtp_rvf_depay_get_fragment_size (GstAvtpRvfDepay * avtprvfdepay,
|
|
GstMapInfo * map, guint16 * fragment_size)
|
|
{
|
|
struct avtp_stream_pdu *pdu;
|
|
guint64 val;
|
|
gint res;
|
|
|
|
pdu = (struct avtp_stream_pdu *) map->data;
|
|
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_NUM_LINES, &val);
|
|
g_assert (res == 0);
|
|
|
|
if (val == 0) { //large raster
|
|
res = avtp_rvf_pdu_get (pdu, AVTP_RVF_FIELD_RAW_I_SEQ_NUM, &val);
|
|
g_assert (res == 0);
|
|
|
|
if (val == avtprvfdepay->i_seq_max)
|
|
*fragment_size = avtprvfdepay->fragment_eol_size;
|
|
else
|
|
*fragment_size = avtprvfdepay->fragment_size;
|
|
} else { //small raster
|
|
*fragment_size = val * avtprvfdepay->line_size;
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_avtp_rvf_depay_internal_push (GstAvtpRvfDepay * avtprvfdepay,
|
|
GstBuffer * buffer, GstMapInfo * map)
|
|
{
|
|
GstAvtpVfDepayBase *avtpvfdepaybase = GST_AVTP_VF_DEPAY_BASE (avtprvfdepay);
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
|
|
GST_LOG_OBJECT (avtprvfdepay,
|
|
"Adding buffer of size %" G_GSIZE_FORMAT " to out_buffer",
|
|
gst_buffer_get_size (buffer));
|
|
|
|
if (avtpvfdepaybase->out_buffer) {
|
|
avtpvfdepaybase->out_buffer =
|
|
gst_buffer_append (avtpvfdepaybase->out_buffer, buffer);
|
|
} else {
|
|
|
|
/* Store only if it's a first fragment of the video frame
|
|
* drop the packet otherwise */
|
|
if (is_first_fragment (avtprvfdepay, map))
|
|
avtpvfdepaybase->out_buffer = buffer;
|
|
}
|
|
|
|
/* We only truly push downstream when we get the last video buffer */
|
|
if (is_last_fragment (avtprvfdepay, map) && avtpvfdepaybase->out_buffer) {
|
|
ret = gst_avtp_vf_depay_base_push (GST_AVTP_VF_DEPAY_BASE (avtprvfdepay));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_avtp_rvf_depay_handle_single_fragment (GstAvtpRvfDepay * avtprvfdepay,
|
|
GstBuffer * buffer, GstMapInfo * map)
|
|
{
|
|
GstClockTime ts;
|
|
GstBuffer *fragment;
|
|
guint16 fragment_size;
|
|
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Handling single fragment unit");
|
|
|
|
fragment = gst_buffer_new ();
|
|
if (G_UNLIKELY (fragment == NULL)) {
|
|
GST_ERROR_OBJECT (avtprvfdepay, "Could not allocate buffer");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
gst_avtp_rvf_depay_get_avtp_timestamp (avtprvfdepay, map, &ts);
|
|
gst_avtp_rvf_depay_get_fragment_size (avtprvfdepay, map, &fragment_size);
|
|
gst_buffer_copy_into (fragment, buffer, GST_BUFFER_COPY_MEMORY,
|
|
AVTP_RVF_HEADER_SIZE, fragment_size);
|
|
|
|
GST_BUFFER_PTS (fragment) = ts;
|
|
GST_BUFFER_DTS (fragment) = ts;
|
|
|
|
return gst_avtp_rvf_depay_internal_push (avtprvfdepay, fragment, map);
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_avtp_rvf_depay_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
|
|
{
|
|
GstAvtpRvfDepay *avtprvfdepay = GST_AVTP_RVF_DEPAY (parent);
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
gboolean lost_packet;
|
|
GstMapInfo map;
|
|
|
|
gst_buffer_map (buffer, &map, GST_MAP_READ);
|
|
|
|
if (!gst_avtp_rvf_depay_validate_avtpdu (avtprvfdepay, &map, &lost_packet)) {
|
|
GST_DEBUG_OBJECT (avtprvfdepay, "Invalid AVTPDU buffer, dropping it");
|
|
goto end;
|
|
}
|
|
if (lost_packet) {
|
|
ret = gst_avtp_rvf_depay_discard (avtprvfdepay);
|
|
if (ret != GST_FLOW_OK)
|
|
goto end;
|
|
}
|
|
|
|
gst_avtp_rvf_depay_handle_single_fragment (avtprvfdepay, buffer, &map);
|
|
|
|
end:
|
|
gst_buffer_unmap (buffer, &map);
|
|
gst_buffer_unref (buffer);
|
|
|
|
return ret;
|
|
}
|