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 AV1RawSequenceHeader *seq = s->raw_seq;
366  AV1Frame *frame = &s->cur_frame;
367 
368  frame->order_hint = header->order_hint;
369 
370  for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
371  int ref_name = i + AV1_REF_FRAME_LAST;
372  int ref_slot = header->ref_frame_idx[i];
373  int ref_order_hint = s->ref[ref_slot].order_hint;
374 
375  frame->order_hints[ref_name] = ref_order_hint;
376  frame->ref_frame_sign_bias[ref_name] =
377  get_relative_dist(seq, ref_order_hint, frame->order_hint);
378  }
379 }
380 
382 {
383  const AV1RawFrameHeader *header = s->raw_frame_header;
384  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
385  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
386 
387  if (!film_grain->apply_grain)
388  return;
389 
390  if (film_grain->update_grain) {
391  memcpy(dst, film_grain, sizeof(*dst));
392  return;
393  }
394 
395  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
396 
397  memcpy(dst, src, sizeof(*dst));
398  dst->grain_seed = film_grain->grain_seed;
399 }
400 
402 
403 {
404  int cur_tile_num =
405  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
406  if (s->tile_num < cur_tile_num) {
407  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
408  sizeof(TileGroupInfo));
409  if (ret < 0) {
410  s->tile_num = 0;
411  return ret;
412  }
413  }
414  s->tile_num = cur_tile_num;
415 
416  return 0;
417 }
418 
419 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
420 {
421  AV1DecContext *s = avctx->priv_data;
422  GetByteContext gb;
423  uint16_t tile_num, tile_row, tile_col;
424  uint32_t size = 0, size_bytes = 0;
425 
426  bytestream2_init(&gb, tile_group->tile_data.data,
427  tile_group->tile_data.data_size);
428  s->tg_start = tile_group->tg_start;
429  s->tg_end = tile_group->tg_end;
430 
431  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
432  tile_row = tile_num / s->raw_frame_header->tile_cols;
433  tile_col = tile_num % s->raw_frame_header->tile_cols;
434 
435  if (tile_num == tile_group->tg_end) {
436  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
437  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
438  s->tile_group_info[tile_num].tile_row = tile_row;
439  s->tile_group_info[tile_num].tile_column = tile_col;
440  return 0;
441  }
442  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
443  if (bytestream2_get_bytes_left(&gb) < size_bytes)
444  return AVERROR_INVALIDDATA;
445  size = 0;
446  for (int i = 0; i < size_bytes; i++)
447  size |= bytestream2_get_byteu(&gb) << 8 * i;
448  if (bytestream2_get_bytes_left(&gb) <= size)
449  return AVERROR_INVALIDDATA;
450  size++;
451 
452  s->tile_group_info[tile_num].tile_size = size;
453  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
454  s->tile_group_info[tile_num].tile_row = tile_row;
455  s->tile_group_info[tile_num].tile_column = tile_col;
456 
457  bytestream2_skipu(&gb, size);
458  }
459 
460  return 0;
461 
462 }
463 
464 static enum AVPixelFormat get_sw_pixel_format(void *logctx,
465  const AV1RawSequenceHeader *seq)
466 {
467  uint8_t bit_depth;
469 
470  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
471  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
472  else if (seq->seq_profile <= 2)
473  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
474  else {
475  av_log(logctx, AV_LOG_ERROR,
476  "Unknown AV1 profile %d.\n", seq->seq_profile);
477  return AV_PIX_FMT_NONE;
478  }
479 
480  if (!seq->color_config.mono_chrome) {
481  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
482  if (seq->color_config.subsampling_x == 0 &&
483  seq->color_config.subsampling_y == 0) {
484  if (bit_depth == 8)
486  else if (bit_depth == 10)
488  else if (bit_depth == 12)
490  else
491  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
492  } else if (seq->color_config.subsampling_x == 1 &&
493  seq->color_config.subsampling_y == 0) {
494  if (bit_depth == 8)
496  else if (bit_depth == 10)
498  else if (bit_depth == 12)
500  else
501  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
502  } else if (seq->color_config.subsampling_x == 1 &&
503  seq->color_config.subsampling_y == 1) {
504  if (bit_depth == 8)
506  else if (bit_depth == 10)
508  else if (bit_depth == 12)
510  else
511  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
512  }
513  } else {
514  if (bit_depth == 8)
516  else if (bit_depth == 10)
518  else if (bit_depth == 12)
520  else
521  av_log(logctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
522  }
523 
524  return pix_fmt;
525 }
526 
528 {
529  AV1DecContext *s = avctx->priv_data;
530  const AV1RawSequenceHeader *seq = s->raw_seq;
531  int ret;
532  enum AVPixelFormat pix_fmt = get_sw_pixel_format(avctx, seq);
533 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
534  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
535  CONFIG_AV1_D3D12VA_HWACCEL + \
536  CONFIG_AV1_NVDEC_HWACCEL + \
537  CONFIG_AV1_VAAPI_HWACCEL + \
538  CONFIG_AV1_VDPAU_HWACCEL + \
539  CONFIG_AV1_VULKAN_HWACCEL)
540  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
541 
542  if (pix_fmt == AV_PIX_FMT_NONE)
543  return -1;
544 
545  switch (pix_fmt) {
546  case AV_PIX_FMT_YUV420P:
547 #if CONFIG_AV1_DXVA2_HWACCEL
548  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
549 #endif
550 #if CONFIG_AV1_D3D11VA_HWACCEL
551  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
552  *fmtp++ = AV_PIX_FMT_D3D11;
553 #endif
554 #if CONFIG_AV1_D3D12VA_HWACCEL
555  *fmtp++ = AV_PIX_FMT_D3D12;
556 #endif
557 #if CONFIG_AV1_NVDEC_HWACCEL
558  *fmtp++ = AV_PIX_FMT_CUDA;
559 #endif
560 #if CONFIG_AV1_VAAPI_HWACCEL
561  *fmtp++ = AV_PIX_FMT_VAAPI;
562 #endif
563 #if CONFIG_AV1_VDPAU_HWACCEL
564  *fmtp++ = AV_PIX_FMT_VDPAU;
565 #endif
566 #if CONFIG_AV1_VULKAN_HWACCEL
567  *fmtp++ = AV_PIX_FMT_VULKAN;
568 #endif
569  break;
571 #if CONFIG_AV1_DXVA2_HWACCEL
572  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
573 #endif
574 #if CONFIG_AV1_D3D11VA_HWACCEL
575  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
576  *fmtp++ = AV_PIX_FMT_D3D11;
577 #endif
578 #if CONFIG_AV1_D3D12VA_HWACCEL
579  *fmtp++ = AV_PIX_FMT_D3D12;
580 #endif
581 #if CONFIG_AV1_NVDEC_HWACCEL
582  *fmtp++ = AV_PIX_FMT_CUDA;
583 #endif
584 #if CONFIG_AV1_VAAPI_HWACCEL
585  *fmtp++ = AV_PIX_FMT_VAAPI;
586 #endif
587 #if CONFIG_AV1_VDPAU_HWACCEL
588  *fmtp++ = AV_PIX_FMT_VDPAU;
589 #endif
590 #if CONFIG_AV1_VULKAN_HWACCEL
591  *fmtp++ = AV_PIX_FMT_VULKAN;
592 #endif
593  break;
595 #if CONFIG_AV1_VULKAN_HWACCEL
596  *fmtp++ = AV_PIX_FMT_VULKAN;
597 #endif
598  break;
599  case AV_PIX_FMT_YUV422P:
600 #if CONFIG_AV1_VULKAN_HWACCEL
601  *fmtp++ = AV_PIX_FMT_VULKAN;
602 #endif
603  break;
605 #if CONFIG_AV1_VULKAN_HWACCEL
606  *fmtp++ = AV_PIX_FMT_VULKAN;
607 #endif
608  break;
610 #if CONFIG_AV1_VULKAN_HWACCEL
611  *fmtp++ = AV_PIX_FMT_VULKAN;
612 #endif
613  break;
614  case AV_PIX_FMT_YUV444P:
615 #if CONFIG_AV1_VULKAN_HWACCEL
616  *fmtp++ = AV_PIX_FMT_VULKAN;
617 #endif
618  break;
620 #if CONFIG_AV1_VULKAN_HWACCEL
621  *fmtp++ = AV_PIX_FMT_VULKAN;
622 #endif
623  break;
625 #if CONFIG_AV1_VULKAN_HWACCEL
626  *fmtp++ = AV_PIX_FMT_VULKAN;
627 #endif
628  break;
629  case AV_PIX_FMT_GRAY8:
630 #if CONFIG_AV1_NVDEC_HWACCEL
631  *fmtp++ = AV_PIX_FMT_CUDA;
632 #endif
633  break;
634  case AV_PIX_FMT_GRAY10:
635 #if CONFIG_AV1_NVDEC_HWACCEL
636  *fmtp++ = AV_PIX_FMT_CUDA;
637 #endif
638  break;
639  }
640 
641  *fmtp++ = pix_fmt;
642  *fmtp = AV_PIX_FMT_NONE;
643 
644  for (int i = 0; pix_fmts[i] != pix_fmt; i++)
645  if (pix_fmts[i] == avctx->pix_fmt) {
646  s->pix_fmt = pix_fmt;
647  return 1;
648  }
649 
650  ret = ff_get_format(avctx, pix_fmts);
651 
652  /**
653  * check if the HW accel is inited correctly. If not, return un-implemented.
654  * Since now the av1 decoder doesn't support native decode, if it will be
655  * implemented in the future, need remove this check.
656  */
657  if (!avctx->hwaccel) {
658  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"
659  " hardware accelerated AV1 decoding.\n");
660  avctx->pix_fmt = AV_PIX_FMT_NONE;
661  return AVERROR(ENOSYS);
662  }
663 
664  s->pix_fmt = pix_fmt;
665  avctx->pix_fmt = ret;
666 
667  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
668  av_get_pix_fmt_name(avctx->pix_fmt));
669 
670  return 0;
671 }
672 
674 {
675  av_frame_unref(f->f);
676  ff_refstruct_unref(&f->hwaccel_picture_private);
677  ff_refstruct_unref(&f->header_ref);
678  f->raw_frame_header = NULL;
679  f->spatial_id = f->temporal_id = 0;
680  memset(f->skip_mode_frame_idx, 0,
681  2 * sizeof(uint8_t));
682  memset(&f->film_grain, 0, sizeof(f->film_grain));
683  f->coded_lossless = 0;
684 }
685 
686 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
687 {
688  int ret;
689 
690  ff_refstruct_replace(&dst->header_ref, src->header_ref);
691 
692  dst->raw_frame_header = src->raw_frame_header;
693 
694  if (!src->f->buf[0])
695  return 0;
696 
697  ret = av_frame_ref(dst->f, src->f);
698  if (ret < 0)
699  goto fail;
700 
702  src->hwaccel_picture_private);
703 
704  dst->spatial_id = src->spatial_id;
705  dst->temporal_id = src->temporal_id;
706  memcpy(dst->gm_invalid,
707  src->gm_invalid,
708  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
709  memcpy(dst->gm_type,
710  src->gm_type,
711  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
712  memcpy(dst->gm_params,
713  src->gm_params,
714  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
715  memcpy(dst->skip_mode_frame_idx,
716  src->skip_mode_frame_idx,
717  2 * sizeof(uint8_t));
718  memcpy(&dst->film_grain,
719  &src->film_grain,
720  sizeof(dst->film_grain));
721  dst->coded_lossless = src->coded_lossless;
722 
723  dst->order_hint = src->order_hint;
724  memcpy(dst->ref_frame_sign_bias, src->ref_frame_sign_bias,
725  sizeof(dst->ref_frame_sign_bias));
726  memcpy(dst->order_hints, src->order_hints,
727  sizeof(dst->order_hints));
728 
729  return 0;
730 
731 fail:
732  av1_frame_unref(dst);
733  return AVERROR(ENOMEM);
734 }
735 
737 {
738  AV1DecContext *s = avctx->priv_data;
739  AV1RawMetadataITUTT35 itut_t35;
740 
741  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
742  if (s->ref[i].f) {
743  av1_frame_unref(&s->ref[i]);
744  av_frame_free(&s->ref[i].f);
745  }
746  }
747  if (s->cur_frame.f) {
748  av1_frame_unref(&s->cur_frame);
749  av_frame_free(&s->cur_frame.f);
750  }
751  av_buffer_unref(&s->seq_data_ref);
752  ff_refstruct_unref(&s->seq_ref);
753  ff_refstruct_unref(&s->header_ref);
754  ff_refstruct_unref(&s->cll_ref);
755  ff_refstruct_unref(&s->mdcv_ref);
756  av_freep(&s->tile_group_info);
757 
758  while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
759  av_buffer_unref(&itut_t35.payload_ref);
760  av_fifo_freep2(&s->itut_t35_fifo);
761 
762  ff_cbs_fragment_free(&s->current_obu);
763  ff_cbs_close(&s->cbc);
764  ff_dovi_ctx_unref(&s->dovi);
765 
766  return 0;
767 }
768 
770  const AV1RawSequenceHeader *seq)
771 {
772  int width = seq->max_frame_width_minus_1 + 1;
773  int height = seq->max_frame_height_minus_1 + 1;
774 
775  avctx->profile = seq->seq_profile;
776  avctx->level = seq->seq_level_idx[0];
777 
778  avctx->color_range =
783 
784  switch (seq->color_config.chroma_sample_position) {
785  case AV1_CSP_VERTICAL:
787  break;
788  case AV1_CSP_COLOCATED:
790  break;
791  }
792 
793  if (seq->film_grain_params_present)
795  else
797 
798  if (avctx->width != width || avctx->height != height) {
799  int ret = ff_set_dimensions(avctx, width, height);
800  if (ret < 0)
801  return ret;
802  }
803 
804  if (seq->timing_info_present_flag)
807  seq->timing_info.time_scale);
808 
809  if (avctx->pix_fmt == AV_PIX_FMT_NONE)
810  avctx->pix_fmt = get_sw_pixel_format(avctx, seq);
811 
812  return 0;
813 }
814 
816  const AV1RawFrameHeader *header)
817 {
818  AVRational aspect_ratio;
819  int width = header->frame_width_minus_1 + 1;
820  int height = header->frame_height_minus_1 + 1;
821  int r_width = header->render_width_minus_1 + 1;
822  int r_height = header->render_height_minus_1 + 1;
823  int ret;
824 
825  if (avctx->width != width || avctx->height != height) {
826  ret = ff_set_dimensions(avctx, width, height);
827  if (ret < 0)
828  return ret;
829  }
830 
831  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
832  (int64_t)height * r_width,
833  (int64_t)width * r_height,
834  INT_MAX);
835 
836  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
837  ret = ff_set_sar(avctx, aspect_ratio);
838  if (ret < 0)
839  return ret;
840  }
841 
842  return 0;
843 }
844 
853 };
854 
856 {
857  AV1DecContext *s = avctx->priv_data;
859  const AVPacketSideData *sd;
860  int ret;
861 
862  s->avctx = avctx;
863  s->pkt = avctx->internal->in_pkt;
864  s->pix_fmt = AV_PIX_FMT_NONE;
865 
866  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
867  s->ref[i].f = av_frame_alloc();
868  if (!s->ref[i].f)
869  return AVERROR(ENOMEM);
870  }
871 
872  s->cur_frame.f = av_frame_alloc();
873  if (!s->cur_frame.f)
874  return AVERROR(ENOMEM);
875 
876  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
877  if (ret < 0)
878  return ret;
879 
880  s->cbc->decompose_unit_types = decompose_unit_types;
881  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);
882 
883  s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),
885  if (!s->itut_t35_fifo)
886  return AVERROR(ENOMEM);
887 
888  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
889 
890  if (avctx->extradata && avctx->extradata_size) {
892  &s->current_obu,
893  avctx);
894  if (ret < 0) {
895  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
896  goto end;
897  }
898 
899  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
900  if (!seq) {
901  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
902  goto end;
903  }
904 
905  ret = set_context_with_sequence(avctx, seq);
906  if (ret < 0) {
907  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
908  goto end;
909  }
910 
911  end:
912  ff_cbs_fragment_reset(&s->current_obu);
913  }
914 
915  s->dovi.logctx = avctx;
916  s->dovi.dv_profile = 10; // default for AV1
918  if (sd && sd->size > 0)
920 
921  return ret;
922 }
923 
925 {
926  AV1DecContext *s = avctx->priv_data;
927  AV1RawFrameHeader *header= s->raw_frame_header;
928  AVFrame *frame;
929  int ret;
930 
932  if (ret < 0) {
933  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
934  return ret;
935  }
936 
937  if ((ret = ff_thread_get_buffer(avctx, f->f, AV_GET_BUFFER_FLAG_REF)) < 0)
938  goto fail;
939 
940  frame = f->f;
941  if (header->frame_type == AV1_FRAME_KEY)
942  frame->flags |= AV_FRAME_FLAG_KEY;
943  else
944  frame->flags &= ~AV_FRAME_FLAG_KEY;
945 
946  switch (header->frame_type) {
947  case AV1_FRAME_KEY:
949  frame->pict_type = AV_PICTURE_TYPE_I;
950  break;
951  case AV1_FRAME_INTER:
952  frame->pict_type = AV_PICTURE_TYPE_P;
953  break;
954  case AV1_FRAME_SWITCH:
955  frame->pict_type = AV_PICTURE_TYPE_SP;
956  break;
957  }
958 
959  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
960  if (ret < 0)
961  goto fail;
962 
963  return 0;
964 
965 fail:
967  return ret;
968 }
969 
971  const AV1RawMetadataITUTT35 *itut_t35)
972 {
973  GetByteContext gb;
974  AV1DecContext *s = avctx->priv_data;
975  int ret, provider_code;
976 
977  bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);
978 
979  provider_code = bytestream2_get_be16(&gb);
980  switch (provider_code) {
982  uint32_t user_identifier = bytestream2_get_be32(&gb);
983  switch (user_identifier) {
984  case MKBETAG('G', 'A', '9', '4'): { // closed captions
985  AVBufferRef *buf = NULL;
986 
988  if (ret < 0)
989  return ret;
990  if (!ret)
991  break;
992 
994  if (ret < 0)
995  return ret;
996 
998  break;
999  }
1000  default: // ignore unsupported identifiers
1001  break;
1002  }
1003  break;
1004  }
1006  AVDynamicHDRPlus *hdrplus;
1007  int provider_oriented_code = bytestream2_get_be16(&gb);
1008  int application_identifier = bytestream2_get_byte(&gb);
1009 
1011  provider_oriented_code != 1 || application_identifier != 4)
1012  break;
1013 
1015  if (!hdrplus)
1016  return AVERROR(ENOMEM);
1017 
1018  ret = av_dynamic_hdr_plus_from_t35(hdrplus, gb.buffer,
1020  if (ret < 0)
1021  return ret;
1022  break;
1023  }
1025  int provider_oriented_code = bytestream2_get_be32(&gb);
1027  provider_oriented_code != 0x800)
1028  break;
1029 
1030  ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer,
1031  avctx->err_recognition);
1032  if (ret < 0) {
1033  av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
1034  break; // ignore
1035  }
1036 
1037  ret = ff_dovi_attach_side_data(&s->dovi, frame);
1038  if (ret < 0)
1039  return ret;
1040  break;
1041  }
1042  default: // ignore unsupported provider codes
1043  break;
1044  }
1045 
1046  return 0;
1047 }
1048 
1050 {
1051  AV1DecContext *s = avctx->priv_data;
1052  AV1RawMetadataITUTT35 itut_t35;
1053  int ret = 0;
1054 
1055  if (s->mdcv) {
1056  AVMasteringDisplayMetadata *mastering;
1057 
1058  ret = ff_decode_mastering_display_new(avctx, frame, &mastering);
1059  if (ret < 0)
1060  return ret;
1061 
1062  if (mastering) {
1063  for (int i = 0; i < 3; i++) {
1064  mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);
1065  mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);
1066  }
1067  mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);
1068  mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);
1069 
1070  mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);
1071  mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);
1072 
1073  mastering->has_primaries = 1;
1074  mastering->has_luminance = 1;
1075  }
1076  }
1077 
1078  if (s->cll) {
1079  AVContentLightMetadata *light;
1080 
1081  ret = ff_decode_content_light_new(avctx, frame, &light);
1082  if (ret < 0)
1083  return ret;
1084 
1085  if (light) {
1086  light->MaxCLL = s->cll->max_cll;
1087  light->MaxFALL = s->cll->max_fall;
1088  }
1089  }
1090 
1091  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {
1092  if (ret >= 0)
1093  ret = export_itut_t35(avctx, frame, &itut_t35);
1094  av_buffer_unref(&itut_t35.payload_ref);
1095  }
1096 
1097  return ret;
1098 }
1099 
1101 {
1102  AV1DecContext *s = avctx->priv_data;
1103  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
1104  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(frame->format);
1105  AVFilmGrainParams *fgp;
1106  AVFilmGrainAOMParams *aom;
1107 
1108  av_assert0(pixdesc);
1109  if (!film_grain->apply_grain)
1110  return 0;
1111 
1113  if (!fgp)
1114  return AVERROR(ENOMEM);
1115 
1117  fgp->seed = film_grain->grain_seed;
1118  fgp->width = frame->width;
1119  fgp->height = frame->height;
1120  fgp->color_range = frame->color_range;
1121  fgp->color_primaries = frame->color_primaries;
1122  fgp->color_trc = frame->color_trc;
1123  fgp->color_space = frame->colorspace;
1124  fgp->subsampling_x = pixdesc->log2_chroma_w;
1125  fgp->subsampling_y = pixdesc->log2_chroma_h;
1126 
1127  aom = &fgp->codec.aom;
1129  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
1130  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
1131  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
1132  aom->grain_scale_shift = film_grain->grain_scale_shift;
1133  aom->overlap_flag = film_grain->overlap_flag;
1134  aom->limit_output_range = film_grain->clip_to_restricted_range;
1135 
1136  aom->num_y_points = film_grain->num_y_points;
1137  for (int i = 0; i < film_grain->num_y_points; i++) {
1138  aom->y_points[i][0] = film_grain->point_y_value[i];
1139  aom->y_points[i][1] = film_grain->point_y_scaling[i];
1140  }
1141  aom->num_uv_points[0] = film_grain->num_cb_points;
1142  for (int i = 0; i < film_grain->num_cb_points; i++) {
1143  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
1144  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
1145  }
1146  aom->num_uv_points[1] = film_grain->num_cr_points;
1147  for (int i = 0; i < film_grain->num_cr_points; i++) {
1148  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
1149  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
1150  }
1151 
1152  for (int i = 0; i < 24; i++) {
1153  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
1154  }
1155  for (int i = 0; i < 25; i++) {
1156  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
1157  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
1158  }
1159 
1160  aom->uv_mult[0] = film_grain->cb_mult;
1161  aom->uv_mult[1] = film_grain->cr_mult;
1162  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
1163  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
1164  aom->uv_offset[0] = film_grain->cb_offset;
1165  aom->uv_offset[1] = film_grain->cr_offset;
1166 
1167  return 0;
1168 }
1169 
1171 {
1172  AV1DecContext *s = avctx->priv_data;
1173  const AVFrame *srcframe = s->cur_frame.f;
1174  AVPacket *pkt = s->pkt;
1175  int ret;
1176 
1177  // TODO: all layers
1178  if (s->operating_point_idc &&
1179  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
1180  return 0;
1181 
1182  ret = av_frame_ref(frame, srcframe);
1183  if (ret < 0)
1184  return ret;
1185 
1186  ret = export_metadata(avctx, frame);
1187  if (ret < 0) {
1189  return ret;
1190  }
1191 
1193  ret = export_film_grain(avctx, frame);
1194  if (ret < 0) {
1196  return ret;
1197  }
1198  }
1199 
1200  frame->pts = pkt->pts;
1201  frame->pkt_dts = pkt->dts;
1202 #if FF_API_FRAME_PKT
1204  frame->pkt_size = pkt->size;
1205  frame->pkt_pos = pkt->pos;
1207 #endif
1208 
1210 
1211  return 0;
1212 }
1213 
1215 {
1216  AV1DecContext *s = avctx->priv_data;
1217  const AV1RawFrameHeader *header = s->raw_frame_header;
1218  int ret;
1219 
1220  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1221  if (header->refresh_frame_flags & (1 << i)) {
1222  av1_frame_unref(&s->ref[i]);
1223  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
1224  av_log(avctx, AV_LOG_ERROR,
1225  "Failed to update frame %d in reference list\n", i);
1226  return ret;
1227  }
1228  }
1229  }
1230  return 0;
1231 }
1232 
1234 {
1235  AV1DecContext *s = avctx->priv_data;
1236  int ret;
1237 
1238  av1_frame_unref(&s->cur_frame);
1239 
1240  s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
1241 
1242  s->cur_frame.raw_frame_header = s->raw_frame_header;
1243 
1244  ret = init_tile_data(s);
1245  if (ret < 0) {
1246  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
1247  return ret;
1248  }
1249 
1250  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
1251  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
1252  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
1253  (avctx->skip_frame >= AVDISCARD_NONKEY &&
1254  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
1255  avctx->skip_frame >= AVDISCARD_ALL)
1256  return 0;
1257 
1258  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1259  ret = get_pixel_format(avctx);
1260  if (ret < 0) {
1261  av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format.\n");
1262  return ret;
1263  }
1264 
1265  if (!ret && FF_HW_HAS_CB(avctx, decode_params)) {
1266  ret = FF_HW_CALL(avctx, decode_params, AV1_OBU_SEQUENCE_HEADER,
1267  s->seq_data_ref->data, s->seq_data_ref->size);
1268  if (ret < 0) {
1269  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1270  return ret;
1271  }
1272  }
1273  }
1274 
1275  ret = av1_frame_alloc(avctx, &s->cur_frame);
1276  if (ret < 0) {
1277  av_log(avctx, AV_LOG_ERROR,
1278  "Failed to allocate space for current frame.\n");
1279  return ret;
1280  }
1281 
1285  order_hint_info(s);
1287 
1288  return ret;
1289 }
1290 
1292 {
1293  AV1DecContext *s = avctx->priv_data;
1294  AV1RawTileGroup *raw_tile_group = NULL;
1295  int i = 0, ret;
1296 
1297  for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {
1298  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1299  AV1RawOBU *obu = unit->content;
1300  const AV1RawOBUHeader *header;
1301 
1302  av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu);
1303 
1304  if (unit->type == AV1_OBU_TILE_LIST) {
1305  av_log(avctx, AV_LOG_ERROR, "Large scale tile decoding is unsupported.\n");
1307  goto end;
1308  }
1309 
1310  if (!obu)
1311  continue;
1312 
1313  header = &obu->header;
1314 
1315  switch (unit->type) {
1317  ret = av_buffer_replace(&s->seq_data_ref, unit->data_ref);
1318  if (ret < 0)
1319  goto end;
1320 
1321  s->seq_data_ref->data = unit->data;
1322  s->seq_data_ref->size = unit->data_size;
1323  ff_refstruct_replace(&s->seq_ref, unit->content_ref);
1324 
1325  s->raw_seq = &obu->obu.sequence_header;
1326 
1327  ret = set_context_with_sequence(avctx, s->raw_seq);
1328  if (ret < 0) {
1329  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1330  s->raw_seq = NULL;
1331  goto end;
1332  }
1333 
1334  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1335 
1336  s->pix_fmt = AV_PIX_FMT_NONE;
1337 
1338  break;
1340  if (s->raw_frame_header)
1341  break;
1342  // fall-through
1343  case AV1_OBU_FRAME:
1344  case AV1_OBU_FRAME_HEADER:
1345  if (!s->raw_seq) {
1346  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1348  goto end;
1349  }
1350 
1351  ff_refstruct_replace(&s->header_ref, unit->content_ref);
1352 
1353  if (unit->type == AV1_OBU_FRAME)
1354  s->raw_frame_header = &obu->obu.frame.header;
1355  else
1356  s->raw_frame_header = &obu->obu.frame_header;
1357 
1358  if (s->raw_frame_header->show_existing_frame) {
1359  av1_frame_unref(&s->cur_frame);
1360 
1361  ret = av1_frame_ref(avctx, &s->cur_frame,
1362  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1363  if (ret < 0) {
1364  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
1365  goto end;
1366  }
1367 
1368  ret = update_reference_list(avctx);
1369  if (ret < 0) {
1370  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1371  goto end;
1372  }
1373 
1374  if (s->cur_frame.f->buf[0]) {
1375  ret = set_output_frame(avctx, frame);
1376  if (ret < 0)
1377  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1378  }
1379 
1380  s->raw_frame_header = NULL;
1381  i++;
1382 
1383  goto end;
1384  }
1385 
1386  ret = get_current_frame(avctx);
1387  if (ret < 0) {
1388  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1389  goto end;
1390  }
1391 
1392  s->cur_frame.spatial_id = header->spatial_id;
1393  s->cur_frame.temporal_id = header->temporal_id;
1394 
1395  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1396  ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);
1397  if (ret < 0) {
1398  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1399  goto end;
1400  }
1401  }
1402  if (unit->type != AV1_OBU_FRAME)
1403  break;
1404  // fall-through
1405  case AV1_OBU_TILE_GROUP:
1406  if (!s->raw_frame_header) {
1407  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1409  goto end;
1410  }
1411 
1412  if (unit->type == AV1_OBU_FRAME)
1413  raw_tile_group = &obu->obu.frame.tile_group;
1414  else
1415  raw_tile_group = &obu->obu.tile_group;
1416 
1417  ret = get_tiles_info(avctx, raw_tile_group);
1418  if (ret < 0)
1419  goto end;
1420 
1421  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1422  ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,
1423  raw_tile_group->tile_data.data_size);
1424  if (ret < 0) {
1425  av_log(avctx, AV_LOG_ERROR,
1426  "HW accel decode slice fail.\n");
1427  goto end;
1428  }
1429  }
1430  break;
1431  case AV1_OBU_TILE_LIST:
1433  case AV1_OBU_PADDING:
1434  break;
1435  case AV1_OBU_METADATA:
1436  switch (obu->obu.metadata.metadata_type) {
1438  ff_refstruct_replace(&s->cll_ref, unit->content_ref);
1439  s->cll = &obu->obu.metadata.metadata.hdr_cll;
1440  break;
1442  ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
1443  s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
1444  break;
1446  AV1RawMetadataITUTT35 itut_t35;
1447  memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));
1449  if (!itut_t35.payload_ref) {
1450  ret = AVERROR(ENOMEM);
1451  goto end;
1452  }
1453  ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);
1454  if (ret < 0) {
1455  av_buffer_unref(&itut_t35.payload_ref);
1456  goto end;
1457  }
1458  break;
1459  }
1460  default:
1461  break;
1462  }
1463  break;
1464  default:
1465  av_log(avctx, AV_LOG_DEBUG,
1466  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1467  unit->type, unit->data_size);
1468  }
1469 
1470  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1471  int show_frame = s->raw_frame_header->show_frame;
1472  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1473  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
1474  if (ret < 0) {
1475  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1476  goto end;
1477  }
1478  }
1479 
1480  ret = update_reference_list(avctx);
1481  if (ret < 0) {
1482  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1483  goto end;
1484  }
1485 
1486  if (s->raw_frame_header->show_frame && s->cur_frame.f->buf[0]) {
1487  ret = set_output_frame(avctx, frame);
1488  if (ret < 0) {
1489  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1490  goto end;
1491  }
1492  }
1493  raw_tile_group = NULL;
1494  s->raw_frame_header = NULL;
1495  if (show_frame) {
1496  i++;
1497  goto end;
1498  }
1499  }
1500  }
1501 
1502  ret = AVERROR(EAGAIN);
1503 end:
1504  av_assert0(i <= s->current_obu.nb_units);
1505  s->nb_unit = i;
1506 
1507  if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {
1508  if (ret < 0)
1509  s->raw_frame_header = NULL;
1510  av_packet_unref(s->pkt);
1511  ff_cbs_fragment_reset(&s->current_obu);
1512  s->nb_unit = 0;
1513  }
1514  if (!ret && !frame->buf[0])
1515  ret = AVERROR(EAGAIN);
1516 
1517  return ret;
1518 }
1519 
1521 {
1522  AV1DecContext *s = avctx->priv_data;
1523  int ret;
1524 
1525  do {
1526  if (!s->current_obu.nb_units) {
1527  ret = ff_decode_get_packet(avctx, s->pkt);
1528  if (ret < 0)
1529  return ret;
1530 
1531  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);
1532  if (ret < 0) {
1533  ff_cbs_fragment_reset(&s->current_obu);
1534  av_packet_unref(s->pkt);
1535  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1536  return ret;
1537  }
1538 
1539  s->nb_unit = 0;
1540  av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",
1541  s->current_obu.nb_units);
1542  }
1543 
1545  } while (ret == AVERROR(EAGAIN));
1546 
1547  return ret;
1548 }
1549 
1551 {
1552  AV1DecContext *s = avctx->priv_data;
1553  AV1RawMetadataITUTT35 itut_t35;
1554 
1555  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1556  av1_frame_unref(&s->ref[i]);
1557 
1558  av1_frame_unref(&s->cur_frame);
1559  s->operating_point_idc = 0;
1560  s->nb_unit = 0;
1561  s->raw_frame_header = NULL;
1562  s->raw_seq = NULL;
1563  s->cll = NULL;
1564  s->mdcv = NULL;
1565  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
1566  av_buffer_unref(&itut_t35.payload_ref);
1567 
1568  ff_cbs_fragment_reset(&s->current_obu);
1569  ff_cbs_flush(s->cbc);
1570 
1571  if (FF_HW_HAS_CB(avctx, flush))
1572  FF_HW_SIMPLE_CALL(avctx, flush);
1573 }
1574 
1575 #define OFFSET(x) offsetof(AV1DecContext, x)
1576 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1577 static const AVOption av1_options[] = {
1578  { "operating_point", "Select an operating point of the scalable bitstream",
1579  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1580  { NULL }
1581 };
1582 
1583 static const AVClass av1_class = {
1584  .class_name = "AV1 decoder",
1585  .item_name = av_default_item_name,
1586  .option = av1_options,
1587  .version = LIBAVUTIL_VERSION_INT,
1588 };
1589 
1591  .p.name = "av1",
1592  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1593  .p.type = AVMEDIA_TYPE_VIDEO,
1594  .p.id = AV_CODEC_ID_AV1,
1595  .priv_data_size = sizeof(AV1DecContext),
1596  .init = av1_decode_init,
1597  .close = av1_decode_free,
1599  .p.capabilities = AV_CODEC_CAP_DR1,
1601  .flush = av1_decode_flush,
1602  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1603  .p.priv_class = &av1_class,
1604  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1605 #if CONFIG_AV1_DXVA2_HWACCEL
1606  HWACCEL_DXVA2(av1),
1607 #endif
1608 #if CONFIG_AV1_D3D11VA_HWACCEL
1609  HWACCEL_D3D11VA(av1),
1610 #endif
1611 #if CONFIG_AV1_D3D11VA2_HWACCEL
1612  HWACCEL_D3D11VA2(av1),
1613 #endif
1614 #if CONFIG_AV1_D3D12VA_HWACCEL
1615  HWACCEL_D3D12VA(av1),
1616 #endif
1617 #if CONFIG_AV1_NVDEC_HWACCEL
1618  HWACCEL_NVDEC(av1),
1619 #endif
1620 #if CONFIG_AV1_VAAPI_HWACCEL
1621  HWACCEL_VAAPI(av1),
1622 #endif
1623 #if CONFIG_AV1_VDPAU_HWACCEL
1624  HWACCEL_VDPAU(av1),
1625 #endif
1626 #if CONFIG_AV1_VULKAN_HWACCEL
1627  HWACCEL_VULKAN(av1),
1628 #endif
1629 
1630  NULL
1631  },
1632 };
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:92
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:1360
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
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:223
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
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:85
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:855
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
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:1971
AV1RawFilmGrainParams::grain_seed
uint16_t grain_seed
Definition: cbs_av1.h:135
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AV1RawSequenceHeader::timing_info_present_flag
uint8_t timing_info_present_flag
Definition: cbs_av1.h:78
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:111
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:1222
order_hint_info
static void order_hint_info(AV1DecContext *s)
Definition: av1dec.c:362
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
AVFilmGrainParams::codec
union AVFilmGrainParams::@371 codec
Additional fields may be added both here and in any structure included.
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:924
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
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
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
get_current_frame
static int get_current_frame(AVCodecContext *avctx)
Definition: av1dec.c:1233
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
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
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:769
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
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:116
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:126
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:845
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV1_OBU_TEMPORAL_DELIMITER
@ AV1_OBU_TEMPORAL_DELIMITER
Definition: av1.h:31
AV1RawTileData::data
uint8_t * data
Definition: cbs_av1.h:292
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
get_relative_dist
static int get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: av1dec.c:258
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
AV1RawOBU::header
AV1RawOBUHeader header
Definition: cbs_av1.h:401
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
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
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:63
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
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:74
round_two
static uint64_t round_two(uint64_t x, uint16_t n)
Definition: av1dec.c:141
AV1RawFrame::header
AV1RawFrameHeader header
Definition: cbs_av1.h:306
AV1RawFilmGrainParams::cr_mult
uint8_t cr_mult
Definition: cbs_av1.h:158
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h: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_parse.h
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:122
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1577
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:686
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_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:69
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
AV1Frame::ref_frame_sign_bias
uint8_t ref_frame_sign_bias[AV1_TOTAL_REFS_PER_FRAME]
Definition: av1dec.h:60
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:625
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
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:107
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:2085
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
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:973
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:736
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:401
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:1214
decode.h
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:161
get_sw_pixel_format
static enum AVPixelFormat get_sw_pixel_format(void *logctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:464
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:108
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:419
export_itut_t35
static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame, const AV1RawMetadataITUTT35 *itut_t35)
Definition: av1dec.c:970
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:114
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:2012
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:381
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1590
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
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:120
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
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
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:673
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:815
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h: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
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:106
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
resolve_divisor
static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
Resolve divisor process.
Definition: av1dec.c:157
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:135
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
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:117
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
AV1RawMetadata::metadata
union AV1RawMetadata::@43 metadata
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
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
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
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
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:73
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
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:1576
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
AV1Frame::order_hint
uint8_t order_hint
Definition: av1dec.h:58
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:89
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:1520
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1550
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
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:112
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:1100
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
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:87
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
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:274
AV1_METADATA_TYPE_ITUT_T35
@ AV1_METADATA_TYPE_ITUT_T35
Definition: av1.h:47
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:76
delta
float delta
Definition: vorbis_enc_data.h:430
AV1_DIV_LUT_PREC_BITS
@ AV1_DIV_LUT_PREC_BITS
Definition: av1.h:121
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
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
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:1583
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
AV1Frame::order_hints
uint8_t order_hints[AV1_TOTAL_REFS_PER_FRAME]
Definition: av1dec.h:63
ret
ret
Definition: filter_design.txt:187
AV1_WARP_PARAM_REDUCE_BITS
@ AV1_WARP_PARAM_REDUCE_BITS
Definition: av1.h:118
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
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:2057
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
AV1RawFilmGrainParams::film_grain_params_ref_idx
uint8_t film_grain_params_ref_idx
Definition: cbs_av1.h:137
read_global_param
static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
Definition: av1dec.c:99
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h: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
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
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:110
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:292
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:1049
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
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
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
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
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
get_pixel_format
static int get_pixel_format(AVCodecContext *avctx)
Definition: av1dec.c:527
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:1575
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
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:66
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AV1RawFilmGrainParams
Definition: cbs_av1.h:133
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:109
sequence_header
static int FUNC() sequence_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawSequenceHeader *current)
Definition: cbs_mpeg2_syntax_template.c:19
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:134
av1_receive_frame_internal
static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1291
AV1RawOBU::obu
union AV1RawOBU::@44 obu
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:1170
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
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:115
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