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/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"
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  st->avg_frame_rate = 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, 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 {
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 
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 
286  .p.name = "av1",
287  .p.long_name = NULL_IF_CONFIG_SMALL("AV1 Annex B"),
288  .p.extensions = "obu",
290  .p.priv_class = &av1_demuxer_class,
291  .priv_data_size = sizeof(AV1DemuxContext),
292  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
295  .read_packet = annexb_read_packet,
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;
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;
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 
431  .p.name = "obu",
432  .p.long_name = NULL_IF_CONFIG_SMALL("AV1 low overhead OBU"),
433  .p.extensions = "obu",
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,
440  .read_packet = obu_read_packet,
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:258
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
AVOption
AVOption.
Definition: opt.h:357
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:99
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:60
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: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
s
#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: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: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
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: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:94
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:603
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:1023
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
i
#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:91
ret
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:231
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:612
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:318
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:501
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:346
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:86