FFmpeg: libavformat/av1dec.c Source File

FFmpeg

[フレーム]

libavformat

av1dec.c

Go to the documentation of this file.

1 /*

2 * AV1 Annex B demuxer

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

22 #include "config_components.h"

24 #include "libavutil/common.h"

25 #include "libavutil/opt.h"

26 #include "libavcodec/av1_parse.h"

27 #include "libavcodec/bsf.h"

28 #include "avformat.h"

29 #include "avio_internal.h"

30 #include "demux.h"

31 #include "internal.h"

33 typedef struct AV1DemuxContext {

34 const AVClass *class;

35 AVBSFContext *bsf;

36 AVRational framerate;

37 uint32_t temporal_unit_size;

38 uint32_t frame_unit_size;

39 } AV1DemuxContext;

41 //return < 0 if we need more data

42 static int get_score(int type, int *seq)

43 {

44 switch (type) {

45 case AV1_OBU_SEQUENCE_HEADER:

46 *seq = 1;

47 return -1;

48 case AV1_OBU_FRAME:

49 case AV1_OBU_FRAME_HEADER:

50 return *seq ? AVPROBE_SCORE_EXTENSION + 1 : 0;

51 case AV1_OBU_METADATA:

52 case AV1_OBU_PADDING:

53 return -1;

54 default:

55 break;

56 }

57 return 0;

58 }

60 static int av1_read_header(AVFormatContext *s)

61 {

62 AV1DemuxContext *const c = s->priv_data;

63 const AVBitStreamFilter *filter = av_bsf_get_by_name("av1_frame_merge");

64 AVStream *st;

65 FFStream *sti;

66 int ret;

68 if (!filter) {

69 av_log(s, AV_LOG_ERROR, "av1_frame_merge bitstream filter "

70 "not found. This is a bug, please report it.\n");

71 return AVERROR_BUG;

72 }

74 st = avformat_new_stream(s, NULL);

75 if (!st)

76 return AVERROR(ENOMEM);

77 sti = ffstream(st);

79 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

80 st->codecpar->codec_id = AV_CODEC_ID_AV1;

81 sti->need_parsing = AVSTREAM_PARSE_HEADERS;

83 st->avg_frame_rate = c->framerate;

84 // taken from rawvideo demuxers

85 avpriv_set_pts_info(st, 64, 1, 1200000);

87 ret = av_bsf_alloc(filter, &c->bsf);

88 if (ret < 0)

89 return ret;

91 ret = avcodec_parameters_copy(c->bsf->par_in, st->codecpar);

92 if (ret < 0)

93 return ret;

95 ret = av_bsf_init(c->bsf);

96 if (ret < 0)

97 return ret;

99 return 0;

100 }

101

102 static int av1_read_close(AVFormatContext *s)

103 {

104 AV1DemuxContext *const c = s->priv_data;

105

106 av_bsf_free(&c->bsf);

107 return 0;

108 }

109

110 #define DEC AV_OPT_FLAG_DECODING_PARAM

111 #define OFFSET(x) offsetof(AV1DemuxContext, x)

112 static const AVOption av1_options[] = {

113 { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC},

114 { NULL },

115 };

116 #undef OFFSET

117

118 static const AVClass av1_demuxer_class = {

119 .class_name = "AV1 Annex B/low overhead OBU demuxer",

120 .item_name = av_default_item_name,

121 .option = av1_options,

122 .version = LIBAVUTIL_VERSION_INT,

123 };

124

125 #if CONFIG_AV1_DEMUXER

126

127 static int leb(AVIOContext *pb, uint32_t *len, int eof) {

128 int more, i = 0;

129 *len = 0;

130 do {

131 unsigned bits;

132 int byte = avio_r8(pb);

133 if (pb->error)

134 return pb->error;

135 if (pb->eof_reached)

136 return (eof && !i) ? AVERROR_EOF : AVERROR_INVALIDDATA;

137 more = byte & 0x80;

138 bits = byte & 0x7f;

139 if (i <= 3 || (i == 4 && bits < (1 << 4)))

140 *len |= bits << (i * 7);

141 else if (bits)

142 return AVERROR_INVALIDDATA;

143 if (++i == 8 && more)

144 return AVERROR_INVALIDDATA;

145 } while (more);

146 return i;

147 }

148

149 static int read_obu(const uint8_t *buf, int size, int64_t *obu_size, int *type)

150 {

151 int start_pos, temporal_id, spatial_id;

152 int len;

153

154 len = parse_obu_header(buf, size, obu_size, &start_pos,

155 type, &temporal_id, &spatial_id);

156 if (len < 0)

157 return len;

158

159 return 0;

160 }

161

162 static int annexb_probe(const AVProbeData *p)

163 {

164 FFIOContext ctx;

165 AVIOContext *const pb = &ctx.pub;

166 int64_t obu_size;

167 uint32_t temporal_unit_size, frame_unit_size, obu_unit_size;

168 int seq = 0;

169 int ret, type, cnt = 0;

170

171 ffio_init_read_context(&ctx, p->buf, p->buf_size);

172

173 ret = leb(pb, &temporal_unit_size, 1);

174 if (ret < 0)

175 return 0;

176 cnt += ret;

177 ret = leb(pb, &frame_unit_size, 0);

178 if (ret < 0 || ((int64_t)frame_unit_size + ret) > temporal_unit_size)

179 return 0;

180 cnt += ret;

181 ret = leb(pb, &obu_unit_size, 0);

182 if (ret < 0 || ((int64_t)obu_unit_size + ret) >= frame_unit_size)

183 return 0;

184 cnt += ret;

185

186 frame_unit_size -= obu_unit_size + ret;

187

188 avio_skip(pb, obu_unit_size);

189 if (pb->eof_reached || pb->error)

190 return 0;

191

192 // Check that the first OBU is a Temporal Delimiter.

193 ret = read_obu(p->buf + cnt, FFMIN(p->buf_size - cnt, obu_unit_size), &obu_size, &type);

194 if (ret < 0 || type != AV1_OBU_TEMPORAL_DELIMITER || obu_size > 0)

195 return 0;

196 cnt += obu_unit_size;

197

198 do {

199 ret = leb(pb, &obu_unit_size, 0);

200 if (ret < 0 || ((int64_t)obu_unit_size + ret) > frame_unit_size)

201 return 0;

202 cnt += ret;

203

204 avio_skip(pb, obu_unit_size);

205 if (pb->eof_reached || pb->error)

206 return 0;

207

208 ret = read_obu(p->buf + cnt, FFMIN(p->buf_size - cnt, obu_unit_size), &obu_size, &type);

209 if (ret < 0)

210 return 0;

211 cnt += obu_unit_size;

212

213 ret = get_score(type, &seq);

214 if (ret >= 0)

215 return ret;

216

217 frame_unit_size -= obu_unit_size + ret;

218 } while (frame_unit_size);

219

220 return 0;

221 }

222

223 static int annexb_read_packet(AVFormatContext *s, AVPacket *pkt)

224 {

225 AV1DemuxContext *const c = s->priv_data;

226 uint32_t obu_unit_size;

227 int ret, len;

228

229 retry:

230 if (avio_feof(s->pb)) {

231 if (c->temporal_unit_size || c->frame_unit_size)

232 return AVERROR_INVALIDDATA;

233 goto end;

234 }

235

236 if (!c->temporal_unit_size) {

237 len = leb(s->pb, &c->temporal_unit_size, 1);

238 if (len == AVERROR_EOF) goto end;

239 else if (len < 0) return len;

240 }

241

242 if (!c->frame_unit_size) {

243 len = leb(s->pb, &c->frame_unit_size, 0);

244 if (len < 0)

245 return len;

246 if (((int64_t)c->frame_unit_size + len) > c->temporal_unit_size)

247 return AVERROR_INVALIDDATA;

248 c->temporal_unit_size -= len;

249 }

250

251 len = leb(s->pb, &obu_unit_size, 0);

252 if (len < 0)

253 return len;

254 if (((int64_t)obu_unit_size + len) > c->frame_unit_size)

255 return AVERROR_INVALIDDATA;

256

257 ret = av_get_packet(s->pb, pkt, obu_unit_size);

258 if (ret < 0)

259 return ret;

260 if (ret != obu_unit_size)

261 return AVERROR_INVALIDDATA;

262

263 c->temporal_unit_size -= obu_unit_size + len;

264 c->frame_unit_size -= obu_unit_size + len;

265

266 end:

267 ret = av_bsf_send_packet(c->bsf, pkt);

268 if (ret < 0) {

269 av_log(s, AV_LOG_ERROR, "Failed to send packet to "

270 "av1_frame_merge filter\n");

271 return ret;

272 }

273

274 ret = av_bsf_receive_packet(c->bsf, pkt);

275 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)

276 av_log(s, AV_LOG_ERROR, "av1_frame_merge filter failed to "

277 "send output packet\n");

278

279 if (ret == AVERROR(EAGAIN))

280 goto retry;

281

282 return ret;

283 }

284

285 const FFInputFormat ff_av1_demuxer = {

286 .p.name = "av1",

287 .p.long_name = NULL_IF_CONFIG_SMALL("AV1 Annex B"),

288 .p.extensions = "obu",

289 .p.flags = AVFMT_GENERIC_INDEX | AVFMT_NOTIMESTAMPS,

290 .p.priv_class = &av1_demuxer_class,

291 .priv_data_size = sizeof(AV1DemuxContext),

292 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

293 .read_probe = annexb_probe,

294 .read_header = av1_read_header,

295 .read_packet = annexb_read_packet,

296 .read_close = av1_read_close,

297 };

298 #endif

299

300 #if CONFIG_OBU_DEMUXER

301 //For low overhead obu, we can't foresee the obu size before we parsed the header.

302 //So, we can't use parse_obu_header here, since it will check size <= buf_size

303 //see c27c7b49dc for more details

304 static int read_obu_with_size(const uint8_t *buf, int buf_size, int64_t *obu_size, int *type)

305 {

306 GetBitContext gb;

307 int ret, extension_flag, start_pos;

308 int64_t size;

309

310 ret = init_get_bits8(&gb, buf, FFMIN(buf_size, MAX_OBU_HEADER_SIZE));

311 if (ret < 0)

312 return ret;

313

314 if (get_bits1(&gb) != 0) // obu_forbidden_bit

315 return AVERROR_INVALIDDATA;

316

317 *type = get_bits(&gb, 4);

318 extension_flag = get_bits1(&gb);

319 if (!get_bits1(&gb)) // has_size_flag

320 return AVERROR_INVALIDDATA;

321 skip_bits1(&gb); // obu_reserved_1bit

322

323 if (extension_flag) {

324 get_bits(&gb, 3); // temporal_id

325 get_bits(&gb, 2); // spatial_id

326 skip_bits(&gb, 3); // extension_header_reserved_3bits

327 }

328

329 *obu_size = get_leb128(&gb);

330 if (*obu_size > INT_MAX)

331 return AVERROR_INVALIDDATA;

332

333 if (get_bits_left(&gb) < 0)

334 return AVERROR_INVALIDDATA;

335

336 start_pos = get_bits_count(&gb) / 8;

337

338 size = *obu_size + start_pos;

339 if (size > INT_MAX)

340 return AVERROR_INVALIDDATA;

341 return size;

342 }

343

344 static int obu_probe(const AVProbeData *p)

345 {

346 int64_t obu_size;

347 int seq = 0;

348 int ret, type, cnt;

349

350 // Check that the first OBU is a Temporal Delimiter.

351 cnt = read_obu_with_size(p->buf, p->buf_size, &obu_size, &type);

352 if (cnt < 0 || type != AV1_OBU_TEMPORAL_DELIMITER || obu_size != 0)

353 return 0;

354

355 while (1) {

356 ret = read_obu_with_size(p->buf + cnt, p->buf_size - cnt, &obu_size, &type);

357 if (ret < 0 || obu_size <= 0)

358 return 0;

359 cnt += FFMIN(ret, p->buf_size - cnt);

360

361 ret = get_score(type, &seq);

362 if (ret >= 0)

363 return ret;

364 }

365 return 0;

366 }

367

368 static int obu_get_packet(AVFormatContext *s, AVPacket *pkt)

369 {

370 AV1DemuxContext *const c = s->priv_data;

371 uint8_t header[MAX_OBU_HEADER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

372 int64_t obu_size;

373 int size;

374 int ret, len, type;

375

376 if ((ret = ffio_ensure_seekback(s->pb, MAX_OBU_HEADER_SIZE)) < 0)

377 return ret;

378 size = avio_read(s->pb, header, MAX_OBU_HEADER_SIZE);

379 if (size < 0)

380 return size;

381

382 len = read_obu_with_size(header, size, &obu_size, &type);

383 if (len < 0) {

384 av_log(c, AV_LOG_ERROR, "Failed to read obu\n");

385 return len;

386 }

387 avio_seek(s->pb, -size, SEEK_CUR);

388

389 ret = av_get_packet(s->pb, pkt, len);

390 if (ret != len) {

391 av_log(c, AV_LOG_ERROR, "Failed to get packet for obu\n");

392 return ret < 0 ? ret : AVERROR_INVALIDDATA;

393 }

394 return 0;

395 }

396

397 static int obu_read_packet(AVFormatContext *s, AVPacket *pkt)

398 {

399 AV1DemuxContext *const c = s->priv_data;

400 int ret;

401

402 if (s->io_repositioned) {

403 av_bsf_flush(c->bsf);

404 s->io_repositioned = 0;

405 }

406 while (1) {

407 ret = obu_get_packet(s, pkt);

408 /* In case of AVERROR_EOF we need to flush the BSF. Conveniently

409 * obu_get_packet() returns a blank pkt in this case which

410 * can be used to signal that the BSF should be flushed. */

411 if (ret < 0 && ret != AVERROR_EOF)

412 return ret;

413 ret = av_bsf_send_packet(c->bsf, pkt);

414 if (ret < 0) {

415 av_log(s, AV_LOG_ERROR, "Failed to send packet to "

416 "av1_frame_merge filter\n");

417 return ret;

418 }

419 ret = av_bsf_receive_packet(c->bsf, pkt);

420 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)

421 av_log(s, AV_LOG_ERROR, "av1_frame_merge filter failed to "

422 "send output packet\n");

423 if (ret != AVERROR(EAGAIN))

424 break;

425 }

426

427 return ret;

428 }

429

430 const FFInputFormat ff_obu_demuxer = {

431 .p.name = "obu",

432 .p.long_name = NULL_IF_CONFIG_SMALL("AV1 low overhead OBU"),

433 .p.extensions = "obu",

434 .p.flags = AVFMT_GENERIC_INDEX | AVFMT_NO_BYTE_SEEK | AVFMT_NOTIMESTAMPS,

435 .p.priv_class = &av1_demuxer_class,

436 .priv_data_size = sizeof(AV1DemuxContext),

437 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

438 .read_probe = obu_probe,

439 .read_header = av1_read_header,

440 .read_packet = obu_read_packet,

441 .read_close = av1_read_close,

442 };

443 #endif

AVFMT_NO_BYTE_SEEK

#define AVFMT_NO_BYTE_SEEK

Format does not allow seeking by bytes.

Definition: avformat.h:487

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

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

opt.h

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

ff_av1_demuxer

const FFInputFormat ff_av1_demuxer

get_score

static int get_score(int type, int *seq)

Definition: av1dec.c:42

AV1DemuxContext

Definition: av1dec.c:33

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

AV_OPT_TYPE_VIDEO_RATE

@ AV_OPT_TYPE_VIDEO_RATE

offset must point to AVRational

Definition: opt.h:248

AVFMT_NOTIMESTAMPS

#define AVFMT_NOTIMESTAMPS

Format does not need / have any timestamps.

Definition: avformat.h:479

int64_t

long long int64_t

Definition: coverity.c:34

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:266

AVOption

AVOption.

Definition: opt.h:346

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:832

AVIOContext::error

int error

contains the error code or 0 if no error happened

Definition: avio.h:239

filter

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter

Definition: filter_design.txt:228

ffio_init_read_context

void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)

Wrap a buffer in an AVIOContext for reading.

Definition: aviobuf.c:98

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:454

AV1_OBU_TEMPORAL_DELIMITER

@ AV1_OBU_TEMPORAL_DELIMITER

Definition: av1.h:31

av_bsf_free

void av_bsf_free(AVBSFContext **pctx)

Free a bitstream filter context and everything associated with it; write NULL into the supplied point...

Definition: bsf.c:52

FFIOContext

Definition: avio_internal.h:28

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:381

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

av1_parse.h

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:853

bsf.h

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:417

AV1_OBU_FRAME_HEADER

@ AV1_OBU_FRAME_HEADER

Definition: av1.h:32

GetBitContext

Definition: get_bits.h:108

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

AVFMT_GENERIC_INDEX

#define AVFMT_GENERIC_INDEX

Use generic index building code.

Definition: avformat.h:480

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

annexb_probe

static int annexb_probe(const AVProbeData *p)

Definition: evcdec.c:60

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

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:41

parse_obu_header

static int parse_obu_header(const uint8_t *buf, int buf_size, int64_t *obu_size, int *start_pos, int *type, int *temporal_id, int *spatial_id)

Definition: av1_parse.h:92

#define s(width, name)

Definition: cbs_vp9.c:198

av_bsf_flush

void av_bsf_flush(AVBSFContext *ctx)

Reset the internal bitstream filter state.

Definition: bsf.c:190

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:453

av1_read_close

static int av1_read_close(AVFormatContext *s)

Definition: av1dec.c:102

bits

uint8_t bits

Definition: vp3data.h:128

ctx

AVFormatContext * ctx

Definition: movenc.c:48

av_bsf_alloc

int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)

Allocate a context for a given bitstream filter.

Definition: bsf.c:104

FF_INFMT_FLAG_INIT_CLEANUP

#define FF_INFMT_FLAG_INIT_CLEANUP

For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...

Definition: demux.h:35

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:386

AVFormatContext

Format I/O context.

Definition: avformat.h:1255

internal.h

DEC

#define DEC

Definition: av1dec.c:110

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:766

framerate

float framerate

Definition: av1_levels.c:29

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

av_bsf_init

int av_bsf_init(AVBSFContext *ctx)

Prepare the filter for use, after all the parameters and options have been set.

Definition: bsf.c:149

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:550

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:280

av_bsf_receive_packet

int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)

Retrieve a filtered packet.

Definition: bsf.c:230

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:461

AV1DemuxContext::bsf

AVBSFContext * bsf

Definition: av1dec.c:35

AV1_OBU_FRAME

@ AV1_OBU_FRAME

Definition: av1.h:35

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

OFFSET

#define OFFSET(x)

Definition: av1dec.c:111

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

FFStream

Definition: internal.h:193

av_bsf_send_packet

int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)

Submit a packet for filtering.

Definition: bsf.c:202

size

int size

Definition: twinvq_data.h:10344

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:41

header

static const uint8_t header[24]

Definition: sdr2.c:68

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:602

ffio_ensure_seekback

int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)

Ensures that the requested seekback buffer size will be available.

Definition: aviobuf.c:1022

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:413

AV1DemuxContext::frame_unit_size

uint32_t frame_unit_size

Definition: av1dec.c:38

AV1_OBU_PADDING

@ AV1_OBU_PADDING

Definition: av1.h:39

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

Definition: cbs_h2645.c:255

avio_internal.h

common.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

demux.h

len

int len

Definition: vorbis_enc_data.h:426

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:103

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:743

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:230

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

AVSTREAM_PARSE_HEADERS

@ AVSTREAM_PARSE_HEADERS

Only parse headers, do not repack.

Definition: avformat.h:594

avformat.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AV1DemuxContext::temporal_unit_size

uint32_t temporal_unit_size

Definition: av1dec.c:37

AVBitStreamFilter

Definition: bsf.h:111

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:611

AVIOContext::eof_reached

int eof_reached

true if was unable to read due to error or eof

Definition: avio.h:238

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:317

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

av1_options

static const AVOption av1_options[]

Definition: av1dec.c:112

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

av1_read_header

static int av1_read_header(AVFormatContext *s)

Definition: av1dec.c:60

av1_demuxer_class

static const AVClass av1_demuxer_class

Definition: av1dec.c:118

FFInputFormat

Definition: demux.h:37

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

ff_obu_demuxer

const FFInputFormat ff_obu_demuxer

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

AV1DemuxContext::framerate

AVRational framerate

Definition: av1dec.c:36

AV1_OBU_METADATA

@ AV1_OBU_METADATA

Definition: av1.h:34

avcodec_parameters_copy

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)

Copy the contents of src to dst.

Definition: codec_par.c:106

MAX_OBU_HEADER_SIZE

#define MAX_OBU_HEADER_SIZE

Definition: av1_parse.h:36

get_leb128

static int64_t get_leb128(GetBitContext *gb)

Read a unsigned integer coded as a variable number of up to eight little-endian bytes,...

Definition: leb.h:57

avio_feof

int avio_feof(AVIOContext *s)

Similar to feof() but also returns nonzero on read errors.

Definition: aviobuf.c:345

av_bsf_get_by_name

const AVBitStreamFilter * av_bsf_get_by_name(const char *name)

Definition: bitstream_filters.c:86

Generated on Thu Sep 26 2024 23:14:50 for FFmpeg by doxygen 1.8.17