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/avcodec.h"

27 #include "libavcodec/av1_parse.h"

28 #include "libavcodec/bsf.h"

29 #include "avformat.h"

30 #include "avio_internal.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 sti->avctx->framerate = 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) {

128 int more, i = 0;

129 uint8_t byte;

130 *len = 0;

131 do {

132 unsigned bits;

133 byte = avio_r8(pb);

134 more = byte & 0x80;

135 bits = byte & 0x7f;

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

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

138 else if (bits)

139 return AVERROR_INVALIDDATA;

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

141 return AVERROR_INVALIDDATA;

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

143 return pb->error ? pb->error : AVERROR(EIO);

144 } while (more);

145 return i;

146 }

147

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

149 {

150 int start_pos, temporal_id, spatial_id;

151 int len;

152

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

154 type, &temporal_id, &spatial_id);

155 if (len < 0)

156 return len;

157

158 return 0;

159 }

160

161 static int annexb_probe(const AVProbeData *p)

162 {

163 FFIOContext ctx;

164 AVIOContext *const pb = &ctx.pub;

165 int64_t obu_size;

166 uint32_t temporal_unit_size, frame_unit_size, obu_unit_size;

167 int seq = 0;

168 int ret, type, cnt = 0;

169

170 ffio_init_context(&ctx, p->buf, p->buf_size, 0,

171 NULL, NULL, NULL, NULL);

172

173 ret = leb(pb, &temporal_unit_size);

174 if (ret < 0)

175 return 0;

176 cnt += ret;

177 ret = leb(pb, &frame_unit_size);

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);

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);

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(EIO);

233 goto end;

234 }

235

236 if (!c->temporal_unit_size) {

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

238 if (len < 0) return AVERROR_INVALIDDATA;

239 }

240

241 if (!c->frame_unit_size) {

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

243 if (len < 0 || ((int64_t)c->frame_unit_size + len) > c->temporal_unit_size)

244 return AVERROR_INVALIDDATA;

245 c->temporal_unit_size -= len;

246 }

247

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

249 if (len < 0 || ((int64_t)obu_unit_size + len) > c->frame_unit_size)

250 return AVERROR_INVALIDDATA;

251

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

253 if (ret < 0)

254 return ret;

255 if (ret != obu_unit_size)

256 return AVERROR(EIO);

257

258 c->temporal_unit_size -= obu_unit_size + len;

259 c->frame_unit_size -= obu_unit_size + len;

260

261 end:

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

263 if (ret < 0) {

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

265 "av1_frame_merge filter\n");

266 return ret;

267 }

268

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

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

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

272 "send output packet\n");

273

274 if (ret == AVERROR(EAGAIN))

275 goto retry;

276

277 return ret;

278 }

279

280 const AVInputFormat ff_av1_demuxer = {

281 .name = "av1",

282 .long_name = NULL_IF_CONFIG_SMALL("AV1 Annex B"),

283 .priv_data_size = sizeof(AV1DemuxContext),

284 .flags_internal = FF_FMT_INIT_CLEANUP,

285 .read_probe = annexb_probe,

286 .read_header = av1_read_header,

287 .read_packet = annexb_read_packet,

288 .read_close = av1_read_close,

289 .extensions = "obu",

290 .flags = AVFMT_GENERIC_INDEX,

291 .priv_class = &av1_demuxer_class,

292 };

293 #endif

294

295 #if CONFIG_OBU_DEMUXER

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

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

298 //see c27c7b49dc for more details

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

300 {

301 GetBitContext gb;

302 int ret, extension_flag, start_pos;

303 int64_t size;

304

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

306 if (ret < 0)

307 return ret;

308

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

310 return AVERROR_INVALIDDATA;

311

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

313 extension_flag = get_bits1(&gb);

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

315 return AVERROR_INVALIDDATA;

316 skip_bits1(&gb); // obu_reserved_1bit

317

318 if (extension_flag) {

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

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

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

322 }

323

324 *obu_size = leb128(&gb);

325 if (*obu_size > INT_MAX)

326 return AVERROR_INVALIDDATA;

327

328 if (get_bits_left(&gb) < 0)

329 return AVERROR_INVALIDDATA;

330

331 start_pos = get_bits_count(&gb) / 8;

332

333 size = *obu_size + start_pos;

334 if (size > INT_MAX)

335 return AVERROR_INVALIDDATA;

336 return size;

337 }

338

339 static int obu_probe(const AVProbeData *p)

340 {

341 int64_t obu_size;

342 int seq = 0;

343 int ret, type, cnt;

344

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

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

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

348 return 0;

349

350 while (1) {

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

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

353 return 0;

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

355

356 ret = get_score(type, &seq);

357 if (ret >= 0)

358 return ret;

359 }

360 return 0;

361 }

362

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

364 {

365 AV1DemuxContext *const c = s->priv_data;

366 uint8_t header[MAX_OBU_HEADER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

367 int64_t obu_size;

368 int size;

369 int ret, len, type;

370

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

372 return ret;

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

374 if (size < 0)

375 return size;

376

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

378 if (len < 0) {

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

380 return len;

381 }

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

383

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

385 if (ret != len) {

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

387 return ret < 0 ? ret : AVERROR_INVALIDDATA;

388 }

389 return 0;

390 }

391

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

393 {

394 AV1DemuxContext *const c = s->priv_data;

395 int ret;

396

397 if (s->io_repositioned) {

398 av_bsf_flush(c->bsf);

399 s->io_repositioned = 0;

400 }

401 while (1) {

402 ret = obu_get_packet(s, pkt);

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

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

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

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

407 return ret;

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

409 if (ret < 0) {

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

411 "av1_frame_merge filter\n");

412 return ret;

413 }

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

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

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

417 "send output packet\n");

418 if (ret != AVERROR(EAGAIN))

419 break;

420 }

421

422 return ret;

423 }

424

425 const AVInputFormat ff_obu_demuxer = {

426 .name = "obu",

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

428 .priv_data_size = sizeof(AV1DemuxContext),

429 .flags_internal = FF_FMT_INIT_CLEANUP,

430 .read_probe = obu_probe,

431 .read_header = av1_read_header,

432 .read_packet = obu_read_packet,

433 .read_close = av1_read_close,

434 .extensions = "obu",

435 .flags = AVFMT_GENERIC_INDEX | AVFMT_NO_BYTE_SEEK,

436 .priv_class = &av1_demuxer_class,

437 };

438 #endif

AVFMT_NO_BYTE_SEEK

#define AVFMT_NO_BYTE_SEEK

Format does not allow seeking by bytes.

Definition: avformat.h:487

FF_FMT_INIT_CLEANUP

#define FF_FMT_INIT_CLEANUP

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

Definition: internal.h:47

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

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

avformat_new_stream

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

Add a new stream to a media file.

Definition: options.c:243

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:58

get_score

static int get_score(int type, int *seq)

Definition: av1dec.c:42

AV1DemuxContext

Definition: av1dec.c:33

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

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

ff_obu_demuxer

const AVInputFormat ff_obu_demuxer

AVOption

AVOption.

Definition: opt.h:251

AVIOContext::error

int error

contains the error code or 0 if no error happened

Definition: avio.h:245

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

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

FFIOContext

Definition: avio_internal.h:29

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:371

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:1750

framerate

int framerate

Definition: h264_levels.c:65

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:325

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

bsf.h

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:413

AV1_OBU_FRAME_HEADER

@ AV1_OBU_FRAME_HEADER

Definition: av1.h:32

GetBitContext

Definition: get_bits.h:107

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

FFStream::avctx

struct AVCodecContext * avctx

The codec context used by avformat_find_stream_info, the parser, etc.

Definition: internal.h:223

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

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

AVInputFormat

Definition: avformat.h:546

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:524

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

#define s(width, name)

Definition: cbs_vp9.c:256

av_bsf_flush

void av_bsf_flush(AVBSFContext *ctx)

Reset the internal bitstream filter state.

Definition: bsf.c:191

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:551

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

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:386

AVFormatContext

Format I/O context.

Definition: avformat.h:1104

internal.h

DEC

#define DEC

Definition: av1dec.c:110

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:861

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

leb128

#define leb128(name)

Definition: cbs_av1.c:705

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

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:545

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

av_bsf_receive_packet

int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)

Retrieve a filtered packet.

Definition: bsf.c:231

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

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

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

byte

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_WB16 unsigned int_TMPL byte

Definition: bytestream.h:99

FFStream

Definition: internal.h:196

av_bsf_send_packet

int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)

Submit a packet for filtering.

Definition: bsf.c:203

ff_av1_demuxer

const AVInputFormat ff_av1_demuxer

size

int size

Definition: twinvq_data.h:10344

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

header

static const uint8_t header[24]

Definition: sdr2.c:67

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:624

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

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:403

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

avio_internal.h

ffio_init_context

void ffio_init_context(FFIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))

Definition: aviobuf.c:81

common.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

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