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 "refstruct.h"
42 #include "thread.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  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
285  dist = get_relative_dist(seq, ref_hint, header->order_hint);
286  if (dist < 0) {
287  if (forward_idx < 0 ||
288  get_relative_dist(seq, ref_hint, forward_hint) > 0) {
289  forward_idx = i;
290  forward_hint = ref_hint;
291  }
292  } else if (dist > 0) {
293  if (backward_idx < 0 ||
294  get_relative_dist(seq, ref_hint, backward_hint) < 0) {
295  backward_idx = i;
296  backward_hint = ref_hint;
297  }
298  }
299  }
300 
301  if (forward_idx < 0) {
302  return;
303  } else if (backward_idx >= 0) {
304  s->cur_frame.skip_mode_frame_idx[0] =
305  AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);
306  s->cur_frame.skip_mode_frame_idx[1] =
307  AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);
308  return;
309  }
310 
311  second_forward_idx = -1;
312  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
313  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
314  if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {
315  if (second_forward_idx < 0 ||
316  get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {
317  second_forward_idx = i;
318  second_forward_hint = ref_hint;
319  }
320  }
321  }
322 
323  if (second_forward_idx < 0)
324  return;
325 
326  s->cur_frame.skip_mode_frame_idx[0] =
327  AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);
328  s->cur_frame.skip_mode_frame_idx[1] =
329  AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);
330 }
331 
333 {
334  const AV1RawFrameHeader *header = s->raw_frame_header;
335  int i;
336 
337  if (header->delta_q_y_dc || header->delta_q_u_ac ||
338  header->delta_q_u_dc || header->delta_q_v_ac ||
339  header->delta_q_v_dc) {
340  s->cur_frame.coded_lossless = 0;
341  return;
342  }
343 
344  s->cur_frame.coded_lossless = 1;
345  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
346  int qindex;
347  if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
348  qindex = (header->base_q_idx +
349  header->feature_value[i][AV1_SEG_LVL_ALT_Q]);
350  } else {
351  qindex = header->base_q_idx;
352  }
353  qindex = av_clip_uintp2(qindex, 8);
354 
355  if (qindex) {
356  s->cur_frame.coded_lossless = 0;
357  return;
358  }
359  }
360 }
361 
363 {
364  const AV1RawFrameHeader *header = s->raw_frame_header;
365  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
366  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
367 
368  if (!film_grain->apply_grain)
369  return;
370 
371  if (film_grain->update_grain) {
372  memcpy(dst, film_grain, sizeof(*dst));
373  return;
374  }
375 
376  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
377 
378  memcpy(dst, src, sizeof(*dst));
379  dst->grain_seed = film_grain->grain_seed;
380 }
381 
383 
384 {
385  int cur_tile_num =
386  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
387  if (s->tile_num < cur_tile_num) {
388  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
389  sizeof(TileGroupInfo));
390  if (ret < 0) {
391  s->tile_num = 0;
392  return ret;
393  }
394  }
395  s->tile_num = cur_tile_num;
396 
397  return 0;
398 }
399 
400 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
401 {
402  AV1DecContext *s = avctx->priv_data;
403  GetByteContext gb;
404  uint16_t tile_num, tile_row, tile_col;
405  uint32_t size = 0, size_bytes = 0;
406 
407  bytestream2_init(&gb, tile_group->tile_data.data,
408  tile_group->tile_data.data_size);
409  s->tg_start = tile_group->tg_start;
410  s->tg_end = tile_group->tg_end;
411 
412  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
413  tile_row = tile_num / s->raw_frame_header->tile_cols;
414  tile_col = tile_num % s->raw_frame_header->tile_cols;
415 
416  if (tile_num == tile_group->tg_end) {
417  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
418  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
419  s->tile_group_info[tile_num].tile_row = tile_row;
420  s->tile_group_info[tile_num].tile_column = tile_col;
421  return 0;
422  }
423  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
424  if (bytestream2_get_bytes_left(&gb) < size_bytes)
425  return AVERROR_INVALIDDATA;
426  size = 0;
427  for (int i = 0; i < size_bytes; i++)
428  size |= bytestream2_get_byteu(&gb) << 8 * i;
429  if (bytestream2_get_bytes_left(&gb) <= size)
430  return AVERROR_INVALIDDATA;
431  size++;
432 
433  s->tile_group_info[tile_num].tile_size = size;
434  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
435  s->tile_group_info[tile_num].tile_row = tile_row;
436  s->tile_group_info[tile_num].tile_column = tile_col;
437 
438  bytestream2_skipu(&gb, size);
439  }
440 
441  return 0;
442 
443 }
444 
445 static enum AVPixelFormat get_sw_pixel_format(void *logctx,
446  const AV1RawSequenceHeader *seq)
447 {
448  uint8_t bit_depth;
450 
451  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
452  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
453  else if (seq->seq_profile <= 2)
454  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
455  else {
456  av_log(logctx, AV_LOG_ERROR,
457  "Unknown AV1 profile %d.\n", seq->seq_profile);
458  return AV_PIX_FMT_NONE;
459  }
460 
461  if (!seq->color_config.mono_chrome) {
462  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
463  if (seq->color_config.subsampling_x == 0 &&
464  seq->color_config.subsampling_y == 0) {
465  if (bit_depth == 8)
467  else if (bit_depth == 10)
469  else if (bit_depth == 12)
471  else
472  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
473  } else if (seq->color_config.subsampling_x == 1 &&
474  seq->color_config.subsampling_y == 0) {
475  if (bit_depth == 8)
477  else if (bit_depth == 10)
479  else if (bit_depth == 12)
481  else
482  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
483  } else if (seq->color_config.subsampling_x == 1 &&
484  seq->color_config.subsampling_y == 1) {
485  if (bit_depth == 8)
487  else if (bit_depth == 10)
489  else if (bit_depth == 12)
491  else
492  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
493  }
494  } else {
495  if (bit_depth == 8)
497  else if (bit_depth == 10)
499  else if (bit_depth == 12)
501  else
502  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
503  }
504 
505  return pix_fmt;
506 }
507 
509 {
510  AV1DecContext *s = avctx->priv_data;
511  const AV1RawSequenceHeader *seq = s->raw_seq;
512  int ret;
513  enum AVPixelFormat pix_fmt = get_sw_pixel_format(avctx, seq);
514 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
515  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
516  CONFIG_AV1_D3D12VA_HWACCEL + \
517  CONFIG_AV1_NVDEC_HWACCEL + \
518  CONFIG_AV1_VAAPI_HWACCEL + \
519  CONFIG_AV1_VDPAU_HWACCEL + \
520  CONFIG_AV1_VULKAN_HWACCEL)
521  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
522 
523  if (pix_fmt == AV_PIX_FMT_NONE)
524  return -1;
525 
526  switch (pix_fmt) {
527  case AV_PIX_FMT_YUV420P:
528 #if CONFIG_AV1_DXVA2_HWACCEL
529  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
530 #endif
531 #if CONFIG_AV1_D3D11VA_HWACCEL
532  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
533  *fmtp++ = AV_PIX_FMT_D3D11;
534 #endif
535 #if CONFIG_AV1_D3D12VA_HWACCEL
536  *fmtp++ = AV_PIX_FMT_D3D12;
537 #endif
538 #if CONFIG_AV1_NVDEC_HWACCEL
539  *fmtp++ = AV_PIX_FMT_CUDA;
540 #endif
541 #if CONFIG_AV1_VAAPI_HWACCEL
542  *fmtp++ = AV_PIX_FMT_VAAPI;
543 #endif
544 #if CONFIG_AV1_VDPAU_HWACCEL
545  *fmtp++ = AV_PIX_FMT_VDPAU;
546 #endif
547 #if CONFIG_AV1_VULKAN_HWACCEL
548  *fmtp++ = AV_PIX_FMT_VULKAN;
549 #endif
550  break;
552 #if CONFIG_AV1_DXVA2_HWACCEL
553  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
554 #endif
555 #if CONFIG_AV1_D3D11VA_HWACCEL
556  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
557  *fmtp++ = AV_PIX_FMT_D3D11;
558 #endif
559 #if CONFIG_AV1_D3D12VA_HWACCEL
560  *fmtp++ = AV_PIX_FMT_D3D12;
561 #endif
562 #if CONFIG_AV1_NVDEC_HWACCEL
563  *fmtp++ = AV_PIX_FMT_CUDA;
564 #endif
565 #if CONFIG_AV1_VAAPI_HWACCEL
566  *fmtp++ = AV_PIX_FMT_VAAPI;
567 #endif
568 #if CONFIG_AV1_VDPAU_HWACCEL
569  *fmtp++ = AV_PIX_FMT_VDPAU;
570 #endif
571 #if CONFIG_AV1_VULKAN_HWACCEL
572  *fmtp++ = AV_PIX_FMT_VULKAN;
573 #endif
574  break;
576 #if CONFIG_AV1_VULKAN_HWACCEL
577  *fmtp++ = AV_PIX_FMT_VULKAN;
578 #endif
579  break;
580  case AV_PIX_FMT_YUV422P:
581 #if CONFIG_AV1_VULKAN_HWACCEL
582  *fmtp++ = AV_PIX_FMT_VULKAN;
583 #endif
584  break;
586 #if CONFIG_AV1_VULKAN_HWACCEL
587  *fmtp++ = AV_PIX_FMT_VULKAN;
588 #endif
589  break;
591 #if CONFIG_AV1_VULKAN_HWACCEL
592  *fmtp++ = AV_PIX_FMT_VULKAN;
593 #endif
594  break;
595  case AV_PIX_FMT_YUV444P:
596 #if CONFIG_AV1_VULKAN_HWACCEL
597  *fmtp++ = AV_PIX_FMT_VULKAN;
598 #endif
599  break;
601 #if CONFIG_AV1_VULKAN_HWACCEL
602  *fmtp++ = AV_PIX_FMT_VULKAN;
603 #endif
604  break;
606 #if CONFIG_AV1_VULKAN_HWACCEL
607  *fmtp++ = AV_PIX_FMT_VULKAN;
608 #endif
609  break;
610  case AV_PIX_FMT_GRAY8:
611 #if CONFIG_AV1_NVDEC_HWACCEL
612  *fmtp++ = AV_PIX_FMT_CUDA;
613 #endif
614  break;
615  case AV_PIX_FMT_GRAY10:
616 #if CONFIG_AV1_NVDEC_HWACCEL
617  *fmtp++ = AV_PIX_FMT_CUDA;
618 #endif
619  break;
620  }
621 
622  *fmtp++ = pix_fmt;
623  *fmtp = AV_PIX_FMT_NONE;
624 
625  for (int i = 0; pix_fmts[i] != pix_fmt; i++)
626  if (pix_fmts[i] == avctx->pix_fmt) {
627  s->pix_fmt = pix_fmt;
628  return 1;
629  }
630 
631  ret = ff_get_format(avctx, pix_fmts);
632 
633  /**
634  * check if the HW accel is inited correctly. If not, return un-implemented.
635  * Since now the av1 decoder doesn't support native decode, if it will be
636  * implemented in the future, need remove this check.
637  */
638  if (!avctx->hwaccel) {
639  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"
640  " hardware accelerated AV1 decoding.\n");
641  avctx->pix_fmt = AV_PIX_FMT_NONE;
642  return AVERROR(ENOSYS);
643  }
644 
645  s->pix_fmt = pix_fmt;
646  avctx->pix_fmt = ret;
647 
648  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
649  av_get_pix_fmt_name(avctx->pix_fmt));
650 
651  return 0;
652 }
653 
655 {
656  av_frame_unref(f->f);
657  ff_refstruct_unref(&f->hwaccel_picture_private);
658  ff_refstruct_unref(&f->header_ref);
659  f->raw_frame_header = NULL;
660  f->spatial_id = f->temporal_id = 0;
661  memset(f->skip_mode_frame_idx, 0,
662  2 * sizeof(uint8_t));
663  memset(&f->film_grain, 0, sizeof(f->film_grain));
664  f->coded_lossless = 0;
665 }
666 
667 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
668 {
669  int ret;
670 
671  ff_refstruct_replace(&dst->header_ref, src->header_ref);
672 
673  dst->raw_frame_header = src->raw_frame_header;
674 
675  if (!src->f->buf[0])
676  return 0;
677 
678  ret = av_frame_ref(dst->f, src->f);
679  if (ret < 0)
680  goto fail;
681 
683  src->hwaccel_picture_private);
684 
685  dst->spatial_id = src->spatial_id;
686  dst->temporal_id = src->temporal_id;
687  memcpy(dst->gm_invalid,
688  src->gm_invalid,
689  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
690  memcpy(dst->gm_type,
691  src->gm_type,
692  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
693  memcpy(dst->gm_params,
694  src->gm_params,
695  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
696  memcpy(dst->skip_mode_frame_idx,
697  src->skip_mode_frame_idx,
698  2 * sizeof(uint8_t));
699  memcpy(&dst->film_grain,
700  &src->film_grain,
701  sizeof(dst->film_grain));
702  dst->coded_lossless = src->coded_lossless;
703 
704  return 0;
705 
706 fail:
707  av1_frame_unref(dst);
708  return AVERROR(ENOMEM);
709 }
710 
712 {
713  AV1DecContext *s = avctx->priv_data;
714  AV1RawMetadataITUTT35 itut_t35;
715 
716  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
717  if (s->ref[i].f) {
718  av1_frame_unref(&s->ref[i]);
719  av_frame_free(&s->ref[i].f);
720  }
721  }
722  if (s->cur_frame.f) {
723  av1_frame_unref(&s->cur_frame);
724  av_frame_free(&s->cur_frame.f);
725  }
726  av_buffer_unref(&s->seq_data_ref);
727  ff_refstruct_unref(&s->seq_ref);
728  ff_refstruct_unref(&s->header_ref);
729  ff_refstruct_unref(&s->cll_ref);
730  ff_refstruct_unref(&s->mdcv_ref);
731  av_freep(&s->tile_group_info);
732 
733  while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
734  av_buffer_unref(&itut_t35.payload_ref);
735  av_fifo_freep2(&s->itut_t35_fifo);
736 
737  ff_cbs_fragment_free(&s->current_obu);
738  ff_cbs_close(&s->cbc);
739  ff_dovi_ctx_unref(&s->dovi);
740 
741  return 0;
742 }
743 
745  const AV1RawSequenceHeader *seq)
746 {
747  int width = seq->max_frame_width_minus_1 + 1;
748  int height = seq->max_frame_height_minus_1 + 1;
749 
750  avctx->profile = seq->seq_profile;
751  avctx->level = seq->seq_level_idx[0];
752 
753  avctx->color_range =
758 
759  switch (seq->color_config.chroma_sample_position) {
760  case AV1_CSP_VERTICAL:
762  break;
763  case AV1_CSP_COLOCATED:
765  break;
766  }
767 
768  if (seq->film_grain_params_present)
770  else
772 
773  if (avctx->width != width || avctx->height != height) {
774  int ret = ff_set_dimensions(avctx, width, height);
775  if (ret < 0)
776  return ret;
777  }
778 
779  if (seq->timing_info_present_flag)
782  seq->timing_info.time_scale);
783 
784  if (avctx->pix_fmt == AV_PIX_FMT_NONE)
785  avctx->pix_fmt = get_sw_pixel_format(avctx, seq);
786 
787  return 0;
788 }
789 
791  const AV1RawFrameHeader *header)
792 {
793  AVRational aspect_ratio;
794  int width = header->frame_width_minus_1 + 1;
795  int height = header->frame_height_minus_1 + 1;
796  int r_width = header->render_width_minus_1 + 1;
797  int r_height = header->render_height_minus_1 + 1;
798  int ret;
799 
800  if (avctx->width != width || avctx->height != height) {
801  ret = ff_set_dimensions(avctx, width, height);
802  if (ret < 0)
803  return ret;
804  }
805 
806  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
807  (int64_t)height * r_width,
808  (int64_t)width * r_height,
809  INT_MAX);
810 
811  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
812  ret = ff_set_sar(avctx, aspect_ratio);
813  if (ret < 0)
814  return ret;
815  }
816 
817  return 0;
818 }
819 
828 };
829 
831 {
832  AV1DecContext *s = avctx->priv_data;
834  const AVPacketSideData *sd;
835  int ret;
836 
837  s->avctx = avctx;
838  s->pkt = avctx->internal->in_pkt;
839  s->pix_fmt = AV_PIX_FMT_NONE;
840 
841  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
842  s->ref[i].f = av_frame_alloc();
843  if (!s->ref[i].f)
844  return AVERROR(ENOMEM);
845  }
846 
847  s->cur_frame.f = av_frame_alloc();
848  if (!s->cur_frame.f)
849  return AVERROR(ENOMEM);
850 
851  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
852  if (ret < 0)
853  return ret;
854 
855  s->cbc->decompose_unit_types = decompose_unit_types;
856  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);
857 
858  s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),
860  if (!s->itut_t35_fifo)
861  return AVERROR(ENOMEM);
862 
863  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
864 
865  if (avctx->extradata && avctx->extradata_size) {
867  &s->current_obu,
868  avctx);
869  if (ret < 0) {
870  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
871  goto end;
872  }
873 
874  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
875  if (!seq) {
876  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
877  goto end;
878  }
879 
880  ret = set_context_with_sequence(avctx, seq);
881  if (ret < 0) {
882  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
883  goto end;
884  }
885 
886  end:
887  ff_cbs_fragment_reset(&s->current_obu);
888  }
889 
890  s->dovi.logctx = avctx;
891  s->dovi.dv_profile = 10; // default for AV1
893  if (sd && sd->size > 0)
895 
896  return ret;
897 }
898 
900 {
901  AV1DecContext *s = avctx->priv_data;
902  AV1RawFrameHeader *header= s->raw_frame_header;
903  AVFrame *frame;
904  int ret;
905 
907  if (ret < 0) {
908  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
909  return ret;
910  }
911 
912  if ((ret = ff_thread_get_buffer(avctx, f->f, AV_GET_BUFFER_FLAG_REF)) < 0)
913  goto fail;
914 
915  frame = f->f;
916  if (header->frame_type == AV1_FRAME_KEY)
917  frame->flags |= AV_FRAME_FLAG_KEY;
918  else
919  frame->flags &= ~AV_FRAME_FLAG_KEY;
920 
921  switch (header->frame_type) {
922  case AV1_FRAME_KEY:
924  frame->pict_type = AV_PICTURE_TYPE_I;
925  break;
926  case AV1_FRAME_INTER:
927  frame->pict_type = AV_PICTURE_TYPE_P;
928  break;
929  case AV1_FRAME_SWITCH:
930  frame->pict_type = AV_PICTURE_TYPE_SP;
931  break;
932  }
933 
934  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
935  if (ret < 0)
936  goto fail;
937 
938  return 0;
939 
940 fail:
942  return ret;
943 }
944 
946  const AV1RawMetadataITUTT35 *itut_t35)
947 {
948  GetByteContext gb;
949  AV1DecContext *s = avctx->priv_data;
950  int ret, provider_code;
951 
952  bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);
953 
954  provider_code = bytestream2_get_be16(&gb);
955  switch (provider_code) {
957  uint32_t user_identifier = bytestream2_get_be32(&gb);
958  switch (user_identifier) {
959  case MKBETAG('G', 'A', '9', '4'): { // closed captions
960  AVBufferRef *buf = NULL;
961 
963  if (ret < 0)
964  return ret;
965  if (!ret)
966  break;
967 
969  if (ret < 0)
970  return ret;
971 
973  break;
974  }
975  default: // ignore unsupported identifiers
976  break;
977  }
978  break;
979  }
981  AVDynamicHDRPlus *hdrplus;
982  int provider_oriented_code = bytestream2_get_be16(&gb);
983  int application_identifier = bytestream2_get_byte(&gb);
984 
986  provider_oriented_code != 1 || application_identifier != 4)
987  break;
988 
990  if (!hdrplus)
991  return AVERROR(ENOMEM);
992 
995  if (ret < 0)
996  return ret;
997  break;
998  }
1000  int provider_oriented_code = bytestream2_get_be32(&gb);
1002  provider_oriented_code != 0x800)
1003  break;
1004 
1005  ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer,
1006  avctx->err_recognition);
1007  if (ret < 0) {
1008  av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
1009  break; // ignore
1010  }
1011 
1012  ret = ff_dovi_attach_side_data(&s->dovi, frame);
1013  if (ret < 0)
1014  return ret;
1015  break;
1016  }
1017  default: // ignore unsupported provider codes
1018  break;
1019  }
1020 
1021  return 0;
1022 }
1023 
1025 {
1026  AV1DecContext *s = avctx->priv_data;
1027  AV1RawMetadataITUTT35 itut_t35;
1028  int ret = 0;
1029 
1030  if (s->mdcv) {
1031  AVMasteringDisplayMetadata *mastering;
1032 
1033  ret = ff_decode_mastering_display_new(avctx, frame, &mastering);
1034  if (ret < 0)
1035  return ret;
1036 
1037  if (mastering) {
1038  for (int i = 0; i < 3; i++) {
1039  mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);
1040  mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);
1041  }
1042  mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);
1043  mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);
1044 
1045  mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);
1046  mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);
1047 
1048  mastering->has_primaries = 1;
1049  mastering->has_luminance = 1;
1050  }
1051  }
1052 
1053  if (s->cll) {
1054  AVContentLightMetadata *light;
1055 
1056  ret = ff_decode_content_light_new(avctx, frame, &light);
1057  if (ret < 0)
1058  return ret;
1059 
1060  if (light) {
1061  light->MaxCLL = s->cll->max_cll;
1062  light->MaxFALL = s->cll->max_fall;
1063  }
1064  }
1065 
1066  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {
1067  if (ret >= 0)
1068  ret = export_itut_t35(avctx, frame, &itut_t35);
1069  av_buffer_unref(&itut_t35.payload_ref);
1070  }
1071 
1072  return ret;
1073 }
1074 
1076 {
1077  AV1DecContext *s = avctx->priv_data;
1078  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
1079  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(frame->format);
1080  AVFilmGrainParams *fgp;
1081  AVFilmGrainAOMParams *aom;
1082 
1083  av_assert0(pixdesc);
1084  if (!film_grain->apply_grain)
1085  return 0;
1086 
1088  if (!fgp)
1089  return AVERROR(ENOMEM);
1090 
1092  fgp->seed = film_grain->grain_seed;
1093  fgp->width = frame->width;
1094  fgp->height = frame->height;
1095  fgp->color_range = frame->color_range;
1096  fgp->color_primaries = frame->color_primaries;
1097  fgp->color_trc = frame->color_trc;
1098  fgp->color_space = frame->colorspace;
1099  fgp->subsampling_x = pixdesc->log2_chroma_w;
1100  fgp->subsampling_y = pixdesc->log2_chroma_h;
1101 
1102  aom = &fgp->codec.aom;
1104  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
1105  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
1106  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
1107  aom->grain_scale_shift = film_grain->grain_scale_shift;
1108  aom->overlap_flag = film_grain->overlap_flag;
1109  aom->limit_output_range = film_grain->clip_to_restricted_range;
1110 
1111  aom->num_y_points = film_grain->num_y_points;
1112  for (int i = 0; i < film_grain->num_y_points; i++) {
1113  aom->y_points[i][0] = film_grain->point_y_value[i];
1114  aom->y_points[i][1] = film_grain->point_y_scaling[i];
1115  }
1116  aom->num_uv_points[0] = film_grain->num_cb_points;
1117  for (int i = 0; i < film_grain->num_cb_points; i++) {
1118  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
1119  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
1120  }
1121  aom->num_uv_points[1] = film_grain->num_cr_points;
1122  for (int i = 0; i < film_grain->num_cr_points; i++) {
1123  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
1124  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
1125  }
1126 
1127  for (int i = 0; i < 24; i++) {
1128  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
1129  }
1130  for (int i = 0; i < 25; i++) {
1131  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
1132  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
1133  }
1134 
1135  aom->uv_mult[0] = film_grain->cb_mult;
1136  aom->uv_mult[1] = film_grain->cr_mult;
1137  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
1138  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
1139  aom->uv_offset[0] = film_grain->cb_offset;
1140  aom->uv_offset[1] = film_grain->cr_offset;
1141 
1142  return 0;
1143 }
1144 
1146 {
1147  AV1DecContext *s = avctx->priv_data;
1148  const AVFrame *srcframe = s->cur_frame.f;
1149  AVPacket *pkt = s->pkt;
1150  int ret;
1151 
1152  // TODO: all layers
1153  if (s->operating_point_idc &&
1154  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
1155  return 0;
1156 
1157  ret = av_frame_ref(frame, srcframe);
1158  if (ret < 0)
1159  return ret;
1160 
1161  ret = export_metadata(avctx, frame);
1162  if (ret < 0) {
1164  return ret;
1165  }
1166 
1168  ret = export_film_grain(avctx, frame);
1169  if (ret < 0) {
1171  return ret;
1172  }
1173  }
1174 
1175  frame->pts = pkt->pts;
1176  frame->pkt_dts = pkt->dts;
1177 #if FF_API_FRAME_PKT
1179  frame->pkt_size = pkt->size;
1180  frame->pkt_pos = pkt->pos;
1182 #endif
1183 
1185 
1186  return 0;
1187 }
1188 
1190 {
1191  AV1DecContext *s = avctx->priv_data;
1192  const AV1RawFrameHeader *header = s->raw_frame_header;
1193  int ret;
1194 
1195  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1196  if (header->refresh_frame_flags & (1 << i)) {
1197  av1_frame_unref(&s->ref[i]);
1198  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
1199  av_log(avctx, AV_LOG_ERROR,
1200  "Failed to update frame %d in reference list\n", i);
1201  return ret;
1202  }
1203  }
1204  }
1205  return 0;
1206 }
1207 
1209 {
1210  AV1DecContext *s = avctx->priv_data;
1211  int ret;
1212 
1213  av1_frame_unref(&s->cur_frame);
1214 
1215  s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
1216 
1217  s->cur_frame.raw_frame_header = s->raw_frame_header;
1218 
1219  ret = init_tile_data(s);
1220  if (ret < 0) {
1221  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
1222  return ret;
1223  }
1224 
1225  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
1226  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
1227  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
1228  (avctx->skip_frame >= AVDISCARD_NONKEY &&
1229  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
1230  avctx->skip_frame >= AVDISCARD_ALL)
1231  return 0;
1232 
1233  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1234  ret = get_pixel_format(avctx);
1235  if (ret < 0) {
1236  av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format.\n");
1237  return ret;
1238  }
1239 
1240  if (!ret && FF_HW_HAS_CB(avctx, decode_params)) {
1241  ret = FF_HW_CALL(avctx, decode_params, AV1_OBU_SEQUENCE_HEADER,
1242  s->seq_data_ref->data, s->seq_data_ref->size);
1243  if (ret < 0) {
1244  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1245  return ret;
1246  }
1247  }
1248  }
1249 
1250  ret = av1_frame_alloc(avctx, &s->cur_frame);
1251  if (ret < 0) {
1252  av_log(avctx, AV_LOG_ERROR,
1253  "Failed to allocate space for current frame.\n");
1254  return ret;
1255  }
1256 
1261 
1262  return ret;
1263 }
1264 
1266 {
1267  AV1DecContext *s = avctx->priv_data;
1268  AV1RawTileGroup *raw_tile_group = NULL;
1269  int i = 0, ret;
1270 
1271  for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {
1272  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1273  AV1RawOBU *obu = unit->content;
1274  const AV1RawOBUHeader *header;
1275 
1276  av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu);
1277 
1278  if (unit->type == AV1_OBU_TILE_LIST) {
1279  av_log(avctx, AV_LOG_ERROR, "Large scale tile decoding is unsupported.\n");
1281  goto end;
1282  }
1283 
1284  if (!obu)
1285  continue;
1286 
1287  header = &obu->header;
1288 
1289  switch (unit->type) {
1291  ret = av_buffer_replace(&s->seq_data_ref, unit->data_ref);
1292  if (ret < 0)
1293  goto end;
1294 
1295  s->seq_data_ref->data = unit->data;
1296  s->seq_data_ref->size = unit->data_size;
1297  ff_refstruct_replace(&s->seq_ref, unit->content_ref);
1298 
1299  s->raw_seq = &obu->obu.sequence_header;
1300 
1301  ret = set_context_with_sequence(avctx, s->raw_seq);
1302  if (ret < 0) {
1303  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1304  s->raw_seq = NULL;
1305  goto end;
1306  }
1307 
1308  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1309 
1310  s->pix_fmt = AV_PIX_FMT_NONE;
1311 
1312  break;
1314  if (s->raw_frame_header)
1315  break;
1316  // fall-through
1317  case AV1_OBU_FRAME:
1318  case AV1_OBU_FRAME_HEADER:
1319  if (!s->raw_seq) {
1320  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1322  goto end;
1323  }
1324 
1325  ff_refstruct_replace(&s->header_ref, unit->content_ref);
1326 
1327  if (unit->type == AV1_OBU_FRAME)
1328  s->raw_frame_header = &obu->obu.frame.header;
1329  else
1330  s->raw_frame_header = &obu->obu.frame_header;
1331 
1332  if (s->raw_frame_header->show_existing_frame) {
1333  av1_frame_unref(&s->cur_frame);
1334 
1335  ret = av1_frame_ref(avctx, &s->cur_frame,
1336  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1337  if (ret < 0) {
1338  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
1339  goto end;
1340  }
1341 
1342  ret = update_reference_list(avctx);
1343  if (ret < 0) {
1344  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1345  goto end;
1346  }
1347 
1348  if (s->cur_frame.f->buf[0]) {
1349  ret = set_output_frame(avctx, frame);
1350  if (ret < 0)
1351  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1352  }
1353 
1354  s->raw_frame_header = NULL;
1355  i++;
1356 
1357  goto end;
1358  }
1359 
1360  ret = get_current_frame(avctx);
1361  if (ret < 0) {
1362  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1363  goto end;
1364  }
1365 
1366  s->cur_frame.spatial_id = header->spatial_id;
1367  s->cur_frame.temporal_id = header->temporal_id;
1368 
1369  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1370  ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);
1371  if (ret < 0) {
1372  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1373  goto end;
1374  }
1375  }
1376  if (unit->type != AV1_OBU_FRAME)
1377  break;
1378  // fall-through
1379  case AV1_OBU_TILE_GROUP:
1380  if (!s->raw_frame_header) {
1381  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1383  goto end;
1384  }
1385 
1386  if (unit->type == AV1_OBU_FRAME)
1387  raw_tile_group = &obu->obu.frame.tile_group;
1388  else
1389  raw_tile_group = &obu->obu.tile_group;
1390 
1391  ret = get_tiles_info(avctx, raw_tile_group);
1392  if (ret < 0)
1393  goto end;
1394 
1395  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1396  ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,
1397  raw_tile_group->tile_data.data_size);
1398  if (ret < 0) {
1399  av_log(avctx, AV_LOG_ERROR,
1400  "HW accel decode slice fail.\n");
1401  goto end;
1402  }
1403  }
1404  break;
1405  case AV1_OBU_TILE_LIST:
1407  case AV1_OBU_PADDING:
1408  break;
1409  case AV1_OBU_METADATA:
1410  switch (obu->obu.metadata.metadata_type) {
1412  ff_refstruct_replace(&s->cll_ref, unit->content_ref);
1413  s->cll = &obu->obu.metadata.metadata.hdr_cll;
1414  break;
1416  ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
1417  s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
1418  break;
1420  AV1RawMetadataITUTT35 itut_t35;
1421  memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));
1423  if (!itut_t35.payload_ref) {
1424  ret = AVERROR(ENOMEM);
1425  goto end;
1426  }
1427  ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);
1428  if (ret < 0) {
1429  av_buffer_unref(&itut_t35.payload_ref);
1430  goto end;
1431  }
1432  break;
1433  }
1434  default:
1435  break;
1436  }
1437  break;
1438  default:
1439  av_log(avctx, AV_LOG_DEBUG,
1440  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1441  unit->type, unit->data_size);
1442  }
1443 
1444  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1445  int show_frame = s->raw_frame_header->show_frame;
1446  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1447  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
1448  if (ret < 0) {
1449  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1450  goto end;
1451  }
1452  }
1453 
1454  ret = update_reference_list(avctx);
1455  if (ret < 0) {
1456  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1457  goto end;
1458  }
1459 
1460  if (s->raw_frame_header->show_frame && s->cur_frame.f->buf[0]) {
1461  ret = set_output_frame(avctx, frame);
1462  if (ret < 0) {
1463  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1464  goto end;
1465  }
1466  }
1467  raw_tile_group = NULL;
1468  s->raw_frame_header = NULL;
1469  if (show_frame) {
1470  i++;
1471  goto end;
1472  }
1473  }
1474  }
1475 
1476  ret = AVERROR(EAGAIN);
1477 end:
1478  av_assert0(i <= s->current_obu.nb_units);
1479  s->nb_unit = i;
1480 
1481  if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {
1482  if (ret < 0)
1483  s->raw_frame_header = NULL;
1484  av_packet_unref(s->pkt);
1485  ff_cbs_fragment_reset(&s->current_obu);
1486  s->nb_unit = 0;
1487  }
1488  if (!ret && !frame->buf[0])
1489  ret = AVERROR(EAGAIN);
1490 
1491  return ret;
1492 }
1493 
1495 {
1496  AV1DecContext *s = avctx->priv_data;
1497  int ret;
1498 
1499  do {
1500  if (!s->current_obu.nb_units) {
1501  ret = ff_decode_get_packet(avctx, s->pkt);
1502  if (ret < 0)
1503  return ret;
1504 
1505  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);
1506  if (ret < 0) {
1507  ff_cbs_fragment_reset(&s->current_obu);
1508  av_packet_unref(s->pkt);
1509  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1510  return ret;
1511  }
1512 
1513  s->nb_unit = 0;
1514  av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",
1515  s->current_obu.nb_units);
1516  }
1517 
1519  } while (ret == AVERROR(EAGAIN));
1520 
1521  return ret;
1522 }
1523 
1525 {
1526  AV1DecContext *s = avctx->priv_data;
1527  AV1RawMetadataITUTT35 itut_t35;
1528 
1529  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1530  av1_frame_unref(&s->ref[i]);
1531 
1532  av1_frame_unref(&s->cur_frame);
1533  s->operating_point_idc = 0;
1534  s->nb_unit = 0;
1535  s->raw_frame_header = NULL;
1536  s->raw_seq = NULL;
1537  s->cll = NULL;
1538  s->mdcv = NULL;
1539  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
1540  av_buffer_unref(&itut_t35.payload_ref);
1541 
1542  ff_cbs_fragment_reset(&s->current_obu);
1543  ff_cbs_flush(s->cbc);
1544 
1545  if (FF_HW_HAS_CB(avctx, flush))
1546  FF_HW_SIMPLE_CALL(avctx, flush);
1547 }
1548 
1549 #define OFFSET(x) offsetof(AV1DecContext, x)
1550 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1551 static const AVOption av1_options[] = {
1552  { "operating_point", "Select an operating point of the scalable bitstream",
1553  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1554  { NULL }
1555 };
1556 
1557 static const AVClass av1_class = {
1558  .class_name = "AV1 decoder",
1559  .item_name = av_default_item_name,
1560  .option = av1_options,
1561  .version = LIBAVUTIL_VERSION_INT,
1562 };
1563 
1565  .p.name = "av1",
1566  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1567  .p.type = AVMEDIA_TYPE_VIDEO,
1568  .p.id = AV_CODEC_ID_AV1,
1569  .priv_data_size = sizeof(AV1DecContext),
1570  .init = av1_decode_init,
1571  .close = av1_decode_free,
1573  .p.capabilities = AV_CODEC_CAP_DR1,
1575  .flush = av1_decode_flush,
1576  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1577  .p.priv_class = &av1_class,
1578  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1579 #if CONFIG_AV1_DXVA2_HWACCEL
1580  HWACCEL_DXVA2(av1),
1581 #endif
1582 #if CONFIG_AV1_D3D11VA_HWACCEL
1583  HWACCEL_D3D11VA(av1),
1584 #endif
1585 #if CONFIG_AV1_D3D11VA2_HWACCEL
1586  HWACCEL_D3D11VA2(av1),
1587 #endif
1588 #if CONFIG_AV1_D3D12VA_HWACCEL
1589  HWACCEL_D3D12VA(av1),
1590 #endif
1591 #if CONFIG_AV1_NVDEC_HWACCEL
1592  HWACCEL_NVDEC(av1),
1593 #endif
1594 #if CONFIG_AV1_VAAPI_HWACCEL
1595  HWACCEL_VAAPI(av1),
1596 #endif
1597 #if CONFIG_AV1_VDPAU_HWACCEL
1598  HWACCEL_VDPAU(av1),
1599 #endif
1600 #if CONFIG_AV1_VULKAN_HWACCEL
1601  HWACCEL_VULKAN(av1),
1602 #endif
1603 
1604  NULL
1605  },
1606 };
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:1358
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:427
AV1RawTimingInfo::time_scale
uint32_t time_scale
Definition: cbs_av1.h:60
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:89
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1427
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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:221
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:830
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:42
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:255
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:47
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:134
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, AVFrameSideData **psd)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:1842
AV1RawFilmGrainParams::grain_seed
uint16_t grain_seed
Definition: cbs_av1.h:135
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AV1_WARP_PARAM_REDUCE_BITS
@ AV1_WARP_PARAM_REDUCE_BITS
Definition: av1.h:118
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:114
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:1220
AV1RawOBU::obu
union AV1RawOBU::@40 obu
AV1RawColorConfig::color_range
uint8_t color_range
Definition: cbs_av1.h:51
coded_lossless_param
static void coded_lossless_param(AV1DecContext *s)
Definition: av1dec.c:332
GetByteContext
Definition: bytestream.h:33
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:2965
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:899
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:123
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:108
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:1420
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
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
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:1208
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
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
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:120
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:375
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:744
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:686
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
AV1Frame::raw_frame_header
AV1RawFrameHeader * raw_frame_header
Definition: av1dec.h:42
AVOption
AVOption.
Definition: opt.h:346
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
b
#define b
Definition: input.c:41
AV1RawSequenceHeader::timing_info
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
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
decompose_unit_types
static const CodedBitstreamUnitType decompose_unit_types[]
Definition: av1dec.c:820
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
thread.h
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
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in FFCodec caps_internal and use ff_thread_get_buffer() to allocate frames. Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
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
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:115
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:284
AV1RawFilmGrainParams::chroma_scaling_from_luma
uint8_t chroma_scaling_from_luma
Definition: cbs_av1.h:141
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
AVPacketSideData::size
size_t size
Definition: packet.h:377
AV1RawFilmGrainParams::ar_coeffs_cr_plus_128
uint8_t ar_coeffs_cr_plus_128[25]
Definition: cbs_av1.h:152
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:69
av1_parse.h
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1551
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:667
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1819
fail
#define fail()
Definition: checkasm.h:179
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
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
refstruct.h
ITU_T_T35_PROVIDER_CODE_ATSC
#define ITU_T_T35_PROVIDER_CODE_ATSC
Definition: itut35.h:25
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:63
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_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
AV1RawFilmGrainParams::cb_luma_mult
uint8_t cb_luma_mult
Definition: cbs_av1.h:156
AV1Frame
Definition: av1dec.h:36
AV1RawFilmGrainParams::overlap_flag
uint8_t overlap_flag
Definition: cbs_av1.h:161
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2910
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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
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:626
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:524
AV1Frame::spatial_id
int spatial_id
Definition: av1dec.h:45
width
#define width
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:1956
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
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:425
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
AV1Frame::film_grain
AV1RawFilmGrainParams film_grain
Definition: av1dec.h:53
av1_decode_free
static av_cold int av1_decode_free(AVCodecContext *avctx)
Definition: av1dec.c:711
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
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
init_tile_data
static int init_tile_data(AV1DecContext *s)
Definition: av1dec.c:382
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:376
update_reference_list
static int update_reference_list(AVCodecContext *avctx)
Definition: av1dec.c:1189
decode.h
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:161
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
get_sw_pixel_format
static enum AVPixelFormat get_sw_pixel_format(void *logctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:445
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
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:400
export_itut_t35
static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame, const AV1RawMetadataITUTT35 *itut_t35)
Definition: av1dec.c:945
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
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:1883
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1798
load_grain_params
static void load_grain_params(AV1DecContext *s)
Definition: av1dec.c:362
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1564
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
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
AV1RawOBU
Definition: cbs_av1.h:400
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_clip_int16
#define av_clip_int16
Definition: common.h:114
HWACCEL_MAX
#define HWACCEL_MAX
NULL
#define NULL
Definition: coverity.c:32
AV1Frame::gm_params
int32_t gm_params[AV1_NUM_REF_FRAMES][6]
Definition: av1dec.h:49
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:110
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:695
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:280
hwaccel_internal.h
AV1RawFrameHeader
Definition: cbs_av1.h:165
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:707
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:709
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
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:654
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
ff_dovi_update_cfg
void ff_dovi_update_cfg(DOVIContext *s, const AVDOVIDecoderConfigurationRecord *cfg)
Read the contents of an AVDOVIDecoderConfigurationRecord (usually provided by stream side data) and u...
Definition: dovi_rpu.c:85
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:368
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:790
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
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:479
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:1783
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:791
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_DIV_LUT_PREC_BITS
@ AV1_DIV_LUT_PREC_BITS
Definition: av1.h:121
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:27
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:218
f
f
Definition: af_crystalizer.c:121
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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
AVPacket::size
int size
Definition: packet.h:525
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:122
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
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:384
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
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:85
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:65
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
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:109
AV1Frame::skip_mode_frame_idx
uint8_t skip_mode_frame_idx[2]
Definition: av1dec.h:51
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:54
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
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:165
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
height
#define height
AV1Frame::f
AVFrame * f
Definition: av1dec.h:37
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:1550
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
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_receive_frame
static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1494
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:74
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1524
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
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:1075
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
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:217
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:517
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1795
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:523
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
AV1Frame::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference.
Definition: av1dec.h:39
AV1RawMetadata::hdr_mdcv
AV1RawMetadataHDRMDCV hdr_mdcv
Definition: cbs_av1.h:385
AV1Frame::header_ref
AV1RawOBU * header_ref
RefStruct reference backing raw_frame_header.
Definition: av1dec.h:41
AV1RawMetadata::metadata
union AV1RawMetadata::@39 metadata
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:74
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
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:702
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:618
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:657
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:112
AV1RawMetadataITUTT35::payload_ref
AVBufferRef * payload_ref
Definition: cbs_av1.h:355
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
AV1_METADATA_TYPE_ITUT_T35
@ AV1_METADATA_TYPE_ITUT_T35
Definition: av1.h:47
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:1557
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:71
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
AV1Frame::gm_invalid
uint8_t gm_invalid[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:47
AVFilmGrainParams::codec
union AVFilmGrainParams::@367 codec
Additional fields may be added both here and in any structure included.
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
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:1928
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
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:135
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:482
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
AV1RawMetadataITUTT35
Definition: cbs_av1.h:350
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:117
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:293
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
Definition: opt.h:235
AV1RawFilmGrainParams::ar_coeff_lag
uint8_t ar_coeff_lag
Definition: cbs_av1.h:149
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
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:1024
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:112
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:1926
AV1RawFilmGrainParams::ar_coeffs_cb_plus_128
uint8_t ar_coeffs_cb_plus_128[25]
Definition: cbs_av1.h:151
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:1797
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
AV1RawFilmGrainParams::cr_offset
uint16_t cr_offset
Definition: cbs_av1.h:160
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
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 Dovi RPU NAL and update the parsed values in the DOVIContext struct.
Definition: dovi_rpu.c:376
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:23
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
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:116
AV1Frame::temporal_id
int temporal_id
Definition: av1dec.h:44
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
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:106
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
get_pixel_format
static int get_pixel_format(AVCodecContext *avctx)
Definition: av1dec.c:508
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:28
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
OFFSET
#define OFFSET(x)
Definition: av1dec.c:1549
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:107
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
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
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
d
d
Definition: ffmpeg_filter.c:424
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
TileGroupInfo
Definition: av1dec.h:58
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:87
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
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:92
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:111
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:1265
AV1Frame::coded_lossless
uint8_t coded_lossless
Definition: av1dec.h:55
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
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
AV1Frame::gm_type
uint8_t gm_type[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:48
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:1145
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:642
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
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_rpu.c:93
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:2885
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:54
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