FFmpeg
rtpdec_rfc4175.c
Go to the documentation of this file.
1 /*
2  * RTP Depacketization of RAW video (TR-03)
3  * Copyright (c) 2016 Savoir-faire Linux, Inc
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /* Development sponsored by CBC/Radio-Canada */
23 
24 #include "avio_internal.h"
25 #include "rtpdec_formats.h"
26 #include "libavutil/avstring.h"
27 #include "libavutil/pixdesc.h"
28 
29 struct PayloadContext {
30  char *sampling;
31  int depth;
32  int width;
33  int height;
34 
36  unsigned int frame_size;
37  unsigned int pgroup; /* size of the pixel group in bytes */
38  unsigned int xinc;
39 
40  uint32_t timestamp;
41 };
42 
44 {
46  int bits_per_sample = 0;
47  int tag = 0;
48 
49  if (!strncmp(data->sampling, "YCbCr-4:2:2", 11)) {
50  tag = MKTAG('U', 'Y', 'V', 'Y');
51  data->xinc = 2;
52 
53  if (data->depth == 8) {
54  data->pgroup = 4;
55  bits_per_sample = 16;
56  pixfmt = AV_PIX_FMT_UYVY422;
57  } else if (data->depth == 10) {
58  data->pgroup = 5;
59  bits_per_sample = 20;
60  pixfmt = AV_PIX_FMT_YUV422P10;
61  } else {
62  return AVERROR_INVALIDDATA;
63  }
64  } else {
65  return AVERROR_INVALIDDATA;
66  }
67 
68  stream->codecpar->format = pixfmt;
69  stream->codecpar->codec_tag = tag;
70  stream->codecpar->bits_per_coded_sample = bits_per_sample;
71  data->frame_size = data->width * data->height * data->pgroup / data->xinc;
72 
73  return 0;
74 }
75 
77  PayloadContext *data, const char *attr,
78  const char *value)
79 {
80  if (!strncmp(attr, "width", 5))
81  data->width = atoi(value);
82  else if (!strncmp(attr, "height", 6))
83  data->height = atoi(value);
84  else if (!strncmp(attr, "sampling", 8))
85  data->sampling = av_strdup(value);
86  else if (!strncmp(attr, "depth", 5))
87  data->depth = atoi(value);
88 
89  return 0;
90 }
91 
92 static int rfc4175_parse_sdp_line(AVFormatContext *s, int st_index,
93  PayloadContext *data, const char *line)
94 {
95  const char *p;
96 
97  if (st_index < 0)
98  return 0;
99 
100  if (av_strstart(line, "fmtp:", &p)) {
101  AVStream *stream = s->streams[st_index];
102  int ret = ff_parse_fmtp(s, stream, data, p, rfc4175_parse_fmtp);
103 
104  if (ret < 0)
105  return ret;
106 
107 
108  if (!data->sampling || !data->depth || !data->width || !data->height)
109  return -1;
110 
111  stream->codecpar->width = data->width;
112  stream->codecpar->height = data->height;
113 
114  ret = rfc4175_parse_format(stream, data);
115  av_freep(&data->sampling);
116 
117  return ret;
118  }
119 
120  return 0;
121 }
122 
124  int stream_index)
125 {
126  int ret;
127 
128  pkt->stream_index = stream_index;
129  ret = av_packet_from_data(pkt, data->frame, data->frame_size);
130  if (ret < 0) {
131  av_freep(&data->frame);
132  }
133 
134  data->frame = NULL;
135 
136  return ret;
137 }
138 
140  AVStream *st, AVPacket *pkt, uint32_t *timestamp,
141  const uint8_t * buf, int len,
142  uint16_t seq, int flags)
143 {
144  int length, line, offset, cont;
145  const uint8_t *headers = buf + 2; /* skip extended seqnum */
146  const uint8_t *payload = buf + 2;
147  int payload_len = len - 2;
148  int missed_last_packet = 0;
149 
150  uint8_t *dest;
151 
152  if (*timestamp != data->timestamp) {
153  if (data->frame) {
154  /*
155  * if we're here, it means that two RTP packets didn't have the
156  * same timestamp, which is a sign that they were packets from two
157  * different frames, but we didn't get the flag RTP_FLAG_MARKER on
158  * the first one of these frames (last packet of a frame).
159  * Finalize the previous frame anyway by filling the AVPacket.
160  */
161  av_log(ctx, AV_LOG_ERROR, "Missed previous RTP Marker\n");
162  missed_last_packet = 1;
163  rfc4175_finalize_packet(data, pkt, st->index);
164  }
165 
166  data->frame = av_malloc(data->frame_size);
167 
168  data->timestamp = *timestamp;
169 
170  if (!data->frame) {
171  av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
172  return AVERROR(ENOMEM);
173  }
174  }
175 
176  /*
177  * looks for the 'Continuation bit' in scan lines' headers
178  * to find where data start
179  */
180  do {
181  if (payload_len < 6)
182  return AVERROR_INVALIDDATA;
183 
184  cont = payload[4] & 0x80;
185  payload += 6;
186  payload_len -= 6;
187  } while (cont);
188 
189  /* and now iterate over every scan lines */
190  do {
191  int copy_offset;
192 
193  if (payload_len < data->pgroup)
194  return AVERROR_INVALIDDATA;
195 
196  length = (headers[0] << 8) | headers[1];
197  line = ((headers[2] & 0x7f) << 8) | headers[3];
198  offset = ((headers[4] & 0x7f) << 8) | headers[5];
199  cont = headers[4] & 0x80;
200  headers += 6;
201 
202  if (length % data->pgroup)
203  return AVERROR_INVALIDDATA;
204 
205  if (length > payload_len)
206  length = payload_len;
207 
208  /* prevent ill-formed packets to write after buffer's end */
209  copy_offset = (line * data->width + offset) * data->pgroup / data->xinc;
210  if (copy_offset + length > data->frame_size)
211  return AVERROR_INVALIDDATA;
212 
213  dest = data->frame + copy_offset;
214  memcpy(dest, payload, length);
215 
216  payload += length;
217  payload_len -= length;
218  } while (cont);
219 
220  if ((flags & RTP_FLAG_MARKER)) {
221  return rfc4175_finalize_packet(data, pkt, st->index);
222  } else if (missed_last_packet) {
223  return 0;
224  }
225 
226  return AVERROR(EAGAIN);
227 }
228 
230  .enc_name = "raw",
231  .codec_type = AVMEDIA_TYPE_VIDEO,
232  .codec_id = AV_CODEC_ID_BITPACKED,
233  .priv_data_size = sizeof(PayloadContext),
234  .parse_sdp_a_line = rfc4175_parse_sdp_line,
236 };
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
AVPacket pkt
Definition: rtpdec_qt.c:37
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static int rfc4175_parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line)
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index, int flush)
Parse a packet, add all split parts to parse_queue.
Definition: utils.c:1447
RTP/JPEG specific private data.
Definition: rdt.c:83
int index
stream index in AVFormatContext
Definition: avformat.h:882
AVIOContext * frame
current frame buffer
Definition: rtpdec_jpeg.c:35
Format I/O context.
Definition: avformat.h:1358
static int rfc4175_parse_format(AVStream *stream, PayloadContext *data)
uint8_t * frame
uint8_t
#define av_malloc(s)
int width
Video only.
Definition: avcodec.h:4034
unsigned int xinc
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
Initialize a reference-counted packet from av_malloc()ed data.
Definition: avpacket.c:152
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)
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
uint32_t tag
Definition: movenc.c:1531
#define av_log(a,...)
uint32_t timestamp
current frame timestamp
Definition: rtpdec_ac3.c:31
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:93
Definition: graph2dot.c:48
GLsizei GLsizei * length
Definition: opengl_enc.c:114
unsigned int frame_size
const RTPDynamicProtocolHandler ff_rfc4175_rtp_handler
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
if(ret)
Stream structure.
Definition: avformat.h:881
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
static int rfc4175_parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
uint8_t * buf
the temporary storage buffer
Definition: rtpdec_asf.c:183
int ff_parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *p, int(*parse_fmtp)(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value))
Definition: rtpdec.c:889
const char * enc_name
Definition: rtpdec.h:116
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
static int rfc4175_finalize_packet(PayloadContext *data, AVPacket *pkt, int stream_index)
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:33
unsigned int pgroup
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:202
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4010
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3972
int stream_index
Definition: avcodec.h:1482
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:1
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:366
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457