| /* GStreamer | |
| * Copyright (C) <2008> Wim Taymans <wim.taymans@gmail.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., 51 Franklin St, Fifth Floor, | |
| * Boston, MA 02110-1301, USA. | |
| */ | |
| #ifdef HAVE_CONFIG_H | |
| # include "config.h" | |
| #endif | |
| #include <string.h> | |
| #include <gst/rtp/gstrtpbuffer.h> | |
| #include <gst/video/video.h> | |
| #include "gstrtpvrawpay.h" | |
| #include "gstrtputils.h" | |
| enum | |
| { | |
| PROP_CHUNKS_PER_FRAME = 1 | |
| }; | |
| #define DEFAULT_CHUNKS_PER_FRAME 10 | |
| GST_DEBUG_CATEGORY_STATIC (rtpvrawpay_debug); | |
| #define GST_CAT_DEFAULT (rtpvrawpay_debug) | |
| static GstStaticPadTemplate gst_rtp_vraw_pay_sink_template = | |
| GST_STATIC_PAD_TEMPLATE ("sink", | |
| GST_PAD_SINK, | |
| GST_PAD_ALWAYS, | |
| GST_STATIC_CAPS ("video/x-raw, " | |
| "format = (string) { RGB, RGBA, BGR, BGRA, AYUV, UYVY, I420, Y41B, UYVP }, " | |
| "width = (int) [ 1, 32767 ], " "height = (int) [ 1, 32767 ]; ") | |
| ); | |
| static GstStaticPadTemplate gst_rtp_vraw_pay_src_template = | |
| GST_STATIC_PAD_TEMPLATE ("src", | |
| GST_PAD_SRC, | |
| GST_PAD_ALWAYS, | |
| GST_STATIC_CAPS ("application/x-rtp, " | |
| "media = (string) \"video\", " | |
| "payload = (int) " GST_RTP_PAYLOAD_DYNAMIC_STRING ", " | |
| "clock-rate = (int) 90000, " | |
| "encoding-name = (string) \"RAW\"," | |
| "sampling = (string) { \"RGB\", \"RGBA\", \"BGR\", \"BGRA\", " | |
| "\"YCbCr-4:4:4\", \"YCbCr-4:2:2\", \"YCbCr-4:2:0\", " | |
| "\"YCbCr-4:1:1\" }," | |
| /* we cannot express these as strings | |
| * "width = (string) [1 32767]," | |
| * "height = (string) [1 32767]," | |
| */ | |
| "depth = (string) { \"8\", \"10\", \"12\", \"16\" }," | |
| "colorimetry = (string) { \"BT601-5\", \"BT709-2\", \"SMPTE240M\" }" | |
| /* optional | |
| * interlace = | |
| * top-field-first = | |
| * chroma-position = (string) | |
| * gamma = (float) | |
| */ | |
| ) | |
| ); | |
| static gboolean gst_rtp_vraw_pay_setcaps (GstRTPBasePayload * payload, | |
| GstCaps * caps); | |
| static GstFlowReturn gst_rtp_vraw_pay_handle_buffer (GstRTPBasePayload * | |
| payload, GstBuffer * buffer); | |
| static void gst_rtp_vraw_pay_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec); | |
| static void gst_rtp_vraw_pay_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec); | |
| G_DEFINE_TYPE (GstRtpVRawPay, gst_rtp_vraw_pay, GST_TYPE_RTP_BASE_PAYLOAD) | |
| static void gst_rtp_vraw_pay_class_init (GstRtpVRawPayClass * klass) | |
| { | |
| GstRTPBasePayloadClass *gstrtpbasepayload_class; | |
| GstElementClass *gstelement_class; | |
| GObjectClass *gobject_class; | |
| gobject_class = (GObjectClass *) klass; | |
| gstelement_class = (GstElementClass *) klass; | |
| gstrtpbasepayload_class = (GstRTPBasePayloadClass *) klass; | |
| gobject_class->set_property = gst_rtp_vraw_pay_set_property; | |
| gobject_class->get_property = gst_rtp_vraw_pay_get_property; | |
| g_object_class_install_property (gobject_class, | |
| PROP_CHUNKS_PER_FRAME, | |
| g_param_spec_int ("chunks-per-frame", "Chunks per Frame", | |
| "Split and send out each frame in multiple chunks to reduce overhead", | |
| 1, G_MAXINT, DEFAULT_CHUNKS_PER_FRAME, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) | |
| ); | |
| gstrtpbasepayload_class->set_caps = gst_rtp_vraw_pay_setcaps; | |
| gstrtpbasepayload_class->handle_buffer = gst_rtp_vraw_pay_handle_buffer; | |
| gst_element_class_add_static_pad_template (gstelement_class, | |
| &gst_rtp_vraw_pay_src_template); | |
| gst_element_class_add_static_pad_template (gstelement_class, | |
| &gst_rtp_vraw_pay_sink_template); | |
| gst_element_class_set_static_metadata (gstelement_class, | |
| "RTP Raw Video payloader", "Codec/Payloader/Network/RTP", | |
| "Payload raw video as RTP packets (RFC 4175)", | |
| "Wim Taymans <wim.taymans@gmail.com>"); | |
| GST_DEBUG_CATEGORY_INIT (rtpvrawpay_debug, "rtpvrawpay", 0, | |
| "Raw video RTP Payloader"); | |
| } | |
| static void | |
| gst_rtp_vraw_pay_init (GstRtpVRawPay * rtpvrawpay) | |
| { | |
| rtpvrawpay->chunks_per_frame = DEFAULT_CHUNKS_PER_FRAME; | |
| } | |
| static gboolean | |
| gst_rtp_vraw_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps) | |
| { | |
| GstRtpVRawPay *rtpvrawpay; | |
| gboolean res; | |
| gint pgroup, xinc, yinc; | |
| const gchar *depthstr, *samplingstr, *colorimetrystr; | |
| gchar *wstr, *hstr; | |
| GstVideoInfo info; | |
| rtpvrawpay = GST_RTP_VRAW_PAY (payload); | |
| if (!gst_video_info_from_caps (&info, caps)) | |
| goto invalid_caps; | |
| rtpvrawpay->vinfo = info; | |
| if (gst_video_colorimetry_matches (&info.colorimetry, | |
| GST_VIDEO_COLORIMETRY_BT601)) { | |
| colorimetrystr = "BT601-5"; | |
| } else if (gst_video_colorimetry_matches (&info.colorimetry, | |
| GST_VIDEO_COLORIMETRY_BT709)) { | |
| colorimetrystr = "BT709-2"; | |
| } else if (gst_video_colorimetry_matches (&info.colorimetry, | |
| GST_VIDEO_COLORIMETRY_SMPTE240M)) { | |
| colorimetrystr = "SMPTE240M"; | |
| } else { | |
| colorimetrystr = "SMPTE240M"; | |
| } | |
| xinc = yinc = 1; | |
| /* these values are the only thing we can do */ | |
| depthstr = "8"; | |
| switch (GST_VIDEO_INFO_FORMAT (&info)) { | |
| case GST_VIDEO_FORMAT_RGBA: | |
| samplingstr = "RGBA"; | |
| pgroup = 4; | |
| break; | |
| case GST_VIDEO_FORMAT_BGRA: | |
| samplingstr = "BGRA"; | |
| pgroup = 4; | |
| break; | |
| case GST_VIDEO_FORMAT_RGB: | |
| samplingstr = "RGB"; | |
| pgroup = 3; | |
| break; | |
| case GST_VIDEO_FORMAT_BGR: | |
| samplingstr = "BGR"; | |
| pgroup = 3; | |
| break; | |
| case GST_VIDEO_FORMAT_AYUV: | |
| samplingstr = "YCbCr-4:4:4"; | |
| pgroup = 3; | |
| break; | |
| case GST_VIDEO_FORMAT_UYVY: | |
| samplingstr = "YCbCr-4:2:2"; | |
| pgroup = 4; | |
| xinc = 2; | |
| break; | |
| case GST_VIDEO_FORMAT_Y41B: | |
| samplingstr = "YCbCr-4:1:1"; | |
| pgroup = 6; | |
| xinc = 4; | |
| break; | |
| case GST_VIDEO_FORMAT_I420: | |
| samplingstr = "YCbCr-4:2:0"; | |
| pgroup = 6; | |
| xinc = yinc = 2; | |
| break; | |
| case GST_VIDEO_FORMAT_UYVP: | |
| samplingstr = "YCbCr-4:2:2"; | |
| pgroup = 5; | |
| xinc = 2; | |
| depthstr = "10"; | |
| break; | |
| default: | |
| goto unknown_format; | |
| break; | |
| } | |
| if (GST_VIDEO_INFO_IS_INTERLACED (&info)) { | |
| yinc *= 2; | |
| } | |
| rtpvrawpay->pgroup = pgroup; | |
| rtpvrawpay->xinc = xinc; | |
| rtpvrawpay->yinc = yinc; | |
| GST_DEBUG_OBJECT (payload, "width %d, height %d, sampling %s", | |
| GST_VIDEO_INFO_WIDTH (&info), GST_VIDEO_INFO_HEIGHT (&info), samplingstr); | |
| GST_DEBUG_OBJECT (payload, "xinc %d, yinc %d, pgroup %d", xinc, yinc, pgroup); | |
| wstr = g_strdup_printf ("%d", GST_VIDEO_INFO_WIDTH (&info)); | |
| hstr = g_strdup_printf ("%d", GST_VIDEO_INFO_HEIGHT (&info)); | |
| gst_rtp_base_payload_set_options (payload, "video", TRUE, "RAW", 90000); | |
| if (GST_VIDEO_INFO_IS_INTERLACED (&info)) { | |
| res = gst_rtp_base_payload_set_outcaps (payload, "sampling", G_TYPE_STRING, | |
| samplingstr, "depth", G_TYPE_STRING, depthstr, "width", G_TYPE_STRING, | |
| wstr, "height", G_TYPE_STRING, hstr, "colorimetry", G_TYPE_STRING, | |
| colorimetrystr, "interlace", G_TYPE_STRING, "true", NULL); | |
| } else { | |
| res = gst_rtp_base_payload_set_outcaps (payload, "sampling", G_TYPE_STRING, | |
| samplingstr, "depth", G_TYPE_STRING, depthstr, "width", G_TYPE_STRING, | |
| wstr, "height", G_TYPE_STRING, hstr, "colorimetry", G_TYPE_STRING, | |
| colorimetrystr, NULL); | |
| } | |
| g_free (wstr); | |
| g_free (hstr); | |
| return res; | |
| /* ERRORS */ | |
| invalid_caps: | |
| { | |
| GST_ERROR_OBJECT (payload, "could not parse caps"); | |
| return FALSE; | |
| } | |
| unknown_format: | |
| { | |
| GST_ERROR_OBJECT (payload, "unknown caps format"); | |
| return FALSE; | |
| } | |
| } | |
| static GstFlowReturn | |
| gst_rtp_vraw_pay_handle_buffer (GstRTPBasePayload * payload, GstBuffer * buffer) | |
| { | |
| GstRtpVRawPay *rtpvrawpay; | |
| GstFlowReturn ret = GST_FLOW_OK; | |
| gfloat packets_per_packline; | |
| guint pgroups_per_packet; | |
| guint packlines_per_list, buffers_per_list; | |
| guint lines_delay; /* after how many packed lines we push out a buffer list */ | |
| guint last_line; /* last pack line number we pushed out a buffer list */ | |
| guint line, offset; | |
| guint8 *p0, *yp, *up, *vp; | |
| guint ystride, uvstride; | |
| guint xinc, yinc; | |
| guint pgroup; | |
| guint mtu; | |
| guint width, height; | |
| gint field, fields; | |
| GstVideoFormat format; | |
| GstVideoFrame frame; | |
| gint interlaced; | |
| gboolean use_buffer_lists; | |
| GstBufferList *list = NULL; | |
| GstRTPBuffer rtp = { NULL, }; | |
| rtpvrawpay = GST_RTP_VRAW_PAY (payload); | |
| if (!gst_video_frame_map (&frame, &rtpvrawpay->vinfo, buffer, GST_MAP_READ)) { | |
| gst_buffer_unref (buffer); | |
| return GST_FLOW_ERROR; | |
| } | |
| GST_LOG_OBJECT (rtpvrawpay, "new frame of %" G_GSIZE_FORMAT " bytes", | |
| gst_buffer_get_size (buffer)); | |
| /* get pointer and strides of the planes */ | |
| p0 = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0); | |
| yp = GST_VIDEO_FRAME_COMP_DATA (&frame, 0); | |
| up = GST_VIDEO_FRAME_COMP_DATA (&frame, 1); | |
| vp = GST_VIDEO_FRAME_COMP_DATA (&frame, 2); | |
| ystride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, 0); | |
| uvstride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, 1); | |
| mtu = GST_RTP_BASE_PAYLOAD_MTU (payload); | |
| /* amount of bytes for one pixel */ | |
| pgroup = rtpvrawpay->pgroup; | |
| width = GST_VIDEO_INFO_WIDTH (&rtpvrawpay->vinfo); | |
| height = GST_VIDEO_INFO_HEIGHT (&rtpvrawpay->vinfo); | |
| interlaced = GST_VIDEO_INFO_IS_INTERLACED (&rtpvrawpay->vinfo); | |
| format = GST_VIDEO_INFO_FORMAT (&rtpvrawpay->vinfo); | |
| yinc = rtpvrawpay->yinc; | |
| xinc = rtpvrawpay->xinc; | |
| /* after how many packed lines we push out a buffer list */ | |
| lines_delay = GST_ROUND_UP_4 (height / rtpvrawpay->chunks_per_frame); | |
| /* calculate how many buffers we expect to store in a single buffer list */ | |
| pgroups_per_packet = (mtu - (12 + 14)) / pgroup; | |
| packets_per_packline = width / (xinc * pgroups_per_packet * 1.0); | |
| packlines_per_list = height / (yinc * rtpvrawpay->chunks_per_frame); | |
| buffers_per_list = packlines_per_list * packets_per_packline; | |
| buffers_per_list = GST_ROUND_UP_8 (buffers_per_list); | |
| use_buffer_lists = buffers_per_list > 1 && | |
| (rtpvrawpay->chunks_per_frame < (height / yinc)); | |
| fields = 1 + interlaced; | |
| /* start with line 0, offset 0 */ | |
| for (field = 0; field < fields; field++) { | |
| line = field; | |
| offset = 0; | |
| last_line = 0; | |
| if (use_buffer_lists) | |
| list = gst_buffer_list_new_sized (buffers_per_list); | |
| /* write all lines */ | |
| while (line < height) { | |
| guint left, pack_line; | |
| GstBuffer *out; | |
| guint8 *outdata, *headers; | |
| gboolean next_line, complete = FALSE; | |
| guint length, cont, pixels; | |
| /* get the max allowed payload length size, we try to fill the complete MTU */ | |
| left = gst_rtp_buffer_calc_payload_len (mtu, 0, 0); | |
| out = gst_rtp_buffer_new_allocate (left, 0, 0); | |
| if (field == 0) { | |
| GST_BUFFER_PTS (out) = GST_BUFFER_PTS (buffer); | |
| } else { | |
| GST_BUFFER_PTS (out) = GST_BUFFER_PTS (buffer) + | |
| GST_BUFFER_DURATION (buffer) / 2; | |
| } | |
| gst_rtp_buffer_map (out, GST_MAP_WRITE, &rtp); | |
| outdata = gst_rtp_buffer_get_payload (&rtp); | |
| GST_LOG_OBJECT (rtpvrawpay, "created buffer of size %u for MTU %u", left, | |
| mtu); | |
| /* | |
| * 0 1 2 3 | |
| * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | |
| * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| * | Extended Sequence Number | Length | | |
| * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| * |F| Line No |C| Offset | | |
| * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| * | Length |F| Line No | | |
| * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| * |C| Offset | . | |
| * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ . | |
| * . . | |
| * . Two (partial) lines of video data . | |
| * . . | |
| * +---------------------------------------------------------------+ | |
| */ | |
| /* need 2 bytes for the extended sequence number */ | |
| *outdata++ = 0; | |
| *outdata++ = 0; | |
| left -= 2; | |
| /* the headers start here */ | |
| headers = outdata; | |
| /* make sure we can fit at least *one* header and pixel */ | |
| if (!(left > (6 + pgroup))) { | |
| gst_rtp_buffer_unmap (&rtp); | |
| gst_buffer_unref (out); | |
| goto too_small; | |
| } | |
| /* while we can fit at least one header and one pixel */ | |
| while (left > (6 + pgroup)) { | |
| /* we need a 6 bytes header */ | |
| left -= 6; | |
| /* get how may bytes we need for the remaining pixels */ | |
| pixels = width - offset; | |
| length = (pixels * pgroup) / xinc; | |
| if (left >= length) { | |
| /* pixels and header fit completely, we will write them and skip to the | |
| * next line. */ | |
| next_line = TRUE; | |
| } else { | |
| /* line does not fit completely, see how many pixels fit */ | |
| pixels = (left / pgroup) * xinc; | |
| length = (pixels * pgroup) / xinc; | |
| next_line = FALSE; | |
| } | |
| GST_LOG_OBJECT (rtpvrawpay, "filling %u bytes in %u pixels", length, | |
| pixels); | |
| left -= length; | |
| /* write length */ | |
| *outdata++ = (length >> 8) & 0xff; | |
| *outdata++ = length & 0xff; | |
| /* write line no */ | |
| *outdata++ = ((line >> 8) & 0x7f) | ((field << 7) & 0x80); | |
| *outdata++ = line & 0xff; | |
| if (next_line) { | |
| /* go to next line we do this here to make the check below easier */ | |
| line += yinc; | |
| } | |
| /* calculate continuation marker */ | |
| cont = (left > (6 + pgroup) && line < height) ? 0x80 : 0x00; | |
| /* write offset and continuation marker */ | |
| *outdata++ = ((offset >> 8) & 0x7f) | cont; | |
| *outdata++ = offset & 0xff; | |
| if (next_line) { | |
| /* reset offset */ | |
| offset = 0; | |
| GST_LOG_OBJECT (rtpvrawpay, "go to next line %u", line); | |
| } else { | |
| offset += pixels; | |
| GST_LOG_OBJECT (rtpvrawpay, "next offset %u", offset); | |
| } | |
| if (!cont) | |
| break; | |
| } | |
| GST_LOG_OBJECT (rtpvrawpay, "consumed %u bytes", | |
| (guint) (outdata - headers)); | |
| /* second pass, read headers and write the data */ | |
| while (TRUE) { | |
| guint offs, lin; | |
| /* read length and cont */ | |
| length = (headers[0] << 8) | headers[1]; | |
| lin = ((headers[2] & 0x7f) << 8) | headers[3]; | |
| offs = ((headers[4] & 0x7f) << 8) | headers[5]; | |
| cont = headers[4] & 0x80; | |
| pixels = length / pgroup; | |
| headers += 6; | |
| GST_LOG_OBJECT (payload, | |
| "writing length %u, line %u, offset %u, cont %d", length, lin, offs, | |
| cont); | |
| switch (format) { | |
| case GST_VIDEO_FORMAT_RGB: | |
| case GST_VIDEO_FORMAT_RGBA: | |
| case GST_VIDEO_FORMAT_BGR: | |
| case GST_VIDEO_FORMAT_BGRA: | |
| case GST_VIDEO_FORMAT_UYVY: | |
| case GST_VIDEO_FORMAT_UYVP: | |
| offs /= xinc; | |
| memcpy (outdata, p0 + (lin * ystride) + (offs * pgroup), length); | |
| outdata += length; | |
| break; | |
| case GST_VIDEO_FORMAT_AYUV: | |
| { | |
| gint i; | |
| guint8 *datap; | |
| datap = p0 + (lin * ystride) + (offs * 4); | |
| for (i = 0; i < pixels; i++) { | |
| *outdata++ = datap[2]; | |
| *outdata++ = datap[1]; | |
| *outdata++ = datap[3]; | |
| datap += 4; | |
| } | |
| break; | |
| } | |
| case GST_VIDEO_FORMAT_I420: | |
| { | |
| gint i; | |
| guint uvoff; | |
| guint8 *yd1p, *yd2p, *udp, *vdp; | |
| yd1p = yp + (lin * ystride) + (offs); | |
| yd2p = yd1p + ystride; | |
| uvoff = (lin / yinc * uvstride) + (offs / xinc); | |
| udp = up + uvoff; | |
| vdp = vp + uvoff; | |
| for (i = 0; i < pixels; i++) { | |
| *outdata++ = *yd1p++; | |
| *outdata++ = *yd1p++; | |
| *outdata++ = *yd2p++; | |
| *outdata++ = *yd2p++; | |
| *outdata++ = *udp++; | |
| *outdata++ = *vdp++; | |
| } | |
| break; | |
| } | |
| case GST_VIDEO_FORMAT_Y41B: | |
| { | |
| gint i; | |
| guint uvoff; | |
| guint8 *ydp, *udp, *vdp; | |
| ydp = yp + (lin * ystride) + offs; | |
| uvoff = (lin / yinc * uvstride) + (offs / xinc); | |
| udp = up + uvoff; | |
| vdp = vp + uvoff; | |
| for (i = 0; i < pixels; i++) { | |
| *outdata++ = *udp++; | |
| *outdata++ = *ydp++; | |
| *outdata++ = *ydp++; | |
| *outdata++ = *vdp++; | |
| *outdata++ = *ydp++; | |
| *outdata++ = *ydp++; | |
| } | |
| break; | |
| } | |
| default: | |
| gst_rtp_buffer_unmap (&rtp); | |
| gst_buffer_unref (out); | |
| goto unknown_sampling; | |
| } | |
| if (!cont) | |
| break; | |
| } | |
| if (line >= height) { | |
| GST_LOG_OBJECT (rtpvrawpay, "field/frame complete, set marker"); | |
| gst_rtp_buffer_set_marker (&rtp, TRUE); | |
| complete = TRUE; | |
| } | |
| gst_rtp_buffer_unmap (&rtp); | |
| if (left > 0) { | |
| GST_LOG_OBJECT (rtpvrawpay, "we have %u bytes left", left); | |
| gst_buffer_resize (out, 0, gst_buffer_get_size (out) - left); | |
| } | |
| gst_rtp_copy_video_meta (rtpvrawpay, out, buffer); | |
| /* Now either push out the buffer directly */ | |
| if (!use_buffer_lists) { | |
| ret = gst_rtp_base_payload_push (payload, out); | |
| continue; | |
| } | |
| /* or add the buffer to buffer list ... */ | |
| gst_buffer_list_add (list, out); | |
| /* .. and check if we need to push out the list */ | |
| pack_line = (line - field) / fields; | |
| if (complete || (pack_line > last_line && pack_line % lines_delay == 0)) { | |
| GST_LOG_OBJECT (rtpvrawpay, "pushing list of %u buffers up to pack " | |
| "line %u", gst_buffer_list_length (list), pack_line); | |
| ret = gst_rtp_base_payload_push_list (payload, list); | |
| list = NULL; | |
| if (!complete) | |
| list = gst_buffer_list_new_sized (buffers_per_list); | |
| last_line = pack_line; | |
| } | |
| } | |
| } | |
| gst_video_frame_unmap (&frame); | |
| gst_buffer_unref (buffer); | |
| return ret; | |
| /* ERRORS */ | |
| unknown_sampling: | |
| { | |
| GST_ELEMENT_ERROR (payload, STREAM, FORMAT, | |
| (NULL), ("unimplemented sampling")); | |
| gst_video_frame_unmap (&frame); | |
| gst_buffer_unref (buffer); | |
| return GST_FLOW_NOT_SUPPORTED; | |
| } | |
| too_small: | |
| { | |
| GST_ELEMENT_ERROR (payload, RESOURCE, NO_SPACE_LEFT, | |
| (NULL), ("not enough space to send at least one pixel")); | |
| gst_video_frame_unmap (&frame); | |
| gst_buffer_unref (buffer); | |
| return GST_FLOW_NOT_SUPPORTED; | |
| } | |
| } | |
| static void | |
| gst_rtp_vraw_pay_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec) | |
| { | |
| GstRtpVRawPay *rtpvrawpay; | |
| rtpvrawpay = GST_RTP_VRAW_PAY (object); | |
| switch (prop_id) { | |
| case PROP_CHUNKS_PER_FRAME: | |
| rtpvrawpay->chunks_per_frame = g_value_get_int (value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| gst_rtp_vraw_pay_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec) | |
| { | |
| GstRtpVRawPay *rtpvrawpay; | |
| rtpvrawpay = GST_RTP_VRAW_PAY (object); | |
| switch (prop_id) { | |
| case PROP_CHUNKS_PER_FRAME: | |
| g_value_set_int (value, rtpvrawpay->chunks_per_frame); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| gboolean | |
| gst_rtp_vraw_pay_plugin_init (GstPlugin * plugin) | |
| { | |
| return gst_element_register (plugin, "rtpvrawpay", | |
| GST_RANK_SECONDARY, GST_TYPE_RTP_VRAW_PAY); | |
| } |