FFmpeg  4.3.6
av1.c
Go to the documentation of this file.
1 /*
2  * AV1 helper functions for muxers
3  * Copyright (c) 2018 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 "libavutil/avassert.h"
23 #include "libavutil/mem.h"
24 #include "libavcodec/av1.h"
25 #include "libavcodec/av1_parse.h"
26 #include "libavcodec/profiles.h"
27 #include "libavcodec/put_bits.h"
28 #include "av1.h"
29 #include "avio.h"
30 #include "avio_internal.h"
31 
32 static int av1_filter_obus(AVIOContext *pb, const uint8_t *buf,
33  int size, int *offset)
34 {
35  const uint8_t *start = buf, *end = buf + size;
36  int64_t obu_size;
37  int off, start_pos, type, temporal_id, spatial_id;
38  enum {
39  START_NOT_FOUND,
40  START_FOUND,
41  END_FOUND,
42  OFFSET_IMPOSSIBLE,
43  } state = START_NOT_FOUND;
44 
45  off = size = 0;
46  while (buf < end) {
47  int len = parse_obu_header(buf, end - buf, &obu_size, &start_pos,
48  &type, &temporal_id, &spatial_id);
49  if (len < 0)
50  return len;
51 
52  switch (type) {
55  case AV1_OBU_TILE_LIST:
56  case AV1_OBU_PADDING:
57  if (state == START_FOUND)
58  state = END_FOUND;
59  break;
60  default:
61  if (state == START_NOT_FOUND) {
62  off = buf - start;
63  state = START_FOUND;
64  } else if (state == END_FOUND) {
65  state = OFFSET_IMPOSSIBLE;
66  }
67  if (pb)
68  avio_write(pb, buf, len);
69  size += len;
70  break;
71  }
72  buf += len;
73  }
74 
75  if (offset)
76  *offset = state != OFFSET_IMPOSSIBLE ? off : -1;
77 
78  return size;
79 }
80 
81 int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
82 {
83  return av1_filter_obus(pb, buf, size, NULL);
84 }
85 
87  int *size, int *offset)
88 {
89  AVIOContext pb;
90  uint8_t *buf;
91  int len, off, ret;
92 
93  len = ret = av1_filter_obus(NULL, in, *size, &off);
94  if (ret < 0) {
95  return ret;
96  }
97  if (off >= 0) {
98  *out = (uint8_t *)in;
99  *size = len;
100  *offset = off;
101 
102  return 0;
103  }
104 
106  if (!buf)
107  return AVERROR(ENOMEM);
108 
109  ffio_init_context(&pb, buf, len, 1, NULL, NULL, NULL, NULL);
110 
111  ret = av1_filter_obus(&pb, in, *size, NULL);
112  av_assert1(ret == len);
113 
114  memset(buf + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
115 
116  *out = buf;
117  *size = len;
118  *offset = 0;
119 
120  return 0;
121 }
122 
123 static inline void uvlc(GetBitContext *gb)
124 {
125  int leading_zeros = 0;
126 
127  while (get_bits_left(gb)) {
128  if (get_bits1(gb))
129  break;
130  leading_zeros++;
131  }
132 
133  if (leading_zeros >= 32)
134  return;
135 
136  skip_bits_long(gb, leading_zeros);
137 }
138 
140 {
141  int twelve_bit = 0;
142  int high_bitdepth = get_bits1(gb);
143  if (seq_params->profile == FF_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
144  twelve_bit = get_bits1(gb);
145 
146  seq_params->bitdepth = 8 + (high_bitdepth * 2) + (twelve_bit * 2);
147 
148  if (seq_params->profile == FF_PROFILE_AV1_HIGH)
149  seq_params->monochrome = 0;
150  else
151  seq_params->monochrome = get_bits1(gb);
152 
153  seq_params->color_description_present_flag = get_bits1(gb);
154  if (seq_params->color_description_present_flag) {
155  seq_params->color_primaries = get_bits(gb, 8);
156  seq_params->transfer_characteristics = get_bits(gb, 8);
157  seq_params->matrix_coefficients = get_bits(gb, 8);
158  } else {
162  }
163 
164  if (seq_params->monochrome) {
165  seq_params->color_range = get_bits1(gb);
166  seq_params->chroma_subsampling_x = 1;
167  seq_params->chroma_subsampling_y = 1;
168  seq_params->chroma_sample_position = 0;
169  return 0;
170  } else if (seq_params->color_primaries == AVCOL_PRI_BT709 &&
172  seq_params->matrix_coefficients == AVCOL_SPC_RGB) {
173  seq_params->chroma_subsampling_x = 0;
174  seq_params->chroma_subsampling_y = 0;
175  } else {
176  seq_params->color_range = get_bits1(gb);
177 
178  if (seq_params->profile == FF_PROFILE_AV1_MAIN) {
179  seq_params->chroma_subsampling_x = 1;
180  seq_params->chroma_subsampling_y = 1;
181  } else if (seq_params->profile == FF_PROFILE_AV1_HIGH) {
182  seq_params->chroma_subsampling_x = 0;
183  seq_params->chroma_subsampling_y = 0;
184  } else {
185  if (twelve_bit) {
186  seq_params->chroma_subsampling_x = get_bits1(gb);
187  if (seq_params->chroma_subsampling_x)
188  seq_params->chroma_subsampling_y = get_bits1(gb);
189  else
190  seq_params->chroma_subsampling_y = 0;
191  } else {
192  seq_params->chroma_subsampling_x = 1;
193  seq_params->chroma_subsampling_y = 0;
194  }
195  }
196  if (seq_params->chroma_subsampling_x && seq_params->chroma_subsampling_y)
197  seq_params->chroma_sample_position = get_bits(gb, 2);
198  }
199 
200  skip_bits1(gb); // separate_uv_delta_q
201 
202  return 0;
203 }
204 
205 static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
206 {
207  GetBitContext gb;
208  int reduced_still_picture_header;
209  int frame_width_bits_minus_1, frame_height_bits_minus_1;
210  int size_bits, ret;
211 
212  size_bits = get_obu_bit_length(buf, size, AV1_OBU_SEQUENCE_HEADER);
213  if (size_bits < 0)
214  return size_bits;
215 
216  ret = init_get_bits(&gb, buf, size_bits);
217  if (ret < 0)
218  return ret;
219 
220  memset(seq_params, 0, sizeof(*seq_params));
221 
222  seq_params->profile = get_bits(&gb, 3);
223 
224  skip_bits1(&gb); // still_picture
225  reduced_still_picture_header = get_bits1(&gb);
226 
227  if (reduced_still_picture_header) {
228  seq_params->level = get_bits(&gb, 5);
229  seq_params->tier = 0;
230  } else {
231  int initial_display_delay_present_flag, operating_points_cnt_minus_1;
232  int decoder_model_info_present_flag, buffer_delay_length_minus_1;
233 
234  if (get_bits1(&gb)) { // timing_info_present_flag
235  skip_bits_long(&gb, 32); // num_units_in_display_tick
236  skip_bits_long(&gb, 32); // time_scale
237 
238  if (get_bits1(&gb)) // equal_picture_interval
239  uvlc(&gb); // num_ticks_per_picture_minus_1
240 
241  decoder_model_info_present_flag = get_bits1(&gb);
242  if (decoder_model_info_present_flag) {
243  buffer_delay_length_minus_1 = get_bits(&gb, 5);
244  skip_bits_long(&gb, 32); // num_units_in_decoding_tick
245  skip_bits(&gb, 10); // buffer_removal_time_length_minus_1 (5)
246  // frame_presentation_time_length_minus_1 (5)
247  }
248  } else
249  decoder_model_info_present_flag = 0;
250 
251  initial_display_delay_present_flag = get_bits1(&gb);
252 
253  operating_points_cnt_minus_1 = get_bits(&gb, 5);
254  for (int i = 0; i <= operating_points_cnt_minus_1; i++) {
255  int seq_level_idx, seq_tier;
256 
257  skip_bits(&gb, 12); // operating_point_idc
258  seq_level_idx = get_bits(&gb, 5);
259 
260  if (seq_level_idx > 7)
261  seq_tier = get_bits1(&gb);
262  else
263  seq_tier = 0;
264 
265  if (decoder_model_info_present_flag) {
266  if (get_bits1(&gb)) { // decoder_model_present_for_this_op
267  skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // decoder_buffer_delay
268  skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // encoder_buffer_delay
269  skip_bits1(&gb); // low_delay_mode_flag
270  }
271  }
272 
273  if (initial_display_delay_present_flag) {
274  if (get_bits1(&gb)) // initial_display_delay_present_for_this_op
275  skip_bits(&gb, 4); // initial_display_delay_minus_1
276  }
277 
278  if (i == 0) {
279  seq_params->level = seq_level_idx;
280  seq_params->tier = seq_tier;
281  }
282  }
283  }
284 
285  frame_width_bits_minus_1 = get_bits(&gb, 4);
286  frame_height_bits_minus_1 = get_bits(&gb, 4);
287 
288  skip_bits(&gb, frame_width_bits_minus_1 + 1); // max_frame_width_minus_1
289  skip_bits(&gb, frame_height_bits_minus_1 + 1); // max_frame_height_minus_1
290 
291  if (!reduced_still_picture_header) {
292  if (get_bits1(&gb)) // frame_id_numbers_present_flag
293  skip_bits(&gb, 7); // delta_frame_id_length_minus_2 (4), additional_frame_id_length_minus_1 (3)
294  }
295 
296  skip_bits(&gb, 3); // use_128x128_superblock (1), enable_filter_intra (1), enable_intra_edge_filter (1)
297 
298  if (!reduced_still_picture_header) {
299  int enable_order_hint, seq_force_screen_content_tools;
300 
301  skip_bits(&gb, 4); // enable_interintra_compound (1), enable_masked_compound (1)
302  // enable_warped_motion (1), enable_dual_filter (1)
303 
304  enable_order_hint = get_bits1(&gb);
305  if (enable_order_hint)
306  skip_bits(&gb, 2); // enable_jnt_comp (1), enable_ref_frame_mvs (1)
307 
308  if (get_bits1(&gb)) // seq_choose_screen_content_tools
309  seq_force_screen_content_tools = 2;
310  else
311  seq_force_screen_content_tools = get_bits1(&gb);
312 
313  if (seq_force_screen_content_tools) {
314  if (!get_bits1(&gb)) // seq_choose_integer_mv
315  skip_bits1(&gb); // seq_force_integer_mv
316  }
317 
318  if (enable_order_hint)
319  skip_bits(&gb, 3); // order_hint_bits_minus_1
320  }
321 
322  skip_bits(&gb, 3); // enable_superres (1), enable_cdef (1), enable_restoration (1)
323 
324  parse_color_config(seq_params, &gb);
325 
326  skip_bits1(&gb); // film_grain_params_present
327 
328  if (get_bits_left(&gb))
329  return AVERROR_INVALIDDATA;
330 
331  return 0;
332 }
333 
335 {
336  int64_t obu_size;
337  int start_pos, type, temporal_id, spatial_id;
338 
339  if (size <= 0)
340  return AVERROR_INVALIDDATA;
341 
342  while (size > 0) {
343  int len = parse_obu_header(buf, size, &obu_size, &start_pos,
344  &type, &temporal_id, &spatial_id);
345  if (len < 0)
346  return len;
347 
348  switch (type) {
350  if (!obu_size)
351  return AVERROR_INVALIDDATA;
352 
353  return parse_sequence_header(seq, buf + start_pos, obu_size);
354  default:
355  break;
356  }
357  size -= len;
358  buf += len;
359  }
360 
361  return AVERROR_INVALIDDATA;
362 }
363 
364 int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
365 {
366  AVIOContext *seq_pb = NULL, *meta_pb = NULL;
367  AV1SequenceParameters seq_params;
368  PutBitContext pbc;
369  uint8_t header[4];
370  uint8_t *seq, *meta;
371  int64_t obu_size;
372  int start_pos, type, temporal_id, spatial_id;
373  int ret, nb_seq = 0, seq_size, meta_size;
374 
375  if (size <= 0)
376  return AVERROR_INVALIDDATA;
377 
378  ret = avio_open_dyn_buf(&seq_pb);
379  if (ret < 0)
380  return ret;
381  ret = avio_open_dyn_buf(&meta_pb);
382  if (ret < 0)
383  goto fail;
384 
385  while (size > 0) {
386  int len = parse_obu_header(buf, size, &obu_size, &start_pos,
387  &type, &temporal_id, &spatial_id);
388  if (len < 0) {
389  ret = len;
390  goto fail;
391  }
392 
393  switch (type) {
395  nb_seq++;
396  if (!obu_size || nb_seq > 1) {
397  ret = AVERROR_INVALIDDATA;
398  goto fail;
399  }
400  ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);
401  if (ret < 0)
402  goto fail;
403 
404  avio_write(seq_pb, buf, len);
405  break;
406  case AV1_OBU_METADATA:
407  if (!obu_size) {
408  ret = AVERROR_INVALIDDATA;
409  goto fail;
410  }
411  avio_write(meta_pb, buf, len);
412  break;
413  default:
414  break;
415  }
416  size -= len;
417  buf += len;
418  }
419 
420  seq_size = avio_get_dyn_buf(seq_pb, &seq);
421  if (!seq_size) {
422  ret = AVERROR_INVALIDDATA;
423  goto fail;
424  }
425 
426  init_put_bits(&pbc, header, sizeof(header));
427 
428  put_bits(&pbc, 1, 1); // marker
429  put_bits(&pbc, 7, 1); // version
430  put_bits(&pbc, 3, seq_params.profile);
431  put_bits(&pbc, 5, seq_params.level);
432  put_bits(&pbc, 1, seq_params.tier);
433  put_bits(&pbc, 1, seq_params.bitdepth > 8);
434  put_bits(&pbc, 1, seq_params.bitdepth == 12);
435  put_bits(&pbc, 1, seq_params.monochrome);
436  put_bits(&pbc, 1, seq_params.chroma_subsampling_x);
437  put_bits(&pbc, 1, seq_params.chroma_subsampling_y);
438  put_bits(&pbc, 2, seq_params.chroma_sample_position);
439  put_bits(&pbc, 8, 0); // padding
440  flush_put_bits(&pbc);
441 
442  avio_write(pb, header, sizeof(header));
443  avio_write(pb, seq, seq_size);
444 
445  meta_size = avio_get_dyn_buf(meta_pb, &meta);
446  if (meta_size)
447  avio_write(pb, meta, meta_size);
448 
449 fail:
450  ffio_free_dyn_buf(&seq_pb);
451  ffio_free_dyn_buf(&meta_pb);
452 
453  return ret;
454 }
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Buffered I/O operations.
static struct @314 state
int size
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
Memory handling functions.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and write the resulting bitstream ...
Definition: av1.c:81
uint8_t transfer_characteristics
Definition: av1.h:39
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1356
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:510
uint8_t chroma_sample_position
Definition: av1.h:36
uint8_t monochrome
Definition: av1.h:33
uint8_t chroma_subsampling_x
Definition: av1.h:34
uint8_t
#define av_malloc(s)
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:364
static const uint8_t header[24]
Definition: sdr2.c:67
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AVERROR(e)
Definition: error.h:43
int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out, int *size, int *offset)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and return the result in a data bu...
Definition: av1.c:86
uint8_t color_range
Definition: av1.h:41
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:457
simple assert() macros that are a bit more flexible than ISO C assert().
static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
Definition: av1.c:205
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
#define fail()
Definition: checkasm.h:123
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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:100
uint8_t color_description_present_flag
Definition: av1.h:37
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1431
static void uvlc(GetBitContext *gb)
Definition: av1.c:123
AV1 common definitions.
uint8_t color_primaries
Definition: av1.h:38
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1954
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:1952
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
cl_device_type type
static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)
Definition: av1.c:139
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:494
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
int ffio_init_context(AVIOContext *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:76
static int get_obu_bit_length(const uint8_t *buf, int size, int type)
Definition: av1_parse.h:144
uint8_t chroma_subsampling_y
Definition: av1.h:35
int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
Parses a Sequence Header from the the provided buffer.
Definition: av1.c:334
uint8_t level
Definition: av1.h:30
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
uint8_t tier
Definition: av1.h:31
int len
static int av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size, int *offset)
Definition: av1.c:32
FILE * out
Definition: movenc.c:54
uint8_t matrix_coefficients
Definition: av1.h:40
uint8_t bitdepth
Definition: av1.h:32
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1953
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1368
uint8_t profile
Definition: av1.h:29
bitstream writer API