FFmpeg: libavformat/rtpdec_mpeg4.c Source File

FFmpeg

[フレーム]

libavformat

rtpdec_mpeg4.c

Go to the documentation of this file.

1 /*

2 * Common code for the RTP depacketization of MPEG-4 formats.

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 */

23 /**

24 * @file

25 * @brief MPEG-4 / RTP Code

26 * @author Fabrice Bellard

27 * @author Romain Degez

28 */

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"

37 #define MAX_AAC_HBR_FRAME_SIZE 8191

39 /** Structure listing useful vars to parse RTP packet payload */

40 struct PayloadContext {

41 int bitrate;

42 int sizelength;

43 int indexlength;

44 int indexdeltalength;

45 int profile_level_id;

46 int streamtype;

47 int objecttype;

48 char *mode;

50 /** mpeg 4 AU headers */

51 struct AUHeaders {

52 int size;

53 int index;

54 int cts_flag;

55 int cts;

56 int dts_flag;

57 int dts;

58 int rap_flag;

59 int streamstate;

60 } *au_headers;

61 int au_headers_allocated;

62 int nb_au_headers;

63 int au_headers_length_bytes;

64 int cur_au_index;

66 uint8_t buf[FFMAX(RTP_MAX_PACKET_LENGTH, MAX_AAC_HBR_FRAME_SIZE)];

67 int buf_pos, buf_size;

68 uint32_t timestamp;

69 };

71 typedef struct AttrNameMap {

72 const char *str;

73 uint16_t type;

74 uint32_t offset;

76 /** Range for integer values */

77 struct Range {

78 int min;

79 int max;

80 } range;

81 } AttrNameMap;

83 /* All known fmtp parameters and the corresponding RTPAttrTypeEnum */

84 #define ATTR_NAME_TYPE_INT 0

85 #define ATTR_NAME_TYPE_STR 1

86 static const AttrNameMap attr_names[] = {

87 { "bitrate", ATTR_NAME_TYPE_INT,

88 offsetof(PayloadContext, bitrate),

89 {0, INT32_MAX} },

90 { "SizeLength", ATTR_NAME_TYPE_INT,

91 offsetof(PayloadContext, sizelength),

92 {0, 32} }, // SizeLength number of bits used to encode AU-size integer value

93 { "IndexLength", ATTR_NAME_TYPE_INT,

94 offsetof(PayloadContext, indexlength),

95 {0, 32} }, // IndexLength number of bits used to encode AU-Index integer value

96 { "IndexDeltaLength", ATTR_NAME_TYPE_INT,

97 offsetof(PayloadContext, indexdeltalength),

98 {0, 32} }, // IndexDeltaLength number of bits to encode AU-Index-delta integer value

99 { "profile-level-id", ATTR_NAME_TYPE_INT,

100 offsetof(PayloadContext, profile_level_id),

101 {INT32_MIN, INT32_MAX} }, // It differs depending on StreamType

102 { "StreamType", ATTR_NAME_TYPE_INT,

103 offsetof(PayloadContext, streamtype),

104 {0x00, 0x3F} }, // Values from ISO/IEC 14496-1, 'StreamType Values' table

105 { "mode", ATTR_NAME_TYPE_STR,

106 offsetof(PayloadContext, mode),

107 {0} },

108 { NULL, -1, -1, {0} },

109 };

110

111 static void close_context(PayloadContext *data)

112 {

113 av_freep(&data->au_headers);

114 av_freep(&data->mode);

115 }

116

117 static int parse_fmtp_config(AVCodecParameters *par, const char *value)

118 {

119 /* decode the hexa encoded parameter */

120 int len = ff_hex_to_data(NULL, value), ret;

121

122 if ((ret = ff_alloc_extradata(par, len)) < 0)

123 return ret;

124 ff_hex_to_data(par->extradata, value);

125 return 0;

126 }

127

128 static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)

129 {

130 int au_headers_length, au_header_size, i;

131 GetBitContext getbitcontext;

132 int ret;

133

134 if (len < 2)

135 return AVERROR_INVALIDDATA;

136

137 /* decode the first 2 bytes where the AUHeader sections are stored

138 length in bits */

139 au_headers_length = AV_RB16(buf);

140

141 if (au_headers_length > RTP_MAX_PACKET_LENGTH)

142 return -1;

143

144 data->au_headers_length_bytes = (au_headers_length + 7) / 8;

145

146 /* skip AU headers length section (2 bytes) */

147 buf += 2;

148 len -= 2;

149

150 if (len < data->au_headers_length_bytes)

151 return AVERROR_INVALIDDATA;

152

153 ret = init_get_bits(&getbitcontext, buf, data->au_headers_length_bytes * 8);

154 if (ret < 0)

155 return ret;

156

157 /* XXX: Wrong if optional additional sections are present (cts, dts etc...) */

158 au_header_size = data->sizelength + data->indexlength;

159 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))

160 return -1;

161

162 data->nb_au_headers = au_headers_length / au_header_size;

163 if (!data->au_headers || data->au_headers_allocated < data->nb_au_headers) {

164 av_free(data->au_headers);

165 data->au_headers = av_malloc(sizeof(struct AUHeaders) * data->nb_au_headers);

166 if (!data->au_headers)

167 return AVERROR(ENOMEM);

168 data->au_headers_allocated = data->nb_au_headers;

169 }

170

171 for (i = 0; i < data->nb_au_headers; ++i) {

172 data->au_headers[i].size = get_bits_long(&getbitcontext, data->sizelength);

173 data->au_headers[i].index = get_bits_long(&getbitcontext, data->indexlength);

174 }

175

176 return 0;

177 }

178

179

180 /* Follows RFC 3640 */

181 static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data,

182 AVStream *st, AVPacket *pkt, uint32_t *timestamp,

183 const uint8_t *buf, int len, uint16_t seq,

184 int flags)

185 {

186 int ret;

187

188

189 if (!buf) {

190 if (data->cur_au_index > data->nb_au_headers) {

191 av_log(ctx, AV_LOG_ERROR, "Invalid parser state\n");

192 return AVERROR_INVALIDDATA;

193 }

194 if (data->buf_size - data->buf_pos < data->au_headers[data->cur_au_index].size) {

195 av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");

196 return AVERROR_INVALIDDATA;

197 }

198 if ((ret = av_new_packet(pkt, data->au_headers[data->cur_au_index].size)) < 0) {

199 av_log(ctx, AV_LOG_ERROR, "Out of memory\n");

200 return ret;

201 }

202 memcpy(pkt->data, &data->buf[data->buf_pos], data->au_headers[data->cur_au_index].size);

203 data->buf_pos += data->au_headers[data->cur_au_index].size;

204 pkt->stream_index = st->index;

205 data->cur_au_index++;

206

207 if (data->cur_au_index == data->nb_au_headers) {

208 data->buf_pos = 0;

209 return 0;

210 }

211

212 return 1;

213 }

214

215 if (rtp_parse_mp4_au(data, buf, len)) {

216 av_log(ctx, AV_LOG_ERROR, "Error parsing AU headers\n");

217 return -1;

218 }

219

220 buf += data->au_headers_length_bytes + 2;

221 len -= data->au_headers_length_bytes + 2;

222 if (data->nb_au_headers == 1 && len < data->au_headers[0].size) {

223 /* Packet is fragmented */

224

225 if (!data->buf_pos) {

226 if (data->au_headers[0].size > MAX_AAC_HBR_FRAME_SIZE) {

227 av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");

228 return AVERROR_INVALIDDATA;

229 }

230

231 data->buf_size = data->au_headers[0].size;

232 data->timestamp = *timestamp;

233 }

234

235 if (data->timestamp != *timestamp ||

236 data->au_headers[0].size != data->buf_size ||

237 data->buf_pos + len > MAX_AAC_HBR_FRAME_SIZE) {

238 data->buf_pos = 0;

239 data->buf_size = 0;

240 av_log(ctx, AV_LOG_ERROR, "Invalid packet received\n");

241 return AVERROR_INVALIDDATA;

242 }

243

244 memcpy(&data->buf[data->buf_pos], buf, len);

245 data->buf_pos += len;

246

247 if (!(flags & RTP_FLAG_MARKER))

248 return AVERROR(EAGAIN);

249

250 if (data->buf_pos != data->buf_size) {

251 data->buf_pos = 0;

252 av_log(ctx, AV_LOG_ERROR, "Missed some packets, discarding frame\n");

253 return AVERROR_INVALIDDATA;

254 }

255

256 data->buf_pos = 0;

257 ret = av_new_packet(pkt, data->buf_size);

258 if (ret < 0) {

259 av_log(ctx, AV_LOG_ERROR, "Out of memory\n");

260 return ret;

261 }

262 pkt->stream_index = st->index;

263

264 memcpy(pkt->data, data->buf, data->buf_size);

265

266 return 0;

267 }

268

269 if (len < data->au_headers[0].size) {

270 av_log(ctx, AV_LOG_ERROR, "First AU larger than packet size\n");

271 return AVERROR_INVALIDDATA;

272 }

273 if ((ret = av_new_packet(pkt, data->au_headers[0].size)) < 0) {

274 av_log(ctx, AV_LOG_ERROR, "Out of memory\n");

275 return ret;

276 }

277 memcpy(pkt->data, buf, data->au_headers[0].size);

278 len -= data->au_headers[0].size;

279 buf += data->au_headers[0].size;

280 pkt->stream_index = st->index;

281

282 if (len > 0 && data->nb_au_headers > 1) {

283 data->buf_size = FFMIN(len, sizeof(data->buf));

284 memcpy(data->buf, buf, data->buf_size);

285 data->cur_au_index = 1;

286 data->buf_pos = 0;

287 return 1;

288 }

289

290 return 0;

291 }

292

293 static int parse_fmtp(AVFormatContext *s,

294 AVStream *stream, PayloadContext *data,

295 const char *attr, const char *value)

296 {

297 AVCodecParameters *par = stream->codecpar;

298 int res, i;

299

300 if (!strcmp(attr, "config")) {

301 res = parse_fmtp_config(par, value);

302

303 if (res < 0)

304 return res;

305 }

306

307 if (par->codec_id == AV_CODEC_ID_AAC) {

308 /* Looking for a known attribute */

309 for (i = 0; attr_names[i].str; ++i) {

310 if (!av_strcasecmp(attr, attr_names[i].str)) {

311 if (attr_names[i].type == ATTR_NAME_TYPE_INT) {

312 char *end_ptr = NULL;

313 long long int val = strtoll(value, &end_ptr, 10);

314 if (end_ptr == value || end_ptr[0] != '0円') {

315 av_log(s, AV_LOG_ERROR,

316 "The %s field value is not a valid number: %s\n",

317 attr, value);

318 return AVERROR_INVALIDDATA;

319 }

320 if (val < attr_names[i].range.min ||

321 val > attr_names[i].range.max) {

322 av_log(s, AV_LOG_ERROR,

323 "fmtp field %s should be in range [%d,%d] (provided value: %lld)",

324 attr, attr_names[i].range.min, attr_names[i].range.max, val);

325 return AVERROR_INVALIDDATA;

326 }

327

328 *(int *)((char *)data+

329 attr_names[i].offset) = (int) val;

330 } else if (attr_names[i].type == ATTR_NAME_TYPE_STR) {

331 char *val = av_strdup(value);

332 if (!val)

333 return AVERROR(ENOMEM);

334 *(char **)((char *)data+

335 attr_names[i].offset) = val;

336 }

337 }

338 }

339 if (!strcmp(attr, "bitrate")) {

340 par->bit_rate = data->bitrate;

341 }

342 }

343 return 0;

344 }

345

346 static int parse_sdp_line(AVFormatContext *s, int st_index,

347 PayloadContext *data, const char *line)

348 {

349 const char *p;

350

351 if (st_index < 0)

352 return 0;

353

354 if (av_strstart(line, "fmtp:", &p))

355 return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);

356

357 return 0;

358 }

359

360 const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler = {

361 .enc_name = "MP4V-ES",

362 .codec_type = AVMEDIA_TYPE_VIDEO,

363 .codec_id = AV_CODEC_ID_MPEG4,

364 .need_parsing = AVSTREAM_PARSE_FULL,

365 .priv_data_size = sizeof(PayloadContext),

366 .parse_sdp_a_line = parse_sdp_line,

367 };

368

369 const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler = {

370 .enc_name = "mpeg4-generic",

371 .codec_type = AVMEDIA_TYPE_AUDIO,

372 .codec_id = AV_CODEC_ID_AAC,

373 .need_parsing = AVSTREAM_PARSE_HEADERS,

374 .priv_data_size = sizeof(PayloadContext),

375 .parse_sdp_a_line = parse_sdp_line,

376 .close = close_context,

377 .parse_packet = aac_parse_packet,

378 };

flags

const SwsFlags flags[]

Definition: swscale.c:61

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:360

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:946

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:424

av_strcasecmp

int av_strcasecmp(const char *a, const char *b)

Locale-independent case-insensitive compare.

Definition: avstring.c:208

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

mode

Definition: swscale.c:56

PayloadContext::objecttype

int objecttype

Definition: rtpdec_mpeg4.c:47

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:588

data

const char data[16]

Definition: mxf.c:149

AttrNameMap

Definition: rtpdec_mpeg4.c:71

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

PayloadContext::profile_level_id

int profile_level_id

Definition: rtpdec_mpeg4.c:45

close_context

static void close_context(PayloadContext *data)

Definition: rtpdec_mpeg4.c:111

PayloadContext::sizelength

int sizelength

Definition: rtpdec_mpeg4.c:42

PayloadContext::indexlength

int indexlength

Definition: rtpdec_mpeg4.c:43

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:517

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

PayloadContext::AUHeaders

mpeg 4 AU headers

Definition: rtpdec_mpeg4.c:51

PayloadContext::timestamp

uint32_t timestamp

last received timestamp for frame

Definition: rtpdec_ac3.c:31

RTPDynamicProtocolHandler::enc_name

const char * enc_name

Definition: rtpdec.h:117

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

PayloadContext::nb_au_headers

int nb_au_headers

Definition: rtpdec_mpeg4.c:62

PayloadContext::buf_pos

int buf_pos

Definition: rtpdec_mpeg4.c:67

parse_fmtp

static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)

Definition: rtpdec_mpeg4.c:293

GetBitContext

Definition: get_bits.h:109

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:210

AttrNameMap::range

struct AttrNameMap::Range range

#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:72

bitrate

int64_t bitrate

Definition: av1_levels.c:47

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

PayloadContext::au_headers_length_bytes

int au_headers_length_bytes

Definition: rtpdec_mpeg4.c:63

ctx

AVFormatContext * ctx

Definition: movenc.c:49

PayloadContext::streamtype

int streamtype

Definition: rtpdec_mpeg4.c:46

get_bits.h

PayloadContext::AUHeaders::dts

int dts

Definition: rtpdec_mpeg4.c:57

PayloadContext::AUHeaders::rap_flag

int rap_flag

Definition: rtpdec_mpeg4.c:58

ff_hex_to_data

int ff_hex_to_data(uint8_t *data, const char *p)

Parse a string of hexadecimal strings.

Definition: utils.c:479

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

NULL

#define NULL

Definition: coverity.c:32

PayloadContext::bitrate

int bitrate

Definition: rtpdec_mpeg4.c:41

PayloadContext::au_headers_allocated

int au_headers_allocated

Definition: rtpdec_mpeg4.c:61

AV_CODEC_ID_AAC

@ AV_CODEC_ID_AAC

Definition: codec_id.h:461

PayloadContext::AUHeaders::cts

int cts

Definition: rtpdec_mpeg4.c:55

parse_fmtp_config

static int parse_fmtp_config(AVCodecParameters *par, const char *value)

Definition: rtpdec_mpeg4.c:117

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:181

ATTR_NAME_TYPE_INT

#define ATTR_NAME_TYPE_INT

Definition: rtpdec_mpeg4.c:84

size

int size

Definition: twinvq_data.h:10344

PayloadContext::buf_size

int buf_size

Definition: rtpdec_mpeg4.c:67

PayloadContext::AUHeaders::index

int index

Definition: rtpdec_mpeg4.c:53

range

enum AVColorRange range

Definition: mediacodec_wrapper.c:2594

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:77

AttrNameMap::type

uint16_t type

Definition: rtpdec_mpeg4.c:73

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

PayloadContext::AUHeaders::dts_flag

int dts_flag

Definition: rtpdec_mpeg4.c:56

ATTR_NAME_TYPE_STR

#define ATTR_NAME_TYPE_STR

Definition: rtpdec_mpeg4.c:85

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:346

len

int len

Definition: vorbis_enc_data.h:426

attr_names

static const AttrNameMap attr_names[]

Definition: rtpdec_mpeg4.c:86

AttrNameMap::Range::min

int min

Definition: rtpdec_mpeg4.c:78

AttrNameMap::Range::max

int max

Definition: rtpdec_mpeg4.c:79

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

rtp_parse_mp4_au

static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)

Definition: rtpdec_mpeg4.c:128

PayloadContext::AUHeaders::size

int size

Definition: rtpdec_mpeg4.c:52

AVSTREAM_PARSE_HEADERS

@ AVSTREAM_PARSE_HEADERS

Only parse headers, do not repack.

Definition: avformat.h:590

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:369

PayloadContext::buf

uint8_t * buf

the temporary storage buffer

Definition: rtpdec_asf.c:186

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:750

AttrNameMap::offset

uint32_t offset

Definition: rtpdec_mpeg4.c:74

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

PayloadContext::AUHeaders::cts_flag

int cts_flag

Definition: rtpdec_mpeg4.c:54

AVPacket::stream_index

int stream_index

Definition: packet.h:590

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:1162

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:272

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

mem.h

PayloadContext::mode

char * mode

Definition: rtpdec_mpeg4.c:48

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

PayloadContext::cur_au_index

int cur_au_index

Definition: rtpdec_mpeg4.c:64

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:565

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVSTREAM_PARSE_FULL

@ AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:589

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: codec_par.h:97

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:44

PayloadContext

RTP/AV1 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:59

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:237

Generated on Tue Nov 18 2025 19:23:34 for FFmpeg by doxygen 1.8.17