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_NVDEC_HWACCEL + \
515  CONFIG_AV1_VAAPI_HWACCEL + \
516  CONFIG_AV1_VDPAU_HWACCEL + \
517  CONFIG_AV1_VULKAN_HWACCEL)
518  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
519 
520  if (pix_fmt == AV_PIX_FMT_NONE)
521  return -1;
522 
523  switch (pix_fmt) {
524  case AV_PIX_FMT_YUV420P:
525 #if CONFIG_AV1_DXVA2_HWACCEL
526  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
527 #endif
528 #if CONFIG_AV1_D3D11VA_HWACCEL
529  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
530  *fmtp++ = AV_PIX_FMT_D3D11;
531 #endif
532 #if CONFIG_AV1_NVDEC_HWACCEL
533  *fmtp++ = AV_PIX_FMT_CUDA;
534 #endif
535 #if CONFIG_AV1_VAAPI_HWACCEL
536  *fmtp++ = AV_PIX_FMT_VAAPI;
537 #endif
538 #if CONFIG_AV1_VDPAU_HWACCEL
539  *fmtp++ = AV_PIX_FMT_VDPAU;
540 #endif
541 #if CONFIG_AV1_VULKAN_HWACCEL
542  *fmtp++ = AV_PIX_FMT_VULKAN;
543 #endif
544  break;
546 #if CONFIG_AV1_DXVA2_HWACCEL
547  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
548 #endif
549 #if CONFIG_AV1_D3D11VA_HWACCEL
550  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
551  *fmtp++ = AV_PIX_FMT_D3D11;
552 #endif
553 #if CONFIG_AV1_NVDEC_HWACCEL
554  *fmtp++ = AV_PIX_FMT_CUDA;
555 #endif
556 #if CONFIG_AV1_VAAPI_HWACCEL
557  *fmtp++ = AV_PIX_FMT_VAAPI;
558 #endif
559 #if CONFIG_AV1_VDPAU_HWACCEL
560  *fmtp++ = AV_PIX_FMT_VDPAU;
561 #endif
562 #if CONFIG_AV1_VULKAN_HWACCEL
563  *fmtp++ = AV_PIX_FMT_VULKAN;
564 #endif
565  break;
567 #if CONFIG_AV1_VULKAN_HWACCEL
568  *fmtp++ = AV_PIX_FMT_VULKAN;
569 #endif
570  break;
571  case AV_PIX_FMT_YUV422P:
572 #if CONFIG_AV1_VULKAN_HWACCEL
573  *fmtp++ = AV_PIX_FMT_VULKAN;
574 #endif
575  break;
577 #if CONFIG_AV1_VULKAN_HWACCEL
578  *fmtp++ = AV_PIX_FMT_VULKAN;
579 #endif
580  break;
582 #if CONFIG_AV1_VULKAN_HWACCEL
583  *fmtp++ = AV_PIX_FMT_VULKAN;
584 #endif
585  break;
586  case AV_PIX_FMT_YUV444P:
587 #if CONFIG_AV1_VULKAN_HWACCEL
588  *fmtp++ = AV_PIX_FMT_VULKAN;
589 #endif
590  break;
592 #if CONFIG_AV1_VULKAN_HWACCEL
593  *fmtp++ = AV_PIX_FMT_VULKAN;
594 #endif
595  break;
597 #if CONFIG_AV1_VULKAN_HWACCEL
598  *fmtp++ = AV_PIX_FMT_VULKAN;
599 #endif
600  break;
601  case AV_PIX_FMT_GRAY8:
602 #if CONFIG_AV1_NVDEC_HWACCEL
603  *fmtp++ = AV_PIX_FMT_CUDA;
604 #endif
605  break;
606  case AV_PIX_FMT_GRAY10:
607 #if CONFIG_AV1_NVDEC_HWACCEL
608  *fmtp++ = AV_PIX_FMT_CUDA;
609 #endif
610  break;
611  }
612 
613  *fmtp++ = pix_fmt;
614  *fmtp = AV_PIX_FMT_NONE;
615 
616  ret = ff_get_format(avctx, pix_fmts);
617 
618  /**
619  * check if the HW accel is inited correctly. If not, return un-implemented.
620  * Since now the av1 decoder doesn't support native decode, if it will be
621  * implemented in the future, need remove this check.
622  */
623  if (!avctx->hwaccel) {
624  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"
625  " hardware accelerated AV1 decoding.\n");
626  avctx->pix_fmt = AV_PIX_FMT_NONE;
627  return AVERROR(ENOSYS);
628  }
629 
630  s->pix_fmt = pix_fmt;
631  avctx->pix_fmt = ret;
632 
633  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
634  av_get_pix_fmt_name(avctx->pix_fmt));
635 
636  return 0;
637 }
638 
640 {
641  av_frame_unref(f->f);
642  ff_refstruct_unref(&f->hwaccel_picture_private);
643  ff_refstruct_unref(&f->header_ref);
644  f->raw_frame_header = NULL;
645  f->spatial_id = f->temporal_id = 0;
646  memset(f->skip_mode_frame_idx, 0,
647  2 * sizeof(uint8_t));
648  memset(&f->film_grain, 0, sizeof(f->film_grain));
649  f->coded_lossless = 0;
650 }
651 
652 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
653 {
654  int ret;
655 
656  ff_refstruct_replace(&dst->header_ref, src->header_ref);
657 
658  dst->raw_frame_header = src->raw_frame_header;
659 
660  if (!src->f->buf[0])
661  return 0;
662 
663  ret = av_frame_ref(dst->f, src->f);
664  if (ret < 0)
665  goto fail;
666 
668  src->hwaccel_picture_private);
669 
670  dst->spatial_id = src->spatial_id;
671  dst->temporal_id = src->temporal_id;
672  memcpy(dst->gm_invalid,
673  src->gm_invalid,
674  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
675  memcpy(dst->gm_type,
676  src->gm_type,
677  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
678  memcpy(dst->gm_params,
679  src->gm_params,
680  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
681  memcpy(dst->skip_mode_frame_idx,
682  src->skip_mode_frame_idx,
683  2 * sizeof(uint8_t));
684  memcpy(&dst->film_grain,
685  &src->film_grain,
686  sizeof(dst->film_grain));
687  dst->coded_lossless = src->coded_lossless;
688 
689  return 0;
690 
691 fail:
692  av1_frame_unref(dst);
693  return AVERROR(ENOMEM);
694 }
695 
697 {
698  AV1DecContext *s = avctx->priv_data;
699  AV1RawMetadataITUTT35 itut_t35;
700 
701  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
702  if (s->ref[i].f) {
703  av1_frame_unref(&s->ref[i]);
704  av_frame_free(&s->ref[i].f);
705  }
706  }
707  if (s->cur_frame.f) {
708  av1_frame_unref(&s->cur_frame);
709  av_frame_free(&s->cur_frame.f);
710  }
711  ff_refstruct_unref(&s->seq_ref);
712  ff_refstruct_unref(&s->header_ref);
713  ff_refstruct_unref(&s->cll_ref);
714  ff_refstruct_unref(&s->mdcv_ref);
715  av_freep(&s->tile_group_info);
716 
717  while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
718  av_buffer_unref(&itut_t35.payload_ref);
719  av_fifo_freep2(&s->itut_t35_fifo);
720 
721  ff_cbs_fragment_free(&s->current_obu);
722  ff_cbs_close(&s->cbc);
723 
724  return 0;
725 }
726 
728  const AV1RawSequenceHeader *seq)
729 {
730  int width = seq->max_frame_width_minus_1 + 1;
731  int height = seq->max_frame_height_minus_1 + 1;
732 
733  avctx->profile = seq->seq_profile;
734  avctx->level = seq->seq_level_idx[0];
735 
736  avctx->color_range =
741 
742  switch (seq->color_config.chroma_sample_position) {
743  case AV1_CSP_VERTICAL:
745  break;
746  case AV1_CSP_COLOCATED:
748  break;
749  }
750 
751  if (seq->film_grain_params_present)
753  else
755 
756  if (avctx->width != width || avctx->height != height) {
757  int ret = ff_set_dimensions(avctx, width, height);
758  if (ret < 0)
759  return ret;
760  }
761 
762  if (seq->timing_info_present_flag)
765  seq->timing_info.time_scale);
766 
767  return 0;
768 }
769 
771  const AV1RawFrameHeader *header)
772 {
773  AVRational aspect_ratio;
774  int width = header->frame_width_minus_1 + 1;
775  int height = header->frame_height_minus_1 + 1;
776  int r_width = header->render_width_minus_1 + 1;
777  int r_height = header->render_height_minus_1 + 1;
778  int ret;
779 
780  if (avctx->width != width || avctx->height != height) {
781  ret = ff_set_dimensions(avctx, width, height);
782  if (ret < 0)
783  return ret;
784  }
785 
786  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
787  (int64_t)height * r_width,
788  (int64_t)width * r_height,
789  INT_MAX);
790 
791  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
792  ret = ff_set_sar(avctx, aspect_ratio);
793  if (ret < 0)
794  return ret;
795  }
796 
797  return 0;
798 }
799 
808 };
809 
811 {
812  AV1DecContext *s = avctx->priv_data;
814  int ret;
815 
816  s->avctx = avctx;
817  s->pkt = avctx->internal->in_pkt;
818  s->pix_fmt = AV_PIX_FMT_NONE;
819 
820  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
821  s->ref[i].f = av_frame_alloc();
822  if (!s->ref[i].f)
823  return AVERROR(ENOMEM);
824  }
825 
826  s->cur_frame.f = av_frame_alloc();
827  if (!s->cur_frame.f)
828  return AVERROR(ENOMEM);
829 
830  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
831  if (ret < 0)
832  return ret;
833 
834  s->cbc->decompose_unit_types = decompose_unit_types;
835  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);
836 
837  s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),
839  if (!s->itut_t35_fifo)
840  return AVERROR(ENOMEM);
841 
842  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
843 
844  if (avctx->extradata && avctx->extradata_size) {
846  &s->current_obu,
847  avctx);
848  if (ret < 0) {
849  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
850  goto end;
851  }
852 
853  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
854  if (!seq) {
855  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
856  goto end;
857  }
858 
859  ret = set_context_with_sequence(avctx, seq);
860  if (ret < 0) {
861  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
862  goto end;
863  }
864 
865  avctx->pix_fmt = get_sw_pixel_format(avctx, seq);
866 
867  end:
868  ff_cbs_fragment_reset(&s->current_obu);
869  }
870 
871  return ret;
872 }
873 
875 {
876  AV1DecContext *s = avctx->priv_data;
877  AV1RawFrameHeader *header= s->raw_frame_header;
878  AVFrame *frame;
879  int ret;
880 
882  if (ret < 0) {
883  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
884  return ret;
885  }
886 
887  if ((ret = ff_thread_get_buffer(avctx, f->f, AV_GET_BUFFER_FLAG_REF)) < 0)
888  goto fail;
889 
890  frame = f->f;
891  if (header->frame_type == AV1_FRAME_KEY)
893  else
895 
896  switch (header->frame_type) {
897  case AV1_FRAME_KEY:
900  break;
901  case AV1_FRAME_INTER:
903  break;
904  case AV1_FRAME_SWITCH:
906  break;
907  }
908 
909  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
910  if (ret < 0)
911  goto fail;
912 
913  return 0;
914 
915 fail:
917  return ret;
918 }
919 
921  const AV1RawMetadataITUTT35 *itut_t35)
922 {
923  GetByteContext gb;
924  int ret, provider_code;
925 
926  bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);
927 
928  provider_code = bytestream2_get_be16(&gb);
929  switch (provider_code) {
930  case 0x31: { // atsc_provider_code
931  uint32_t user_identifier = bytestream2_get_be32(&gb);
932  switch (user_identifier) {
933  case MKBETAG('G', 'A', '9', '4'): { // closed captions
934  AVBufferRef *buf = NULL;
935 
937  if (ret < 0)
938  return ret;
939  if (!ret)
940  break;
941 
943  av_buffer_unref(&buf);
944 
946  break;
947  }
948  default: // ignore unsupported identifiers
949  break;
950  }
951  break;
952  }
953  case 0x3C: { // smpte_provider_code
954  AVDynamicHDRPlus *hdrplus;
955  int provider_oriented_code = bytestream2_get_be16(&gb);
956  int application_identifier = bytestream2_get_byte(&gb);
957 
958  if (itut_t35->itu_t_t35_country_code != 0xB5 ||
959  provider_oriented_code != 1 || application_identifier != 4)
960  break;
961 
963  if (!hdrplus)
964  return AVERROR(ENOMEM);
965 
968  if (ret < 0)
969  return ret;
970  break;
971  }
972  default: // ignore unsupported provider codes
973  break;
974  }
975 
976  return 0;
977 }
978 
980 {
981  AV1DecContext *s = avctx->priv_data;
982  AV1RawMetadataITUTT35 itut_t35;
983  int ret = 0;
984 
985  if (s->mdcv) {
987  if (!mastering)
988  return AVERROR(ENOMEM);
989 
990  for (int i = 0; i < 3; i++) {
991  mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);
992  mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);
993  }
994  mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);
995  mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);
996 
997  mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);
998  mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);
999 
1000  mastering->has_primaries = 1;
1001  mastering->has_luminance = 1;
1002  }
1003 
1004  if (s->cll) {
1006  if (!light)
1007  return AVERROR(ENOMEM);
1008 
1009  light->MaxCLL = s->cll->max_cll;
1010  light->MaxFALL = s->cll->max_fall;
1011  }
1012 
1013  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {
1014  if (ret >= 0)
1015  ret = export_itut_t35(avctx, frame, &itut_t35);
1016  av_buffer_unref(&itut_t35.payload_ref);
1017  }
1018 
1019  return ret;
1020 }
1021 
1023 {
1024  AV1DecContext *s = avctx->priv_data;
1025  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
1026  AVFilmGrainParams *fgp;
1027  AVFilmGrainAOMParams *aom;
1028 
1029  if (!film_grain->apply_grain)
1030  return 0;
1031 
1033  if (!fgp)
1034  return AVERROR(ENOMEM);
1035 
1037  fgp->seed = film_grain->grain_seed;
1038 
1039  aom = &fgp->codec.aom;
1041  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
1042  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
1043  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
1044  aom->grain_scale_shift = film_grain->grain_scale_shift;
1045  aom->overlap_flag = film_grain->overlap_flag;
1046  aom->limit_output_range = film_grain->clip_to_restricted_range;
1047 
1048  aom->num_y_points = film_grain->num_y_points;
1049  for (int i = 0; i < film_grain->num_y_points; i++) {
1050  aom->y_points[i][0] = film_grain->point_y_value[i];
1051  aom->y_points[i][1] = film_grain->point_y_scaling[i];
1052  }
1053  aom->num_uv_points[0] = film_grain->num_cb_points;
1054  for (int i = 0; i < film_grain->num_cb_points; i++) {
1055  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
1056  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
1057  }
1058  aom->num_uv_points[1] = film_grain->num_cr_points;
1059  for (int i = 0; i < film_grain->num_cr_points; i++) {
1060  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
1061  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
1062  }
1063 
1064  for (int i = 0; i < 24; i++) {
1065  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
1066  }
1067  for (int i = 0; i < 25; i++) {
1068  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
1069  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
1070  }
1071 
1072  aom->uv_mult[0] = film_grain->cb_mult;
1073  aom->uv_mult[1] = film_grain->cr_mult;
1074  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
1075  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
1076  aom->uv_offset[0] = film_grain->cb_offset;
1077  aom->uv_offset[1] = film_grain->cr_offset;
1078 
1079  return 0;
1080 }
1081 
1083 {
1084  AV1DecContext *s = avctx->priv_data;
1085  const AVFrame *srcframe = s->cur_frame.f;
1086  AVPacket *pkt = s->pkt;
1087  int ret;
1088 
1089  // TODO: all layers
1090  if (s->operating_point_idc &&
1091  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
1092  return 0;
1093 
1094  ret = av_frame_ref(frame, srcframe);
1095  if (ret < 0)
1096  return ret;
1097 
1098  ret = export_metadata(avctx, frame);
1099  if (ret < 0) {
1101  return ret;
1102  }
1103 
1105  ret = export_film_grain(avctx, frame);
1106  if (ret < 0) {
1108  return ret;
1109  }
1110  }
1111 
1112  frame->pts = pkt->pts;
1113  frame->pkt_dts = pkt->dts;
1114 #if FF_API_FRAME_PKT
1116  frame->pkt_size = pkt->size;
1117  frame->pkt_pos = pkt->pos;
1119 #endif
1120 
1122 
1123  return 0;
1124 }
1125 
1127 {
1128  AV1DecContext *s = avctx->priv_data;
1129  const AV1RawFrameHeader *header = s->raw_frame_header;
1130  int ret;
1131 
1132  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1133  if (header->refresh_frame_flags & (1 << i)) {
1134  av1_frame_unref(&s->ref[i]);
1135  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
1136  av_log(avctx, AV_LOG_ERROR,
1137  "Failed to update frame %d in reference list\n", i);
1138  return ret;
1139  }
1140  }
1141  }
1142  return 0;
1143 }
1144 
1146 {
1147  AV1DecContext *s = avctx->priv_data;
1148  int ret;
1149 
1150  av1_frame_unref(&s->cur_frame);
1151 
1152  s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
1153 
1154  s->cur_frame.raw_frame_header = s->raw_frame_header;
1155 
1156  ret = init_tile_data(s);
1157  if (ret < 0) {
1158  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
1159  return ret;
1160  }
1161 
1162  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
1163  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
1164  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
1165  (avctx->skip_frame >= AVDISCARD_NONKEY &&
1166  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
1167  avctx->skip_frame >= AVDISCARD_ALL)
1168  return 0;
1169 
1170  ret = av1_frame_alloc(avctx, &s->cur_frame);
1171  if (ret < 0) {
1172  av_log(avctx, AV_LOG_ERROR,
1173  "Failed to allocate space for current frame.\n");
1174  return ret;
1175  }
1176 
1181 
1182  return ret;
1183 }
1184 
1186 {
1187  AV1DecContext *s = avctx->priv_data;
1188  AV1RawTileGroup *raw_tile_group = NULL;
1189  int i = 0, ret;
1190 
1191  for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {
1192  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1193  AV1RawOBU *obu = unit->content;
1194  const AV1RawOBUHeader *header;
1195 
1196  if (!obu)
1197  continue;
1198 
1199  header = &obu->header;
1200  av_log(avctx, AV_LOG_DEBUG, "Obu idx:%d, obu type:%d.\n", i, unit->type);
1201 
1202  switch (unit->type) {
1204  ff_refstruct_replace(&s->seq_ref, unit->content_ref);
1205 
1206  s->raw_seq = &obu->obu.sequence_header;
1207 
1208  ret = set_context_with_sequence(avctx, s->raw_seq);
1209  if (ret < 0) {
1210  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1211  s->raw_seq = NULL;
1212  goto end;
1213  }
1214 
1215  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1216 
1217  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1218  ret = get_pixel_format(avctx);
1219  if (ret < 0) {
1220  av_log(avctx, AV_LOG_ERROR,
1221  "Failed to get pixel format.\n");
1222  s->raw_seq = NULL;
1223  goto end;
1224  }
1225  }
1226 
1227  if (FF_HW_HAS_CB(avctx, decode_params)) {
1228  ret = FF_HW_CALL(avctx, decode_params, unit->type,
1229  unit->data, unit->data_size);
1230  if (ret < 0) {
1231  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1232  s->raw_seq = NULL;
1233  goto end;
1234  }
1235  }
1236  break;
1238  if (s->raw_frame_header)
1239  break;
1240  // fall-through
1241  case AV1_OBU_FRAME:
1242  case AV1_OBU_FRAME_HEADER:
1243  if (!s->raw_seq) {
1244  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1246  goto end;
1247  }
1248 
1249  ff_refstruct_replace(&s->header_ref, unit->content_ref);
1250 
1251  if (unit->type == AV1_OBU_FRAME)
1252  s->raw_frame_header = &obu->obu.frame.header;
1253  else
1254  s->raw_frame_header = &obu->obu.frame_header;
1255 
1256  if (s->raw_frame_header->show_existing_frame) {
1257  av1_frame_unref(&s->cur_frame);
1258 
1259  ret = av1_frame_ref(avctx, &s->cur_frame,
1260  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1261  if (ret < 0) {
1262  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
1263  goto end;
1264  }
1265 
1266  ret = update_reference_list(avctx);
1267  if (ret < 0) {
1268  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1269  goto end;
1270  }
1271 
1272  if (s->cur_frame.f->buf[0]) {
1273  ret = set_output_frame(avctx, frame);
1274  if (ret < 0)
1275  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1276  }
1277 
1278  s->raw_frame_header = NULL;
1279  i++;
1280 
1281  goto end;
1282  }
1283 
1284  ret = get_current_frame(avctx);
1285  if (ret < 0) {
1286  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1287  goto end;
1288  }
1289 
1290  s->cur_frame.spatial_id = header->spatial_id;
1291  s->cur_frame.temporal_id = header->temporal_id;
1292 
1293  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1294  ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);
1295  if (ret < 0) {
1296  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1297  goto end;
1298  }
1299  }
1300  if (unit->type != AV1_OBU_FRAME)
1301  break;
1302  // fall-through
1303  case AV1_OBU_TILE_GROUP:
1304  if (!s->raw_frame_header) {
1305  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1307  goto end;
1308  }
1309 
1310  if (unit->type == AV1_OBU_FRAME)
1311  raw_tile_group = &obu->obu.frame.tile_group;
1312  else
1313  raw_tile_group = &obu->obu.tile_group;
1314 
1315  ret = get_tiles_info(avctx, raw_tile_group);
1316  if (ret < 0)
1317  goto end;
1318 
1319  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1320  ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,
1321  raw_tile_group->tile_data.data_size);
1322  if (ret < 0) {
1323  av_log(avctx, AV_LOG_ERROR,
1324  "HW accel decode slice fail.\n");
1325  goto end;
1326  }
1327  }
1328  break;
1329  case AV1_OBU_TILE_LIST:
1331  case AV1_OBU_PADDING:
1332  break;
1333  case AV1_OBU_METADATA:
1334  switch (obu->obu.metadata.metadata_type) {
1336  ff_refstruct_replace(&s->cll_ref, unit->content_ref);
1337  s->cll = &obu->obu.metadata.metadata.hdr_cll;
1338  break;
1340  ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
1341  s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
1342  break;
1344  AV1RawMetadataITUTT35 itut_t35;
1345  memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));
1347  if (!itut_t35.payload_ref) {
1348  ret = AVERROR(ENOMEM);
1349  goto end;
1350  }
1351  ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);
1352  if (ret < 0) {
1353  av_buffer_unref(&itut_t35.payload_ref);
1354  goto end;
1355  }
1356  break;
1357  }
1358  default:
1359  break;
1360  }
1361  break;
1362  default:
1363  av_log(avctx, AV_LOG_DEBUG,
1364  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1365  unit->type, unit->data_size);
1366  }
1367 
1368  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1369  int show_frame = s->raw_frame_header->show_frame;
1370  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1371  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
1372  if (ret < 0) {
1373  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1374  goto end;
1375  }
1376  }
1377 
1378  ret = update_reference_list(avctx);
1379  if (ret < 0) {
1380  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1381  goto end;
1382  }
1383 
1384  if (s->raw_frame_header->show_frame && s->cur_frame.f->buf[0]) {
1385  ret = set_output_frame(avctx, frame);
1386  if (ret < 0) {
1387  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1388  goto end;
1389  }
1390  }
1391  raw_tile_group = NULL;
1392  s->raw_frame_header = NULL;
1393  if (show_frame) {
1394  i++;
1395  goto end;
1396  }
1397  }
1398  }
1399 
1400  ret = AVERROR(EAGAIN);
1401 end:
1402  av_assert0(i <= s->current_obu.nb_units);
1403  s->nb_unit = i;
1404 
1405  if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {
1406  if (ret < 0)
1407  s->raw_frame_header = NULL;
1408  av_packet_unref(s->pkt);
1409  ff_cbs_fragment_reset(&s->current_obu);
1410  s->nb_unit = 0;
1411  }
1412 
1413  return ret;
1414 }
1415 
1417 {
1418  AV1DecContext *s = avctx->priv_data;
1419  int ret;
1420 
1421  do {
1422  if (!s->current_obu.nb_units) {
1423  ret = ff_decode_get_packet(avctx, s->pkt);
1424  if (ret < 0)
1425  return ret;
1426 
1427  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);
1428  if (ret < 0) {
1429  ff_cbs_fragment_reset(&s->current_obu);
1430  av_packet_unref(s->pkt);
1431  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1432  return ret;
1433  }
1434 
1435  s->nb_unit = 0;
1436  av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",
1437  s->current_obu.nb_units);
1438  }
1439 
1441  } while (ret == AVERROR(EAGAIN));
1442 
1443  return ret;
1444 }
1445 
1447 {
1448  AV1DecContext *s = avctx->priv_data;
1449  AV1RawMetadataITUTT35 itut_t35;
1450 
1451  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1452  av1_frame_unref(&s->ref[i]);
1453 
1454  av1_frame_unref(&s->cur_frame);
1455  s->operating_point_idc = 0;
1456  s->nb_unit = 0;
1457  s->raw_frame_header = NULL;
1458  s->raw_seq = NULL;
1459  s->cll = NULL;
1460  s->mdcv = NULL;
1461  while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
1462  av_buffer_unref(&itut_t35.payload_ref);
1463 
1464  ff_cbs_fragment_reset(&s->current_obu);
1465  ff_cbs_flush(s->cbc);
1466 
1467  if (FF_HW_HAS_CB(avctx, flush))
1468  FF_HW_SIMPLE_CALL(avctx, flush);
1469 }
1470 
1471 #define OFFSET(x) offsetof(AV1DecContext, x)
1472 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1473 static const AVOption av1_options[] = {
1474  { "operating_point", "Select an operating point of the scalable bitstream",
1475  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1476  { NULL }
1477 };
1478 
1479 static const AVClass av1_class = {
1480  .class_name = "AV1 decoder",
1481  .item_name = av_default_item_name,
1482  .option = av1_options,
1483  .version = LIBAVUTIL_VERSION_INT,
1484 };
1485 
1487  .p.name = "av1",
1488  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1489  .p.type = AVMEDIA_TYPE_VIDEO,
1490  .p.id = AV_CODEC_ID_AV1,
1491  .priv_data_size = sizeof(AV1DecContext),
1492  .init = av1_decode_init,
1493  .close = av1_decode_free,
1495  .p.capabilities = AV_CODEC_CAP_DR1,
1496  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1497  .flush = av1_decode_flush,
1498  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1499  .p.priv_class = &av1_class,
1500  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1501 #if CONFIG_AV1_DXVA2_HWACCEL
1502  HWACCEL_DXVA2(av1),
1503 #endif
1504 #if CONFIG_AV1_D3D11VA_HWACCEL
1505  HWACCEL_D3D11VA(av1),
1506 #endif
1507 #if CONFIG_AV1_D3D11VA2_HWACCEL
1508  HWACCEL_D3D11VA2(av1),
1509 #endif
1510 #if CONFIG_AV1_NVDEC_HWACCEL
1511  HWACCEL_NVDEC(av1),
1512 #endif
1513 #if CONFIG_AV1_VAAPI_HWACCEL
1514  HWACCEL_VAAPI(av1),
1515 #endif
1516 #if CONFIG_AV1_VDPAU_HWACCEL
1517  HWACCEL_VDPAU(av1),
1518 #endif
1519 #if CONFIG_AV1_VULKAN_HWACCEL
1520  HWACCEL_VULKAN(av1),
1521 #endif
1522 
1523  NULL
1524  },
1525 };
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
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:134
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:423
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:1435
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:253
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:64
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:810
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:136
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
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:106
AV1RawFilmGrainParams::grain_seed
uint16_t grain_seed
Definition: cbs_av1.h:135
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1029
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
AV1_METADATA_TYPE_ITUT_T35
@ AV1_METADATA_TYPE_ITUT_T35
Definition: av1.h:47
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:179
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:874
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:120
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:68
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
AV1RawMetadata::metadata
union AV1RawMetadata::@29 metadata
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:1145
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
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:236
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:1022
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:727
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:673
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:165
internal.h
AV1Frame::raw_frame_header
AV1RawFrameHeader * raw_frame_header
Definition: av1dec.h:40
AVFilmGrainParams::codec
union AVFilmGrainParams::@337 codec
Additional fields may be added both here and in any structure included.
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:133
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:468
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:247
FFCodec
Definition: codec_internal.h:127
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:116
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:800
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:376
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:135
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:1803
AV1RawFilmGrainParams::ar_coeffs_cr_plus_128
uint8_t ar_coeffs_cr_plus_128[25]
Definition: cbs_av1.h:152
AV1_DIV_LUT_PREC_BITS
@ AV1_DIV_LUT_PREC_BITS
Definition: av1.h:120
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:109
av1_parse.h
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:88
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1473
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:652
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1766
fail
#define fail()
Definition: checkasm.h:138
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
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
AV1RawMetadataITUTT35::payload_size
size_t payload_size
Definition: cbs_av1.h:356
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:73
inverse_recenter
static uint32_t inverse_recenter(int r, uint32_t v)
Definition: av1dec.c:70
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV1RawFilmGrainParams::ar_coeff_shift_minus_6
uint8_t ar_coeff_shift_minus_6
Definition: cbs_av1.h:153
CodedBitstreamUnit::data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:81
AV1RawFilmGrainParams::num_y_points
uint8_t num_y_points
Definition: cbs_av1.h:138
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
round_two_signed
static int64_t round_two_signed(int64_t x, uint16_t n)
Definition: av1dec.c:146
AVRational::num
int num
Numerator.
Definition: rational.h:59
refstruct.h
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:88
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:471
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:1015
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2706
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
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:62
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
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
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:543
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:1838
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:127
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:421
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_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:111
av1_decode_free
static av_cold int av1_decode_free(AVCodecContext *avctx)
Definition: av1dec.c:696
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:83
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:1126
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:66
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:920
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1907
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:449
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1486
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:111
HWACCEL_MAX
#define HWACCEL_MAX
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:115
NULL
#define NULL
Definition: coverity.c:32
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:1039
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:694
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:119
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:696
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:476
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:639
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
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:86
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
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:91
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:770
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:469
skip_mode_params
static void skip_mode_params(AV1DecContext *s)
Definition: av1dec.c:264
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
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:1740
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:284
AV1RawOBU::obu
union AV1RawOBU::@30 obu
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:624
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:114
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
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:492
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:473
size
int size
Definition: twinvq_data.h:10344
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
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
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:475
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:490
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:1472
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:333
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:119
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:110
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:288
av1_receive_frame
static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1416
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1446
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:187
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:1022
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:217
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:484
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1904
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:542
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
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:77
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:1046
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:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:656
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
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:84
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:1479
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
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:121
ret
ret
Definition: filter_design.txt:187
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AV1_OBU_TILE_LIST
@ AV1_OBU_TILE_LIST
Definition: av1.h:37
AV1Frame::gm_invalid
uint8_t gm_invalid[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:45
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_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:156
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:472
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:441
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
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:105
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
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:1596
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:979
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
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:113
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:2057
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:1906
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:297
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:71
AV1RawTileGroup
Definition: cbs_av1.h:297
AV1RawFilmGrainParams::cr_offset
uint16_t cr_offset
Definition: cbs_av1.h:160
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:108
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:70
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:367
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AV1RawFilmGrainParams::point_cb_scaling
uint8_t point_cb_scaling[10]
Definition: cbs_av1.h:144
AV1RawMetadataITUTT35::itu_t_t35_country_code
uint8_t itu_t_t35_country_code
Definition: cbs_av1.h:351
mastering_display_metadata.h
AV1RawFrame::tile_group
AV1RawTileGroup tile_group
Definition: cbs_av1.h:307
decode_signed_subexp_with_ref
static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low, int high, int r)
Definition: av1dec.c:90
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:83
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:468
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:468
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
OFFSET
#define OFFSET(x)
Definition: av1dec.c:1471
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:511
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:368
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
TileGroupInfo
Definition: av1dec.h:56
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
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av1_receive_frame_internal
static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:1185
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:107
AV1Frame::coded_lossless
uint8_t coded_lossless
Definition: av1dec.h:53
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:450
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:129
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:1082
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:116
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:822
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:416
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:2884
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
AV1_WARP_PARAM_REDUCE_BITS
@ AV1_WARP_PARAM_REDUCE_BITS
Definition: av1.h:117