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 "libavutil/mem.h"
35 #include "libavcodec/get_bits.h"
36 
37  #define MAX_AAC_HBR_FRAME_SIZE 8191
38 
39 /** Structure listing useful vars to parse RTP packet payload */
40 struct PayloadContext {
41   int sizelength;
42   int indexlength;
43   int indexdeltalength;
44   int profile_level_id;
45   int streamtype;
46   int objecttype;
47   char *mode;
48 
49  /** mpeg 4 AU headers */
50   struct AUHeaders {
51   int size;
52   int index;
53   int cts_flag;
54   int cts;
55   int dts_flag;
56   int dts;
57   int rap_flag;
58   int streamstate;
59  } *au_headers;
60   int au_headers_allocated;
61   int nb_au_headers;
62   int au_headers_length_bytes;
63   int cur_au_index;
64 
65   uint8_t buf[FFMAX(RTP_MAX_PACKET_LENGTH, MAX_AAC_HBR_FRAME_SIZE)];
66   int buf_pos, buf_size;
67  uint32_t timestamp;
68 };
69 
70  typedef struct AttrNameMap {
71   const char *str;
72   uint16_t type;
73   uint32_t offset;
74 
75  /** Range for integer values */
76   struct Range {
77   int min;
78   int max;
79  } range;
80 } AttrNameMap;
81 
82 /* All known fmtp parameters and the corresponding RTPAttrTypeEnum */
83  #define ATTR_NAME_TYPE_INT 0
84  #define ATTR_NAME_TYPE_STR 1
85  static const AttrNameMap attr_names[] = {
86  { "SizeLength", ATTR_NAME_TYPE_INT,
87  offsetof(PayloadContext, sizelength),
88  {0, 32} }, // SizeLength number of bits used to encode AU-size integer value
89  { "IndexLength", ATTR_NAME_TYPE_INT,
90  offsetof(PayloadContext, indexlength),
91  {0, 32} }, // IndexLength number of bits used to encode AU-Index integer value
92  { "IndexDeltaLength", ATTR_NAME_TYPE_INT,
93  offsetof(PayloadContext, indexdeltalength),
94  {0, 32} }, // IndexDeltaLength number of bits to encode AU-Index-delta integer value
95  { "profile-level-id", ATTR_NAME_TYPE_INT,
96  offsetof(PayloadContext, profile_level_id),
97  {INT32_MIN, INT32_MAX} }, // It differs depending on StreamType
98  { "StreamType", ATTR_NAME_TYPE_INT,
99  offsetof(PayloadContext, streamtype),
100  {0x00, 0x3F} }, // Values from ISO/IEC 14496-1, 'StreamType Values' table
101  { "mode", ATTR_NAME_TYPE_STR,
102  offsetof(PayloadContext, mode),
103  {0} },
104  { NULL, -1, -1, {0} },
105 };
106 
107  static void close_context(PayloadContext *data)
108 {
109  av_freep(&data->au_headers);
110  av_freep(&data->mode);
111 }
112 
113  static int parse_fmtp_config(AVCodecParameters *par, const char *value)
114 {
115  /* decode the hexa encoded parameter */
116  int len = ff_hex_to_data(NULL, value), ret;
117 
118  if ((ret = ff_alloc_extradata(par, len)) < 0)
119  return ret;
120  ff_hex_to_data(par->extradata, value);
121  return 0;
122 }
123 
124  static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)
125 {
126  int au_headers_length, au_header_size, i;
127  GetBitContext getbitcontext;
128  int ret;
129 
130  if (len < 2)
131  return AVERROR_INVALIDDATA;
132 
133  /* decode the first 2 bytes where the AUHeader sections are stored
134  length in bits */
135  au_headers_length = AV_RB16(buf);
136 
137  if (au_headers_length > RTP_MAX_PACKET_LENGTH)
138  return -1;
139 
140  data->au_headers_length_bytes = (au_headers_length + 7) / 8;
141 
142  /* skip AU headers length section (2 bytes) */
143  buf += 2;
144  len -= 2;
145 
146  if (len < data->au_headers_length_bytes)
147  return AVERROR_INVALIDDATA;
148 
149  ret = init_get_bits(&getbitcontext, buf, data->au_headers_length_bytes * 8);
150  if (ret < 0)
151  return ret;
152 
153  /* XXX: Wrong if optional additional sections are present (cts, dts etc...) */
154  au_header_size = data->sizelength + data->indexlength;
155  if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
156  return -1;
157 
158  data->nb_au_headers = au_headers_length / au_header_size;
159  if (!data->au_headers || data->au_headers_allocated < data->nb_au_headers) {
160  av_free(data->au_headers);
161  data->au_headers = av_malloc(sizeof(struct AUHeaders) * data->nb_au_headers);
162  if (!data->au_headers)
163  return AVERROR(ENOMEM);
164  data->au_headers_allocated = data->nb_au_headers;
165  }
166 
167  for (i = 0; i < data->nb_au_headers; ++i) {
168  data->au_headers[i].size = get_bits_long(&getbitcontext, data->sizelength);
169  data->au_headers[i].index = get_bits_long(&getbitcontext, data->indexlength);
170  }
171 
172  return 0;
173 }
174 
175 
176 /* Follows RFC 3640 */
177  static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data,
178  AVStream *st, AVPacket *pkt, uint32_t *timestamp,
179  const uint8_t *buf, int len, uint16_t seq,
180  int flags)
181 {
182  int ret;
183 
184 
185  if (!buf) {
186  if (data->cur_au_index > data->nb_au_headers) {
187  av_log(ctx, AV_LOG_ERROR, "Invalid parser state\n");
188  return AVERROR_INVALIDDATA;
189  }
190  if (data->buf_size - data->buf_pos < data->au_headers[data->cur_au_index].size) {
191  av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
192  return AVERROR_INVALIDDATA;
193  }
194  if ((ret = av_new_packet(pkt, data->au_headers[data->cur_au_index].size)) < 0) {
195  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
196  return ret;
197  }
198  memcpy(pkt->data, &data->buf[data->buf_pos], data->au_headers[data->cur_au_index].size);
199  data->buf_pos += data->au_headers[data->cur_au_index].size;
200  pkt->stream_index = st->index;
201  data->cur_au_index++;
202 
203  if (data->cur_au_index == data->nb_au_headers) {
204  data->buf_pos = 0;
205  return 0;
206  }
207 
208  return 1;
209  }
210 
211  if (rtp_parse_mp4_au(data, buf, len)) {
212  av_log(ctx, AV_LOG_ERROR, "Error parsing AU headers\n");
213  return -1;
214  }
215 
216  buf += data->au_headers_length_bytes + 2;
217  len -= data->au_headers_length_bytes + 2;
218  if (data->nb_au_headers == 1 && len < data->au_headers[0].size) {
219  /* Packet is fragmented */
220 
221  if (!data->buf_pos) {
222  if (data->au_headers[0].size > MAX_AAC_HBR_FRAME_SIZE) {
223  av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
224  return AVERROR_INVALIDDATA;
225  }
226 
227  data->buf_size = data->au_headers[0].size;
228  data->timestamp = *timestamp;
229  }
230 
231  if (data->timestamp != *timestamp ||
232  data->au_headers[0].size != data->buf_size ||
233  data->buf_pos + len > MAX_AAC_HBR_FRAME_SIZE) {
234  data->buf_pos = 0;
235  data->buf_size = 0;
236  av_log(ctx, AV_LOG_ERROR, "Invalid packet received\n");
237  return AVERROR_INVALIDDATA;
238  }
239 
240  memcpy(&data->buf[data->buf_pos], buf, len);
241  data->buf_pos += len;
242 
243  if (!(flags & RTP_FLAG_MARKER))
244  return AVERROR(EAGAIN);
245 
246  if (data->buf_pos != data->buf_size) {
247  data->buf_pos = 0;
248  av_log(ctx, AV_LOG_ERROR, "Missed some packets, discarding frame\n");
249  return AVERROR_INVALIDDATA;
250  }
251 
252  data->buf_pos = 0;
253  ret = av_new_packet(pkt, data->buf_size);
254  if (ret < 0) {
255  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
256  return ret;
257  }
258  pkt->stream_index = st->index;
259 
260  memcpy(pkt->data, data->buf, data->buf_size);
261 
262  return 0;
263  }
264 
265  if (len < data->au_headers[0].size) {
266  av_log(ctx, AV_LOG_ERROR, "First AU larger than packet size\n");
267  return AVERROR_INVALIDDATA;
268  }
269  if ((ret = av_new_packet(pkt, data->au_headers[0].size)) < 0) {
270  av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
271  return ret;
272  }
273  memcpy(pkt->data, buf, data->au_headers[0].size);
274  len -= data->au_headers[0].size;
275  buf += data->au_headers[0].size;
276  pkt->stream_index = st->index;
277 
278  if (len > 0 && data->nb_au_headers > 1) {
279  data->buf_size = FFMIN(len, sizeof(data->buf));
280  memcpy(data->buf, buf, data->buf_size);
281  data->cur_au_index = 1;
282  data->buf_pos = 0;
283  return 1;
284  }
285 
286  return 0;
287 }
288 
289  static int parse_fmtp(AVFormatContext *s,
290  AVStream *stream, PayloadContext *data,
291  const char *attr, const char *value)
292 {
293  AVCodecParameters *par = stream->codecpar;
294  int res, i;
295 
296  if (!strcmp(attr, "config")) {
297  res = parse_fmtp_config(par, value);
298 
299  if (res < 0)
300  return res;
301  }
302 
303  if (par->codec_id == AV_CODEC_ID_AAC) {
304  /* Looking for a known attribute */
305  for (i = 0; attr_names[i].str; ++i) {
306  if (!av_strcasecmp(attr, attr_names[i].str)) {
307  if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
308  char *end_ptr = NULL;
309  long long int val = strtoll(value, &end_ptr, 10);
310  if (end_ptr == value || end_ptr[0] != '0円') {
311  av_log(s, AV_LOG_ERROR,
312  "The %s field value is not a valid number: %s\n",
313  attr, value);
314  return AVERROR_INVALIDDATA;
315  }
316  if (val < attr_names[i].range.min ||
317  val > attr_names[i].range.max) {
318  av_log(s, AV_LOG_ERROR,
319  "fmtp field %s should be in range [%d,%d] (provided value: %lld)",
320  attr, attr_names[i].range.min, attr_names[i].range.max, val);
321  return AVERROR_INVALIDDATA;
322  }
323 
324  *(int *)((char *)data+
325  attr_names[i].offset) = (int) val;
326  } else if (attr_names[i].type == ATTR_NAME_TYPE_STR) {
327  char *val = av_strdup(value);
328  if (!val)
329  return AVERROR(ENOMEM);
330  *(char **)((char *)data+
331  attr_names[i].offset) = val;
332  }
333  }
334  }
335  }
336  return 0;
337 }
338 
339  static int parse_sdp_line(AVFormatContext *s, int st_index,
340  PayloadContext *data, const char *line)
341 {
342  const char *p;
343 
344  if (st_index < 0)
345  return 0;
346 
347  if (av_strstart(line, "fmtp:", &p))
348  return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);
349 
350  return 0;
351 }
352 
353  const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler = {
354  .enc_name = "MP4V-ES",
355  .codec_type = AVMEDIA_TYPE_VIDEO,
356  .codec_id = AV_CODEC_ID_MPEG4,
357  .need_parsing = AVSTREAM_PARSE_FULL,
358  .priv_data_size = sizeof(PayloadContext),
359  .parse_sdp_a_line = parse_sdp_line,
360 };
361 
362  const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler = {
363  .enc_name = "mpeg4-generic",
364  .codec_type = AVMEDIA_TYPE_AUDIO,
365  .codec_id = AV_CODEC_ID_AAC,
366  .priv_data_size = sizeof(PayloadContext),
367  .parse_sdp_a_line = parse_sdp_line,
368  .close = close_context,
369  .parse_packet = aac_parse_packet,
370 };
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
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:353
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
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:965
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
PayloadContext::objecttype
int objecttype
Definition: rtpdec_mpeg4.c:46
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:539
data
const char data[16]
Definition: mxf.c:148
AttrNameMap
Definition: rtpdec_mpeg4.c:70
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
PayloadContext::profile_level_id
int profile_level_id
Definition: rtpdec_mpeg4.c:44
close_context
static void close_context(PayloadContext *data)
Definition: rtpdec_mpeg4.c:107
PayloadContext::sizelength
int sizelength
Definition: rtpdec_mpeg4.c:41
PayloadContext::indexlength
int indexlength
Definition: rtpdec_mpeg4.c:42
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
PayloadContext::AUHeaders
mpeg 4 AU headers
Definition: rtpdec_mpeg4.c:50
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:61
PayloadContext::buf_pos
int buf_pos
Definition: rtpdec_mpeg4.c:66
parse_fmtp
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
Definition: rtpdec_mpeg4.c:289
GetBitContext
Definition: get_bits.h:108
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:60
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:198
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: packet.c:98
AttrNameMap::str
const char * str
Definition: rtpdec_mpeg4.c:71
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
PayloadContext::au_headers_length_bytes
int au_headers_length_bytes
Definition: rtpdec_mpeg4.c:62
ctx
AVFormatContext * ctx
Definition: movenc.c:49
PayloadContext::streamtype
int streamtype
Definition: rtpdec_mpeg4.c:45
get_bits.h
PayloadContext::AUHeaders::dts
int dts
Definition: rtpdec_mpeg4.c:56
PayloadContext::AUHeaders::rap_flag
int rap_flag
Definition: rtpdec_mpeg4.c:57
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:469
AVFormatContext
Format I/O context.
Definition: avformat.h:1287
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
NULL
#define NULL
Definition: coverity.c:32
PayloadContext::au_headers_allocated
int au_headers_allocated
Definition: rtpdec_mpeg4.c:60
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
PayloadContext::AUHeaders::cts
int cts
Definition: rtpdec_mpeg4.c:54
parse_fmtp_config
static int parse_fmtp_config(AVCodecParameters *par, const char *value)
Definition: rtpdec_mpeg4.c:113
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:177
ATTR_NAME_TYPE_INT
#define ATTR_NAME_TYPE_INT
Definition: rtpdec_mpeg4.c:83
size
int size
Definition: twinvq_data.h:10344
PayloadContext::buf_size
int buf_size
Definition: rtpdec_mpeg4.c:66
PayloadContext::AUHeaders::index
int index
Definition: rtpdec_mpeg4.c:52
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
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:36
MAX_AAC_HBR_FRAME_SIZE
#define MAX_AAC_HBR_FRAME_SIZE
Definition: rtpdec_mpeg4.c:37
AttrNameMap::Range
Range for integer values.
Definition: rtpdec_mpeg4.c:76
AttrNameMap::type
uint16_t type
Definition: rtpdec_mpeg4.c:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
PayloadContext::AUHeaders::dts_flag
int dts_flag
Definition: rtpdec_mpeg4.c:55
ATTR_NAME_TYPE_STR
#define ATTR_NAME_TYPE_STR
Definition: rtpdec_mpeg4.c:84
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:339
len
int len
Definition: vorbis_enc_data.h:426
attr_names
static const AttrNameMap attr_names[]
Definition: rtpdec_mpeg4.c:85
AttrNameMap::Range::min
int min
Definition: rtpdec_mpeg4.c:77
AttrNameMap::Range::max
int max
Definition: rtpdec_mpeg4.c:78
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
rtp_parse_mp4_au
static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)
Definition: rtpdec_mpeg4.c:124
PayloadContext::AUHeaders::size
int size
Definition: rtpdec_mpeg4.c:51
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:362
PayloadContext::buf
uint8_t * buf
the temporary storage buffer
Definition: rtpdec_asf.c:184
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
AttrNameMap::offset
uint32_t offset
Definition: rtpdec_mpeg4.c:73
mode
mode
Definition: ebur128.h:83
PayloadContext::AUHeaders::cts_flag
int cts_flag
Definition: rtpdec_mpeg4.c:53
AVPacket::stream_index
int stream_index
Definition: packet.h:541
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:1155
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
PayloadContext::mode
char * mode
Definition: rtpdec_mpeg4.c:47
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
PayloadContext::cur_au_index
int cur_au_index
Definition: rtpdec_mpeg4.c:63
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:43
PayloadContext
RTP/JPEG specific private data.
Definition: rdt.c:85
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:58
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:227
Generated on Fri Aug 22 2025 13:59:34 for FFmpeg by   doxygen 1.8.17

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