FFmpeg: libavformat/rtpdec_mpeg4.c Source File

FFmpeg
rtpdec_mpeg4.c
Go to the documentation of this file.
1 /*
2  * Common code for the RTP depacketization of MPEG-4 formats.
3  * Copyright (c) 2010 Fabrice Bellard
4  * Romain Degez
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * @brief MPEG-4 / RTP Code
26  * @author Fabrice Bellard
27  * @author Romain Degez
28  */
29 
30 #include "rtpdec_formats.h"
31 #include "internal.h"
32 #include "libavutil/attributes.h"
33 #include "libavutil/avstring.h"
34 #include "libavcodec/get_bits.h"
35 
36  #define MAX_AAC_HBR_FRAME_SIZE 8191
37 
38 /** Structure listing useful vars to parse RTP packet payload */
39 struct PayloadContext {
40   int sizelength;
41   int indexlength;
42   int indexdeltalength;
43   int profile_level_id;
44   int streamtype;
45   int objecttype;
46   char *mode;
47 
48  /** mpeg 4 AU headers */
49   struct AUHeaders {
50   int size;
51   int index;
52   int cts_flag;
53   int cts;
54   int dts_flag;
55   int dts;
56   int rap_flag;
57   int streamstate;
58  } *au_headers;
59   int au_headers_allocated;
60   int nb_au_headers;
61   int au_headers_length_bytes;
62   int cur_au_index;
63 
64   uint8_t buf[FFMAX(RTP_MAX_PACKET_LENGTH, MAX_AAC_HBR_FRAME_SIZE)];
65   int buf_pos, buf_size;
66  uint32_t timestamp;
67 };
68 
69  typedef struct AttrNameMap {
70   const char *str;
71   uint16_t type;
72   uint32_t offset;
73 
74  /** Range for integer values */
75   struct Range {
76   int min;
77   int max;
78  } range;
79 } AttrNameMap;
80 
81 /* All known fmtp parameters and the corresponding RTPAttrTypeEnum */
82  #define ATTR_NAME_TYPE_INT 0
83  #define ATTR_NAME_TYPE_STR 1
84  static const AttrNameMap attr_names[] = {
85  { "SizeLength", ATTR_NAME_TYPE_INT,
86  offsetof(PayloadContext, sizelength),
87  {0, 32} }, // SizeLength number of bits used to encode AU-size integer value
88  { "IndexLength", ATTR_NAME_TYPE_INT,
89  offsetof(PayloadContext, indexlength),
90  {0, 32} }, // IndexLength number of bits used to encode AU-Index integer value
91  { "IndexDeltaLength", ATTR_NAME_TYPE_INT,
92  offsetof(PayloadContext, indexdeltalength),
93  {0, 32} }, // IndexDeltaLength number of bits to encode AU-Index-delta integer value
94  { "profile-level-id", ATTR_NAME_TYPE_INT,
95  offsetof(PayloadContext, profile_level_id),
96  {INT32_MIN, INT32_MAX} }, // It differs depending on StreamType
97  { "StreamType", ATTR_NAME_TYPE_INT,
98  offsetof(PayloadContext, streamtype),
99  {0x00, 0x3F} }, // Values from ISO/IEC 14496-1, 'StreamType Values' table
100  { "mode", ATTR_NAME_TYPE_STR,
101  offsetof(PayloadContext, mode),
102  {0} },
103  { NULL, -1, -1, {0} },
104 };
105 
106  static void close_context(PayloadContext *data)
107 {
108  av_freep(&data->au_headers);
109  av_freep(&data->mode);
110 }
111 
112  static int parse_fmtp_config(AVCodecParameters *par, const char *value)
113 {
114  /* decode the hexa encoded parameter */
115  int len = ff_hex_to_data(NULL, value), ret;
116 
117  if ((ret = ff_alloc_extradata(par, len)) < 0)
118  return ret;
119  ff_hex_to_data(par->extradata, value);
120  return 0;
121 }
122 
123  static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)
124 {
125  int au_headers_length, au_header_size, i;
126  GetBitContext getbitcontext;
127  int ret;
128 
129  if (len < 2)
130  return AVERROR_INVALIDDATA;
131 
132  /* decode the first 2 bytes where the AUHeader sections are stored
133  length in bits */
134  au_headers_length = AV_RB16(buf);
135 
136  if (au_headers_length > RTP_MAX_PACKET_LENGTH)
137  return -1;
138 
139  data->au_headers_length_bytes = (au_headers_length + 7) / 8;
140 
141  /* skip AU headers length section (2 bytes) */
142  buf += 2;
143  len -= 2;
144 
145  if (len < data->au_headers_length_bytes)
146  return AVERROR_INVALIDDATA;
147 
148  ret = init_get_bits(&getbitcontext, buf, data->au_headers_length_bytes * 8);
149  if (ret < 0)
150  return ret;
151 
152  /* XXX: Wrong if optional additional sections are present (cts, dts etc...) */
153  au_header_size = data->sizelength + data->indexlength;
154  if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
155  return -1;
156 
157  data->nb_au_headers = au_headers_length / au_header_size;
158  if (!data->au_headers || data->au_headers_allocated < data->nb_au_headers) {
159  av_free(data->au_headers);
160  data->au_headers = av_malloc(sizeof(struct AUHeaders) * data->nb_au_headers);
161  if (!data->au_headers)
162  return AVERROR(ENOMEM);
163  data->au_headers_allocated = data->nb_au_headers;
164  }
165 
166  for (i = 0; i < data->nb_au_headers; ++i) {
167  data->au_headers[i].size = get_bits_long(&getbitcontext, data->sizelength);
168  data->au_headers[i].index = get_bits_long(&getbitcontext, data->indexlength);
169  }
170 
171  return 0;
172 }
173 
174 
175 /* Follows RFC 3640 */
176  static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data,
177  AVStream *st, AVPacket *pkt, uint32_t *timestamp,
178  const uint8_t *buf, int len, uint16_t seq,
179  int flags)
180 {
181  int ret;
182 
183 
184  if (!buf) {
185  if (data->cur_au_index > data->nb_au_headers) {
186  av_log(ctx, AV_LOG_ERROR, "Invalid parser state\n");
187  return AVERROR_INVALIDDATA;
188  }
189  if (data->buf_size - data->buf_pos < data->au_headers[data->cur_au_index].size) {
190  av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
191  return AVERROR_INVALIDDATA;
192  }
193  if ((ret = av_new_packet(pkt, data->au_headers[data->cur_au_index].size)) < 0) {
194  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
195  return ret;
196  }
197  memcpy(pkt->data, &data->buf[data->buf_pos], data->au_headers[data->cur_au_index].size);
198  data->buf_pos += data->au_headers[data->cur_au_index].size;
199  pkt->stream_index = st->index;
200  data->cur_au_index++;
201 
202  if (data->cur_au_index == data->nb_au_headers) {
203  data->buf_pos = 0;
204  return 0;
205  }
206 
207  return 1;
208  }
209 
210  if (rtp_parse_mp4_au(data, buf, len)) {
211  av_log(ctx, AV_LOG_ERROR, "Error parsing AU headers\n");
212  return -1;
213  }
214 
215  buf += data->au_headers_length_bytes + 2;
216  len -= data->au_headers_length_bytes + 2;
217  if (data->nb_au_headers == 1 && len < data->au_headers[0].size) {
218  /* Packet is fragmented */
219 
220  if (!data->buf_pos) {
221  if (data->au_headers[0].size > MAX_AAC_HBR_FRAME_SIZE) {
222  av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
223  return AVERROR_INVALIDDATA;
224  }
225 
226  data->buf_size = data->au_headers[0].size;
227  data->timestamp = *timestamp;
228  }
229 
230  if (data->timestamp != *timestamp ||
231  data->au_headers[0].size != data->buf_size ||
232  data->buf_pos + len > MAX_AAC_HBR_FRAME_SIZE) {
233  data->buf_pos = 0;
234  data->buf_size = 0;
235  av_log(ctx, AV_LOG_ERROR, "Invalid packet received\n");
236  return AVERROR_INVALIDDATA;
237  }
238 
239  memcpy(&data->buf[data->buf_pos], buf, len);
240  data->buf_pos += len;
241 
242  if (!(flags & RTP_FLAG_MARKER))
243  return AVERROR(EAGAIN);
244 
245  if (data->buf_pos != data->buf_size) {
246  data->buf_pos = 0;
247  av_log(ctx, AV_LOG_ERROR, "Missed some packets, discarding frame\n");
248  return AVERROR_INVALIDDATA;
249  }
250 
251  data->buf_pos = 0;
252  ret = av_new_packet(pkt, data->buf_size);
253  if (ret < 0) {
254  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
255  return ret;
256  }
257  pkt->stream_index = st->index;
258 
259  memcpy(pkt->data, data->buf, data->buf_size);
260 
261  return 0;
262  }
263 
264  if (len < data->au_headers[0].size) {
265  av_log(ctx, AV_LOG_ERROR, "First AU larger than packet size\n");
266  return AVERROR_INVALIDDATA;
267  }
268  if ((ret = av_new_packet(pkt, data->au_headers[0].size)) < 0) {
269  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
270  return ret;
271  }
272  memcpy(pkt->data, buf, data->au_headers[0].size);
273  len -= data->au_headers[0].size;
274  buf += data->au_headers[0].size;
275  pkt->stream_index = st->index;
276 
277  if (len > 0 && data->nb_au_headers > 1) {
278  data->buf_size = FFMIN(len, sizeof(data->buf));
279  memcpy(data->buf, buf, data->buf_size);
280  data->cur_au_index = 1;
281  data->buf_pos = 0;
282  return 1;
283  }
284 
285  return 0;
286 }
287 
288  static int parse_fmtp(AVFormatContext *s,
289  AVStream *stream, PayloadContext *data,
290  const char *attr, const char *value)
291 {
292  AVCodecParameters *par = stream->codecpar;
293  int res, i;
294 
295  if (!strcmp(attr, "config")) {
296  res = parse_fmtp_config(par, value);
297 
298  if (res < 0)
299  return res;
300  }
301 
302  if (par->codec_id == AV_CODEC_ID_AAC) {
303  /* Looking for a known attribute */
304  for (i = 0; attr_names[i].str; ++i) {
305  if (!av_strcasecmp(attr, attr_names[i].str)) {
306  if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
307  char *end_ptr = NULL;
308  long long int val = strtoll(value, &end_ptr, 10);
309  if (end_ptr == value || end_ptr[0] != '0円') {
310  av_log(s, AV_LOG_ERROR,
311  "The %s field value is not a valid number: %s\n",
312  attr, value);
313  return AVERROR_INVALIDDATA;
314  }
315  if (val < attr_names[i].range.min ||
316  val > attr_names[i].range.max) {
317  av_log(s, AV_LOG_ERROR,
318  "fmtp field %s should be in range [%d,%d] (provided value: %lld)",
319  attr, attr_names[i].range.min, attr_names[i].range.max, val);
320  return AVERROR_INVALIDDATA;
321  }
322 
323  *(int *)((char *)data+
324  attr_names[i].offset) = (int) val;
325  } else if (attr_names[i].type == ATTR_NAME_TYPE_STR) {
326  char *val = av_strdup(value);
327  if (!val)
328  return AVERROR(ENOMEM);
329  *(char **)((char *)data+
330  attr_names[i].offset) = val;
331  }
332  }
333  }
334  }
335  return 0;
336 }
337 
338  static int parse_sdp_line(AVFormatContext *s, int st_index,
339  PayloadContext *data, const char *line)
340 {
341  const char *p;
342 
343  if (st_index < 0)
344  return 0;
345 
346  if (av_strstart(line, "fmtp:", &p))
347  return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);
348 
349  return 0;
350 }
351 
352  const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler = {
353  .enc_name = "MP4V-ES",
354  .codec_type = AVMEDIA_TYPE_VIDEO,
355  .codec_id = AV_CODEC_ID_MPEG4,
356  .need_parsing = AVSTREAM_PARSE_FULL,
357  .priv_data_size = sizeof(PayloadContext),
358  .parse_sdp_a_line = parse_sdp_line,
359 };
360 
361  const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler = {
362  .enc_name = "mpeg4-generic",
363  .codec_type = AVMEDIA_TYPE_AUDIO,
364  .codec_id = AV_CODEC_ID_AAC,
365  .priv_data_size = sizeof(PayloadContext),
366  .parse_sdp_a_line = parse_sdp_line,
367  .close = close_context,
368  .parse_packet = aac_parse_packet,
369 };
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:75
AVERROR
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
ff_mp4v_es_dynamic_handler
const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler
Definition: rtpdec_mpeg4.c:352
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:53
PayloadContext::au_headers
struct PayloadContext::AUHeaders * au_headers
rtpdec_formats.h
ff_parse_fmtp
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:964
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:218
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
PayloadContext::objecttype
int objecttype
Definition: rtpdec_mpeg4.c:45
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:94
AVPacket::data
uint8_t * data
Definition: packet.h:374
data
const char data[16]
Definition: mxf.c:143
AttrNameMap
Definition: rtpdec_mpeg4.c:69
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
PayloadContext::profile_level_id
int profile_level_id
Definition: rtpdec_mpeg4.c:43
close_context
static void close_context(PayloadContext *data)
Definition: rtpdec_mpeg4.c:106
PayloadContext::sizelength
int sizelength
Definition: rtpdec_mpeg4.c:40
PayloadContext::indexlength
int indexlength
Definition: rtpdec_mpeg4.c:41
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
PayloadContext::AUHeaders
mpeg 4 AU headers
Definition: rtpdec_mpeg4.c:49
PayloadContext::timestamp
uint32_t timestamp
current frame timestamp
Definition: rtpdec_ac3.c:31
RTPDynamicProtocolHandler::enc_name
const char * enc_name
Definition: rtpdec.h:117
PayloadContext::nb_au_headers
int nb_au_headers
Definition: rtpdec_mpeg4.c:60
PayloadContext::buf_pos
int buf_pos
Definition: rtpdec_mpeg4.c:65
parse_fmtp
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
Definition: rtpdec_mpeg4.c:288
GetBitContext
Definition: get_bits.h:61
val
static double val(void *priv, double ch)
Definition: aeval.c:77
type
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 type
Definition: writing_filters.txt:86
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AttrNameMap::range
struct AttrNameMap::Range range
s
#define s(width, name)
Definition: cbs_vp9.c:256
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
AttrNameMap::str
const char * str
Definition: rtpdec_mpeg4.c:70
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
PayloadContext::au_headers_length_bytes
int au_headers_length_bytes
Definition: rtpdec_mpeg4.c:61
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PayloadContext::streamtype
int streamtype
Definition: rtpdec_mpeg4.c:44
get_bits.h
PayloadContext::AUHeaders::dts
int dts
Definition: rtpdec_mpeg4.c:55
PayloadContext::AUHeaders::rap_flag
int rap_flag
Definition: rtpdec_mpeg4.c:56
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:475
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
NULL
#define NULL
Definition: coverity.c:32
PayloadContext::au_headers_allocated
int au_headers_allocated
Definition: rtpdec_mpeg4.c:59
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:429
PayloadContext::AUHeaders::cts
int cts
Definition: rtpdec_mpeg4.c:53
parse_fmtp_config
static int parse_fmtp_config(AVCodecParameters *par, const char *value)
Definition: rtpdec_mpeg4.c:112
aac_parse_packet
static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags)
Definition: rtpdec_mpeg4.c:176
ATTR_NAME_TYPE_INT
#define ATTR_NAME_TYPE_INT
Definition: rtpdec_mpeg4.c:82
size
int size
Definition: twinvq_data.h:10344
PayloadContext::buf_size
int buf_size
Definition: rtpdec_mpeg4.c:65
PayloadContext::AUHeaders::index
int index
Definition: rtpdec_mpeg4.c:51
line
Definition: graph2dot.c:48
attributes.h
av_strstart
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:37
MAX_AAC_HBR_FRAME_SIZE
#define MAX_AAC_HBR_FRAME_SIZE
Definition: rtpdec_mpeg4.c:36
AttrNameMap::Range
Range for integer values.
Definition: rtpdec_mpeg4.c:75
AttrNameMap::type
uint16_t type
Definition: rtpdec_mpeg4.c:71
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
PayloadContext::AUHeaders::dts_flag
int dts_flag
Definition: rtpdec_mpeg4.c:54
ATTR_NAME_TYPE_STR
#define ATTR_NAME_TYPE_STR
Definition: rtpdec_mpeg4.c:83
value
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 default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
parse_sdp_line
static int parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line)
Definition: rtpdec_mpeg4.c:338
len
int len
Definition: vorbis_enc_data.h:426
attr_names
static const AttrNameMap attr_names[]
Definition: rtpdec_mpeg4.c:84
AttrNameMap::Range::min
int min
Definition: rtpdec_mpeg4.c:76
AttrNameMap::Range::max
int max
Definition: rtpdec_mpeg4.c:77
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
rtp_parse_mp4_au
static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)
Definition: rtpdec_mpeg4.c:123
PayloadContext::AUHeaders::size
int size
Definition: rtpdec_mpeg4.c:50
RTP_MAX_PACKET_LENGTH
#define RTP_MAX_PACKET_LENGTH
Definition: rtpdec.h:37
ff_mpeg4_generic_dynamic_handler
const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler
Definition: rtpdec_mpeg4.c:361
PayloadContext::buf
uint8_t * buf
the temporary storage buffer
Definition: rtpdec_asf.c:183
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:956
AttrNameMap::offset
uint32_t offset
Definition: rtpdec_mpeg4.c:72
mode
mode
Definition: ebur128.h:83
PayloadContext::AUHeaders::cts_flag
int cts_flag
Definition: rtpdec_mpeg4.c:52
AVPacket::stream_index
int stream_index
Definition: packet.h:376
parse_packet
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index, int flush)
Parse a packet, add all split parts to parse_queue.
Definition: demux.c:1118
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
PayloadContext::mode
char * mode
Definition: rtpdec_mpeg4.c:46
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
PayloadContext::cur_au_index
int cur_au_index
Definition: rtpdec_mpeg4.c:62
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
convert_header.str
string str
Definition: convert_header.py:20
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:798
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avstring.h
PayloadContext::indexdeltalength
int indexdeltalength
Definition: rtpdec_mpeg4.c:42
PayloadContext
RTP/JPEG specific private data.
Definition: rdt.c:83
RTPDynamicProtocolHandler
Definition: rtpdec.h:116
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
PayloadContext::AUHeaders::streamstate
int streamstate
Definition: rtpdec_mpeg4.c:57
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:238
Generated on Wed Aug 24 2022 21:42:19 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /