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 
24 #include "libavutil/pixdesc.h"
25 #include "libavutil/opt.h"
26 #include "avcodec.h"
27 #include "av1dec.h"
28 #include "bytestream.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 #include "hwconfig.h"
32 #include "profiles.h"
33 #include "thread.h"
34 
35 /**< same with Div_Lut defined in spec 7.11.3.7 */
36 static const uint16_t div_lut[AV1_DIV_LUT_NUM] = {
37  16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
38  15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
39  15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
40  14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
41  13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
42  13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
43  13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
44  12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
45  12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
46  11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
47  11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
48  11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
49  10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
50  10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
51  10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,
52  9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,
53  9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,
54  9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,
55  9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,
56  9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,
57  8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,
58  8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,
59  8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,
60  8240, 8224, 8208, 8192
61 };
62 
63 static uint32_t inverse_recenter(int r, uint32_t v)
64 {
65  if (v > 2 * r)
66  return v;
67  else if (v & 1)
68  return r - ((v + 1) >> 1);
69  else
70  return r + (v >> 1);
71 }
72 
73 static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,
74  int mx, int r)
75 {
76  if ((r << 1) <= mx) {
77  return inverse_recenter(r, sub_exp);
78  } else {
79  return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);
80  }
81 }
82 
83 static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,
84  int high, int r)
85 {
86  int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);
87  return x + low;
88 }
89 
90 static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
91 {
92  uint8_t primary_frame, prev_frame;
93  uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;
94  int32_t r, prev_gm_param;
95 
96  primary_frame = s->raw_frame_header->primary_ref_frame;
97  prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
98  abs_bits = AV1_GM_ABS_ALPHA_BITS;
99  prec_bits = AV1_GM_ALPHA_PREC_BITS;
100 
101  /* setup_past_independence() sets PrevGmParams to default values. We can
102  * simply point to the current's frame gm_params as they will be initialized
103  * with defaults at this point.
104  */
105  if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)
106  prev_gm_param = s->cur_frame.gm_params[ref][idx];
107  else
108  prev_gm_param = s->ref[prev_frame].gm_params[ref][idx];
109 
110  if (idx < 2) {
112  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -
113  !s->raw_frame_header->allow_high_precision_mv;
114  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -
115  !s->raw_frame_header->allow_high_precision_mv;
116  } else {
117  abs_bits = AV1_GM_ABS_TRANS_BITS;
118  prec_bits = AV1_GM_TRANS_PREC_BITS;
119  }
120  }
121  round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
122  prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;
123  sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
124  mx = 1 << abs_bits;
125  r = (prev_gm_param >> prec_diff) - sub;
126 
127  s->cur_frame.gm_params[ref][idx] =
128  (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],
129  -mx, mx + 1, r) << prec_diff) + round;
130 }
131 
132 static uint64_t round_two(uint64_t x, uint16_t n)
133 {
134  if (n == 0)
135  return x;
136  return ((x + ((uint64_t)1 << (n - 1))) >> n);
137 }
138 
139 static int64_t round_two_signed(int64_t x, uint16_t n)
140 {
141  return ((x<0) ? -((int64_t)round_two(-x, n)) : (int64_t)round_two(x, n));
142 }
143 
144 /**
145  * Resolve divisor process.
146  * see spec 7.11.3.7
147  */
148 static int16_t resolve_divisor(uint32_t d, uint16_t *shift)
149 {
150  int32_t e, f;
151 
152  *shift = av_log2(d);
153  e = d - (1 << (*shift));
154  if (*shift > AV1_DIV_LUT_BITS)
156  else
157  f = e << (AV1_DIV_LUT_BITS - (*shift));
158 
160 
161  return div_lut[f];
162 }
163 
164 /**
165  * check if global motion params is valid.
166  * see spec 7.11.3.6
167  */
168 static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)
169 {
170  int16_t alpha, beta, gamma, delta, divf, divs;
171  int64_t v, w;
172  int32_t *param = &s->cur_frame.gm_params[idx][0];
173  if (param[2] < 0)
174  return 0;
175 
176  alpha = av_clip_int16(param[2] - (1 << AV1_WARPEDMODEL_PREC_BITS));
177  beta = av_clip_int16(param[3]);
178  divf = resolve_divisor(abs(param[2]), &divs);
179  v = (int64_t)param[4] * (1 << AV1_WARPEDMODEL_PREC_BITS);
180  w = (int64_t)param[3] * param[4];
181  gamma = av_clip_int16((int)round_two_signed((v * divf), divs));
182  delta = av_clip_int16(param[5] - (int)round_two_signed((w * divf), divs) - (1 << AV1_WARPEDMODEL_PREC_BITS));
183 
188 
189  if ((4 * abs(alpha) + 7 * abs(beta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS) ||
190  (4 * abs(gamma) + 4 * abs(delta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS))
191  return 0;
192 
193  return 1;
194 }
195 
196 /**
197 * update gm type/params, since cbs already implemented part of this funcation,
198 * so we don't need to full implement spec.
199 */
201 {
202  const AV1RawFrameHeader *header = s->raw_frame_header;
203  int type, ref;
204 
206  s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;
207  for (int i = 0; i < 6; i++)
208  s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?
209  1 << AV1_WARPEDMODEL_PREC_BITS : 0;
210  }
211  if (header->frame_type == AV1_FRAME_KEY ||
212  header->frame_type == AV1_FRAME_INTRA_ONLY)
213  return;
214 
216  if (header->is_global[ref]) {
217  if (header->is_rot_zoom[ref]) {
219  } else {
220  type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
222  }
223  } else {
225  }
226  s->cur_frame.gm_type[ref] = type;
227 
228  if (type >= AV1_WARP_MODEL_ROTZOOM) {
229  read_global_param(s, type, ref, 2);
230  read_global_param(s, type, ref, 3);
231  if (type == AV1_WARP_MODEL_AFFINE) {
232  read_global_param(s, type, ref, 4);
233  read_global_param(s, type, ref, 5);
234  } else {
235  s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];
236  s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];
237  }
238  }
240  read_global_param(s, type, ref, 0);
241  read_global_param(s, type, ref, 1);
242  }
243  if (type <= AV1_WARP_MODEL_AFFINE) {
244  s->cur_frame.gm_invalid[ref] = !get_shear_params_valid(s, ref);
245  }
246  }
247 }
248 
250  unsigned int a, unsigned int b)
251 {
252  unsigned int diff = a - b;
253  unsigned int m = 1 << seq->order_hint_bits_minus_1;
254  return (diff & (m - 1)) - (diff & m);
255 }
256 
258 {
259  const AV1RawFrameHeader *header = s->raw_frame_header;
260  const AV1RawSequenceHeader *seq = s->raw_seq;
261 
262  int forward_idx, backward_idx;
263  int forward_hint, backward_hint;
264  int second_forward_idx, second_forward_hint;
265  int ref_hint, dist, i;
266 
267  if (!header->skip_mode_present)
268  return;
269 
270  forward_idx = -1;
271  backward_idx = -1;
272  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
273  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
274  dist = get_relative_dist(seq, ref_hint, header->order_hint);
275  if (dist < 0) {
276  if (forward_idx < 0 ||
277  get_relative_dist(seq, ref_hint, forward_hint) > 0) {
278  forward_idx = i;
279  forward_hint = ref_hint;
280  }
281  } else if (dist > 0) {
282  if (backward_idx < 0 ||
283  get_relative_dist(seq, ref_hint, backward_hint) < 0) {
284  backward_idx = i;
285  backward_hint = ref_hint;
286  }
287  }
288  }
289 
290  if (forward_idx < 0) {
291  return;
292  } else if (backward_idx >= 0) {
293  s->cur_frame.skip_mode_frame_idx[0] =
294  AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);
295  s->cur_frame.skip_mode_frame_idx[1] =
296  AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);
297  return;
298  }
299 
300  second_forward_idx = -1;
301  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
302  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
303  if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {
304  if (second_forward_idx < 0 ||
305  get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {
306  second_forward_idx = i;
307  second_forward_hint = ref_hint;
308  }
309  }
310  }
311 
312  if (second_forward_idx < 0)
313  return;
314 
315  s->cur_frame.skip_mode_frame_idx[0] =
316  AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);
317  s->cur_frame.skip_mode_frame_idx[1] =
318  AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);
319 }
320 
322 {
323  const AV1RawFrameHeader *header = s->raw_frame_header;
324  int i;
325 
326  if (header->delta_q_y_dc || header->delta_q_u_ac ||
327  header->delta_q_u_dc || header->delta_q_v_ac ||
328  header->delta_q_v_dc) {
329  s->cur_frame.coded_lossless = 0;
330  return;
331  }
332 
333  s->cur_frame.coded_lossless = 1;
334  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
335  int qindex;
336  if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
337  qindex = (header->base_q_idx +
338  header->feature_value[i][AV1_SEG_LVL_ALT_Q]);
339  } else {
340  qindex = header->base_q_idx;
341  }
342  qindex = av_clip_uintp2(qindex, 8);
343 
344  if (qindex) {
345  s->cur_frame.coded_lossless = 0;
346  return;
347  }
348  }
349 }
350 
352 {
353  const AV1RawFrameHeader *header = s->raw_frame_header;
354  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
355  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
356 
357  if (!film_grain->apply_grain)
358  return;
359 
360  if (film_grain->update_grain) {
361  memcpy(dst, film_grain, sizeof(*dst));
362  return;
363  }
364 
365  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
366 
367  memcpy(dst, src, sizeof(*dst));
368  dst->grain_seed = film_grain->grain_seed;
369 }
370 
372 
373 {
374  int cur_tile_num =
375  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
376  if (s->tile_num < cur_tile_num) {
377  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
378  sizeof(TileGroupInfo));
379  if (ret < 0) {
380  s->tile_num = 0;
381  return ret;
382  }
383  }
384  s->tile_num = cur_tile_num;
385 
386  return 0;
387 }
388 
389 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
390 {
391  AV1DecContext *s = avctx->priv_data;
392  GetByteContext gb;
393  uint16_t tile_num, tile_row, tile_col;
394  uint32_t size = 0, size_bytes = 0;
395 
396  bytestream2_init(&gb, tile_group->tile_data.data,
397  tile_group->tile_data.data_size);
398  s->tg_start = tile_group->tg_start;
399  s->tg_end = tile_group->tg_end;
400 
401  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
402  tile_row = tile_num / s->raw_frame_header->tile_cols;
403  tile_col = tile_num % s->raw_frame_header->tile_cols;
404 
405  if (tile_num == tile_group->tg_end) {
406  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
407  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
408  s->tile_group_info[tile_num].tile_row = tile_row;
409  s->tile_group_info[tile_num].tile_column = tile_col;
410  return 0;
411  }
412  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
413  if (bytestream2_get_bytes_left(&gb) < size_bytes)
414  return AVERROR_INVALIDDATA;
415  size = 0;
416  for (int i = 0; i < size_bytes; i++)
417  size |= bytestream2_get_byteu(&gb) << 8 * i;
418  if (bytestream2_get_bytes_left(&gb) <= size)
419  return AVERROR_INVALIDDATA;
420  size++;
421 
422  s->tile_group_info[tile_num].tile_size = size;
423  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
424  s->tile_group_info[tile_num].tile_row = tile_row;
425  s->tile_group_info[tile_num].tile_column = tile_col;
426 
427  bytestream2_skipu(&gb, size);
428  }
429 
430  return 0;
431 
432 }
433 
435 {
436  AV1DecContext *s = avctx->priv_data;
437  const AV1RawSequenceHeader *seq = s->raw_seq;
438  uint8_t bit_depth;
439  int ret;
441 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
442  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
443  CONFIG_AV1_NVDEC_HWACCEL + \
444  CONFIG_AV1_VAAPI_HWACCEL + \
445  CONFIG_AV1_VDPAU_HWACCEL)
446  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
447 
448  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
449  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
450  else if (seq->seq_profile <= 2)
451  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
452  else {
453  av_log(avctx, AV_LOG_ERROR,
454  "Unknown AV1 profile %d.\n", seq->seq_profile);
455  return -1;
456  }
457 
458  if (!seq->color_config.mono_chrome) {
459  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
460  if (seq->color_config.subsampling_x == 0 &&
461  seq->color_config.subsampling_y == 0) {
462  if (bit_depth == 8)
464  else if (bit_depth == 10)
466  else if (bit_depth == 12)
468  else
469  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
470  } else if (seq->color_config.subsampling_x == 1 &&
471  seq->color_config.subsampling_y == 0) {
472  if (bit_depth == 8)
474  else if (bit_depth == 10)
476  else if (bit_depth == 12)
478  else
479  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
480  } else if (seq->color_config.subsampling_x == 1 &&
481  seq->color_config.subsampling_y == 1) {
482  if (bit_depth == 8)
484  else if (bit_depth == 10)
486  else if (bit_depth == 12)
488  else
489  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
490  }
491  } else {
492  if (bit_depth == 8)
494  else if (bit_depth == 10)
496  else if (bit_depth == 12)
498  else
499  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
500  }
501 
502  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
504 
505  if (pix_fmt == AV_PIX_FMT_NONE)
506  return -1;
507 
508  switch (pix_fmt) {
509  case AV_PIX_FMT_YUV420P:
510 #if CONFIG_AV1_DXVA2_HWACCEL
511  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
512 #endif
513 #if CONFIG_AV1_D3D11VA_HWACCEL
514  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
515  *fmtp++ = AV_PIX_FMT_D3D11;
516 #endif
517 #if CONFIG_AV1_NVDEC_HWACCEL
518  *fmtp++ = AV_PIX_FMT_CUDA;
519 #endif
520 #if CONFIG_AV1_VAAPI_HWACCEL
521  *fmtp++ = AV_PIX_FMT_VAAPI;
522 #endif
523 #if CONFIG_AV1_VDPAU_HWACCEL
524  *fmtp++ = AV_PIX_FMT_VDPAU;
525 #endif
526  break;
528 #if CONFIG_AV1_DXVA2_HWACCEL
529  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
530 #endif
531 #if CONFIG_AV1_D3D11VA_HWACCEL
532  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
533  *fmtp++ = AV_PIX_FMT_D3D11;
534 #endif
535 #if CONFIG_AV1_NVDEC_HWACCEL
536  *fmtp++ = AV_PIX_FMT_CUDA;
537 #endif
538 #if CONFIG_AV1_VAAPI_HWACCEL
539  *fmtp++ = AV_PIX_FMT_VAAPI;
540 #endif
541 #if CONFIG_AV1_VDPAU_HWACCEL
542  *fmtp++ = AV_PIX_FMT_VDPAU;
543 #endif
544  break;
545  case AV_PIX_FMT_GRAY8:
546 #if CONFIG_AV1_NVDEC_HWACCEL
547  *fmtp++ = AV_PIX_FMT_CUDA;
548 #endif
549  break;
550  case AV_PIX_FMT_GRAY10:
551 #if CONFIG_AV1_NVDEC_HWACCEL
552  *fmtp++ = AV_PIX_FMT_CUDA;
553 #endif
554  break;
555  }
556 
557  *fmtp++ = pix_fmt;
558  *fmtp = AV_PIX_FMT_NONE;
559 
561  if (ret < 0)
562  return ret;
563 
564  /**
565  * check if the HW accel is inited correctly. If not, return un-implemented.
566  * Since now the av1 decoder doesn't support native decode, if it will be
567  * implemented in the future, need remove this check.
568  */
569  if (!avctx->hwaccel) {
570  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't suppport"
571  " hardware accelerated AV1 decoding.\n");
572  return AVERROR(ENOSYS);
573  }
574 
575  s->pix_fmt = pix_fmt;
576  avctx->pix_fmt = ret;
577 
578  return 0;
579 }
580 
582 {
583  ff_thread_release_buffer(avctx, f->f);
584  av_buffer_unref(&f->hwaccel_priv_buf);
585  f->hwaccel_picture_private = NULL;
586  av_buffer_unref(&f->header_ref);
587  f->raw_frame_header = NULL;
588  f->spatial_id = f->temporal_id = 0;
589  memset(f->skip_mode_frame_idx, 0,
590  2 * sizeof(uint8_t));
591  memset(&f->film_grain, 0, sizeof(f->film_grain));
592  f->coded_lossless = 0;
593 }
594 
595 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
596 {
597  int ret;
598 
599  ret = av_buffer_replace(&dst->header_ref, src->header_ref);
600  if (ret < 0)
601  return ret;
602 
603  dst->raw_frame_header = src->raw_frame_header;
604 
605  if (!src->f->buf[0])
606  return 0;
607 
608  ret = av_frame_ref(dst->f, src->f);
609  if (ret < 0)
610  goto fail;
611 
612  if (src->hwaccel_picture_private) {
613  dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
614  if (!dst->hwaccel_priv_buf)
615  goto fail;
617  }
618 
619  dst->spatial_id = src->spatial_id;
620  dst->temporal_id = src->temporal_id;
621  memcpy(dst->gm_invalid,
622  src->gm_invalid,
623  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
624  memcpy(dst->gm_type,
625  src->gm_type,
626  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
627  memcpy(dst->gm_params,
628  src->gm_params,
629  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
630  memcpy(dst->skip_mode_frame_idx,
631  src->skip_mode_frame_idx,
632  2 * sizeof(uint8_t));
633  memcpy(&dst->film_grain,
634  &src->film_grain,
635  sizeof(dst->film_grain));
636  dst->coded_lossless = src->coded_lossless;
637 
638  return 0;
639 
640 fail:
641  av1_frame_unref(avctx, dst);
642  return AVERROR(ENOMEM);
643 }
644 
646 {
647  AV1DecContext *s = avctx->priv_data;
648 
649  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
650  av1_frame_unref(avctx, &s->ref[i]);
651  av_frame_free(&s->ref[i].f);
652  }
653  av1_frame_unref(avctx, &s->cur_frame);
654  av_frame_free(&s->cur_frame.f);
655 
656  av_buffer_unref(&s->seq_ref);
657  av_buffer_unref(&s->header_ref);
658  av_freep(&s->tile_group_info);
659 
660  ff_cbs_fragment_free(&s->current_obu);
661  ff_cbs_close(&s->cbc);
662 
663  return 0;
664 }
665 
667  const AV1RawSequenceHeader *seq)
668 {
669  int width = seq->max_frame_width_minus_1 + 1;
670  int height = seq->max_frame_height_minus_1 + 1;
671 
672  avctx->profile = seq->seq_profile;
673  avctx->level = seq->seq_level_idx[0];
674 
675  avctx->color_range =
680 
681  switch (seq->color_config.chroma_sample_position) {
682  case AV1_CSP_VERTICAL:
684  break;
685  case AV1_CSP_COLOCATED:
687  break;
688  }
689 
690  if (seq->film_grain_params_present)
692  else
694 
695  if (avctx->width != width || avctx->height != height) {
696  int ret = ff_set_dimensions(avctx, width, height);
697  if (ret < 0)
698  return ret;
699  }
700  avctx->sample_aspect_ratio = (AVRational) { 1, 1 };
701 
703  seq->timing_info.time_scale) {
704  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
706  seq->timing_info.time_scale,
707  INT_MAX);
710  }
711 
712  return 0;
713 }
714 
716  const AV1RawFrameHeader *header)
717 {
718  AVRational aspect_ratio;
719  int width = header->frame_width_minus_1 + 1;
720  int height = header->frame_height_minus_1 + 1;
721  int r_width = header->render_width_minus_1 + 1;
722  int r_height = header->render_height_minus_1 + 1;
723  int ret;
724 
725  if (avctx->width != width || avctx->height != height) {
726  ret = ff_set_dimensions(avctx, width, height);
727  if (ret < 0)
728  return ret;
729  }
730 
731  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
732  (int64_t)height * r_width,
733  (int64_t)width * r_height,
734  INT_MAX);
735 
736  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
737  ret = ff_set_sar(avctx, aspect_ratio);
738  if (ret < 0)
739  return ret;
740  }
741 
742  return 0;
743 }
744 
746 {
747  AV1DecContext *s = avctx->priv_data;
749  int ret;
750 
751  s->avctx = avctx;
752  s->pix_fmt = AV_PIX_FMT_NONE;
753 
754  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
755  s->ref[i].f = av_frame_alloc();
756  if (!s->ref[i].f) {
757  av_log(avctx, AV_LOG_ERROR,
758  "Failed to allocate reference frame buffer %d.\n", i);
759  return AVERROR(ENOMEM);
760  }
761  }
762 
763  s->cur_frame.f = av_frame_alloc();
764  if (!s->cur_frame.f) {
765  av_log(avctx, AV_LOG_ERROR,
766  "Failed to allocate current frame buffer.\n");
767  return AVERROR(ENOMEM);
768  }
769 
770  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
771  if (ret < 0)
772  return ret;
773 
774  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
775 
776  if (avctx->extradata && avctx->extradata_size) {
778  &s->current_obu,
779  avctx);
780  if (ret < 0) {
781  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
782  return ret;
783  }
784 
785  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
786  if (!seq) {
787  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
788  goto end;
789  }
790 
791  ret = set_context_with_sequence(avctx, seq);
792  if (ret < 0) {
793  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
794  goto end;
795  }
796 
797  end:
798  ff_cbs_fragment_reset(&s->current_obu);
799  }
800 
801  return ret;
802 }
803 
805 {
806  AV1DecContext *s = avctx->priv_data;
807  AV1RawFrameHeader *header= s->raw_frame_header;
808  AVFrame *frame;
809  int ret;
810 
812  if (ret < 0) {
813  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
814  return ret;
815  }
816 
817  if ((ret = ff_thread_get_buffer(avctx, f->f, AV_GET_BUFFER_FLAG_REF)) < 0)
818  goto fail;
819 
820  frame = f->f;
821  frame->key_frame = header->frame_type == AV1_FRAME_KEY;
822 
823  switch (header->frame_type) {
824  case AV1_FRAME_KEY:
826  frame->pict_type = AV_PICTURE_TYPE_I;
827  break;
828  case AV1_FRAME_INTER:
829  frame->pict_type = AV_PICTURE_TYPE_P;
830  break;
831  case AV1_FRAME_SWITCH:
832  frame->pict_type = AV_PICTURE_TYPE_SP;
833  break;
834  }
835 
836  if (avctx->hwaccel) {
837  const AVHWAccel *hwaccel = avctx->hwaccel;
838  if (hwaccel->frame_priv_data_size) {
839  f->hwaccel_priv_buf =
841  if (!f->hwaccel_priv_buf) {
842  ret = AVERROR(ENOMEM);
843  goto fail;
844  }
845  f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
846  }
847  }
848  return 0;
849 
850 fail:
851  av1_frame_unref(avctx, f);
852  return ret;
853 }
854 
856 {
857  AV1DecContext *s = avctx->priv_data;
858  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
859  AVFilmGrainParams *fgp;
861 
862  if (!film_grain->apply_grain)
863  return 0;
864 
866  if (!fgp)
867  return AVERROR(ENOMEM);
868 
870  fgp->seed = film_grain->grain_seed;
871 
872  aom = &fgp->codec.aom;
874  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
875  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
876  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
877  aom->grain_scale_shift = film_grain->grain_scale_shift;
878  aom->overlap_flag = film_grain->overlap_flag;
879  aom->limit_output_range = film_grain->clip_to_restricted_range;
880 
881  aom->num_y_points = film_grain->num_y_points;
882  for (int i = 0; i < film_grain->num_y_points; i++) {
883  aom->y_points[i][0] = film_grain->point_y_value[i];
884  aom->y_points[i][1] = film_grain->point_y_scaling[i];
885  }
886  aom->num_uv_points[0] = film_grain->num_cb_points;
887  for (int i = 0; i < film_grain->num_cb_points; i++) {
888  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
889  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
890  }
891  aom->num_uv_points[1] = film_grain->num_cr_points;
892  for (int i = 0; i < film_grain->num_cr_points; i++) {
893  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
894  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
895  }
896 
897  for (int i = 0; i < 24; i++) {
898  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
899  }
900  for (int i = 0; i < 25; i++) {
901  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
902  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
903  }
904 
905  aom->uv_mult[0] = film_grain->cb_mult;
906  aom->uv_mult[1] = film_grain->cr_mult;
907  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
908  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
909  aom->uv_offset[0] = film_grain->cb_offset;
910  aom->uv_offset[1] = film_grain->cr_offset;
911 
912  return 0;
913 }
914 
916  const AVPacket *pkt, int *got_frame)
917 {
918  AV1DecContext *s = avctx->priv_data;
919  const AVFrame *srcframe = s->cur_frame.f;
920  int ret;
921 
922  // TODO: all layers
923  if (s->operating_point_idc &&
924  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
925  return 0;
926 
927  ret = av_frame_ref(frame, srcframe);
928  if (ret < 0)
929  return ret;
930 
932  ret = export_film_grain(avctx, frame);
933  if (ret < 0) {
935  return ret;
936  }
937  }
938 
939  frame->pts = pkt->pts;
940  frame->pkt_dts = pkt->dts;
941  frame->pkt_size = pkt->size;
942 
943  *got_frame = 1;
944 
945  return 0;
946 }
947 
949 {
950  AV1DecContext *s = avctx->priv_data;
951  const AV1RawFrameHeader *header = s->raw_frame_header;
952  int ret;
953 
954  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
955  if (header->refresh_frame_flags & (1 << i)) {
956  av1_frame_unref(avctx, &s->ref[i]);
957  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
958  av_log(avctx, AV_LOG_ERROR,
959  "Failed to update frame %d in reference list\n", i);
960  return ret;
961  }
962  }
963  }
964  return 0;
965 }
966 
968 {
969  AV1DecContext *s = avctx->priv_data;
970  int ret;
971 
972  av1_frame_unref(avctx, &s->cur_frame);
973 
974  s->cur_frame.header_ref = av_buffer_ref(s->header_ref);
975  if (!s->cur_frame.header_ref)
976  return AVERROR(ENOMEM);
977 
978  s->cur_frame.raw_frame_header = s->raw_frame_header;
979 
980  ret = init_tile_data(s);
981  if (ret < 0) {
982  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
983  return ret;
984  }
985 
986  if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&
987  (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&
988  s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||
989  (avctx->skip_frame >= AVDISCARD_NONKEY &&
990  s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||
991  avctx->skip_frame >= AVDISCARD_ALL)
992  return 0;
993 
994  ret = av1_frame_alloc(avctx, &s->cur_frame);
995  if (ret < 0) {
996  av_log(avctx, AV_LOG_ERROR,
997  "Failed to allocate space for current frame.\n");
998  return ret;
999  }
1000 
1005 
1006  return ret;
1007 }
1008 
1010  int *got_frame, AVPacket *pkt)
1011 {
1012  AV1DecContext *s = avctx->priv_data;
1013  AV1RawTileGroup *raw_tile_group = NULL;
1014  int ret;
1015 
1016  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, pkt);
1017  if (ret < 0) {
1018  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
1019  goto end;
1020  }
1021  av_log(avctx, AV_LOG_DEBUG, "Total obu for this frame:%d.\n",
1022  s->current_obu.nb_units);
1023 
1024  for (int i = 0; i < s->current_obu.nb_units; i++) {
1025  CodedBitstreamUnit *unit = &s->current_obu.units[i];
1026  AV1RawOBU *obu = unit->content;
1027  const AV1RawOBUHeader *header;
1028 
1029  if (!obu)
1030  continue;
1031 
1032  header = &obu->header;
1033  av_log(avctx, AV_LOG_DEBUG, "Obu idx:%d, obu type:%d.\n", i, unit->type);
1034 
1035  switch (unit->type) {
1037  av_buffer_unref(&s->seq_ref);
1038  s->seq_ref = av_buffer_ref(unit->content_ref);
1039  if (!s->seq_ref) {
1040  ret = AVERROR(ENOMEM);
1041  goto end;
1042  }
1043 
1044  s->raw_seq = &obu->obu.sequence_header;
1045 
1046  ret = set_context_with_sequence(avctx, s->raw_seq);
1047  if (ret < 0) {
1048  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
1049  s->raw_seq = NULL;
1050  goto end;
1051  }
1052 
1053  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
1054 
1055  if (s->pix_fmt == AV_PIX_FMT_NONE) {
1056  ret = get_pixel_format(avctx);
1057  if (ret < 0) {
1058  av_log(avctx, AV_LOG_ERROR,
1059  "Failed to get pixel format.\n");
1060  s->raw_seq = NULL;
1061  goto end;
1062  }
1063  }
1064 
1065  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
1066  ret = avctx->hwaccel->decode_params(avctx, unit->type, unit->data,
1067  unit->data_size);
1068  if (ret < 0) {
1069  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
1070  s->raw_seq = NULL;
1071  goto end;
1072  }
1073  }
1074  break;
1076  if (s->raw_frame_header)
1077  break;
1078  // fall-through
1079  case AV1_OBU_FRAME:
1080  case AV1_OBU_FRAME_HEADER:
1081  if (!s->raw_seq) {
1082  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
1084  goto end;
1085  }
1086 
1087  av_buffer_unref(&s->header_ref);
1088  s->header_ref = av_buffer_ref(unit->content_ref);
1089  if (!s->header_ref) {
1090  ret = AVERROR(ENOMEM);
1091  goto end;
1092  }
1093 
1094  if (unit->type == AV1_OBU_FRAME)
1095  s->raw_frame_header = &obu->obu.frame.header;
1096  else
1097  s->raw_frame_header = &obu->obu.frame_header;
1098 
1099  if (s->raw_frame_header->show_existing_frame) {
1100  av1_frame_unref(avctx, &s->cur_frame);
1101 
1102  ret = av1_frame_ref(avctx, &s->cur_frame,
1103  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
1104  if (ret < 0) {
1105  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
1106  goto end;
1107  }
1108 
1109  ret = update_reference_list(avctx);
1110  if (ret < 0) {
1111  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1112  goto end;
1113  }
1114 
1115  if (s->cur_frame.f->buf[0]) {
1116  ret = set_output_frame(avctx, frame, pkt, got_frame);
1117  if (ret < 0)
1118  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1119  }
1120 
1121  s->raw_frame_header = NULL;
1122 
1123  goto end;
1124  }
1125 
1126  ret = get_current_frame(avctx);
1127  if (ret < 0) {
1128  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1129  goto end;
1130  }
1131 
1132  s->cur_frame.spatial_id = header->spatial_id;
1133  s->cur_frame.temporal_id = header->temporal_id;
1134 
1135  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1136  ret = avctx->hwaccel->start_frame(avctx, unit->data,
1137  unit->data_size);
1138  if (ret < 0) {
1139  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1140  goto end;
1141  }
1142  }
1143  if (unit->type != AV1_OBU_FRAME)
1144  break;
1145  // fall-through
1146  case AV1_OBU_TILE_GROUP:
1147  if (!s->raw_frame_header) {
1148  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1150  goto end;
1151  }
1152 
1153  if (unit->type == AV1_OBU_FRAME)
1154  raw_tile_group = &obu->obu.frame.tile_group;
1155  else
1156  raw_tile_group = &obu->obu.tile_group;
1157 
1158  ret = get_tiles_info(avctx, raw_tile_group);
1159  if (ret < 0)
1160  goto end;
1161 
1162  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1163  ret = avctx->hwaccel->decode_slice(avctx,
1164  raw_tile_group->tile_data.data,
1165  raw_tile_group->tile_data.data_size);
1166  if (ret < 0) {
1167  av_log(avctx, AV_LOG_ERROR,
1168  "HW accel decode slice fail.\n");
1169  goto end;
1170  }
1171  }
1172  break;
1173  case AV1_OBU_TILE_LIST:
1175  case AV1_OBU_PADDING:
1176  case AV1_OBU_METADATA:
1177  break;
1178  default:
1179  av_log(avctx, AV_LOG_DEBUG,
1180  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1181  unit->type, unit->data_size);
1182  }
1183 
1184  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1185  if (avctx->hwaccel && s->cur_frame.f->buf[0]) {
1186  ret = avctx->hwaccel->end_frame(avctx);
1187  if (ret < 0) {
1188  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1189  goto end;
1190  }
1191  }
1192 
1193  ret = update_reference_list(avctx);
1194  if (ret < 0) {
1195  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1196  goto end;
1197  }
1198 
1199  if (s->raw_frame_header->show_frame && s->cur_frame.f->buf[0]) {
1200  ret = set_output_frame(avctx, frame, pkt, got_frame);
1201  if (ret < 0) {
1202  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1203  goto end;
1204  }
1205  }
1206  raw_tile_group = NULL;
1207  s->raw_frame_header = NULL;
1208  }
1209  }
1210 
1211 end:
1212  ff_cbs_fragment_reset(&s->current_obu);
1213  if (ret < 0)
1214  s->raw_frame_header = NULL;
1215  return ret;
1216 }
1217 
1219 {
1220  AV1DecContext *s = avctx->priv_data;
1221 
1222  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1223  av1_frame_unref(avctx, &s->ref[i]);
1224 
1225  av1_frame_unref(avctx, &s->cur_frame);
1226  s->operating_point_idc = 0;
1227  s->raw_frame_header = NULL;
1228  s->raw_seq = NULL;
1229 
1230  ff_cbs_flush(s->cbc);
1231 }
1232 
1233 #define OFFSET(x) offsetof(AV1DecContext, x)
1234 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1235 static const AVOption av1_options[] = {
1236  { "operating_point", "Select an operating point of the scalable bitstream",
1237  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1238  { NULL }
1239 };
1240 
1241 static const AVClass av1_class = {
1242  .class_name = "AV1 decoder",
1243  .item_name = av_default_item_name,
1244  .option = av1_options,
1245  .version = LIBAVUTIL_VERSION_INT,
1246 };
1247 
1249  .p.name = "av1",
1250  CODEC_LONG_NAME("Alliance for Open Media AV1"),
1251  .p.type = AVMEDIA_TYPE_VIDEO,
1252  .p.id = AV_CODEC_ID_AV1,
1253  .priv_data_size = sizeof(AV1DecContext),
1254  .init = av1_decode_init,
1255  .close = av1_decode_free,
1257  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
1258  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1260  .flush = av1_decode_flush,
1261  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1262  .p.priv_class = &av1_class,
1263  .bsfs = "av1_frame_split",
1264  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1265 #if CONFIG_AV1_DXVA2_HWACCEL
1266  HWACCEL_DXVA2(av1),
1267 #endif
1268 #if CONFIG_AV1_D3D11VA_HWACCEL
1269  HWACCEL_D3D11VA(av1),
1270 #endif
1271 #if CONFIG_AV1_D3D11VA2_HWACCEL
1272  HWACCEL_D3D11VA2(av1),
1273 #endif
1274 #if CONFIG_AV1_NVDEC_HWACCEL
1275  HWACCEL_NVDEC(av1),
1276 #endif
1277 #if CONFIG_AV1_VAAPI_HWACCEL
1278  HWACCEL_VAAPI(av1),
1279 #endif
1280 #if CONFIG_AV1_VDPAU_HWACCEL
1281  HWACCEL_VDPAU(av1),
1282 #endif
1283 
1284  NULL
1285  },
1286 };
hwconfig.h
AV1RawTimingInfo::num_units_in_display_tick
uint32_t num_units_in_display_tick
Definition: cbs_av1.h:59
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:1369
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
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:225
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:745
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
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:116
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
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:975
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:68
AV1RawSequenceHeader
Definition: cbs_av1.h:73
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
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:321
GetByteContext
Definition: bytestream.h:33
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
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:171
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:804
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:119
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:106
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_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:105
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:967
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:133
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:236
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:968
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:666
w
uint8_t w
Definition: llviddspenc.c:38
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
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:630
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:157
AV1Frame::raw_frame_header
AV1RawFrameHeader * raw_frame_header
Definition: av1dec.h:40
AVOption
AVOption.
Definition: opt.h:251
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
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:431
AV1RawTileGroup::tg_end
uint16_t tg_end
Definition: cbs_av1.h:298
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:219
FFCodec
Definition: codec_internal.h:119
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:73
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
AV1_DIV_LUT_PREC_BITS
@ AV1_DIV_LUT_PREC_BITS
Definition: av1.h:120
AV1RawTileData::data
uint8_t * data
Definition: cbs_av1.h:290
get_relative_dist
static int get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: av1dec.c:249
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:91
AV1RawOBU::header
AV1RawOBUHeader header
Definition: cbs_av1.h:392
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
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:74
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:69
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:127
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
round_two
static uint64_t round_two(uint64_t x, uint16_t n)
Definition: av1dec.c:132
AV1RawFrame::header
AV1RawFrameHeader header
Definition: cbs_av1.h:304
AV1RawFilmGrainParams::cr_mult
uint8_t cr_mult
Definition: cbs_av1.h:158
init
static int init
Definition: av_tx.c:47
AV1RawFilmGrainParams::chroma_scaling_from_luma
uint8_t chroma_scaling_from_luma
Definition: cbs_av1.h:141
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1735
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
AVHWAccel
Definition: avcodec.h:2070
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1235
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:595
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1698
fail
#define fail()
Definition: checkasm.h:133
AV1_OBU_FRAME_HEADER
@ AV1_OBU_FRAME_HEADER
Definition: av1.h:32
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
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 AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). 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
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:110
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:84
inverse_recenter
static uint32_t inverse_recenter(int r, uint32_t v)
Definition: av1dec.c:63
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
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
AVFilmGrainParams::codec
union AVFilmGrainParams::@310 codec
Additional fields may be added both here and in any structure included.
CodedBitstreamUnit::data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:80
AV1RawFilmGrainParams::num_y_points
uint8_t num_y_points
Definition: cbs_av1.h:138
av1_decode_frame
static int av1_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: av1dec.c:1009
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:139
AVRational::num
int num
Numerator.
Definition: rational.h:59
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:104
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:434
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
AV1RawFilmGrainParams::cb_luma_mult
uint8_t cb_luma_mult
Definition: cbs_av1.h:156
AV1Frame
Definition: av1dec.h:33
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:961
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_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
AV1RawFilmGrainParams::grain_scaling_minus_8
uint8_t grain_scaling_minus_8
Definition: cbs_av1.h:148
set_output_frame
static int set_output_frame(AVCodecContext *avctx, AVFrame *frame, const AVPacket *pkt, int *got_frame)
Definition: av1dec.c:915
global_motion_params
static void global_motion_params(AV1DecContext *s)
update gm type/params, since cbs already implemented part of this funcation, so we don't need to full...
Definition: av1dec.c:200
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
AV1Frame::spatial_id
int spatial_id
Definition: av1dec.h:43
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
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:256
AV1Frame::hwaccel_priv_buf
AVBufferRef * hwaccel_priv_buf
Definition: av1dec.h:36
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:376
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:530
AV1_DIV_LUT_BITS
@ AV1_DIV_LUT_BITS
Definition: av1.h:119
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
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:645
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
init_tile_data
static int init_tile_data(AV1DecContext *s)
Definition: av1dec.c:371
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:134
update_reference_list
static int update_reference_list(AVCodecContext *avctx)
Definition: av1dec.c:948
decode.h
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:147
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
av1_frame_unref
static void av1_frame_unref(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:581
AV1_WARP_PARAM_REDUCE_BITS
@ AV1_WARP_PARAM_REDUCE_BITS
Definition: av1.h:117
AV1RawColorConfig::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_av1.h:48
AVHWAccel::decode_params
int(* decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size)
Callback for parameter data (SPS/PPS/VPS etc).
Definition: avcodec.h:2146
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:389
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1850
load_grain_params
static void load_grain_params(AV1DecContext *s)
Definition: av1dec.c:351
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:412
AV1RawOBU::obu
union AV1RawOBU::@27 obu
ff_av1_decoder
const FFCodec ff_av1_decoder
Definition: av1dec.c:1248
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:76
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV1RawOBU
Definition: cbs_av1.h:391
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_clip_int16
#define av_clip_int16
Definition: common.h:110
HWACCEL_MAX
#define HWACCEL_MAX
NULL
#define NULL
Definition: coverity.c:32
AV1Frame::gm_params
int32_t gm_params[AV1_NUM_REF_FRAMES][6]
Definition: av1dec.h: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:982
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
AV1RawFrameHeader
Definition: cbs_av1.h:165
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:651
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:653
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:115
AV1RawTileData::data_size
size_t data_size
Definition: cbs_av1.h:292
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2170
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
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:85
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:106
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:109
AV1_OBU_TILE_GROUP
@ AV1_OBU_TILE_GROUP
Definition: av1.h:33
AV1_DIV_LUT_NUM
@ AV1_DIV_LUT_NUM
Definition: av1.h:121
update_context_with_frame_header
static int update_context_with_frame_header(AVCodecContext *avctx, const AV1RawFrameHeader *header)
Definition: av1dec.c:715
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:432
skip_mode_params
static void skip_mode_params(AV1DecContext *s)
Definition: av1dec.c:257
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AVCodecContext::level
int level
level
Definition: avcodec.h:1676
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:279
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
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:148
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:75
f
f
Definition: af_crystalizer.c:122
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:375
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:115
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:353
decode_unsigned_subexp_with_ref
static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp, int mx, int r)
Definition: av1dec.c:73
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:260
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:436
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:63
AV1RawOBU::sequence_header
AV1RawSequenceHeader sequence_header
Definition: cbs_av1.h:397
AV1Frame::skip_mode_frame_idx
uint8_t skip_mode_frame_idx[2]
Definition: av1dec.h:49
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:438
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
AV1_OBU_SEQUENCE_HEADER
@ AV1_OBU_SEQUENCE_HEADER
Definition: av1.h:30
AVCodecHWConfigInternal
Definition: hwconfig.h:29
header
static const uint8_t header[24]
Definition: sdr2.c:67
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:107
height
#define height
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:83
AV1Frame::f
AVFrame * f
Definition: av1dec.h:34
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:233
VD
#define VD
Definition: av1dec.c:1234
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:305
AV1RawFilmGrainParams::grain_scale_shift
uint8_t grain_scale_shift
Definition: cbs_av1.h:154
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
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
AV1RawOBU::frame_header
AV1RawFrameHeader frame_header
Definition: cbs_av1.h:398
ff_cbs_read_extradata_from_codec
int ff_cbs_read_extradata_from_codec(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecContext *avctx)
Definition: cbs.c:280
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1098
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1218
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:187
export_film_grain
static int export_film_grain(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:855
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:74
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1847
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:499
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2159
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:36
AV1Frame::hwaccel_picture_private
void * hwaccel_picture_private
Definition: av1dec.h:37
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:73
AV1RawTimingInfo::equal_picture_interval
uint8_t equal_picture_interval
Definition: cbs_av1.h:62
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
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:211
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:989
AV1RawTileGroup::tg_start
uint16_t tg_start
Definition: cbs_av1.h:297
FF_CODEC_CAP_SETS_PKT_DTS
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: codec_internal.h:49
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:613
AV1RawOBU::tile_group
AV1RawTileGroup tile_group
Definition: cbs_av1.h:400
AV1RawFilmGrainParams::update_grain
uint8_t update_grain
Definition: cbs_av1.h:136
avcodec.h
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:91
AV1RawTileGroup::tile_data
AV1RawTileData tile_data
Definition: cbs_av1.h:300
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:1241
CodedBitstreamUnit::content_ref
AVBufferRef * content_ref
If content is reference counted, a reference to the buffer containing content.
Definition: cbs.h:111
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
ret
ret
Definition: filter_design.txt:187
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AV1_OBU_TILE_LIST
@ AV1_OBU_TILE_LIST
Definition: av1.h:37
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV1Frame::gm_invalid
uint8_t gm_invalid[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:45
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
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:90
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:435
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:150
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:86
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:168
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
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:65
AVHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2179
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:1550
AV1RawColorConfig::mono_chrome
uint8_t mono_chrome
Definition: cbs_av1.h:44
ff_thread_get_format
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:1029
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
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:2009
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
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:289
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
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:295
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
AVHWAccel::start_frame
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:2132
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:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV1RawOBU::frame
AV1RawFrame frame
Definition: cbs_av1.h:399
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
AV1RawFilmGrainParams::point_cb_scaling
uint8_t point_cb_scaling[10]
Definition: cbs_av1.h:144
AV1RawFrame::tile_group
AV1RawTileGroup tile_group
Definition: cbs_av1.h:305
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:83
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:76
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:114
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:108
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:111
get_pixel_format
static int get_pixel_format(AVCodecContext *avctx)
Definition: av1dec.c:434
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
OFFSET
#define OFFSET(x)
Definition: av1dec.c:1233
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:113
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
AV1Frame::header_ref
AVBufferRef * header_ref
Definition: av1dec.h:39
d
d
Definition: ffmpeg_filter.c:156
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:144
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV1Frame::coded_lossless
uint8_t coded_lossless
Definition: av1dec.h:53
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:413
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:121
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
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:62
AV1_OBU_METADATA
@ AV1_OBU_METADATA
Definition: av1.h:34
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:116
AV1RawFilmGrainParams::num_cr_points
uint8_t num_cr_points
Definition: cbs_av1.h:145
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:106
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:768
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:371
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:2778
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:88
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:427