FFmpeg
av1dec.c
Go to the documentation of this file.
1 /*
2  * AV1 video decoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "config_components.h"
22 
26 #include "libavutil/mem.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/opt.h"
29 #include "avcodec.h"
30 #include "av1_parse.h"
31 #include "av1dec.h"
32 #include "atsc_a53.h"
33 #include "bytestream.h"
34 #include "codec_internal.h"
35 #include "decode.h"
36 #include "hwaccel_internal.h"
37 #include "internal.h"
38 #include "itut35.h"
39 #include "hwconfig.h"
40 #include "profiles.h"
41 #include "progressframe.h"
42 #include "refstruct.h"
43 
44 /**< same with Div_Lut defined in spec 7.11.3.7 */
45 static const uint16_t div_lut[AV1_DIV_LUT_NUM] = {
46  16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
47  15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
48  15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
49  14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
50  13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
51  13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
52  13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
53  12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
54  12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
55  11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
56  11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
57  11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
58  10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
59  10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
60  10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,
61  9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,
62  9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,
63  9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,
64  9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,
65  9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,
66  8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,
67  8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,
68  8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,
69  8240, 8224, 8208, 8192
70 };
71 
72 static uint32_t inverse_recenter(int r, uint32_t v)
73 {
74  if (v > 2 * r)
75  return v;
76  else if (v & 1)
77  return r - ((v + 1) >> 1);
78  else
79  return r + (v >> 1);
80 }
81 
82 static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,
83  int mx, int r)
84 {
85  if ((r << 1) <= mx) {
86  return inverse_recenter(r, sub_exp);
87  } else {
88  return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);
89  }
90 }
91 
92 static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,
93  int high, int r)
94 {
95  int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);
96  return x + low;
97 }
98 
99 static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
100 {
101  uint8_t primary_frame, prev_frame;
102  uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;
103  int32_t r, prev_gm_param;
104 
105  primary_frame = s->raw_frame_header->primary_ref_frame;
106  prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
107  abs_bits = AV1_GM_ABS_ALPHA_BITS;
108  prec_bits = AV1_GM_ALPHA_PREC_BITS;
109 
110  /* setup_past_independence() sets PrevGmParams to default values. We can
111  * simply point to the current's frame gm_params as they will be initialized
112  * with defaults at this point.
113  */
114  if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)
115  prev_gm_param = s->cur_frame.gm_params[ref][idx];
116  else
117  prev_gm_param = s->ref[prev_frame].gm_params[ref][idx];
118 
119  if (idx < 2) {
121  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -
122  !s->raw_frame_header->allow_high_precision_mv;
123  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -
124  !s->raw_frame_header->allow_high_precision_mv;
125  } else {
126  abs_bits = AV1_GM_ABS_TRANS_BITS;
127  prec_bits = AV1_GM_TRANS_PREC_BITS;
128  }
129  }
130  round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
131  prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;
132  sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
133  mx = 1 << abs_bits;
134  r = (prev_gm_param >> prec_diff) - sub;
135 
136  s->cur_frame.gm_params[ref][idx] =
137  (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],
138  -mx, mx + 1, r) << prec_diff) + round;
139 }
140 
141 static uint64_t round_two(uint64_t x, uint16_t n)
142 {
143  if (n == 0)
144  return x;
145  return ((x + ((uint64_t)1 << (n - 1))) >> n);
146 }
147 
148 static int64_t round_two_signed(int64_t x, uint16_t n)
149 {
150  return ((x<0) ? -((int64_t)round_two(-x, n)) : (int64_t)round_two(x, n));
151 }
152 
153 /**
154  * Resolve divisor process.
155  * see spec 7.11.3.7
156  */
157 static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
158 {
159  int32_t e, f;
160 
161  *shift = av_log2(d);
162  e = d - (1 << (*shift));
163  if (*shift > AV1_DIV_LUT_BITS)
165  else
166  f = e << (AV1_DIV_LUT_BITS - (*shift));
167 
169 
170  return div_lut[f];
171 }
172 
173 /**
174  * check if global motion params is valid.
175  * see spec 7.11.3.6
176  */
177 static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)
178 {
179  int16_t alpha, beta, gamma, delta, divf, divs;
180  int64_t v, w;
181  int32_t *param = &s->cur_frame.gm_params[idx][0];
182  if (param[2] <= 0)
183  return 0;
184 
185  alpha = av_clip_int16(param[2] - (1 << AV1_WARPEDMODEL_PREC_BITS));
186  beta = av_clip_int16(param[3]);
187  divf = resolve_divisor(abs(param[2]), &divs);
188  v = (int64_t)param[4] * (1 << AV1_WARPEDMODEL_PREC_BITS);
189  w = (int64_t)param[3] * param[4];
190  gamma = av_clip_int16((int)round_two_signed((v * divf), divs));
191  delta = av_clip_int16(param[5] - (int)round_two_signed((w * divf), divs) - (1 << AV1_WARPEDMODEL_PREC_BITS));
192 
197 
198  if ((4 * abs(alpha) + 7 * abs(beta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS) ||
199  (4 * abs(gamma) + 4 * abs(delta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS))
200  return 0;
201 
202  return 1;
203 }
204 
205 /**
206 * update gm type/params, since cbs already implemented part of this function,
207 * so we don't need to full implement spec.
208 */
210 {
211  const AV1RawFrameHeader *header = s->raw_frame_header;
212  int type, ref;
213 
215  s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;
216  for (int i = 0; i < 6; i++)
217  s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?
218  1 << AV1_WARPEDMODEL_PREC_BITS : 0;
219  }
220  if (header->frame_type == AV1_FRAME_KEY ||
221  header->frame_type == AV1_FRAME_INTRA_ONLY)
222  return;
223 
225  if (header->is_global[ref]) {
226  if (header->is_rot_zoom[ref]) {
228  } else {
229  type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
231  }
232  } else {
234  }
235  s->cur_frame.gm_type[ref] = type;
236 
237  if (type >= AV1_WARP_MODEL_ROTZOOM) {
238  read_global_param(s, type, ref, 2);
239  read_global_param(s, type, ref, 3);
240  if (type == AV1_WARP_MODEL_AFFINE) {
241  read_global_param(s, type, ref, 4);
242  read_global_param(s, type, ref, 5);
243  } else {
244  s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];
245  s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];
246  }
247  }
249  read_global_param(s, type, ref, 0);
250  read_global_param(s, type, ref, 1);
251  }
252  if (type <= AV1_WARP_MODEL_AFFINE) {
253  s->cur_frame.gm_invalid[ref] = !get_shear_params_valid(s, ref);
254  }
255  }
256 }
257 
259  unsigned int a, unsigned int b)
260 {
261  unsigned int diff = a - b;
262  unsigned int m = 1 << seq->order_hint_bits_minus_1;
263  return (diff & (m - 1)) - (diff & m);
264 }
265 
267 {
268  const AV1RawFrameHeader *header = s->raw_frame_header;
269  const AV1RawSequenceHeader *seq = s->raw_seq;
270 
271  int forward_idx, backward_idx;
272  int forward_hint, backward_hint;
273  int second_forward_idx, second_forward_hint;
274  int ref_hint, dist, i;
275 
276  if (header->frame_type == AV1_FRAME_KEY ||
277  header->frame_type == AV1_FRAME_INTRA_ONLY ||
278  !header->reference_select || !seq->enable_order_hint)
279  return;
280 
281  forward_idx = -1;
282  backward_idx = -1;
283  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
284  if (!s->ref[header->ref_frame_idx[i]].raw_frame_header)
285  return;
286  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
287  dist = get_relative_dist(seq, ref_hint, header->order_hint);
288  if (dist < 0) {
289  if (forward_idx < 0 ||
290  get_relative_dist(seq, ref_hint, forward_hint) > 0) {
291  forward_idx = i;
292  forward_hint = ref_hint;
293  }
294  } else if (dist > 0) {
295  if (backward_idx < 0 ||
296  get_relative_dist(seq, ref_hint, backward_hint) < 0) {
297  backward_idx = i;
298  backward_hint = ref_hint;
299  }
300  }
301  }
302 
303  if (forward_idx < 0) {
304  return;
305  } else if (backward_idx >= 0) {
306  s->cur_frame.skip_mode_frame_idx[0] =
307  AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);
308  s->cur_frame.skip_mode_frame_idx[1] =
309  AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);
310  return;
311  }
312 
313  second_forward_idx = -1;
314  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
315  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
316  if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {
317  if (second_forward_idx < 0 ||
318  get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {
319  second_forward_idx = i;
320  second_forward_hint = ref_hint;
321  }
322  }
323  }
324 
325  if (second_forward_idx < 0)
326  return;
327 
328  s->cur_frame.skip_mode_frame_idx[0] =
329  AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);
330  s->cur_frame.skip_mode_frame_idx[1] =
331  AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);
332 }
333 
335 {
336  const AV1RawFrameHeader *header = s->raw_frame_header;
337  int i;
338 
339  if (header->delta_q_y_dc || header->delta_q_u_ac ||
340  header->delta_q_u_dc || header->delta_q_v_ac ||
341  header->delta_q_v_dc) {
342  s->cur_frame.coded_lossless = 0;
343  return;
344  }
345 
346  s->cur_frame.coded_lossless = 1;
347  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
348  int qindex;
349  if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
350  qindex = (header->base_q_idx +
351  header->feature_value[i][AV1_SEG_LVL_ALT_Q]);
352  } else {
353  qindex = header->base_q_idx;
354  }
355  qindex = av_clip_uintp2(qindex, 8);
356 
357  if (qindex) {
358  s->cur_frame.coded_lossless = 0;
359  return;
360  }
361  }
362 }
363 
365 {
366  const AV1RawFrameHeader *header = s->raw_frame_header;
367  const AV1RawSequenceHeader *seq = s->raw_seq;
368  AV1Frame *frame = &s->cur_frame;
369 
370  frame->order_hint = header->order_hint;
371 
372  for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
373  int ref_name = i + AV1_REF_FRAME_LAST;
374  int ref_slot = header->ref_frame_idx[i];
375  int ref_order_hint = s->ref[ref_slot].order_hint;
376 
377  frame->order_hints[ref_name] = ref_order_hint;
378  if (!seq->enable_order_hint) {
379  frame->ref_frame_sign_bias[ref_name] = 0;
380  } else {
381  frame->ref_frame_sign_bias[ref_name] =
382  get_relative_dist(seq, ref_order_hint,
383  frame->order_hint) > 0;
384  }
385  }
386 }
387 
389 {
390  const AV1RawFrameHeader *header = s->raw_frame_header;
391  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
392  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
393 
394  if (!film_grain->apply_grain)
395  return;
396 
397  if (film_grain->update_grain) {
398  memcpy(dst, film_grain, sizeof(*dst));
399  return;
400  }
401 
402  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
403 
404  memcpy(dst, src, sizeof(*dst));
405  dst->grain_seed = film_grain->grain_seed;
406 }
407 
409 
410 {
411  int cur_tile_num =
412  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
413  if (s->tile_num < cur_tile_num) {
414  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
415  sizeof(TileGroupInfo));
416  if (ret < 0) {
417  s->tile_num = 0;
418  return ret;
419  }
420  }
421  s->tile_num = cur_tile_num;
422 
423  return 0;
424 }
425 
426 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
427 {
428  AV1DecContext *s = avctx->priv_data;
429  GetByteContext gb;
430  uint16_t tile_num, tile_row, tile_col;
431  uint32_t size = 0, size_bytes = 0;
432 
433  bytestream2_init(&gb, tile_group->tile_data.data,
434  tile_group->tile_data.data_size);
435  s->tg_start = tile_group->tg_start;
436  s->tg_end = tile_group->tg_end;
437 
438  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
439  tile_row = tile_num / s->raw_frame_header->tile_cols;
440  tile_col = tile_num % s->raw_frame_header->tile_cols;
441 
442  if (tile_num == tile_group->tg_end) {
443  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
444  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
445  s->tile_group_info[tile_num].tile_row = tile_row;
446  s->tile_group_info[tile_num].tile_column = tile_col;
447  return 0;
448  }
449  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
450  if (bytestream2_get_bytes_left(&gb) < size_bytes)
451  return AVERROR_INVALIDDATA;
452  size = 0;
453  for (int i = 0; i < size_bytes; i++)
454  size |= bytestream2_get_byteu(&gb) << 8 * i;
455  if (bytestream2_get_bytes_left(&gb) <= size)
456  return AVERROR_INVALIDDATA;
457  size++;
458 
459  s->tile_group_info[tile_num].tile_size = size;
460  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
461  s->tile_group_info[tile_num].tile_row = tile_row;
462  s->tile_group_info[tile_num].tile_column = tile_col;
463 
464  bytestream2_skipu(&gb, size);
465  }
466 
467  return 0;
468 
469 }
470 
471 static enum AVPixelFormat get_sw_pixel_format(void *logctx,
472  const AV1RawSequenceHeader *seq)
473 {
474  int bit_depth;
476 
477  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
478  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
479  else if (seq->seq_profile <= 2)
480  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
481  else {
482  av_log(logctx, AV_LOG_ERROR,
483  "Unknown AV1 profile %d.\n", seq->seq_profile);
484  return AV_PIX_FMT_NONE;
485  }
486 
487  if (!seq->color_config.mono_chrome) {
488  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
489  if (seq->color_config.subsampling_x == 0 &&
490  seq->color_config.subsampling_y == 0) {
491  if (bit_depth == 8)
493  else if (bit_depth == 10)
495  else if (bit_depth == 12)
497  else
498  av_assert0(0);
499  } else if (seq->color_config.subsampling_x == 1 &&
500  seq->color_config.subsampling_y == 0) {
501  if (bit_depth == 8)
503  else if (bit_depth == 10)
505  else if (bit_depth == 12)
507  else
508  av_assert0(0);
509  } else if (seq->color_config.subsampling_x == 1 &&
510  seq->color_config.subsampling_y == 1) {
511  if (bit_depth == 8)
513  else if (bit_depth == 10)
515  else if (bit_depth == 12)
517  else
518  av_assert0(0);
519  }
520  } else {
521  if (bit_depth == 8)
523  else if (bit_depth == 10)
525  else if (bit_depth == 12)
527  else
528  av_assert0(0);
529  }
530 
531  return pix_fmt;
532 }
533 
535 {
536  AV1DecContext *s = avctx->priv_data;
537  const AV1RawSequenceHeader *seq = s->raw_seq;
538  int ret;
539  enum AVPixelFormat pix_fmt = get_sw_pixel_format(avctx, seq);
540 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
541  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
542  CONFIG_AV1_D3D12VA_HWACCEL + \
543  CONFIG_AV1_NVDEC_HWACCEL + \
544  CONFIG_AV1_VAAPI_HWACCEL + \
545  CONFIG_AV1_VDPAU_HWACCEL + \
546  CONFIG_AV1_VIDEOTOOLBOX_HWACCEL + \
547  CONFIG_AV1_VULKAN_HWACCEL)
548  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
549 
550  if (pix_fmt == AV_PIX_FMT_NONE)
551  return -1;
552 
553  switch (pix_fmt) {
554  case AV_PIX_FMT_YUV420P:
555 #if CONFIG_AV1_DXVA2_HWACCEL
556  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
557 #endif
558 #if CONFIG_AV1_D3D11VA_HWACCEL
559  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
560  *fmtp++ = AV_PIX_FMT_D3D11;
561 #endif
562 #if CONFIG_AV1_D3D12VA_HWACCEL
563  *fmtp++ = AV_PIX_FMT_D3D12;
564 #endif
565 #if CONFIG_AV1_NVDEC_HWACCEL
566  *fmtp++ = AV_PIX_FMT_CUDA;
567 #endif
568 #if CONFIG_AV1_VAAPI_HWACCEL
569  *fmtp++ = AV_PIX_FMT_VAAPI;
570 #endif
571 #if CONFIG_AV1_VDPAU_HWACCEL
572  *fmtp++ = AV_PIX_FMT_VDPAU;
573 #endif
574 #if CONFIG_AV1_VIDEOTOOLBOX_HWACCEL
575  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
576 #endif
577 #if CONFIG_AV1_VULKAN_HWACCEL
578  *fmtp++ = AV_PIX_FMT_VULKAN;
579 #endif
580  break;
582 #if CONFIG_AV1_DXVA2_HWACCEL
583  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
584 #endif
585 #if CONFIG_AV1_D3D11VA_HWACCEL
586  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
587  *fmtp++ = AV_PIX_FMT_D3D11;
588 #endif
589 #if CONFIG_AV1_D3D12VA_HWACCEL
590  *fmtp++ = AV_PIX_FMT_D3D12;
591 #endif
592 #if CONFIG_AV1_NVDEC_HWACCEL
593  *fmtp++ = AV_PIX_FMT_CUDA;
594 #endif
595 #if CONFIG_AV1_VAAPI_HWACCEL
596  *fmtp++ = AV_PIX_FMT_VAAPI;
597 #endif
598 #if CONFIG_AV1_VDPAU_HWACCEL
599  *fmtp++ = AV_PIX_FMT_VDPAU;
600 #endif
601 #if CONFIG_AV1_VIDEOTOOLBOX_HWACCEL
602  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
603 #endif
604 #if CONFIG_AV1_VULKAN_HWACCEL
605  *fmtp++ = AV_PIX_FMT_VULKAN;
606 #endif
607  break;
609 #if CONFIG_AV1_VULKAN_HWACCEL
610  *fmtp++ = AV_PIX_FMT_VULKAN;
611 #endif
612  break;
613  case AV_PIX_FMT_YUV422P:
614 #if CONFIG_AV1_VULKAN_HWACCEL
615  *fmtp++ = AV_PIX_FMT_VULKAN;
616 #endif
617  break;
619 #if CONFIG_AV1_VULKAN_HWACCEL
620  *fmtp++ = AV_PIX_FMT_VULKAN;
621 #endif
622  break;
624 #if CONFIG_AV1_VULKAN_HWACCEL
625  *fmtp++ = AV_PIX_FMT_VULKAN;
626 #endif
627  break;
628  case AV_PIX_FMT_YUV444P:
629 #if CONFIG_AV1_VULKAN_HWACCEL
630  *fmtp++ = AV_PIX_FMT_VULKAN;
631 #endif
632  break;
634 #if CONFIG_AV1_VULKAN_HWACCEL
635  *fmtp++ = AV_PIX_FMT_VULKAN;
636 #endif
637  break;
639 #if CONFIG_AV1_VULKAN_HWACCEL
640  *fmtp++ = AV_PIX_FMT_VULKAN;
641 #endif
642  break;
643  case AV_PIX_FMT_GRAY8:
644 #if CONFIG_AV1_NVDEC_HWACCEL
645  *fmtp++ = AV_PIX_FMT_CUDA;
646 #endif
647  break;
648  case AV_PIX_FMT_GRAY10:
649 #if CONFIG_AV1_NVDEC_HWACCEL
650  *fmtp++ = AV_PIX_FMT_CUDA;
651 #endif
652  break;
653  }
654 
655  *fmtp++ = pix_fmt;
656  *fmtp = AV_PIX_FMT_NONE;
657 
658  for (int i = 0; pix_fmts[i] != pix_fmt; i++)
659  if (pix_fmts[i] == avctx->pix_fmt) {
660  s->pix_fmt = pix_fmt;
661  return 1;
662  }
663 
664  ret = ff_get_format(avctx, pix_fmts);
665 
666  /**
667  * check if the HW accel is inited correctly. If not, return un-implemented.
668  * Since now the av1 decoder doesn't support native decode, if it will be
669  * implemented in the future, need remove this check.
670  */
671  if (!avctx->hwaccel) {
672  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"
673  " hardware accelerated AV1 decoding.\n");
674  avctx->pix_fmt = AV_PIX_FMT_NONE;
675  return AVERROR(ENOSYS);
676  }
677 
678  s->pix_fmt = pix_fmt;
679  avctx->pix_fmt = ret;
680 
681  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
682  av_get_pix_fmt_name(avctx->pix_fmt));
683 
684  return 0;
685 }
686 
688 {
690  ff_refstruct_unref(&f->hwaccel_picture_private);
691  ff_refstruct_unref(&f->header_ref);
692  f->raw_frame_header = NULL;
693  f->spatial_id = f->temporal_id = 0;
694  memset(f->skip_mode_frame_idx, 0,
695  2 * sizeof(uint8_t));
696  memset(&f->film_grain, 0, sizeof(f->film_grain));
697  f->coded_lossless = 0;
698 }
699 
701 {
702  av_assert1(dst != src);
703 
704  ff_refstruct_replace(&dst->header_ref, src->header_ref);
705 
706  dst->raw_frame_header = src->raw_frame_header;
707 
708  ff_progress_frame_replace(&dst->pf, &src->pf);
709 
710  ff_refstruct_replace(&dst->hwaccel_picture_private,
711  src->hwaccel_picture_private);
712 
713  dst->spatial_id = src->spatial_id;
714  dst->temporal_id = src->temporal_id;
715  memcpy(dst->gm_invalid,
716  src->gm_invalid,
717  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
718  memcpy(dst->gm_type,
719  src->gm_type,
720  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
721  memcpy(dst->gm_params,
722  src->gm_params,
723  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
724  memcpy(dst->skip_mode_frame_idx,
725  src->skip_mode_frame_idx,
726  2 * sizeof(uint8_t));
727  memcpy(&dst->film_grain,
728  &src->film_grain,
729  sizeof(dst->film_grain));
730  dst->coded_lossless = src->coded_lossless;
731 
732  dst->order_hint = src->order_hint;
733  memcpy(dst->ref_frame_sign_bias, src->ref_frame_sign_bias,
734  sizeof(dst->ref_frame_sign_bias));
735  memcpy(dst->order_hints, src->order_hints,
736  sizeof(dst->order_hints));
737 
738  dst->force_integer_mv = src->force_integer_mv;
739 }
740 
742 {
743  AV1DecContext *s = avctx->priv_data;
744  AV1RawMetadataITUTT35 itut_t35;
745 
746  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
747  av1_frame_unref(&s->ref[i]);
748  av1_frame_unref(&s->cur_frame);
749  av_buffer_unref(&s->seq_data_ref);
750  ff_refstruct_unref(&s->seq_ref);
751  ff_refstruct_unref(&s->header_ref);
752  ff_refstruct_unref(&s->cll_ref);
753  ff_refstruct_unref(&s->mdcv_ref);
754  av_freep(&s->tile_group_info);
755 
756  while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
757  av_buffer_unref(&itut_t35.payload_ref);
758  av_fifo_freep2(&s->itut_t35_fifo);
759 
760  ff_cbs_fragment_free(&s->current_obu);
761  ff_cbs_close(&s->cbc);
762  ff_dovi_ctx_unref(&s->dovi);
763 
764  return 0;
765 }
766 
768  const AV1RawSequenceHeader *seq)
769 {
770  int width = seq->max_frame_width_minus_1 + 1;
771  int height = seq->max_frame_height_minus_1 + 1;
772 
773  avctx->profile = seq->seq_profile;
774  avctx->level = seq->seq_level_idx[0];
775 
776  avctx->color_range =
781 
782  switch (seq->color_config.chroma_sample_position) {
783  case AV1_CSP_VERTICAL:
785  break;
786  case AV1_CSP_COLOCATED:
788  break;
789  }
790 
791  if (seq->film_grain_params_present)
793  else
795 
796  if (avctx->width != width || avctx->height != height) {
797  int ret = ff_set_dimensions(avctx, width, height);
798  if (ret < 0)
799  return ret;
800  }
801 
802  if (seq->timing_info_present_flag)
805  seq->timing_info.time_scale);
806 
807  if (avctx->pix_fmt == AV_PIX_FMT_NONE)
808  avctx->pix_fmt = get_sw_pixel_format(avctx, seq);
809 
810  return 0;
811 }
812 
814  const AV1RawFrameHeader *header)
815 {
816  AVRational aspect_ratio;
817  int width = header->frame_width_minus_1 + 1;
818  int height = header->frame_height_minus_1 + 1;
819  int r_width = header->render_width_minus_1 + 1;
820  int r_height = header->render_height_minus_1 + 1;
821  int ret;
822 
823  if (avctx->width != width || avctx->height != height) {
824  ret = ff_set_dimensions(avctx, width, height);
825  if (ret < 0)
826  return ret;
827  }
828 
829  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
830  (int64_t)height * r_width,
831  (int64_t)width * r_height,
832  INT_MAX);
833 
834  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
835  ret = ff_set_sar(avctx, aspect_ratio);
836  if (ret < 0)
837  return ret;
838  }
839 
840  return 0;
841 }
842 
851 };
852 
854 {
855  AV1DecContext *s = avctx->priv_data;
857  const AVPacketSideData *sd;
858  int ret;
859 
860  s->avctx = avctx;
861  s->pkt = avctx->internal->in_pkt;
862  s->pix_fmt = AV_PIX_FMT_NONE;
863 
864  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
865  if (ret < 0)
866  return ret;
867 
868  s->cbc->decompose_unit_types = decompose_unit_types;
869  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);
870 
871  s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),
873  if (!s->itut_t35_fifo)
874  return AVERROR(ENOMEM);
875 
876  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
877 
878  if (avctx->extradata && avctx->extradata_size) {
880  &s->current_obu,
881  avctx);
882  if (ret < 0) {
883  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
884  goto end;
885  }
886 
887  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
888  if (!seq) {
889  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
890  goto end;
891  }
892 
893  ret = set_context_with_sequence(avctx, seq);
894  if (ret < 0) {
895  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
896  goto end;
897  }
898 
899  end:
900  ff_cbs_fragment_reset(&s->current_obu);
901  }
902 
903  s->dovi.logctx = avctx;
904  s->dovi.cfg.dv_profile = 10; // default for AV1
906  if (sd && sd->size >= sizeof(s->dovi.cfg))
907  s->dovi.cfg = *(AVDOVIDecoderConfigurationRecord *) sd->data;
908 
909  return ret;
910 }
911 
913 {
914  AV1DecContext *s = avctx->priv_data;
915  AV1RawFrameHeader *header= s->raw_frame_header;
916  AVFrame *frame;
917  int ret;
918 
920  if (ret < 0) {
921  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
922  return ret;
923  }
924 
926  if (ret < 0)
927  goto fail;
928 
929  frame = f->f;
930  if (header->frame_type == AV1_FRAME_KEY)
931  frame->flags |= AV_FRAME_FLAG_KEY;
932  else
933  frame->flags &= ~AV_FRAME_FLAG_KEY;
934 
935  switch (header->frame_type) {
936  case AV1_FRAME_KEY:
938  frame->pict_type = AV_PICTURE_TYPE_I;
939  break;
940  case AV1_FRAME_INTER:
941  frame->pict_type = AV_PICTURE_TYPE_P;
942  break;
943  case AV1_FRAME_SWITCH:
944  frame->pict_type = AV_PICTURE_TYPE_SP;
945  break;
946  }
947 
948  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
949  if (ret < 0)
950  goto fail;
951 
952  return 0;
953 
954 fail:
956  return ret;
957 }
958 
960  const AV1RawMetadataITUTT35 *itut_t35)
961 {
962  GetByteContext gb;
963  AV1DecContext *s = avctx->priv_data;
964  int ret, provider_code;
965 
966  bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);
967 
968  provider_code = bytestream2_get_be16(&gb);
969  switch (provider_code) {
971  uint32_t user_identifier = bytestream2_get_be32(&gb);
972  switch (user_identifier) {
973  case MKBETAG('G', 'A', '9', '4'): { // closed captions
974  AVBufferRef *buf = NULL;
975 
977  if (ret < 0)
978  return ret;
979  if (!ret)
980  break;
981 
983  if (ret < 0)
984  return ret;
985 
987  break;
988  }
989  default: // ignore unsupported identifiers
990  break;
991  }
992  break;
993  }
995  AVDynamicHDRPlus *hdrplus;
996  int provider_oriented_code = bytestream2_get_be16(&gb);
997  int application_identifier = bytestream2_get_byte(&gb);
998 
1000  provider_oriented_code != 1 || application_identifier != 4)
1001  break;
1002 
1004  if (!hdrplus)
1005  return AVERROR(ENOMEM);
1006 
1007  ret = av_dynamic_hdr_plus_from_t35(hdrplus, gb.buffer,
1009  if (ret < 0)
1010  return ret;
1011  break;
1012  }
1014  int provider_oriented_code = bytestream2_get_be32(&gb);
1016  provider_oriented_code != 0x800)
1017  break;
1018 
1019  ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer,
1020  avctx->err_recognition);
1021  if (ret < 0) {
1022  av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
1023  break; // ignore
1024  }
1025 
1026  ret = ff_dovi_attach_side_data(&s->dovi, frame);
1027  if (ret < 0)
1028  return ret;
1029  break;
1030  }
1031  default: // ignore unsupported provider codes
1032  break;
1033  }
1034 
1035  return 0;
1036 }
1037 
1039 {
1040  AV1DecContext *s = avctx->priv_data;
1041  AV1RawMetadataITUTT35 itut_t35;
1042  int ret = 0;
1043 
1044  if (s->mdcv) {
1045  AVMasteringDisplayMetadata *mastering;
1046 
1047  ret = ff_decode_mastering_display_new(avctx, frame, &mastering);
1048  if (ret < 0)
1049  return ret;
1050 
1051  if (mastering) {
1052  for (int i = 0; i < 3; i++) {
1053  mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);
1054  mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);
1055  }
1056  mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);
1057  mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);
1058 
1059  mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);
1060  mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);
1061 
1062  mastering->has_primaries = 1;
1063  mastering->has_luminance = 1;
1064  }
1065  }
1066 
1067  if (s->cll) {
1068  AVContentLightMetadata *light;
1069 
1070  ret = ff_decode_content_light_new(avctx, frame, &light);
1071  if (ret < 0)
1072  return ret;
1073 
1074  if (light) {
1075  light->MaxCLL = s->cll->max_cll;
1076  light->MaxFALL = s->cll->max_fall;
1077  }
1078  }
1079 
1080  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {
1081  if (ret >= 0)
1082  ret = export_itut_t35(avctx, frame, &itut_t35);
1083  av_buffer_unref(&itut_t35.payload_ref);
1084  }
1085 
1086  return ret;
1087 }
1088 
1090 {
1091  AV1DecContext *s = avctx->priv_data;
1092  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
1093  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(frame->format);
1094  AVFilmGrainParams *fgp;
1095  AVFilmGrainAOMParams *aom;
1096 
1097  av_assert0(pixdesc);
1098  if (!film_grain->apply_grain)
1099  return 0;
1100 
1102  if (!fgp)
1103  return AVERROR(ENOMEM);
1104 
1106  fgp->seed = film_grain->grain_seed;
1107  fgp->width = frame->width;
1108  fgp->height = frame->height;
1109  fgp->color_range = frame->color_range;
1110  fgp->color_primaries = frame->color_primaries;
1111  fgp->color_trc = frame->color_trc;
1112  fgp->color_space = frame->colorspace;
1113  fgp->subsampling_x = pixdesc->log2_chroma_w;
1114  fgp->subsampling_y = pixdesc->log2_chroma_h;
1115 
1116  aom = &fgp->codec.aom;
1118  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
1119  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
1120  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
1121  aom->grain_scale_shift = film_grain->grain_scale_shift;
1122  aom->overlap_flag = film_grain->overlap_flag;
1123  aom->limit_output_range = film_grain->clip_to_restricted_range;
1124 
1125  aom->num_y_points = film_grain->num_y_points;
1126  for (int i = 0; i < film_grain->num_y_points; i++) {
1127  aom->y_points[i][0] = film_grain->point_y_value[i];
1128  aom->y_points[i][1] = film_grain->point_y_scaling[i];
1129  }
1130  aom->num_uv_points[0] = film_grain->num_cb_points;
1131  for (int i = 0; i < film_grain->num_cb_points; i++) {
1132  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
1133  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
1134  }
1135  aom->num_uv_points[1] = film_grain->num_cr_points;
1136  for (int i = 0; i < film_grain->num_cr_points; i++) {
1137  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
1138  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
1139  }
1140 
1141  for (int i = 0; i < 24; i++) {
1142  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
1143  }
1144  for (int i = 0; i < 25; i++) {
1145  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
1146  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
1147  }
1148 
1149  aom->uv_mult[0] = film_grain->cb_mult;
1150  aom->uv_mult[1] = film_grain->cr_mult;
1151  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
1152  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
1153  aom->uv_offset[0] = film_grain->cb_offset;
1154  aom->uv_offset[1] = film_grain->cr_offset;
1155 
1156  return 0;
1157 }
1158 
1160 {
1161  AV1DecContext *s = avctx->priv_data;
1162  const AVFrame *srcframe = s->cur_frame.f;
1163  AVPacket *pkt = s->pkt;
1164  int ret;
1165 
1166  // TODO: all layers
1167  if (s->operating_point_idc &&
1168  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
1169  return 0;
1170 
1171  ret = av_frame_ref(frame, srcframe);
1172  if (ret < 0)
1173  return ret;
1174 
1175  ret = export_metadata(avctx, frame);
1176  if (ret < 0) {
1178  return ret;
1179  }
1180 
1182  ret = export_film_grain(avctx, frame);
1183  if (ret < 0) {
1185  return ret;
1186  }
1187  }
1188 
1189  frame->pts = pkt->pts;
1190  frame->pkt_dts = pkt->dts;
1191 #if FF_API_FRAME_PKT
1193  frame->pkt_size = pkt->size;
1194  frame->pkt_pos = pkt->pos;
1196 #endif
1197 
1199 
1200  return 0;
1201 }
1202 
1204 {
1205  AV1DecContext *s = avctx->priv_data;
1206  const AV1RawFrameHeader *header = s->raw_frame_header;
1207 
1208  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1209  if (header->refresh_frame_flags & (1 << i))
1210  av1_frame_replace(&s->ref[i], &s->cur_frame);
1211  }
1212 }
1213 
1215 {
1216  AV1DecContext *s = avctx->priv_data;
1217  int ret;
1218 
1219  av1_frame_unref(&s->cur_frame);
1220 
1221  s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
1222 
1223  s->cur_frame.raw_frame_header = s->raw_frame_header;
1224 
1225  ret = init_tile_data(s);
1226  if (ret < 0) {
1227  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
1228  return ret;
1229  }
1230 
1231  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
1232  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
1233  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
1234  (avctx->skip_frame >= AVDISCARD_NONKEY &&
1235  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
1236  avctx->skip_frame >= AVDISCARD_ALL)
1237  return 0;
1238 
1239  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1240  ret = get_pixel_format(avctx);
1241  if (ret < 0) {
1242  av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format.\n");
1243  return ret;
1244  }
1245 
1246  if (!ret && FF_HW_HAS_CB(avctx, decode_params)) {
1247  ret = FF_HW_CALL(avctx, decode_params, AV1_OBU_SEQUENCE_HEADER,
1248  s->seq_data_ref->data, s->seq_data_ref->size);
1249  if (ret < 0) {
1250  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1251  return ret;
1252  }
1253  }
1254  }
1255 
1256  ret = av1_frame_alloc(avctx, &s->cur_frame);
1257  if (ret < 0) {
1258  av_log(avctx, AV_LOG_ERROR,
1259  "Failed to allocate space for current frame.\n");
1260  return ret;
1261  }
1262 
1266  order_hint_info(s);
1268 
1269  s->cur_frame.force_integer_mv =
1270  s->raw_frame_header->force_integer_mv ||
1271  s->raw_frame_header->frame_type == AV1_FRAME_KEY ||
1272  s->raw_frame_header->frame_type == AV1_FRAME_INTRA_ONLY;
1273 
1274  return ret;
1275 }
1276 
1278 {
1279  AV1DecContext *s = avctx->priv_data;
1280  AV1RawTileGroup *raw_tile_group = NULL;
1281  int i = 0, ret;
1282 
1283  for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {
1284  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1285  AV1RawOBU *obu = unit->content;
1286  const AV1RawOBUHeader *header;
1287 
1288  av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu);
1289 
1290  if (unit->type == AV1_OBU_TILE_LIST) {
1291  av_log(avctx, AV_LOG_ERROR, "Large scale tile decoding is unsupported.\n");
1293  goto end;
1294  }
1295 
1296  if (!obu)
1297  continue;
1298 
1299  header = &obu->header;
1300 
1301  switch (unit->type) {
1303  ret = av_buffer_replace(&s->seq_data_ref, unit->data_ref);
1304  if (ret < 0)
1305  goto end;
1306 
1307  s->seq_data_ref->data = unit->data;
1308  s->seq_data_ref->size = unit->data_size;
1309  ff_refstruct_replace(&s->seq_ref, unit->content_ref);
1310 
1311  s->raw_seq = &obu->obu.sequence_header;
1312 
1313  ret = set_context_with_sequence(avctx, s->raw_seq);
1314  if (ret < 0) {
1315  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1316  s->raw_seq = NULL;
1317  goto end;
1318  }
1319 
1320  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1321 
1322  s->pix_fmt = AV_PIX_FMT_NONE;
1323 
1324  break;
1326  if (s->raw_frame_header)
1327  break;
1328  // fall-through
1329  case AV1_OBU_FRAME:
1330  case AV1_OBU_FRAME_HEADER:
1331  if (!s->raw_seq) {
1332  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1334  goto end;
1335  }
1336 
1337  ff_refstruct_replace(&s->header_ref, unit->content_ref);
1338 
1339  if (unit->type == AV1_OBU_FRAME)
1340  s->raw_frame_header = &obu->obu.frame.header;
1341  else
1342  s->raw_frame_header = &obu->obu.frame_header;
1343 
1344  if (s->raw_frame_header->show_existing_frame) {
1345  av1_frame_replace(&s->cur_frame,
1346  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1347 
1348  update_reference_list(avctx);
1349 
1350  if (s->cur_frame.f) {
1351  ret = set_output_frame(avctx, frame);
1352  if (ret < 0) {
1353  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1354  goto end;
1355  }
1356  }
1357 
1358  s->raw_frame_header = NULL;
1359  i++;
1360  ret = 0;
1361 
1362  goto end;
1363  }
1364 
1365  ret = get_current_frame(avctx);
1366  if (ret < 0) {
1367  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1368  goto end;
1369  }
1370 
1371  s->cur_frame.spatial_id = header->spatial_id;
1372  s->cur_frame.temporal_id = header->temporal_id;
1373 
1374  if (avctx->hwaccel && s->cur_frame.f) {
1375  ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);
1376  if (ret < 0) {
1377  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1378  goto end;
1379  }
1380  }
1381  if (unit->type != AV1_OBU_FRAME)
1382  break;
1383  // fall-through
1384  case AV1_OBU_TILE_GROUP:
1385  if (!s->raw_frame_header) {
1386  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1388  goto end;
1389  }
1390 
1391  if (unit->type == AV1_OBU_FRAME)
1392  raw_tile_group = &obu->obu.frame.tile_group;
1393  else
1394  raw_tile_group = &obu->obu.tile_group;
1395 
1396  ret = get_tiles_info(avctx, raw_tile_group);
1397  if (ret < 0)
1398  goto end;
1399 
1400  if (avctx->hwaccel && s->cur_frame.f) {
1401  ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,
1402  raw_tile_group->tile_data.data_size);
1403  if (ret < 0) {
1404  av_log(avctx, AV_LOG_ERROR,
1405  "HW accel decode slice fail.\n");
1406  goto end;
1407  }
1408  }
1409  break;
1410  case AV1_OBU_TILE_LIST:
1412  case AV1_OBU_PADDING:
1413  break;
1414  case AV1_OBU_METADATA:
1415  switch (obu->obu.metadata.metadata_type) {
1417  ff_refstruct_replace(&s->cll_ref, unit->content_ref);
1418  s->cll = &obu->obu.metadata.metadata.hdr_cll;
1419  break;
1421  ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
1422  s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
1423  break;
1425  AV1RawMetadataITUTT35 itut_t35;
1426  memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));
1428  if (!itut_t35.payload_ref) {
1429  ret = AVERROR(ENOMEM);
1430  goto end;
1431  }
1432  ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);
1433  if (ret < 0) {
1434  av_buffer_unref(&itut_t35.payload_ref);
1435  goto end;
1436  }
1437  break;
1438  }
1439  default:
1440  break;
1441  }
1442  break;
1443  default:
1444  av_log(avctx, AV_LOG_DEBUG,
1445  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1446  unit->type, unit->data_size);
1447  }
1448 
1449  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1450  int show_frame = s->raw_frame_header->show_frame;
1451  // Set nb_unit to point at the next OBU, to indicate which
1452  // OBUs have been processed for this current frame. (If this
1453  // frame gets output, we set nb_unit to this value later too.)
1454  s->nb_unit = i + 1;
1455  if (avctx->hwaccel && s->cur_frame.f) {
1456  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
1457  if (ret < 0) {
1458  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1459  goto end;
1460  }
1461  }
1462 
1463  update_reference_list(avctx);
1464 
1465  // Set start_unit to indicate the first OBU of the next frame.
1466  s->start_unit = s->nb_unit;
1467  raw_tile_group = NULL;
1468  s->raw_frame_header = NULL;
1469 
1470  if (show_frame) {
1471  // cur_frame.f needn't exist due to skip_frame.
1472  if (s->cur_frame.f) {
1473  ret = set_output_frame(avctx, frame);
1474  if (ret < 0) {
1475  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1476  goto end;
1477  }
1478  }
1479  i++;
1480  ret = 0;
1481  goto end;
1482  }
1483  }
1484  }
1485 
1486  ret = AVERROR(EAGAIN);
1487 end:
1488  av_assert0(i <= s->current_obu.nb_units);
1489  s->nb_unit = i;
1490 
1491  if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {
1492  if (ret < 0)
1493  s->raw_frame_header = NULL;
1494  av_packet_unref(s->pkt);
1495  ff_cbs_fragment_reset(&s->current_obu);
1496  s->nb_unit = s->start_unit = 0;
1497  }
1498  if (!ret && !frame->buf[0])
1499  ret = AVERROR(EAGAIN);
1500 
1501  return ret;
1502 }
1503 
1505 {
1506  AV1DecContext *s = avctx->priv_data;
1507  int ret;
1508 
1509  do {
1510  if (!s->current_obu.nb_units) {
1511  ret = ff_decode_get_packet(avctx, s->pkt);
1512  if (ret < 0)
1513  return ret;
1514 
1515  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);
1516  if (ret < 0) {
1517  ff_cbs_fragment_reset(&s->current_obu);
1518  av_packet_unref(s->pkt);
1519  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1520  return ret;
1521  }
1522 
1523  s->nb_unit = s->start_unit = 0;
1524  av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",
1525  s->current_obu.nb_units);
1526  }
1527 
1529  } while (ret == AVERROR(EAGAIN));
1530 
1531  return ret;
1532 }
1533 
1535 {
1536  AV1DecContext *s = avctx->priv_data;
1537  AV1RawMetadataITUTT35 itut_t35;
1538 
1539  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1540  av1_frame_unref(&s->ref[i]);
1541 
1542  av1_frame_unref(&s->cur_frame);
1543  s->operating_point_idc = 0;
1544  s->nb_unit = s->start_unit = 0;
1545  s->raw_frame_header = NULL;
1546  s->raw_seq = NULL;
1547  s->cll = NULL;
1548  s->mdcv = NULL;
1549  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
1550  av_buffer_unref(&itut_t35.payload_ref);
1551 
1552  ff_cbs_fragment_reset(&s->current_obu);
1553  ff_cbs_flush(s->cbc);
1554 
1555  if (FF_HW_HAS_CB(avctx, flush))
1556  FF_HW_SIMPLE_CALL(avctx, flush);
1557 }
1558 
1559 #define OFFSET(x) offsetof(AV1DecContext, x)
1560 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1561 static const AVOption av1_options[] = {
1562  { "operating_point", "Select an operating point of the scalable bitstream",
1563  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1564  { NULL }
1565 };
1566 
1567 static const AVClass av1_class = {
1568  .class_name = "AV1 decoder",
1569  .item_name = av_default_item_name,
1570  .option = av1_options,
1571  .version = LIBAVUTIL_VERSION_INT,
1572 };
1573 
1575  .p.name = "av1",
1576  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1577  .p.type = AVMEDIA_TYPE_VIDEO,
1578  .p.id = AV_CODEC_ID_AV1,
1579  .priv_data_size = sizeof(AV1DecContext),
1580  .init = av1_decode_init,
1581  .close = av1_decode_free,
1583  .p.capabilities = AV_CODEC_CAP_DR1,
1584  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1587  .flush = av1_decode_flush,
1588  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1589  .p.priv_class = &av1_class,
1590  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1591 #if CONFIG_AV1_DXVA2_HWACCEL
1592  HWACCEL_DXVA2(av1),
1593 #endif
1594 #if CONFIG_AV1_D3D11VA_HWACCEL
1595  HWACCEL_D3D11VA(av1),
1596 #endif
1597 #if CONFIG_AV1_D3D11VA2_HWACCEL
1598  HWACCEL_D3D11VA2(av1),
1599 #endif
1600 #if CONFIG_AV1_D3D12VA_HWACCEL
1601  HWACCEL_D3D12VA(av1),
1602 #endif
1603 #if CONFIG_AV1_NVDEC_HWACCEL
1604  HWACCEL_NVDEC(av1),
1605 #endif
1606 #if CONFIG_AV1_VAAPI_HWACCEL
1607  HWACCEL_VAAPI(av1),
1608 #endif
1609 #if CONFIG_AV1_VDPAU_HWACCEL
1610  HWACCEL_VDPAU(av1),
1611 #endif
1612 #if CONFIG_AV1_VIDEOTOOLBOX_HWACCEL
1613  HWACCEL_VIDEOTOOLBOX(av1),
1614 #endif
1615 #if CONFIG_AV1_VULKAN_HWACCEL
1616  HWACCEL_VULKAN(av1),
1617 #endif
1618 
1619  NULL
1620  },
1621 };
update_reference_list
static void update_reference_list(AVCodecContext *avctx)
Definition: av1dec.c:1203
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
ff_get_coded_side_data
const AVPacketSideData * ff_get_coded_side_data(const AVCodecContext *avctx, enum AVPacketSideDataType type)
Get side data of the given type from a decoding context.
Definition: decode.c:1426
hwconfig.h
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
AV1RawTimingInfo::num_units_in_display_tick
uint32_t num_units_in_display_tick
Definition: cbs_av1.h:59
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AV1RawTimingInfo::time_scale
uint32_t time_scale
Definition: cbs_av1.h:60
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1437
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:111
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:248
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
CodedBitstreamUnit::content_ref
void * content_ref
If content is reference counted, a RefStruct reference backing content.
Definition: cbs.h:112
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV1RawColorConfig::color_primaries
uint8_t color_primaries
Definition: cbs_av1.h:47
av1_decode_init
static av_cold int av1_decode_init(AVCodecContext *avctx)
Definition: av1dec.c:853
AV1_OBU_REDUNDANT_FRAME_HEADER
@ AV1_OBU_REDUNDANT_FRAME_HEADER
Definition: av1.h:36
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
AV1RawSequenceHeader::seq_level_idx
uint8_t seq_level_idx[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:87
r
const char * r
Definition: vf_curves.c:127
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
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:266
AV1RawFilmGrainParams::clip_to_restricted_range
uint8_t clip_to_restricted_range
Definition: cbs_av1.h:162
opt.h
ff_dovi_ctx_unref
void ff_dovi_ctx_unref(DOVIContext *s)
Completely reset a DOVIContext, preserving only logctx.
Definition: dovi_rpu.c:29
AV1RawFilmGrainParams::grain_seed
uint16_t grain_seed
Definition: cbs_av1.h:135
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
AV1RawSequenceHeader::timing_info_present_flag
uint8_t timing_info_present_flag
Definition: cbs_av1.h:78
AV1RawSequenceHeader
Definition: cbs_av1.h:73
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1277
order_hint_info
static void order_hint_info(AV1DecContext *s)
Definition: av1dec.c:364
AV1RawColorConfig::color_range
uint8_t color_range
Definition: cbs_av1.h:51
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:63
coded_lossless_param
static void coded_lossless_param(AV1DecContext *s)
Definition: av1dec.c:334
GetByteContext
Definition: bytestream.h:33
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:106
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:912
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1430
AV1RawFilmGrainParams::point_cb_value
uint8_t point_cb_value[10]
Definition: cbs_av1.h:143
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:107
AV1RawFilmGrainParams::apply_grain
uint8_t apply_grain
Definition: cbs_av1.h:134
ff_dovi_rpu_parse
int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size, int err_recognition)
Parse the contents of a Dolby Vision RPU and update the parsed values in the DOVIContext struct.
Definition: dovi_rpudec.c:346
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
int64_t
long long int64_t
Definition: coverity.c:34
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:85
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
get_current_frame
static int get_current_frame(AVCodecContext *avctx)
Definition: av1dec.c:1214
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:260
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:767
w
uint8_t w
Definition: llviddspenc.c:38
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
AV1RawFilmGrainParams::point_y_value
uint8_t point_y_value[14]
Definition: cbs_av1.h:139
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
internal.h
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:122
AVOption
AVOption.
Definition: opt.h:429
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
b
#define b
Definition: input.c:41
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1848
AV1RawSequenceHeader::timing_info
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
high
int high
Definition: dovi_rpuenc.c:38
AVFilmGrainParams::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:282
AV1RawTileGroup::tg_end
uint16_t tg_end
Definition: cbs_av1.h:300
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:254
FFCodec
Definition: codec_internal.h:127
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
AV1_METADATA_TYPE_ITUT_T35
@ AV1_METADATA_TYPE_ITUT_T35
Definition: av1.h:47
decompose_unit_types
static const CodedBitstreamUnitType decompose_unit_types[]
Definition: av1dec.c:843
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV1_OBU_TEMPORAL_DELIMITER
@ AV1_OBU_TEMPORAL_DELIMITER
Definition: av1.h:31
AV1RawTileData::data
uint8_t * data
Definition: cbs_av1.h:292
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
get_relative_dist
static int get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: av1dec.c:258
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
AV1RawOBU::header
AV1RawOBUHeader header
Definition: cbs_av1.h:401
av1_frame_replace
static void av1_frame_replace(AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:700
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:281
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:250
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:74
AV1RawMetadata::itut_t35
AV1RawMetadataITUTT35 itut_t35
Definition: cbs_av1.h:387
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
round_two
static uint64_t round_two(uint64_t x, uint16_t n)
Definition: av1dec.c:141
AV1RawFrame::header
AV1RawFrameHeader header
Definition: cbs_av1.h:306
AV1RawFilmGrainParams::cr_mult
uint8_t cr_mult
Definition: cbs_av1.h:158
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:280
AV1RawFilmGrainParams::chroma_scaling_from_luma
uint8_t chroma_scaling_from_luma
Definition: cbs_av1.h:141
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
AVPacketSideData::size
size_t size
Definition: packet.h:392
AV1RawFilmGrainParams::ar_coeffs_cr_plus_128
uint8_t ar_coeffs_cr_plus_128[25]
Definition: cbs_av1.h:152
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:135
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
av1_parse.h
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:53
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:134
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1561
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1830
fail
#define fail()
Definition: checkasm.h:193
AV1_OBU_FRAME_HEADER
@ AV1_OBU_FRAME_HEADER
Definition: av1.h:32
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
AV1RawFilmGrainParams::point_cr_scaling
uint8_t point_cr_scaling[10]
Definition: cbs_av1.h:147
AV1RawMetadataITUTT35::payload_size
size_t payload_size
Definition: cbs_av1.h:356
inverse_recenter
static uint32_t inverse_recenter(int r, uint32_t v)
Definition: av1dec.c:72
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
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
AV1RawFilmGrainParams::ar_coeff_shift_minus_6
uint8_t ar_coeff_shift_minus_6
Definition: cbs_av1.h:153
CodedBitstreamUnit::data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:81
AV1RawFilmGrainParams::num_y_points
uint8_t num_y_points
Definition: cbs_av1.h:138
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:114
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
round_two_signed
static int64_t round_two_signed(int64_t x, uint16_t n)
Definition: av1dec.c:148
AVRational::num
int num
Numerator.
Definition: rational.h:59
progressframe.h
refstruct.h
ITU_T_T35_PROVIDER_CODE_ATSC
#define ITU_T_T35_PROVIDER_CODE_ATSC
Definition: itut35.h:26
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2137
AVFilmGrainAOMParams
This structure describes how to handle film grain synthesis for AOM codecs.
Definition: film_grain_params.h:44
AV1RawFilmGrainParams::num_cb_points
uint8_t num_cb_points
Definition: cbs_av1.h:142
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
AV1RawFilmGrainParams::cb_luma_mult
uint8_t cb_luma_mult
Definition: cbs_av1.h:156
AV1Frame
Definition: av1dec.h:37
AV1RawFilmGrainParams::overlap_flag
uint8_t overlap_flag
Definition: cbs_av1.h:161
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:69
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2931
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:209
film_grain_params.h
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:117
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVFilmGrainParams::width
int width
Intended display resolution.
Definition: film_grain_params.h:269
AV1RawFilmGrainParams::grain_scaling_minus_8
uint8_t grain_scaling_minus_8
Definition: cbs_av1.h:148
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
global_motion_params
static void global_motion_params(AV1DecContext *s)
update gm type/params, since cbs already implemented part of this function, so we don't need to full ...
Definition: av1dec.c:209
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2251
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:107
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:120
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:431
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
av_film_grain_params_create_side_data
AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)
Allocate a complete AVFilmGrainParams and add it to the frame.
Definition: film_grain_params.c:33
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
av1_decode_free
static av_cold int av1_decode_free(AVCodecContext *avctx)
Definition: av1dec.c:741
AV1RawMetadata::hdr_cll
AV1RawMetadataHDRCLL hdr_cll
Definition: cbs_av1.h:384
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
init_tile_data
static int init_tile_data(AV1DecContext *s)
Definition: av1dec.c:408
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1876
decode.h
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:163
get_sw_pixel_format
static enum AVPixelFormat get_sw_pixel_format(void *logctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:471
AV1RawColorConfig::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_av1.h:48
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
AV1_WARP_PARAM_REDUCE_BITS
@ AV1_WARP_PARAM_REDUCE_BITS
Definition: av1.h:118
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
av1dec.h
get_tiles_info
static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
Definition: av1dec.c:426
export_itut_t35
static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame, const AV1RawMetadataITUTT35 *itut_t35)
Definition: av1dec.c:959
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
ff_decode_mastering_display_new
int ff_decode_mastering_display_new(const AVCodecContext *avctx, AVFrame *frame, AVMasteringDisplayMetadata **mdm)
Wrapper around av_mastering_display_metadata_create_side_data(), which rejects side data overridden b...
Definition: decode.c:2178
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1809
load_grain_params
static void load_grain_params(AV1DecContext *s)
Definition: av1dec.c:388
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:483
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1574
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
ff_parse_a53_cc
int ff_parse_a53_cc(AVBufferRef **pbuf, const uint8_t *data, int size)
Parse a data array for ATSC A53 Part 4 Closed Captions and store them in an AVBufferRef.
Definition: atsc_a53.c:69
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
AV1RawOBU
Definition: cbs_av1.h:400
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:108
av_clip_int16
#define av_clip_int16
Definition: common.h:115
HWACCEL_MAX
#define HWACCEL_MAX
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV1RawFilmGrainParams::cb_mult
uint8_t cb_mult
Definition: cbs_av1.h:155
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
hwaccel_internal.h
AV1RawFrameHeader
Definition: cbs_av1.h:165
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:738
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:740
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
AV1RawTileData::data_size
size_t data_size
Definition: cbs_av1.h:294
av1_frame_unref
static void av1_frame_unref(AV1Frame *f)
Definition: av1dec.c:687
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
AV1RawColorConfig::chroma_sample_position
uint8_t chroma_sample_position
Definition: cbs_av1.h:54
profiles.h
CodedBitstreamUnit::data_size
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:86
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:109
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
AV1_OBU_TILE_GROUP
@ AV1_OBU_TILE_GROUP
Definition: av1.h:33
update_context_with_frame_header
static int update_context_with_frame_header(AVCodecContext *avctx, const AV1RawFrameHeader *header)
Definition: av1dec.c:813
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
skip_mode_params
static void skip_mode_params(AV1DecContext *s)
Definition: av1dec.c:266
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVFilmGrainParams::subsampling_x
int subsampling_x
Intended subsampling ratio, or 0 for luma-only streams.
Definition: film_grain_params.h:274
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:177
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1794
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:284
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:880
AV1RawMetadata::metadata
union AV1RawMetadata::@66 metadata
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
AV1RawSequenceHeader::max_frame_height_minus_1
uint16_t max_frame_height_minus_1
Definition: cbs_av1.h:99
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:115
resolve_divisor
static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
Resolve divisor process.
Definition: av1dec.c:157
AV1_OBU_FRAME
@ AV1_OBU_FRAME
Definition: av1.h:35
AVFilmGrainAOMParams::num_uv_points
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
Definition: film_grain_params.h:62
ITU_T_T35_PROVIDER_CODE_DOLBY
#define ITU_T_T35_PROVIDER_CODE_DOLBY
Definition: itut35.h:28
AV1RawFilmGrainParams::point_cr_value
uint8_t point_cr_value[10]
Definition: cbs_av1.h:146
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:220
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV1RawOBU::obu
union AV1RawOBU::@67 obu
AVPacket::size
int size
Definition: packet.h:540
AV1RawFilmGrainParams::cb_offset
uint16_t cb_offset
Definition: cbs_av1.h:157
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
ff_dovi_attach_side_data
int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
Attach the decoded AVDOVIMetadata as side data to an AVFrame.
Definition: dovi_rpudec.c:64
height
#define height
Definition: dsp.h:85
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:400
decode_unsigned_subexp_with_ref
static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp, int mx, int r)
Definition: av1dec.c:82
codec_internal.h
AV1RawTimingInfo::num_ticks_per_picture_minus_1
uint32_t num_ticks_per_picture_minus_1
Definition: cbs_av1.h:63
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:507
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:85
AV1RawOBU::sequence_header
AV1RawSequenceHeader sequence_header
Definition: cbs_av1.h:406
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:55
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:509
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:238
AV1_OBU_SEQUENCE_HEADER
@ AV1_OBU_SEQUENCE_HEADER
Definition: av1.h:30
AVCodecHWConfigInternal
Definition: hwconfig.h:25
ff_av1_framerate
AVRational ff_av1_framerate(int64_t ticks_per_frame, int64_t units_per_tick, int64_t time_scale)
Definition: av1_parse.c:110
header
static const uint8_t header[24]
Definition: sdr2.c:68
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
VD
#define VD
Definition: av1dec.c:1560
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
AV1RawFilmGrainParams::grain_scale_shift
uint8_t grain_scale_shift
Definition: cbs_av1.h:154
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:69
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
AV1RawOBU::frame_header
AV1RawFrameHeader frame_header
Definition: cbs_av1.h:407
ff_cbs_read_extradata_from_codec
int ff_cbs_read_extradata_from_codec(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecContext *avctx)
Definition: cbs.c:295
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:87
av1_receive_frame
static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1504
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1534
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
AV1RawOBU::metadata
AV1RawMetadata metadata
Definition: cbs_av1.h:411
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
AV1RawMetadata::metadata_type
uint64_t metadata_type
Definition: cbs_av1.h:382
export_film_grain
static int export_film_grain(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1089
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
AVFilmGrainParams::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:280
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:219
CodedBitstreamUnit::data_ref
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:98
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1806
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
div_lut
static const uint16_t div_lut[AV1_DIV_LUT_NUM]
< same with Div_Lut defined in spec 7.11.3.7
Definition: av1dec.c:45
AV1RawMetadata::hdr_mdcv
AV1RawMetadataHDRMDCV hdr_mdcv
Definition: cbs_av1.h:385
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:274
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:83
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
AV1RawMetadataITUTT35::payload
uint8_t * payload
Definition: cbs_av1.h:354
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:708
AV1RawTileGroup::tg_start
uint16_t tg_start
Definition: cbs_av1.h:299
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
AV1RawSequenceHeader::enable_order_hint
uint8_t enable_order_hint
Definition: cbs_av1.h:113
AVCodecContext::height
int height
Definition: avcodec.h:624
GetByteContext::buffer_end
const uint8_t * buffer_end
Definition: bytestream.h:34
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
AV1RawMetadataITUTT35::payload_ref
AVBufferRef * payload_ref
Definition: cbs_av1.h:355
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
AV1RawOBU::tile_group
AV1RawTileGroup tile_group
Definition: cbs_av1.h:409
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
AV1RawFilmGrainParams::update_grain
uint8_t update_grain
Definition: cbs_av1.h:136
avcodec.h
AV1RawTileGroup::tile_data
AV1RawTileData tile_data
Definition: cbs_av1.h:302
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
av1_class
static const AVClass av1_class
Definition: av1dec.c:1567
av_dynamic_hdr_plus_create_side_data
AVDynamicHDRPlus * av_dynamic_hdr_plus_create_side_data(AVFrame *frame)
Allocate a complete AVDynamicHDRPlus and add it to the frame.
Definition: hdr_dynamic_metadata.c:48
AVFilmGrainParams::height
int height
Definition: film_grain_params.h:269
ret
ret
Definition: filter_design.txt:187
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
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:80
AV1_OBU_TILE_LIST
@ AV1_OBU_TILE_LIST
Definition: av1.h:37
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
atsc_a53.h
AV1RawColorConfig::high_bitdepth
uint8_t high_bitdepth
Definition: cbs_av1.h:42
AV1RawFilmGrainParams::cr_luma_mult
uint8_t cr_luma_mult
Definition: cbs_av1.h:159
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:89
ff_decode_content_light_new
int ff_decode_content_light_new(const AVCodecContext *avctx, AVFrame *frame, AVContentLightMetadata **clm)
Wrapper around av_content_light_metadata_create_side_data(), which rejects side data overridden by th...
Definition: decode.c:2223
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
AV1RawFilmGrainParams::film_grain_params_ref_idx
uint8_t film_grain_params_ref_idx
Definition: cbs_av1.h:137
read_global_param
static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
Definition: av1dec.c:99
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:506
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
ff_progress_frame_replace
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...
Definition: decode.c:1883
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
AV1_DIV_LUT_PREC_BITS
@ AV1_DIV_LUT_PREC_BITS
Definition: av1.h:121
AVFilmGrainParams::codec
union AVFilmGrainParams::@435 codec
Additional fields may be added both here and in any structure included.
AV1RawMetadataITUTT35
Definition: cbs_av1.h:350
AVCodecContext
main external API structure.
Definition: avcodec.h:451
get_shear_params_valid
static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)
check if global motion params is valid.
Definition: av1dec.c:177
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
itut35.h
FF_CODEC_RECEIVE_FRAME_CB
#define FF_CODEC_RECEIVE_FRAME_CB(func)
Definition: codec_internal.h:317
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
CodedBitstreamUnitType
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:47
AVFilmGrainAOMParams::uv_offset
int uv_offset[2]
Offset used for component scaling function.
Definition: film_grain_params.h:112
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:171
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AV1RawFilmGrainParams::ar_coeff_lag
uint8_t ar_coeff_lag
Definition: cbs_av1.h:149
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
AV1RawColorConfig::mono_chrome
uint8_t mono_chrome
Definition: cbs_av1.h:44
export_metadata
static int export_metadata(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1038
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
hdr_dynamic_metadata.h
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1937
AV1RawFilmGrainParams::ar_coeffs_cb_plus_128
uint8_t ar_coeffs_cb_plus_128[25]
Definition: cbs_av1.h:151
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:116
AV1RawFilmGrainParams::ar_coeffs_y_plus_128
uint8_t ar_coeffs_y_plus_128[24]
Definition: cbs_av1.h:150
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1808
ff_cbs_read_packet
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:304
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
AV1RawColorConfig::matrix_coefficients
uint8_t matrix_coefficients
Definition: cbs_av1.h:49
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AV1RawTileGroup
Definition: cbs_av1.h:297
AVFilmGrainParams::color_range
enum AVColorRange color_range
Intended video signal characteristics.
Definition: film_grain_params.h:279
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:109
AV1RawFilmGrainParams::cr_offset
uint16_t cr_offset
Definition: cbs_av1.h:160
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:110
AV1RawFilmGrainParams::point_y_scaling
uint8_t point_y_scaling[14]
Definition: cbs_av1.h:140
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVFilmGrainAOMParams::overlap_flag
int overlap_flag
Signals whether to overlap film grain blocks.
Definition: film_grain_params.h:117
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV1RawOBU::frame
AV1RawFrame frame
Definition: cbs_av1.h:408
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AV1RawFilmGrainParams::point_cb_scaling
uint8_t point_cb_scaling[10]
Definition: cbs_av1.h:144
AV1RawMetadataITUTT35::itu_t_t35_country_code
uint8_t itu_t_t35_country_code
Definition: cbs_av1.h:351
mastering_display_metadata.h
AV1RawFrame::tile_group
AV1RawTileGroup tile_group
Definition: cbs_av1.h:307
ITU_T_T35_COUNTRY_CODE_US
#define ITU_T_T35_COUNTRY_CODE_US
Definition: itut35.h:24
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:112
decode_signed_subexp_with_ref
static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low, int high, int r)
Definition: av1dec.c:92
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:90
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
get_pixel_format
static int get_pixel_format(AVCodecContext *avctx)
Definition: av1dec.c:534
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
ITU_T_T35_PROVIDER_CODE_SMTPE
#define ITU_T_T35_PROVIDER_CODE_SMTPE
Definition: itut35.h:30
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:74
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
OFFSET
#define OFFSET(x)
Definition: av1dec.c:1559
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
av_dynamic_hdr_plus_from_t35
int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data, size_t size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).
Definition: hdr_dynamic_metadata.c:61
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
TileGroupInfo
Definition: av1dec.h:78
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AV1RawFilmGrainParams
Definition: cbs_av1.h:133
sequence_header
static int FUNC() sequence_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawSequenceHeader *current)
Definition: cbs_mpeg2_syntax_template.c:19
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av1_receive_frame_internal
static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1277
width
#define width
Definition: dsp.h:85
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:484
AVFilmGrainAOMParams::chroma_scaling_from_luma
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
Definition: film_grain_params.h:56
ff_cbs_flush
av_cold void ff_cbs_flush(CodedBitstreamContext *ctx)
Reset all internal state in a context.
Definition: cbs.c:136
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
AV1RawOBUHeader
Definition: cbs_av1.h:29
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:242
set_output_frame
static int set_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1159
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV1_OBU_METADATA
@ AV1_OBU_METADATA
Definition: av1.h:34
AV1RawFilmGrainParams::num_cr_points
uint8_t num_cr_points
Definition: cbs_av1.h:145
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:648
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
src
#define src
Definition: vp8dsp.c:248
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:63
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3090
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
CodedBitstreamAV1Context
Definition: cbs_av1.h:438