FFmpeg
av1dec.c
Go to the documentation of this file.
1 /*
2  * AV1 Annex B demuxer
3  * Copyright (c) 2019 James Almer <jamrial@gmail.com>
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  */
21 
22 #include "config_components.h"
23 
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"
32 
33 typedef struct AV1DemuxContext {
34  const AVClass *class;
38  uint32_t frame_unit_size;
40 
41 //return < 0 if we need more data
42 static int get_score(int type, int *seq)
43 {
44  switch (type) {
46  *seq = 1;
47  return -1;
48  case AV1_OBU_FRAME:
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 }
59 
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;
67 
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  }
73 
74  st = avformat_new_stream(s, NULL);
75  if (!st)
76  return AVERROR(ENOMEM);
77  sti = ffstream(st);
78 
82 
83  sti->avctx->framerate = c->framerate;
84  // taken from rawvideo demuxers
85  avpriv_set_pts_info(st, 64, 1, 1200000);
86 
87  ret = av_bsf_alloc(filter, &c->bsf);
88  if (ret < 0)
89  return ret;
90 
91  ret = avcodec_parameters_copy(c->bsf->par_in, st->codecpar);
92  if (ret < 0)
93  return ret;
94 
95  ret = av_bsf_init(c->bsf);
96  if (ret < 0)
97  return ret;
98 
99  return 0;
100 }
101 
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 {
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 
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,
287  .read_packet = annexb_read_packet,
289  .extensions = "obu",
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;
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;
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 
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,
432  .read_packet = obu_read_packet,
434  .extensions = "obu",
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:489
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:839
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:237
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:219
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:456
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:467
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1735
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:379
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:763
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:61
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:482
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:656
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
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
s
#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:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
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:1216
internal.h
DEC
#define DEC
Definition: av1dec.c:110
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
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:533
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
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:498
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
c
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:463
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:634
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:1057
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
AV1DemuxContext::frame_unit_size
uint32_t frame_unit_size
Definition: av1dec.c:38
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
i
#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
avcodec.h
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:262
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:799
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:643
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:244
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:349
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:62
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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:74
MAX_OBU_HEADER_SIZE
#define MAX_OBU_HEADER_SIZE
Definition: av1_parse.h:35
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:377
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:82