libavformat/rtpdec_rfc4175.c - third_party/ffmpeg - Git at Google

 /*
  * RTP Depacketization of RAW video (TR-03)
  * Copyright (c) 2016 Savoir-faire Linux, Inc
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg 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.
  *
  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 /* Development sponsored by CBC/Radio-Canada */

 #include "avio_internal.h"
 #include "rtpdec_formats.h"
 #include "libavutil/avstring.h"
 #include "libavutil/pixdesc.h"

 struct PayloadContext {
     char *sampling;
     int depth;
     int width;
     int height;

     uint8_t *frame;
     unsigned int frame_size;
     unsigned int pgroup; /* size of the pixel group in bytes */
     unsigned int xinc;

     uint32_t timestamp;
 };

 static int rfc4175_parse_format(AVStream *stream, PayloadContext *data)
 {
     enum AVPixelFormat pixfmt = AV_PIX_FMT_NONE;
     int bits_per_sample = 0;
     int tag = 0;

     if (!strncmp(data->sampling, "YCbCr-4:2:2", 11)) {
         tag = MKTAG('U', 'Y', 'V', 'Y');
         data->xinc = 2;

         if (data->depth == 8) {
             data->pgroup = 4;
             bits_per_sample = 16;
             pixfmt = AV_PIX_FMT_UYVY422;
         } else if (data->depth == 10) {
             data->pgroup = 5;
             bits_per_sample = 20;
             pixfmt = AV_PIX_FMT_YUV422P10;
         } else {
             return AVERROR_INVALIDDATA;
         }
     } else {
         return AVERROR_INVALIDDATA;
     }

     stream->codecpar->format = pixfmt;
     stream->codecpar->codec_tag = tag;
     stream->codecpar->bits_per_coded_sample = bits_per_sample;
     data->frame_size = data->width * data->height * data->pgroup / data->xinc;

     return 0;
 }

 static int rfc4175_parse_fmtp(AVFormatContext *s, AVStream *stream,
                               PayloadContext *data, const char *attr,
                               const char *value)
 {
     if (!strncmp(attr, "width", 5))
         data->width = atoi(value);
     else if (!strncmp(attr, "height", 6))
         data->height = atoi(value);
     else if (!strncmp(attr, "sampling", 8))
         data->sampling = av_strdup(value);
     else if (!strncmp(attr, "depth", 5))
         data->depth = atoi(value);

     return 0;
 }

 static int rfc4175_parse_sdp_line(AVFormatContext *s, int st_index,
                                   PayloadContext *data, const char *line)
 {
     const char *p;

     if (st_index < 0)
         return 0;

     if (av_strstart(line, "fmtp:", &p)) {
         AVStream *stream = s->streams[st_index];
         int ret = ff_parse_fmtp(s, stream, data, p, rfc4175_parse_fmtp);

         if (ret < 0)
             return ret;


         if (!data->sampling || !data->depth || !data->width || !data->height)
             return -1;

         stream->codecpar->width = data->width;
         stream->codecpar->height = data->height;

         ret = rfc4175_parse_format(stream, data);
         av_freep(&data->sampling);

         return ret;
     }

     return 0;
 }

 static int rfc4175_finalize_packet(PayloadContext *data, AVPacket *pkt,
                                    int stream_index)
 {
    int ret;

    pkt->stream_index = stream_index;
    ret = av_packet_from_data(pkt, data->frame, data->frame_size);
    if (ret < 0) {
        av_freep(&data->frame);
    }

    data->frame = NULL;

    return ret;
 }

 static int rfc4175_handle_packet(AVFormatContext *ctx, PayloadContext *data,
                                  AVStream *st, AVPacket *pkt, uint32_t *timestamp,
                                  const uint8_t * buf, int len,
                                  uint16_t seq, int flags)
 {
     int length, line, offset, cont;
     const uint8_t *headers = buf + 2; /* skip extended seqnum */
     const uint8_t *payload = buf + 2;
     int payload_len = len - 2;
     int missed_last_packet = 0;

     uint8_t *dest;

     if (*timestamp != data->timestamp) {
         if (data->frame) {
             /*
              * if we're here, it means that two RTP packets didn't have the
              * same timestamp, which is a sign that they were packets from two
              * different frames, but we didn't get the flag RTP_FLAG_MARKER on
              * the first one of these frames (last packet of a frame).
              * Finalize the previous frame anyway by filling the AVPacket.
              */
             av_log(ctx, AV_LOG_ERROR, "Missed previous RTP Marker\n");
             missed_last_packet = 1;
             rfc4175_finalize_packet(data, pkt, st->index);
         }

         data->frame = av_malloc(data->frame_size);

         data->timestamp = *timestamp;

         if (!data->frame) {
             av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
             return AVERROR(ENOMEM);
         }
     }

     /*
      * looks for the 'Continuation bit' in scan lines' headers
      * to find where data start
      */
     do {
         if (payload_len < 6)
             return AVERROR_INVALIDDATA;

         cont = payload[4] & 0x80;
         payload += 6;
         payload_len -= 6;
     } while (cont);

     /* and now iterate over every scan lines */
     do {
         int copy_offset;

         if (payload_len < data->pgroup)
             return AVERROR_INVALIDDATA;

         length = (headers[0] << 8) | headers[1];
         line = ((headers[2] & 0x7f) << 8) | headers[3];
         offset = ((headers[4] & 0x7f) << 8) | headers[5];
         cont = headers[4] & 0x80;
         headers += 6;

         if (length % data->pgroup)
             return AVERROR_INVALIDDATA;

         if (length > payload_len)
             length = payload_len;

         /* prevent ill-formed packets to write after buffer's end */
         copy_offset = (line * data->width + offset) * data->pgroup / data->xinc;
         if (copy_offset + length > data->frame_size)
             return AVERROR_INVALIDDATA;

         dest = data->frame + copy_offset;
         memcpy(dest, payload, length);

         payload += length;
         payload_len -= length;
     } while (cont);

     if ((flags & RTP_FLAG_MARKER)) {
         return rfc4175_finalize_packet(data, pkt, st->index);
     } else if (missed_last_packet) {
         return 0;
     }

     return AVERROR(EAGAIN);
 }

 const RTPDynamicProtocolHandler ff_rfc4175_rtp_handler = {
     .enc_name           = "raw",
     .codec_type         = AVMEDIA_TYPE_VIDEO,
     .codec_id           = AV_CODEC_ID_BITPACKED,
     .priv_data_size     = sizeof(PayloadContext),
     .parse_sdp_a_line   = rfc4175_parse_sdp_line,
     .parse_packet       = rfc4175_handle_packet,
 };
	/*
	* RTP Depacketization of RAW video (TR-03)
	* Copyright (c) 2016 Savoir-faire Linux, Inc
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg 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.
	*
	* FFmpeg 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 FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/* Development sponsored by CBC/Radio-Canada */

	#include "avio_internal.h"
	#include "rtpdec_formats.h"
	#include "libavutil/avstring.h"
	#include "libavutil/pixdesc.h"

	struct PayloadContext {
	char *sampling;
	int depth;
	int width;
	int height;

	uint8_t *frame;
	unsigned int frame_size;
	unsigned int pgroup; /* size of the pixel group in bytes */
	unsigned int xinc;

	uint32_t timestamp;
	};

	static int rfc4175_parse_format(AVStream stream, PayloadContext data)
	{
	enum AVPixelFormat pixfmt = AV_PIX_FMT_NONE;
	int bits_per_sample = 0;
	int tag = 0;

	if (!strncmp(data->sampling, "YCbCr-4:2:2", 11)) {
	tag = MKTAG('U', 'Y', 'V', 'Y');
	data->xinc = 2;

	if (data->depth == 8) {
	data->pgroup = 4;
	bits_per_sample = 16;
	pixfmt = AV_PIX_FMT_UYVY422;
	} else if (data->depth == 10) {
	data->pgroup = 5;
	bits_per_sample = 20;
	pixfmt = AV_PIX_FMT_YUV422P10;
	} else {
	return AVERROR_INVALIDDATA;
	}
	} else {
	return AVERROR_INVALIDDATA;
	}

	stream->codecpar->format = pixfmt;
	stream->codecpar->codec_tag = tag;
	stream->codecpar->bits_per_coded_sample = bits_per_sample;
	data->frame_size = data->width * data->height * data->pgroup / data->xinc;

	return 0;
	}

	static int rfc4175_parse_fmtp(AVFormatContext s, AVStream stream,
	PayloadContext data, const char attr,
	const char *value)
	{
	if (!strncmp(attr, "width", 5))
	data->width = atoi(value);
	else if (!strncmp(attr, "height", 6))
	data->height = atoi(value);
	else if (!strncmp(attr, "sampling", 8))
	data->sampling = av_strdup(value);
	else if (!strncmp(attr, "depth", 5))
	data->depth = atoi(value);

	return 0;
	}

	static int rfc4175_parse_sdp_line(AVFormatContext *s, int st_index,
	PayloadContext data, const char line)
	{
	const char *p;

	if (st_index < 0)
	return 0;

	if (av_strstart(line, "fmtp:", &p)) {
	AVStream *stream = s->streams[st_index];
	int ret = ff_parse_fmtp(s, stream, data, p, rfc4175_parse_fmtp);

	if (ret < 0)
	return ret;


	if (!data->sampling \|\| !data->depth \|\| !data->width \|\| !data->height)
	return -1;

	stream->codecpar->width = data->width;
	stream->codecpar->height = data->height;

	ret = rfc4175_parse_format(stream, data);
	av_freep(&data->sampling);

	return ret;
	}

	return 0;
	}

	static int rfc4175_finalize_packet(PayloadContext data, AVPacket pkt,
	int stream_index)
	{
	int ret;

	pkt->stream_index = stream_index;
	ret = av_packet_from_data(pkt, data->frame, data->frame_size);
	if (ret < 0) {
	av_freep(&data->frame);
	}

	data->frame = NULL;

	return ret;
	}

	static int rfc4175_handle_packet(AVFormatContext ctx, PayloadContext data,
	AVStream st, AVPacket pkt, uint32_t *timestamp,
	const uint8_t * buf, int len,
	uint16_t seq, int flags)
	{
	int length, line, offset, cont;
	const uint8_t headers = buf + 2; / skip extended seqnum */
	const uint8_t *payload = buf + 2;
	int payload_len = len - 2;
	int missed_last_packet = 0;

	uint8_t *dest;

	if (*timestamp != data->timestamp) {
	if (data->frame) {
	/*
	* if we're here, it means that two RTP packets didn't have the
	* same timestamp, which is a sign that they were packets from two
	* different frames, but we didn't get the flag RTP_FLAG_MARKER on
	* the first one of these frames (last packet of a frame).
	* Finalize the previous frame anyway by filling the AVPacket.
	*/
	av_log(ctx, AV_LOG_ERROR, "Missed previous RTP Marker\n");
	missed_last_packet = 1;
	rfc4175_finalize_packet(data, pkt, st->index);
	}

	data->frame = av_malloc(data->frame_size);

	data->timestamp = *timestamp;

	if (!data->frame) {
	av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
	return AVERROR(ENOMEM);
	}
	}

	/*
	* looks for the 'Continuation bit' in scan lines' headers
	* to find where data start
	*/
	do {
	if (payload_len < 6)
	return AVERROR_INVALIDDATA;

	cont = payload[4] & 0x80;
	payload += 6;
	payload_len -= 6;
	} while (cont);

	/* and now iterate over every scan lines */
	do {
	int copy_offset;

	if (payload_len < data->pgroup)
	return AVERROR_INVALIDDATA;

	length = (headers[0] << 8) \| headers[1];
	line = ((headers[2] & 0x7f) << 8) \| headers[3];
	offset = ((headers[4] & 0x7f) << 8) \| headers[5];
	cont = headers[4] & 0x80;
	headers += 6;

	if (length % data->pgroup)
	return AVERROR_INVALIDDATA;

	if (length > payload_len)
	length = payload_len;

	/* prevent ill-formed packets to write after buffer's end */
	copy_offset = (line * data->width + offset) * data->pgroup / data->xinc;
	if (copy_offset + length > data->frame_size)
	return AVERROR_INVALIDDATA;

	dest = data->frame + copy_offset;
	memcpy(dest, payload, length);

	payload += length;
	payload_len -= length;
	} while (cont);

	if ((flags & RTP_FLAG_MARKER)) {
	return rfc4175_finalize_packet(data, pkt, st->index);
	} else if (missed_last_packet) {
	return 0;
	}

	return AVERROR(EAGAIN);
	}

	const RTPDynamicProtocolHandler ff_rfc4175_rtp_handler = {
	.enc_name = "raw",
	.codec_type = AVMEDIA_TYPE_VIDEO,
	.codec_id = AV_CODEC_ID_BITPACKED,
	.priv_data_size = sizeof(PayloadContext),
	.parse_sdp_a_line = rfc4175_parse_sdp_line,
	.parse_packet = rfc4175_handle_packet,
	};