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