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 int64_t pos;

40 } AV1DemuxContext;

42 //return < 0 if we need more data

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

44 {

45 switch (type) {

46 case AV1_OBU_SEQUENCE_HEADER:

47 *seq = 1;

48 return -1;

49 case AV1_OBU_FRAME:

50 case AV1_OBU_FRAME_HEADER:

51 return *seq ? AVPROBE_SCORE_EXTENSION + 1 : 0;

52 case AV1_OBU_METADATA:

53 case AV1_OBU_PADDING:

54 return -1;

55 default:

56 break;

57 }

58 return 0;

59 }

61 static int av1_read_header(AVFormatContext *s)

62 {

63 AV1DemuxContext *const c = s->priv_data;

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

65 AVStream *st;

66 FFStream *sti;

67 int ret;

69 if (!filter) {

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

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

72 return AVERROR_BUG;

73 }

75 st = avformat_new_stream(s, NULL);

76 if (!st)

77 return AVERROR(ENOMEM);

78 sti = ffstream(st);

80 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

81 st->codecpar->codec_id = AV_CODEC_ID_AV1;

82 sti->need_parsing = AVSTREAM_PARSE_HEADERS;

84 st->avg_frame_rate = c->framerate;

85 // taken from rawvideo demuxers

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

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

89 if (ret < 0)

90 return ret;

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

93 if (ret < 0)

94 return ret;

96 ret = av_bsf_init(c->bsf);

97 if (ret < 0)

98 return ret;

100 return 0;

101 }

102

103 static int av1_read_close(AVFormatContext *s)

104 {

105 AV1DemuxContext *const c = s->priv_data;

106

107 av_bsf_free(&c->bsf);

108 return 0;

109 }

110

111 #define DEC AV_OPT_FLAG_DECODING_PARAM

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

113 static const AVOption av1_options[] = {

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

115 { NULL },

116 };

117 #undef OFFSET

118

119 static const AVClass av1_demuxer_class = {

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

121 .item_name = av_default_item_name,

122 .option = av1_options,

123 .version = LIBAVUTIL_VERSION_INT,

124 };

125

126 #if CONFIG_AV1_DEMUXER

127

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

129 int more, i = 0;

130 *len = 0;

131 do {

132 unsigned bits;

133 int byte = avio_r8(pb);

134 if (pb->error)

135 return pb->error;

136 if (pb->eof_reached)

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

138 more = byte & 0x80;

139 bits = byte & 0x7f;

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

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

142 else if (bits)

143 return AVERROR_INVALIDDATA;

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

145 return AVERROR_INVALIDDATA;

146 } while (more);

147 return i;

148 }

149

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

151 {

152 int start_pos, temporal_id, spatial_id;

153 int len;

154

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

156 type, &temporal_id, &spatial_id);

157 if (len < 0)

158 return len;

159

160 return 0;

161 }

162

163 static int annexb_probe(const AVProbeData *p)

164 {

165 FFIOContext ctx;

166 AVIOContext *const pb = &ctx.pub;

167 int64_t obu_size;

168 uint32_t temporal_unit_size, frame_unit_size, obu_unit_size;

169 int seq = 0;

170 int ret, type, cnt = 0;

171

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

173

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

175 if (ret < 0)

176 return 0;

177 cnt += ret;

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

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

180 return 0;

181 cnt += ret;

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

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

184 return 0;

185 cnt += ret;

186

187 frame_unit_size -= obu_unit_size + ret;

188

189 avio_skip(pb, obu_unit_size);

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

191 return 0;

192

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

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

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

196 return 0;

197 cnt += obu_unit_size;

198

199 do {

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

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

202 return 0;

203 cnt += ret;

204

205 avio_skip(pb, obu_unit_size);

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

207 return 0;

208

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

210 if (ret < 0)

211 return 0;

212 cnt += obu_unit_size;

213

214 ret = get_score(type, &seq);

215 if (ret >= 0)

216 return ret;

217

218 frame_unit_size -= obu_unit_size + ret;

219 } while (frame_unit_size);

220

221 return 0;

222 }

223

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

225 {

226 AV1DemuxContext *const c = s->priv_data;

227 uint32_t obu_unit_size;

228 int64_t pos = c->pos;

229 int ret, len;

230

231 retry:

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

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

234 return AVERROR_INVALIDDATA;

235 goto end;

236 }

237

238 if (!c->temporal_unit_size) {

239 c->pos = avio_tell(s->pb);

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

241 if (len == AVERROR_EOF) goto end;

242 else if (len < 0) return len;

243 }

244

245 if (!c->frame_unit_size) {

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

247 if (len < 0)

248 return len;

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

250 return AVERROR_INVALIDDATA;

251 c->temporal_unit_size -= len;

252 }

253

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

255 if (len < 0)

256 return len;

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

258 return AVERROR_INVALIDDATA;

259

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

261 if (ret < 0)

262 return ret;

263 if (ret != obu_unit_size)

264 return AVERROR_INVALIDDATA;

265

266 c->temporal_unit_size -= obu_unit_size + len;

267 c->frame_unit_size -= obu_unit_size + len;

268

269 end:

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

271 if (ret < 0) {

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

273 "av1_frame_merge filter\n");

274 return ret;

275 }

276

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

278 if (ret < 0) {

279 if (ret == AVERROR(EAGAIN))

280 goto retry;

281 if (ret != AVERROR_EOF)

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

283 "send output packet\n");

284 return ret;

285 }

286

287 pkt->pos = pos;

288

289 return 0;

290 }

291

292 const FFInputFormat ff_av1_demuxer = {

293 .p.name = "av1",

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

295 .p.extensions = "obu",

296 .p.flags = AVFMT_GENERIC_INDEX | AVFMT_NOTIMESTAMPS,

297 .p.priv_class = &av1_demuxer_class,

298 .priv_data_size = sizeof(AV1DemuxContext),

299 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

300 .read_probe = annexb_probe,

301 .read_header = av1_read_header,

302 .read_packet = annexb_read_packet,

303 .read_close = av1_read_close,

304 };

305 #endif

306

307 #if CONFIG_OBU_DEMUXER

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

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

310 //see c27c7b49dc for more details

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

312 {

313 GetBitContext gb;

314 int ret, extension_flag, start_pos;

315 int64_t size;

316

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

318 if (ret < 0)

319 return ret;

320

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

322 return AVERROR_INVALIDDATA;

323

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

325 extension_flag = get_bits1(&gb);

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

327 return AVERROR_INVALIDDATA;

328 skip_bits1(&gb); // obu_reserved_1bit

329

330 if (extension_flag) {

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

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

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

334 }

335

336 *obu_size = get_leb128(&gb);

337 if (*obu_size > INT_MAX)

338 return AVERROR_INVALIDDATA;

339

340 if (get_bits_left(&gb) < 0)

341 return AVERROR_INVALIDDATA;

342

343 start_pos = get_bits_count(&gb) / 8;

344

345 size = *obu_size + start_pos;

346 if (size > INT_MAX)

347 return AVERROR_INVALIDDATA;

348 return size;

349 }

350

351 static int obu_probe(const AVProbeData *p)

352 {

353 int64_t obu_size;

354 int seq = 0;

355 int ret, type, cnt;

356

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

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

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

360 return 0;

361

362 while (1) {

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

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

365 return 0;

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

367

368 ret = get_score(type, &seq);

369 if (ret >= 0)

370 return ret;

371 }

372 return 0;

373 }

374

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

376 {

377 AV1DemuxContext *const c = s->priv_data;

378 uint8_t header[MAX_OBU_HEADER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

379 int64_t obu_size;

380 int size;

381 int ret, len, type;

382

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

384 return ret;

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

386 if (size < 0)

387 return size;

388

389 memset(header + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

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

391 if (len < 0) {

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

393 return len;

394 }

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

396

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

398 if (ret != len) {

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

400 return ret < 0 ? ret : AVERROR_INVALIDDATA;

401 }

402 return 0;

403 }

404

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

406 {

407 AV1DemuxContext *const c = s->priv_data;

408 int ret;

409

410 if (s->io_repositioned) {

411 av_bsf_flush(c->bsf);

412 s->io_repositioned = 0;

413 }

414 while (1) {

415 ret = obu_get_packet(s, pkt);

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

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

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

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

420 return ret;

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

422 if (ret < 0) {

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

424 "av1_frame_merge filter\n");

425 return ret;

426 }

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

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

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

430 "send output packet\n");

431 if (ret != AVERROR(EAGAIN))

432 break;

433 }

434

435 return ret;

436 }

437

438 const FFInputFormat ff_obu_demuxer = {

439 .p.name = "obu",

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

441 .p.extensions = "obu",

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

443 .p.priv_class = &av1_demuxer_class,

444 .priv_data_size = sizeof(AV1DemuxContext),

445 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

446 .read_probe = obu_probe,

447 .read_header = av1_read_header,

448 .read_packet = obu_read_packet,

449 .read_close = av1_read_close,

450 };

451 #endif

AVFMT_NO_BYTE_SEEK

#define AVFMT_NO_BYTE_SEEK

Format does not allow seeking by bytes.

Definition: avformat.h:486

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:694

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

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

Underlying C type is AVRational.

Definition: opt.h:315

AVFMT_NOTIMESTAMPS

#define AVFMT_NOTIMESTAMPS

Format does not need / have any timestamps.

Definition: avformat.h:478

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

AVOption

AVOption.

Definition: opt.h:429

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:833

AVIOContext::error

int error

contains the error code or 0 if no error happened

Definition: avio.h:239

filter

void(* filter)(uint8_t *src, int stride, int qscale)

Definition: h263dsp.c:29

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

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

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:337

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

bsf.h

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:347

AV1_OBU_FRAME_HEADER

@ AV1_OBU_FRAME_HEADER

Definition: av1.h:32

GetBitContext

Definition: get_bits.h:109

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

AVFMT_GENERIC_INDEX

#define AVFMT_GENERIC_INDEX

Use generic index building code.

Definition: avformat.h:479

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

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:544

read_packet

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

Definition: avio_read_callback.c:42

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

av1_read_close

static int av1_read_close(AVFormatContext *s)

Definition: av1dec.c:103

bits

uint8_t bits

Definition: vp3data.h:128

AV1DemuxContext::pos

int64_t pos

Definition: av1dec.c:39

ctx

AVFormatContext * ctx

Definition: movenc.c:49

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

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

internal.h

DEC

#define DEC

Definition: av1dec.c:111

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

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

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:284

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

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:391

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

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

FFStream

Definition: internal.h:128

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

header

static const uint8_t header[24]

Definition: sdr2.c:68

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:606

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

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:416

read_header

static int read_header(FFV1Context *f, RangeCoder *c)

Definition: ffv1dec.c:498

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

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

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:236

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

AVSTREAM_PARSE_HEADERS

@ AVSTREAM_PARSE_HEADERS

Only parse headers, do not repack.

Definition: avformat.h:590

pos

unsigned int pos

Definition: spdifenc.c:414

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

AVIOContext::eof_reached

int eof_reached

true if was unable to read due to error or eof

Definition: avio.h:238

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

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:321

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

av1_options

static const AVOption av1_options[]

Definition: av1dec.c:113

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

av1_read_header

static int av1_read_header(AVFormatContext *s)

Definition: av1dec.c:61

av1_demuxer_class

static const AVClass av1_demuxer_class

Definition: av1dec.c:119

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:608

FFInputFormat

Definition: demux.h:47

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

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

av_bsf_get_by_name

const AVBitStreamFilter * av_bsf_get_by_name(const char *name)

Definition: bitstream_filters.c:91

Generated on Tue Nov 18 2025 19:22:01 for FFmpeg by doxygen 1.8.17