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/pixdesc.h"
27 #include "libavutil/opt.h"
28 #include "avcodec.h"
29 #include "av1_parse.h"
30 #include "av1dec.h"
31 #include "atsc_a53.h"
32 #include "bytestream.h"
33 #include "codec_internal.h"
34 #include "decode.h"
35 #include "hwaccel_internal.h"
36 #include "internal.h"
37 #include "hwconfig.h"
38 #include "profiles.h"
39 #include "refstruct.h"
40 #include "thread.h"
41 
42 /**< same with Div_Lut defined in spec 7.11.3.7 */
43 static const uint16_t div_lut[AV1_DIV_LUT_NUM] = {
44  16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
45  15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
46  15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
47  14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
48  13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
49  13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
50  13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
51  12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
52  12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
53  11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
54  11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
55  11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
56  10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
57  10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
58  10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,
59  9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,
60  9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,
61  9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,
62  9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,
63  9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,
64  8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,
65  8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,
66  8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,
67  8240, 8224, 8208, 8192
68 };
69 
70 static uint32_t inverse_recenter(int r, uint32_t v)
71 {
72  if (v > 2 * r)
73  return v;
74  else if (v & 1)
75  return r - ((v + 1) >> 1);
76  else
77  return r + (v >> 1);
78 }
79 
80 static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,
81  int mx, int r)
82 {
83  if ((r << 1) <= mx) {
84  return inverse_recenter(r, sub_exp);
85  } else {
86  return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);
87  }
88 }
89 
90 static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,
91  int high, int r)
92 {
93  int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);
94  return x + low;
95 }
96 
97 static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
98 {
99  uint8_t primary_frame, prev_frame;
100  uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;
101  int32_t r, prev_gm_param;
102 
103  primary_frame = s->raw_frame_header->primary_ref_frame;
104  prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
105  abs_bits = AV1_GM_ABS_ALPHA_BITS;
106  prec_bits = AV1_GM_ALPHA_PREC_BITS;
107 
108  /* setup_past_independence() sets PrevGmParams to default values. We can
109  * simply point to the current's frame gm_params as they will be initialized
110  * with defaults at this point.
111  */
112  if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)
113  prev_gm_param = s->cur_frame.gm_params[ref][idx];
114  else
115  prev_gm_param = s->ref[prev_frame].gm_params[ref][idx];
116 
117  if (idx < 2) {
119  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -
120  !s->raw_frame_header->allow_high_precision_mv;
121  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -
122  !s->raw_frame_header->allow_high_precision_mv;
123  } else {
124  abs_bits = AV1_GM_ABS_TRANS_BITS;
125  prec_bits = AV1_GM_TRANS_PREC_BITS;
126  }
127  }
128  round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
129  prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;
130  sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
131  mx = 1 << abs_bits;
132  r = (prev_gm_param >> prec_diff) - sub;
133 
134  s->cur_frame.gm_params[ref][idx] =
135  (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],
136  -mx, mx + 1, r) << prec_diff) + round;
137 }
138 
139 static uint64_t round_two(uint64_t x, uint16_t n)
140 {
141  if (n == 0)
142  return x;
143  return ((x + ((uint64_t)1 << (n - 1))) >> n);
144 }
145 
146 static int64_t round_two_signed(int64_t x, uint16_t n)
147 {
148  return ((x<0) ? -((int64_t)round_two(-x, n)) : (int64_t)round_two(x, n));
149 }
150 
151 /**
152  * Resolve divisor process.
153  * see spec 7.11.3.7
154  */
155 static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
156 {
157  int32_t e, f;
158 
159  *shift = av_log2(d);
160  e = d - (1 << (*shift));
161  if (*shift > AV1_DIV_LUT_BITS)
163  else
164  f = e << (AV1_DIV_LUT_BITS - (*shift));
165 
167 
168  return div_lut[f];
169 }
170 
171 /**
172  * check if global motion params is valid.
173  * see spec 7.11.3.6
174  */
175 static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)
176 {
177  int16_t alpha, beta, gamma, delta, divf, divs;
178  int64_t v, w;
179  int32_t *param = &s->cur_frame.gm_params[idx][0];
180  if (param[2] <= 0)
181  return 0;
182 
183  alpha = av_clip_int16(param[2] - (1 << AV1_WARPEDMODEL_PREC_BITS));
184  beta = av_clip_int16(param[3]);
185  divf = resolve_divisor(abs(param[2]), &divs);
186  v = (int64_t)param[4] * (1 << AV1_WARPEDMODEL_PREC_BITS);
187  w = (int64_t)param[3] * param[4];
188  gamma = av_clip_int16((int)round_two_signed((v * divf), divs));
189  delta = av_clip_int16(param[5] - (int)round_two_signed((w * divf), divs) - (1 << AV1_WARPEDMODEL_PREC_BITS));
190 
195 
196  if ((4 * abs(alpha) + 7 * abs(beta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS) ||
197  (4 * abs(gamma) + 4 * abs(delta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS))
198  return 0;
199 
200  return 1;
201 }
202 
203 /**
204 * update gm type/params, since cbs already implemented part of this function,
205 * so we don't need to full implement spec.
206 */
208 {
209  const AV1RawFrameHeader *header = s->raw_frame_header;
210  int type, ref;
211 
213  s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;
214  for (int i = 0; i < 6; i++)
215  s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?
216  1 << AV1_WARPEDMODEL_PREC_BITS : 0;
217  }
218  if (header->frame_type == AV1_FRAME_KEY ||
219  header->frame_type == AV1_FRAME_INTRA_ONLY)
220  return;
221 
223  if (header->is_global[ref]) {
224  if (header->is_rot_zoom[ref]) {
226  } else {
227  type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
229  }
230  } else {
232  }
233  s->cur_frame.gm_type[ref] = type;
234 
235  if (type >= AV1_WARP_MODEL_ROTZOOM) {
236  read_global_param(s, type, ref, 2);
237  read_global_param(s, type, ref, 3);
238  if (type == AV1_WARP_MODEL_AFFINE) {
239  read_global_param(s, type, ref, 4);
240  read_global_param(s, type, ref, 5);
241  } else {
242  s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];
243  s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];
244  }
245  }
247  read_global_param(s, type, ref, 0);
248  read_global_param(s, type, ref, 1);
249  }
250  if (type <= AV1_WARP_MODEL_AFFINE) {
251  s->cur_frame.gm_invalid[ref] = !get_shear_params_valid(s, ref);
252  }
253  }
254 }
255 
257  unsigned int a, unsigned int b)
258 {
259  unsigned int diff = a - b;
260  unsigned int m = 1 << seq->order_hint_bits_minus_1;
261  return (diff & (m - 1)) - (diff & m);
262 }
263 
265 {
266  const AV1RawFrameHeader *header = s->raw_frame_header;
267  const AV1RawSequenceHeader *seq = s->raw_seq;
268 
269  int forward_idx, backward_idx;
270  int forward_hint, backward_hint;
271  int second_forward_idx, second_forward_hint;
272  int ref_hint, dist, i;
273 
274  if (header->frame_type == AV1_FRAME_KEY ||
275  header->frame_type == AV1_FRAME_INTRA_ONLY ||
276  !header->reference_select || !seq->enable_order_hint)
277  return;
278 
279  forward_idx = -1;
280  backward_idx = -1;
281  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
282  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
283  dist = get_relative_dist(seq, ref_hint, header->order_hint);
284  if (dist < 0) {
285  if (forward_idx < 0 ||
286  get_relative_dist(seq, ref_hint, forward_hint) > 0) {
287  forward_idx = i;
288  forward_hint = ref_hint;
289  }
290  } else if (dist > 0) {
291  if (backward_idx < 0 ||
292  get_relative_dist(seq, ref_hint, backward_hint) < 0) {
293  backward_idx = i;
294  backward_hint = ref_hint;
295  }
296  }
297  }
298 
299  if (forward_idx < 0) {
300  return;
301  } else if (backward_idx >= 0) {
302  s->cur_frame.skip_mode_frame_idx[0] =
303  AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);
304  s->cur_frame.skip_mode_frame_idx[1] =
305  AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);
306  return;
307  }
308 
309  second_forward_idx = -1;
310  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
311  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
312  if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {
313  if (second_forward_idx < 0 ||
314  get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {
315  second_forward_idx = i;
316  second_forward_hint = ref_hint;
317  }
318  }
319  }
320 
321  if (second_forward_idx < 0)
322  return;
323 
324  s->cur_frame.skip_mode_frame_idx[0] =
325  AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);
326  s->cur_frame.skip_mode_frame_idx[1] =
327  AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);
328 }
329 
331 {
332  const AV1RawFrameHeader *header = s->raw_frame_header;
333  int i;
334 
335  if (header->delta_q_y_dc || header->delta_q_u_ac ||
336  header->delta_q_u_dc || header->delta_q_v_ac ||
337  header->delta_q_v_dc) {
338  s->cur_frame.coded_lossless = 0;
339  return;
340  }
341 
342  s->cur_frame.coded_lossless = 1;
343  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
344  int qindex;
345  if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
346  qindex = (header->base_q_idx +
347  header->feature_value[i][AV1_SEG_LVL_ALT_Q]);
348  } else {
349  qindex = header->base_q_idx;
350  }
351  qindex = av_clip_uintp2(qindex, 8);
352 
353  if (qindex) {
354  s->cur_frame.coded_lossless = 0;
355  return;
356  }
357  }
358 }
359 
361 {
362  const AV1RawFrameHeader *header = s->raw_frame_header;
363  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
364  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
365 
366  if (!film_grain->apply_grain)
367  return;
368 
369  if (film_grain->update_grain) {
370  memcpy(dst, film_grain, sizeof(*dst));
371  return;
372  }
373 
374  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
375 
376  memcpy(dst, src, sizeof(*dst));
377  dst->grain_seed = film_grain->grain_seed;
378 }
379 
381 
382 {
383  int cur_tile_num =
384  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
385  if (s->tile_num < cur_tile_num) {
386  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
387  sizeof(TileGroupInfo));
388  if (ret < 0) {
389  s->tile_num = 0;
390  return ret;
391  }
392  }
393  s->tile_num = cur_tile_num;
394 
395  return 0;
396 }
397 
398 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
399 {
400  AV1DecContext *s = avctx->priv_data;
401  GetByteContext gb;
402  uint16_t tile_num, tile_row, tile_col;
403  uint32_t size = 0, size_bytes = 0;
404 
405  bytestream2_init(&gb, tile_group->tile_data.data,
406  tile_group->tile_data.data_size);
407  s->tg_start = tile_group->tg_start;
408  s->tg_end = tile_group->tg_end;
409 
410  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
411  tile_row = tile_num / s->raw_frame_header->tile_cols;
412  tile_col = tile_num % s->raw_frame_header->tile_cols;
413 
414  if (tile_num == tile_group->tg_end) {
415  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
416  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
417  s->tile_group_info[tile_num].tile_row = tile_row;
418  s->tile_group_info[tile_num].tile_column = tile_col;
419  return 0;
420  }
421  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
422  if (bytestream2_get_bytes_left(&gb) < size_bytes)
423  return AVERROR_INVALIDDATA;
424  size = 0;
425  for (int i = 0; i < size_bytes; i++)
426  size |= bytestream2_get_byteu(&gb) << 8 * i;
427  if (bytestream2_get_bytes_left(&gb) <= size)
428  return AVERROR_INVALIDDATA;
429  size++;
430 
431  s->tile_group_info[tile_num].tile_size = size;
432  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
433  s->tile_group_info[tile_num].tile_row = tile_row;
434  s->tile_group_info[tile_num].tile_column = tile_col;
435 
436  bytestream2_skipu(&gb, size);
437  }
438 
439  return 0;
440 
441 }
442 
443 static enum AVPixelFormat get_sw_pixel_format(void *logctx,
444  const AV1RawSequenceHeader *seq)
445 {
446  uint8_t bit_depth;
448 
449  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
450  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
451  else if (seq->seq_profile <= 2)
452  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
453  else {
454  av_log(logctx, AV_LOG_ERROR,
455  "Unknown AV1 profile %d.\n", seq->seq_profile);
456  return AV_PIX_FMT_NONE;
457  }
458 
459  if (!seq->color_config.mono_chrome) {
460  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
461  if (seq->color_config.subsampling_x == 0 &&
462  seq->color_config.subsampling_y == 0) {
463  if (bit_depth == 8)
465  else if (bit_depth == 10)
467  else if (bit_depth == 12)
469  else
470  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
471  } else if (seq->color_config.subsampling_x == 1 &&
472  seq->color_config.subsampling_y == 0) {
473  if (bit_depth == 8)
475  else if (bit_depth == 10)
477  else if (bit_depth == 12)
479  else
480  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
481  } else if (seq->color_config.subsampling_x == 1 &&
482  seq->color_config.subsampling_y == 1) {
483  if (bit_depth == 8)
485  else if (bit_depth == 10)
487  else if (bit_depth == 12)
489  else
490  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
491  }
492  } else {
493  if (bit_depth == 8)
495  else if (bit_depth == 10)
497  else if (bit_depth == 12)
499  else
500  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
501  }
502 
503  return pix_fmt;
504 }
505 
507 {
508  AV1DecContext *s = avctx->priv_data;
509  const AV1RawSequenceHeader *seq = s->raw_seq;
510  int ret;
511  enum AVPixelFormat pix_fmt = get_sw_pixel_format(avctx, seq);
512 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
513  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
514  CONFIG_AV1_D3D12VA_HWACCEL + \
515  CONFIG_AV1_NVDEC_HWACCEL + \
516  CONFIG_AV1_VAAPI_HWACCEL + \
517  CONFIG_AV1_VDPAU_HWACCEL + \
518  CONFIG_AV1_VULKAN_HWACCEL)
519  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
520 
521  if (pix_fmt == AV_PIX_FMT_NONE)
522  return -1;
523 
524  switch (pix_fmt) {
525  case AV_PIX_FMT_YUV420P:
526 #if CONFIG_AV1_DXVA2_HWACCEL
527  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
528 #endif
529 #if CONFIG_AV1_D3D11VA_HWACCEL
530  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
531  *fmtp++ = AV_PIX_FMT_D3D11;
532 #endif
533 #if CONFIG_AV1_D3D12VA_HWACCEL
534  *fmtp++ = AV_PIX_FMT_D3D12;
535 #endif
536 #if CONFIG_AV1_NVDEC_HWACCEL
537  *fmtp++ = AV_PIX_FMT_CUDA;
538 #endif
539 #if CONFIG_AV1_VAAPI_HWACCEL
540  *fmtp++ = AV_PIX_FMT_VAAPI;
541 #endif
542 #if CONFIG_AV1_VDPAU_HWACCEL
543  *fmtp++ = AV_PIX_FMT_VDPAU;
544 #endif
545 #if CONFIG_AV1_VULKAN_HWACCEL
546  *fmtp++ = AV_PIX_FMT_VULKAN;
547 #endif
548  break;
550 #if CONFIG_AV1_DXVA2_HWACCEL
551  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
552 #endif
553 #if CONFIG_AV1_D3D11VA_HWACCEL
554  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
555  *fmtp++ = AV_PIX_FMT_D3D11;
556 #endif
557 #if CONFIG_AV1_D3D12VA_HWACCEL
558  *fmtp++ = AV_PIX_FMT_D3D12;
559 #endif
560 #if CONFIG_AV1_NVDEC_HWACCEL
561  *fmtp++ = AV_PIX_FMT_CUDA;
562 #endif
563 #if CONFIG_AV1_VAAPI_HWACCEL
564  *fmtp++ = AV_PIX_FMT_VAAPI;
565 #endif
566 #if CONFIG_AV1_VDPAU_HWACCEL
567  *fmtp++ = AV_PIX_FMT_VDPAU;
568 #endif
569 #if CONFIG_AV1_VULKAN_HWACCEL
570  *fmtp++ = AV_PIX_FMT_VULKAN;
571 #endif
572  break;
574 #if CONFIG_AV1_VULKAN_HWACCEL
575  *fmtp++ = AV_PIX_FMT_VULKAN;
576 #endif
577  break;
578  case AV_PIX_FMT_YUV422P:
579 #if CONFIG_AV1_VULKAN_HWACCEL
580  *fmtp++ = AV_PIX_FMT_VULKAN;
581 #endif
582  break;
584 #if CONFIG_AV1_VULKAN_HWACCEL
585  *fmtp++ = AV_PIX_FMT_VULKAN;
586 #endif
587  break;
589 #if CONFIG_AV1_VULKAN_HWACCEL
590  *fmtp++ = AV_PIX_FMT_VULKAN;
591 #endif
592  break;
593  case AV_PIX_FMT_YUV444P:
594 #if CONFIG_AV1_VULKAN_HWACCEL
595  *fmtp++ = AV_PIX_FMT_VULKAN;
596 #endif
597  break;
599 #if CONFIG_AV1_VULKAN_HWACCEL
600  *fmtp++ = AV_PIX_FMT_VULKAN;
601 #endif
602  break;
604 #if CONFIG_AV1_VULKAN_HWACCEL
605  *fmtp++ = AV_PIX_FMT_VULKAN;
606 #endif
607  break;
608  case AV_PIX_FMT_GRAY8:
609 #if CONFIG_AV1_NVDEC_HWACCEL
610  *fmtp++ = AV_PIX_FMT_CUDA;
611 #endif
612  break;
613  case AV_PIX_FMT_GRAY10:
614 #if CONFIG_AV1_NVDEC_HWACCEL
615  *fmtp++ = AV_PIX_FMT_CUDA;
616 #endif
617  break;
618  }
619 
620  *fmtp++ = pix_fmt;
621  *fmtp = AV_PIX_FMT_NONE;
622 
623  for (int i = 0; pix_fmts[i] != pix_fmt; i++)
624  if (pix_fmts[i] == avctx->pix_fmt) {
625  s->pix_fmt = pix_fmt;
626  return 1;
627  }
628 
629  ret = ff_get_format(avctx, pix_fmts);
630 
631  /**
632  * check if the HW accel is inited correctly. If not, return un-implemented.
633  * Since now the av1 decoder doesn't support native decode, if it will be
634  * implemented in the future, need remove this check.
635  */
636  if (!avctx->hwaccel) {
637  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"
638  " hardware accelerated AV1 decoding.\n");
639  avctx->pix_fmt = AV_PIX_FMT_NONE;
640  return AVERROR(ENOSYS);
641  }
642 
643  s->pix_fmt = pix_fmt;
644  avctx->pix_fmt = ret;
645 
646  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
647  av_get_pix_fmt_name(avctx->pix_fmt));
648 
649  return 0;
650 }
651 
653 {
654  av_frame_unref(f->f);
655  ff_refstruct_unref(&f->hwaccel_picture_private);
656  ff_refstruct_unref(&f->header_ref);
657  f->raw_frame_header = NULL;
658  f->spatial_id = f->temporal_id = 0;
659  memset(f->skip_mode_frame_idx, 0,
660  2 * sizeof(uint8_t));
661  memset(&f->film_grain, 0, sizeof(f->film_grain));
662  f->coded_lossless = 0;
663 }
664 
665 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
666 {
667  int ret;
668 
669  ff_refstruct_replace(&dst->header_ref, src->header_ref);
670 
671  dst->raw_frame_header = src->raw_frame_header;
672 
673  if (!src->f->buf[0])
674  return 0;
675 
676  ret = av_frame_ref(dst->f, src->f);
677  if (ret < 0)
678  goto fail;
679 
681  src->hwaccel_picture_private);
682 
683  dst->spatial_id = src->spatial_id;
684  dst->temporal_id = src->temporal_id;
685  memcpy(dst->gm_invalid,
686  src->gm_invalid,
687  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
688  memcpy(dst->gm_type,
689  src->gm_type,
690  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
691  memcpy(dst->gm_params,
692  src->gm_params,
693  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
694  memcpy(dst->skip_mode_frame_idx,
695  src->skip_mode_frame_idx,
696  2 * sizeof(uint8_t));
697  memcpy(&dst->film_grain,
698  &src->film_grain,
699  sizeof(dst->film_grain));
700  dst->coded_lossless = src->coded_lossless;
701 
702  return 0;
703 
704 fail:
705  av1_frame_unref(dst);
706  return AVERROR(ENOMEM);
707 }
708 
710 {
711  AV1DecContext *s = avctx->priv_data;
712  AV1RawMetadataITUTT35 itut_t35;
713 
714  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
715  if (s->ref[i].f) {
716  av1_frame_unref(&s->ref[i]);
717  av_frame_free(&s->ref[i].f);
718  }
719  }
720  if (s->cur_frame.f) {
721  av1_frame_unref(&s->cur_frame);
722  av_frame_free(&s->cur_frame.f);
723  }
724  av_buffer_unref(&s->seq_data_ref);
725  ff_refstruct_unref(&s->seq_ref);
726  ff_refstruct_unref(&s->header_ref);
727  ff_refstruct_unref(&s->cll_ref);
728  ff_refstruct_unref(&s->mdcv_ref);
729  av_freep(&s->tile_group_info);
730 
731  while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
732  av_buffer_unref(&itut_t35.payload_ref);
733  av_fifo_freep2(&s->itut_t35_fifo);
734 
735  ff_cbs_fragment_free(&s->current_obu);
736  ff_cbs_close(&s->cbc);
737  ff_dovi_ctx_unref(&s->dovi);
738 
739  return 0;
740 }
741 
743  const AV1RawSequenceHeader *seq)
744 {
745  int width = seq->max_frame_width_minus_1 + 1;
746  int height = seq->max_frame_height_minus_1 + 1;
747 
748  avctx->profile = seq->seq_profile;
749  avctx->level = seq->seq_level_idx[0];
750 
751  avctx->color_range =
756 
757  switch (seq->color_config.chroma_sample_position) {
758  case AV1_CSP_VERTICAL:
760  break;
761  case AV1_CSP_COLOCATED:
763  break;
764  }
765 
766  if (seq->film_grain_params_present)
768  else
770 
771  if (avctx->width != width || avctx->height != height) {
772  int ret = ff_set_dimensions(avctx, width, height);
773  if (ret < 0)
774  return ret;
775  }
776 
777  if (seq->timing_info_present_flag)
780  seq->timing_info.time_scale);
781 
782  if (avctx->pix_fmt == AV_PIX_FMT_NONE)
783  avctx->pix_fmt = get_sw_pixel_format(avctx, seq);
784 
785  return 0;
786 }
787 
789  const AV1RawFrameHeader *header)
790 {
791  AVRational aspect_ratio;
792  int width = header->frame_width_minus_1 + 1;
793  int height = header->frame_height_minus_1 + 1;
794  int r_width = header->render_width_minus_1 + 1;
795  int r_height = header->render_height_minus_1 + 1;
796  int ret;
797 
798  if (avctx->width != width || avctx->height != height) {
799  ret = ff_set_dimensions(avctx, width, height);
800  if (ret < 0)
801  return ret;
802  }
803 
804  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
805  (int64_t)height * r_width,
806  (int64_t)width * r_height,
807  INT_MAX);
808 
809  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
810  ret = ff_set_sar(avctx, aspect_ratio);
811  if (ret < 0)
812  return ret;
813  }
814 
815  return 0;
816 }
817 
826 };
827 
829 {
830  AV1DecContext *s = avctx->priv_data;
832  const AVPacketSideData *sd;
833  int ret;
834 
835  s->avctx = avctx;
836  s->pkt = avctx->internal->in_pkt;
837  s->pix_fmt = AV_PIX_FMT_NONE;
838 
839  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
840  s->ref[i].f = av_frame_alloc();
841  if (!s->ref[i].f)
842  return AVERROR(ENOMEM);
843  }
844 
845  s->cur_frame.f = av_frame_alloc();
846  if (!s->cur_frame.f)
847  return AVERROR(ENOMEM);
848 
849  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
850  if (ret < 0)
851  return ret;
852 
853  s->cbc->decompose_unit_types = decompose_unit_types;
854  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);
855 
856  s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),
858  if (!s->itut_t35_fifo)
859  return AVERROR(ENOMEM);
860 
861  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
862 
863  if (avctx->extradata && avctx->extradata_size) {
865  &s->current_obu,
866  avctx);
867  if (ret < 0) {
868  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
869  goto end;
870  }
871 
872  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
873  if (!seq) {
874  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
875  goto end;
876  }
877 
878  ret = set_context_with_sequence(avctx, seq);
879  if (ret < 0) {
880  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
881  goto end;
882  }
883 
884  end:
885  ff_cbs_fragment_reset(&s->current_obu);
886  }
887 
888  s->dovi.logctx = avctx;
889  s->dovi.dv_profile = 10; // default for AV1
891  if (sd && sd->size > 0)
893 
894  return ret;
895 }
896 
898 {
899  AV1DecContext *s = avctx->priv_data;
900  AV1RawFrameHeader *header= s->raw_frame_header;
901  AVFrame *frame;
902  int ret;
903 
905  if (ret < 0) {
906  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
907  return ret;
908  }
909 
910  if ((ret = ff_thread_get_buffer(avctx, f->f, AV_GET_BUFFER_FLAG_REF)) < 0)
911  goto fail;
912 
913  frame = f->f;
914  if (header->frame_type == AV1_FRAME_KEY)
916  else
918 
919  switch (header->frame_type) {
920  case AV1_FRAME_KEY:
923  break;
924  case AV1_FRAME_INTER:
926  break;
927  case AV1_FRAME_SWITCH:
929  break;
930  }
931 
932  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
933  if (ret < 0)
934  goto fail;
935 
936  return 0;
937 
938 fail:
940  return ret;
941 }
942 
944  const AV1RawMetadataITUTT35 *itut_t35)
945 {
946  GetByteContext gb;
947  AV1DecContext *s = avctx->priv_data;
948  int ret, provider_code;
949 
950  bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);
951 
952  provider_code = bytestream2_get_be16(&gb);
953  switch (provider_code) {
954  case 0x31: { // atsc_provider_code
955  uint32_t user_identifier = bytestream2_get_be32(&gb);
956  switch (user_identifier) {
957  case MKBETAG('G', 'A', '9', '4'): { // closed captions
958  AVBufferRef *buf = NULL;
959 
961  if (ret < 0)
962  return ret;
963  if (!ret)
964  break;
965 
967  if (ret < 0)
968  return ret;
969 
971  break;
972  }
973  default: // ignore unsupported identifiers
974  break;
975  }
976  break;
977  }
978  case 0x3C: { // smpte_provider_code
979  AVDynamicHDRPlus *hdrplus;
980  int provider_oriented_code = bytestream2_get_be16(&gb);
981  int application_identifier = bytestream2_get_byte(&gb);
982 
983  if (itut_t35->itu_t_t35_country_code != 0xB5 ||
984  provider_oriented_code != 1 || application_identifier != 4)
985  break;
986 
988  if (!hdrplus)
989  return AVERROR(ENOMEM);
990 
993  if (ret < 0)
994  return ret;
995  break;
996  }
997  case 0x3B: { // dolby_provider_code
998  int provider_oriented_code = bytestream2_get_be32(&gb);
999  if (itut_t35->itu_t_t35_country_code != 0xB5 || provider_oriented_code != 0x800)
1000  break;
1001 
1002  ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer);
1003  if (ret < 0) {
1004  av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
1005  break; // ignore
1006  }
1007 
1008  ret = ff_dovi_attach_side_data(&s->dovi, frame);
1009  if (ret < 0)
1010  return ret;
1011  break;
1012  }
1013  default: // ignore unsupported provider codes
1014  break;
1015  }
1016 
1017  return 0;
1018 }
1019 
1021 {
1022  AV1DecContext *s = avctx->priv_data;
1023  AV1RawMetadataITUTT35 itut_t35;
1024  int ret = 0;
1025 
1026  if (s->mdcv) {
1027  AVMasteringDisplayMetadata *mastering;
1028 
1029  ret = ff_decode_mastering_display_new(avctx, frame, &mastering);
1030  if (ret < 0)
1031  return ret;
1032 
1033  if (mastering) {
1034  for (int i = 0; i < 3; i++) {
1035  mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);
1036  mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);
1037  }
1038  mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);
1039  mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);
1040 
1041  mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);
1042  mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);
1043 
1044  mastering->has_primaries = 1;
1045  mastering->has_luminance = 1;
1046  }
1047  }
1048 
1049  if (s->cll) {
1050  AVContentLightMetadata *light;
1051 
1052  ret = ff_decode_content_light_new(avctx, frame, &light);
1053  if (ret < 0)
1054  return ret;
1055 
1056  if (light) {
1057  light->MaxCLL = s->cll->max_cll;
1058  light->MaxFALL = s->cll->max_fall;
1059  }
1060  }
1061 
1062  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {
1063  if (ret >= 0)
1064  ret = export_itut_t35(avctx, frame, &itut_t35);
1065  av_buffer_unref(&itut_t35.payload_ref);
1066  }
1067 
1068  return ret;
1069 }
1070 
1072 {
1073  AV1DecContext *s = avctx->priv_data;
1074  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
1075  AVFilmGrainParams *fgp;
1076  AVFilmGrainAOMParams *aom;
1077 
1078  if (!film_grain->apply_grain)
1079  return 0;
1080 
1082  if (!fgp)
1083  return AVERROR(ENOMEM);
1084 
1086  fgp->seed = film_grain->grain_seed;
1087 
1088  aom = &fgp->codec.aom;
1090  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
1091  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
1092  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
1093  aom->grain_scale_shift = film_grain->grain_scale_shift;
1094  aom->overlap_flag = film_grain->overlap_flag;
1095  aom->limit_output_range = film_grain->clip_to_restricted_range;
1096 
1097  aom->num_y_points = film_grain->num_y_points;
1098  for (int i = 0; i < film_grain->num_y_points; i++) {
1099  aom->y_points[i][0] = film_grain->point_y_value[i];
1100  aom->y_points[i][1] = film_grain->point_y_scaling[i];
1101  }
1102  aom->num_uv_points[0] = film_grain->num_cb_points;
1103  for (int i = 0; i < film_grain->num_cb_points; i++) {
1104  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
1105  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
1106  }
1107  aom->num_uv_points[1] = film_grain->num_cr_points;
1108  for (int i = 0; i < film_grain->num_cr_points; i++) {
1109  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
1110  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
1111  }
1112 
1113  for (int i = 0; i < 24; i++) {
1114  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
1115  }
1116  for (int i = 0; i < 25; i++) {
1117  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
1118  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
1119  }
1120 
1121  aom->uv_mult[0] = film_grain->cb_mult;
1122  aom->uv_mult[1] = film_grain->cr_mult;
1123  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
1124  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
1125  aom->uv_offset[0] = film_grain->cb_offset;
1126  aom->uv_offset[1] = film_grain->cr_offset;
1127 
1128  return 0;
1129 }
1130 
1132 {
1133  AV1DecContext *s = avctx->priv_data;
1134  const AVFrame *srcframe = s->cur_frame.f;
1135  AVPacket *pkt = s->pkt;
1136  int ret;
1137 
1138  // TODO: all layers
1139  if (s->operating_point_idc &&
1140  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
1141  return 0;
1142 
1143  ret = av_frame_ref(frame, srcframe);
1144  if (ret < 0)
1145  return ret;
1146 
1147  ret = export_metadata(avctx, frame);
1148  if (ret < 0) {
1150  return ret;
1151  }
1152 
1154  ret = export_film_grain(avctx, frame);
1155  if (ret < 0) {
1157  return ret;
1158  }
1159  }
1160 
1161  frame->pts = pkt->pts;
1162  frame->pkt_dts = pkt->dts;
1163 #if FF_API_FRAME_PKT
1165  frame->pkt_size = pkt->size;
1166  frame->pkt_pos = pkt->pos;
1168 #endif
1169 
1171 
1172  return 0;
1173 }
1174 
1176 {
1177  AV1DecContext *s = avctx->priv_data;
1178  const AV1RawFrameHeader *header = s->raw_frame_header;
1179  int ret;
1180 
1181  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1182  if (header->refresh_frame_flags & (1 << i)) {
1183  av1_frame_unref(&s->ref[i]);
1184  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
1185  av_log(avctx, AV_LOG_ERROR,
1186  "Failed to update frame %d in reference list\n", i);
1187  return ret;
1188  }
1189  }
1190  }
1191  return 0;
1192 }
1193 
1195 {
1196  AV1DecContext *s = avctx->priv_data;
1197  int ret;
1198 
1199  av1_frame_unref(&s->cur_frame);
1200 
1201  s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
1202 
1203  s->cur_frame.raw_frame_header = s->raw_frame_header;
1204 
1205  ret = init_tile_data(s);
1206  if (ret < 0) {
1207  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
1208  return ret;
1209  }
1210 
1211  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
1212  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
1213  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
1214  (avctx->skip_frame >= AVDISCARD_NONKEY &&
1215  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
1216  avctx->skip_frame >= AVDISCARD_ALL)
1217  return 0;
1218 
1219  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1220  ret = get_pixel_format(avctx);
1221  if (ret < 0) {
1222  av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format.\n");
1223  return ret;
1224  }
1225 
1226  if (!ret && FF_HW_HAS_CB(avctx, decode_params)) {
1227  ret = FF_HW_CALL(avctx, decode_params, AV1_OBU_SEQUENCE_HEADER,
1228  s->seq_data_ref->data, s->seq_data_ref->size);
1229  if (ret < 0) {
1230  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1231  return ret;
1232  }
1233  }
1234  }
1235 
1236  ret = av1_frame_alloc(avctx, &s->cur_frame);
1237  if (ret < 0) {
1238  av_log(avctx, AV_LOG_ERROR,
1239  "Failed to allocate space for current frame.\n");
1240  return ret;
1241  }
1242 
1247 
1248  return ret;
1249 }
1250 
1252 {
1253  AV1DecContext *s = avctx->priv_data;
1254  AV1RawTileGroup *raw_tile_group = NULL;
1255  int i = 0, ret;
1256 
1257  for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {
1258  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1259  AV1RawOBU *obu = unit->content;
1260  const AV1RawOBUHeader *header;
1261 
1262  av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu);
1263 
1264  if (unit->type == AV1_OBU_TILE_LIST) {
1265  av_log(avctx, AV_LOG_ERROR, "Large scale tile decoding is unsupported.\n");
1267  goto end;
1268  }
1269 
1270  if (!obu)
1271  continue;
1272 
1273  header = &obu->header;
1274 
1275  switch (unit->type) {
1277  ret = av_buffer_replace(&s->seq_data_ref, unit->data_ref);
1278  if (ret < 0)
1279  goto end;
1280 
1281  s->seq_data_ref->data = unit->data;
1282  s->seq_data_ref->size = unit->data_size;
1283  ff_refstruct_replace(&s->seq_ref, unit->content_ref);
1284 
1285  s->raw_seq = &obu->obu.sequence_header;
1286 
1287  ret = set_context_with_sequence(avctx, s->raw_seq);
1288  if (ret < 0) {
1289  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1290  s->raw_seq = NULL;
1291  goto end;
1292  }
1293 
1294  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1295 
1296  s->pix_fmt = AV_PIX_FMT_NONE;
1297 
1298  break;
1300  if (s->raw_frame_header)
1301  break;
1302  // fall-through
1303  case AV1_OBU_FRAME:
1304  case AV1_OBU_FRAME_HEADER:
1305  if (!s->raw_seq) {
1306  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1308  goto end;
1309  }
1310 
1311  ff_refstruct_replace(&s->header_ref, unit->content_ref);
1312 
1313  if (unit->type == AV1_OBU_FRAME)
1314  s->raw_frame_header = &obu->obu.frame.header;
1315  else
1316  s->raw_frame_header = &obu->obu.frame_header;
1317 
1318  if (s->raw_frame_header->show_existing_frame) {
1319  av1_frame_unref(&s->cur_frame);
1320 
1321  ret = av1_frame_ref(avctx, &s->cur_frame,
1322  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1323  if (ret < 0) {
1324  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
1325  goto end;
1326  }
1327 
1328  ret = update_reference_list(avctx);
1329  if (ret < 0) {
1330  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1331  goto end;
1332  }
1333 
1334  if (s->cur_frame.f->buf[0]) {
1335  ret = set_output_frame(avctx, frame);
1336  if (ret < 0)
1337  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1338  }
1339 
1340  s->raw_frame_header = NULL;
1341  i++;
1342 
1343  goto end;
1344  }
1345 
1346  ret = get_current_frame(avctx);
1347  if (ret < 0) {
1348  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1349  goto end;
1350  }
1351 
1352  s->cur_frame.spatial_id = header->spatial_id;
1353  s->cur_frame.temporal_id = header->temporal_id;
1354 
1355  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1356  ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);
1357  if (ret < 0) {
1358  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1359  goto end;
1360  }
1361  }
1362  if (unit->type != AV1_OBU_FRAME)
1363  break;
1364  // fall-through
1365  case AV1_OBU_TILE_GROUP:
1366  if (!s->raw_frame_header) {
1367  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1369  goto end;
1370  }
1371 
1372  if (unit->type == AV1_OBU_FRAME)
1373  raw_tile_group = &obu->obu.frame.tile_group;
1374  else
1375  raw_tile_group = &obu->obu.tile_group;
1376 
1377  ret = get_tiles_info(avctx, raw_tile_group);
1378  if (ret < 0)
1379  goto end;
1380 
1381  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1382  ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,
1383  raw_tile_group->tile_data.data_size);
1384  if (ret < 0) {
1385  av_log(avctx, AV_LOG_ERROR,
1386  "HW accel decode slice fail.\n");
1387  goto end;
1388  }
1389  }
1390  break;
1391  case AV1_OBU_TILE_LIST:
1393  case AV1_OBU_PADDING:
1394  break;
1395  case AV1_OBU_METADATA:
1396  switch (obu->obu.metadata.metadata_type) {
1398  ff_refstruct_replace(&s->cll_ref, unit->content_ref);
1399  s->cll = &obu->obu.metadata.metadata.hdr_cll;
1400  break;
1402  ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
1403  s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
1404  break;
1406  AV1RawMetadataITUTT35 itut_t35;
1407  memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));
1409  if (!itut_t35.payload_ref) {
1410  ret = AVERROR(ENOMEM);
1411  goto end;
1412  }
1413  ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);
1414  if (ret < 0) {
1415  av_buffer_unref(&itut_t35.payload_ref);
1416  goto end;
1417  }
1418  break;
1419  }
1420  default:
1421  break;
1422  }
1423  break;
1424  default:
1425  av_log(avctx, AV_LOG_DEBUG,
1426  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1427  unit->type, unit->data_size);
1428  }
1429 
1430  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1431  int show_frame = s->raw_frame_header->show_frame;
1432  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1433  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
1434  if (ret < 0) {
1435  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1436  goto end;
1437  }
1438  }
1439 
1440  ret = update_reference_list(avctx);
1441  if (ret < 0) {
1442  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1443  goto end;
1444  }
1445 
1446  if (s->raw_frame_header->show_frame && s->cur_frame.f->buf[0]) {
1447  ret = set_output_frame(avctx, frame);
1448  if (ret < 0) {
1449  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1450  goto end;
1451  }
1452  }
1453  raw_tile_group = NULL;
1454  s->raw_frame_header = NULL;
1455  if (show_frame) {
1456  i++;
1457  goto end;
1458  }
1459  }
1460  }
1461 
1462  ret = AVERROR(EAGAIN);
1463 end:
1464  av_assert0(i <= s->current_obu.nb_units);
1465  s->nb_unit = i;
1466 
1467  if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {
1468  if (ret < 0)
1469  s->raw_frame_header = NULL;
1470  av_packet_unref(s->pkt);
1471  ff_cbs_fragment_reset(&s->current_obu);
1472  s->nb_unit = 0;
1473  }
1474  if (!ret && !frame->buf[0])
1475  ret = AVERROR(EAGAIN);
1476 
1477  return ret;
1478 }
1479 
1481 {
1482  AV1DecContext *s = avctx->priv_data;
1483  int ret;
1484 
1485  do {
1486  if (!s->current_obu.nb_units) {
1487  ret = ff_decode_get_packet(avctx, s->pkt);
1488  if (ret < 0)
1489  return ret;
1490 
1491  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);
1492  if (ret < 0) {
1493  ff_cbs_fragment_reset(&s->current_obu);
1494  av_packet_unref(s->pkt);
1495  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1496  return ret;
1497  }
1498 
1499  s->nb_unit = 0;
1500  av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",
1501  s->current_obu.nb_units);
1502  }
1503 
1505  } while (ret == AVERROR(EAGAIN));
1506 
1507  return ret;
1508 }
1509 
1511 {
1512  AV1DecContext *s = avctx->priv_data;
1513  AV1RawMetadataITUTT35 itut_t35;
1514 
1515  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1516  av1_frame_unref(&s->ref[i]);
1517 
1518  av1_frame_unref(&s->cur_frame);
1519  s->operating_point_idc = 0;
1520  s->nb_unit = 0;
1521  s->raw_frame_header = NULL;
1522  s->raw_seq = NULL;
1523  s->cll = NULL;
1524  s->mdcv = NULL;
1525  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
1526  av_buffer_unref(&itut_t35.payload_ref);
1527 
1528  ff_cbs_fragment_reset(&s->current_obu);
1529  ff_cbs_flush(s->cbc);
1530 
1531  if (FF_HW_HAS_CB(avctx, flush))
1532  FF_HW_SIMPLE_CALL(avctx, flush);
1533 }
1534 
1535 #define OFFSET(x) offsetof(AV1DecContext, x)
1536 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1537 static const AVOption av1_options[] = {
1538  { "operating_point", "Select an operating point of the scalable bitstream",
1539  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1540  { NULL }
1541 };
1542 
1543 static const AVClass av1_class = {
1544  .class_name = "AV1 decoder",
1545  .item_name = av_default_item_name,
1546  .option = av1_options,
1547  .version = LIBAVUTIL_VERSION_INT,
1548 };
1549 
1551  .p.name = "av1",
1552  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1553  .p.type = AVMEDIA_TYPE_VIDEO,
1554  .p.id = AV_CODEC_ID_AV1,
1555  .priv_data_size = sizeof(AV1DecContext),
1556  .init = av1_decode_init,
1557  .close = av1_decode_free,
1559  .p.capabilities = AV_CODEC_CAP_DR1,
1561  .flush = av1_decode_flush,
1562  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1563  .p.priv_class = &av1_class,
1564  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1565 #if CONFIG_AV1_DXVA2_HWACCEL
1566  HWACCEL_DXVA2(av1),
1567 #endif
1568 #if CONFIG_AV1_D3D11VA_HWACCEL
1569  HWACCEL_D3D11VA(av1),
1570 #endif
1571 #if CONFIG_AV1_D3D11VA2_HWACCEL
1572  HWACCEL_D3D11VA2(av1),
1573 #endif
1574 #if CONFIG_AV1_D3D12VA_HWACCEL
1575  HWACCEL_D3D12VA(av1),
1576 #endif
1577 #if CONFIG_AV1_NVDEC_HWACCEL
1578  HWACCEL_NVDEC(av1),
1579 #endif
1580 #if CONFIG_AV1_VAAPI_HWACCEL
1581  HWACCEL_VAAPI(av1),
1582 #endif
1583 #if CONFIG_AV1_VDPAU_HWACCEL
1584  HWACCEL_VDPAU(av1),
1585 #endif
1586 #if CONFIG_AV1_VULKAN_HWACCEL
1587  HWACCEL_VULKAN(av1),
1588 #endif
1589 
1590  NULL
1591  },
1592 };
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:1357
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: avpacket.c:427
AV1RawTimingInfo::time_scale
uint32_t time_scale
Definition: cbs_av1.h:60
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:88
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:220
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:828
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:126
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:44
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:133
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:1837
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:117
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:113
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:1219
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:330
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:185
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:897
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:122
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:107
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
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:1194
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:88
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:236
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:119
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
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:373
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:742
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:683
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:171
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
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
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:612
decompose_unit_types
static const CodedBitstreamUnitType decompose_unit_types[]
Definition: av1dec.c:818
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:245
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:553
get_relative_dist
static int get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: av1dec.c:256
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::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:228
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:141
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:139
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:114
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
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:375
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:68
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:1537
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:665
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:70
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:146
AVRational::num
int num
Numerator.
Definition: rational.h:59
refstruct.h
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:62
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:76
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:2898
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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
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:591
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:207
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:1900
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:31
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:709
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:380
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:374
update_reference_list
static int update_reference_list(AVCodecContext *avctx)
Definition: av1dec.c:1175
decode.h
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:160
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:443
AVFrame::pkt_size
attribute_deprecated int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:684
AV1RawColorConfig::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_av1.h:48
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:398
export_itut_t35
static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame, const AV1RawMetadataITUTT35 *itut_t35)
Definition: av1dec.c:943
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
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:1861
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:360
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1550
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:68
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:113
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:109
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:704
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:706
AVFilmGrainParams::codec
union AVFilmGrainParams::@354 codec
Additional fields may be added both here and in any structure included.
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:652
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:75
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:367
AV1_OBU_TILE_GROUP
@ AV1_OBU_TILE_GROUP
Definition: av1.h:33
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:459
update_context_with_frame_header
static int update_context_with_frame_header(AVCodecContext *avctx, const AV1RawFrameHeader *header)
Definition: av1dec.c:788
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:264
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
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:789
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:120
resolve_divisor
static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
Resolve divisor process.
Definition: av1dec.c:155
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
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
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:121
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:106
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:312
decode_unsigned_subexp_with_ref
static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp, int mx, int r)
Definition: av1dec.c:80
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:262
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:84
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:108
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:216
AVFrame::pkt_pos
attribute_deprecated int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:650
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:164
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
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:223
VD
#define VD
Definition: av1dec.c:1536
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:294
av1_receive_frame
static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1480
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:73
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1510
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:1071
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
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:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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:43
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
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:534
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:666
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:111
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
ff_dovi_rpu_parse
int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
Parse the contents of a Dovi RPU NAL and update the parsed values in the DOVIContext struct.
Definition: dovi_rpu.c:198
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:1543
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
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
AV1Frame::gm_invalid
uint8_t gm_invalid[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:47
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:1873
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:97
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:134
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:141
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:116
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:175
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
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:1020
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:303
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
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
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
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
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:90
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:115
AV1Frame::temporal_id
int temporal_id
Definition: av1dec.h:44
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:89
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:105
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:83
get_pixel_format
static int get_pixel_format(AVCodecContext *avctx)
Definition: av1dec.c:506
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
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:1535
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:106
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:542
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:425
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:86
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:91
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:110
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:1251
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:135
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:220
set_output_frame
static int set_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1131
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
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:83
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:67
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:2882
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:52
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:436