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 
22 #include "libavutil/pixdesc.h"
23 #include "libavutil/opt.h"
24 #include "avcodec.h"
25 #include "av1dec.h"
26 #include "bytestream.h"
27 #include "hwconfig.h"
28 #include "internal.h"
29 #include "profiles.h"
30 
31 static uint32_t inverse_recenter(int r, uint32_t v)
32 {
33  if (v > 2 * r)
34  return v;
35  else if (v & 1)
36  return r - ((v + 1) >> 1);
37  else
38  return r + (v >> 1);
39 }
40 
41 static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,
42  int mx, int r)
43 {
44  if ((r << 1) <= mx) {
45  return inverse_recenter(r, sub_exp);
46  } else {
47  return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);
48  }
49 }
50 
51 static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,
52  int high, int r)
53 {
54  int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);
55  return x + low;
56 }
57 
58 static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
59 {
60  uint8_t primary_frame, prev_frame;
61  uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;
62  int32_t r, prev_gm_param;
63 
64  primary_frame = s->raw_frame_header->primary_ref_frame;
65  prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
66  abs_bits = AV1_GM_ABS_ALPHA_BITS;
67  prec_bits = AV1_GM_ALPHA_PREC_BITS;
68 
69  /* setup_past_independence() sets PrevGmParams to default values. We can
70  * simply point to the current's frame gm_params as they will be initialized
71  * with defaults at this point.
72  */
73  if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)
74  prev_gm_param = s->cur_frame.gm_params[ref][idx];
75  else
76  prev_gm_param = s->ref[prev_frame].gm_params[ref][idx];
77 
78  if (idx < 2) {
80  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -
81  !s->raw_frame_header->allow_high_precision_mv;
82  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -
83  !s->raw_frame_header->allow_high_precision_mv;
84  } else {
85  abs_bits = AV1_GM_ABS_TRANS_BITS;
86  prec_bits = AV1_GM_TRANS_PREC_BITS;
87  }
88  }
89  round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
90  prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;
91  sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
92  mx = 1 << abs_bits;
93  r = (prev_gm_param >> prec_diff) - sub;
94 
95  s->cur_frame.gm_params[ref][idx] =
96  (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],
97  -mx, mx + 1, r) << prec_diff) + round;
98 }
99 
100 /**
101 * update gm type/params, since cbs already implemented part of this funcation,
102 * so we don't need to full implement spec.
103 */
105 {
106  const AV1RawFrameHeader *header = s->raw_frame_header;
107  int type, ref;
108 
110  s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;
111  for (int i = 0; i < 6; i++)
112  s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?
113  1 << AV1_WARPEDMODEL_PREC_BITS : 0;
114  }
115  if (header->frame_type == AV1_FRAME_KEY ||
116  header->frame_type == AV1_FRAME_INTRA_ONLY)
117  return;
118 
120  if (header->is_global[ref]) {
121  if (header->is_rot_zoom[ref]) {
123  } else {
124  type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
126  }
127  } else {
129  }
130  s->cur_frame.gm_type[ref] = type;
131 
132  if (type >= AV1_WARP_MODEL_ROTZOOM) {
133  read_global_param(s, type, ref, 2);
134  read_global_param(s, type, ref, 3);
135  if (type == AV1_WARP_MODEL_AFFINE) {
136  read_global_param(s, type, ref, 4);
137  read_global_param(s, type, ref, 5);
138  } else {
139  s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];
140  s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];
141  }
142  }
144  read_global_param(s, type, ref, 0);
145  read_global_param(s, type, ref, 1);
146  }
147  }
148 }
149 
151  unsigned int a, unsigned int b)
152 {
153  unsigned int diff = a - b;
154  unsigned int m = 1 << seq->order_hint_bits_minus_1;
155  return (diff & (m - 1)) - (diff & m);
156 }
157 
159 {
160  const AV1RawFrameHeader *header = s->raw_frame_header;
161  const AV1RawSequenceHeader *seq = s->raw_seq;
162 
163  int forward_idx, backward_idx;
164  int forward_hint, backward_hint;
165  int second_forward_idx, second_forward_hint;
166  int ref_hint, dist, i;
167 
168  if (!header->skip_mode_present)
169  return;
170 
171  forward_idx = -1;
172  backward_idx = -1;
173  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
174  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
175  dist = get_relative_dist(seq, ref_hint, header->order_hint);
176  if (dist < 0) {
177  if (forward_idx < 0 ||
178  get_relative_dist(seq, ref_hint, forward_hint) > 0) {
179  forward_idx = i;
180  forward_hint = ref_hint;
181  }
182  } else if (dist > 0) {
183  if (backward_idx < 0 ||
184  get_relative_dist(seq, ref_hint, backward_hint) < 0) {
185  backward_idx = i;
186  backward_hint = ref_hint;
187  }
188  }
189  }
190 
191  if (forward_idx < 0) {
192  return;
193  } else if (backward_idx >= 0) {
194  s->cur_frame.skip_mode_frame_idx[0] =
195  AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);
196  s->cur_frame.skip_mode_frame_idx[1] =
197  AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);
198  return;
199  }
200 
201  second_forward_idx = -1;
202  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
203  ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;
204  if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {
205  if (second_forward_idx < 0 ||
206  get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {
207  second_forward_idx = i;
208  second_forward_hint = ref_hint;
209  }
210  }
211  }
212 
213  if (second_forward_idx < 0)
214  return;
215 
216  s->cur_frame.skip_mode_frame_idx[0] =
217  AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);
218  s->cur_frame.skip_mode_frame_idx[1] =
219  AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);
220 }
221 
223 {
224  const AV1RawFrameHeader *header = s->raw_frame_header;
225  int i;
226 
227  if (header->delta_q_y_dc || header->delta_q_u_ac ||
228  header->delta_q_u_dc || header->delta_q_v_ac ||
229  header->delta_q_v_dc) {
230  s->cur_frame.coded_lossless = 0;
231  return;
232  }
233 
234  s->cur_frame.coded_lossless = 1;
235  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
236  int qindex;
237  if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
238  qindex = (header->base_q_idx +
239  header->feature_value[i][AV1_SEG_LVL_ALT_Q]);
240  } else {
241  qindex = header->base_q_idx;
242  }
243  qindex = av_clip_uintp2(qindex, 8);
244 
245  if (qindex) {
246  s->cur_frame.coded_lossless = 0;
247  return;
248  }
249  }
250 }
251 
253 {
254  const AV1RawFrameHeader *header = s->raw_frame_header;
255  const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;
256  AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;
257 
258  if (!film_grain->apply_grain)
259  return;
260 
261  if (film_grain->update_grain) {
262  memcpy(dst, film_grain, sizeof(*dst));
263  return;
264  }
265 
266  src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;
267 
268  memcpy(dst, src, sizeof(*dst));
269  dst->grain_seed = film_grain->grain_seed;
270 }
271 
273 
274 {
275  int cur_tile_num =
276  s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
277  if (s->tile_num < cur_tile_num) {
278  int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
279  sizeof(TileGroupInfo));
280  if (ret < 0) {
281  s->tile_num = 0;
282  return ret;
283  }
284  }
285  s->tile_num = cur_tile_num;
286 
287  return 0;
288 }
289 
290 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
291 {
292  AV1DecContext *s = avctx->priv_data;
293  GetByteContext gb;
294  uint16_t tile_num, tile_row, tile_col;
295  uint32_t size = 0, size_bytes = 0;
296 
297  bytestream2_init(&gb, tile_group->tile_data.data,
298  tile_group->tile_data.data_size);
299  s->tg_start = tile_group->tg_start;
300  s->tg_end = tile_group->tg_end;
301 
302  for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
303  tile_row = tile_num / s->raw_frame_header->tile_cols;
304  tile_col = tile_num % s->raw_frame_header->tile_cols;
305 
306  if (tile_num == tile_group->tg_end) {
307  s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
308  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
309  s->tile_group_info[tile_num].tile_row = tile_row;
310  s->tile_group_info[tile_num].tile_column = tile_col;
311  return 0;
312  }
313  size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
314  if (bytestream2_get_bytes_left(&gb) < size_bytes)
315  return AVERROR_INVALIDDATA;
316  size = 0;
317  for (int i = 0; i < size_bytes; i++)
318  size |= bytestream2_get_byteu(&gb) << 8 * i;
319  if (bytestream2_get_bytes_left(&gb) <= size)
320  return AVERROR_INVALIDDATA;
321  size++;
322 
323  s->tile_group_info[tile_num].tile_size = size;
324  s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
325  s->tile_group_info[tile_num].tile_row = tile_row;
326  s->tile_group_info[tile_num].tile_column = tile_col;
327 
328  bytestream2_skipu(&gb, size);
329  }
330 
331  return 0;
332 
333 }
334 
336 {
337  AV1DecContext *s = avctx->priv_data;
338  const AV1RawSequenceHeader *seq = s->raw_seq;
339  uint8_t bit_depth;
340  int ret;
342 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \
343  CONFIG_AV1_D3D11VA_HWACCEL * 2 + \
344  CONFIG_AV1_NVDEC_HWACCEL + \
345  CONFIG_AV1_VAAPI_HWACCEL)
346  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
347 
348  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
349  bit_depth = seq->color_config.twelve_bit ? 12 : 10;
350  else if (seq->seq_profile <= 2)
351  bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
352  else {
353  av_log(avctx, AV_LOG_ERROR,
354  "Unknown AV1 profile %d.\n", seq->seq_profile);
355  return -1;
356  }
357 
358  if (!seq->color_config.mono_chrome) {
359  // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
360  if (seq->color_config.subsampling_x == 0 &&
361  seq->color_config.subsampling_y == 0) {
362  if (bit_depth == 8)
364  else if (bit_depth == 10)
366  else if (bit_depth == 12)
368  else
369  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
370  } else if (seq->color_config.subsampling_x == 1 &&
371  seq->color_config.subsampling_y == 0) {
372  if (bit_depth == 8)
374  else if (bit_depth == 10)
376  else if (bit_depth == 12)
378  else
379  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
380  } else if (seq->color_config.subsampling_x == 1 &&
381  seq->color_config.subsampling_y == 1) {
382  if (bit_depth == 8)
384  else if (bit_depth == 10)
386  else if (bit_depth == 12)
388  else
389  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
390  }
391  } else {
392  if (bit_depth == 8)
394  else if (bit_depth == 10)
396  else if (bit_depth == 12)
398  else
399  av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
400  }
401 
402  av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
404 
405  if (pix_fmt == AV_PIX_FMT_NONE)
406  return -1;
407  s->pix_fmt = pix_fmt;
408 
409  switch (s->pix_fmt) {
410  case AV_PIX_FMT_YUV420P:
411 #if CONFIG_AV1_DXVA2_HWACCEL
412  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
413 #endif
414 #if CONFIG_AV1_D3D11VA_HWACCEL
415  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
416  *fmtp++ = AV_PIX_FMT_D3D11;
417 #endif
418 #if CONFIG_AV1_NVDEC_HWACCEL
419  *fmtp++ = AV_PIX_FMT_CUDA;
420 #endif
421 #if CONFIG_AV1_VAAPI_HWACCEL
422  *fmtp++ = AV_PIX_FMT_VAAPI;
423 #endif
424  break;
426 #if CONFIG_AV1_DXVA2_HWACCEL
427  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
428 #endif
429 #if CONFIG_AV1_D3D11VA_HWACCEL
430  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
431  *fmtp++ = AV_PIX_FMT_D3D11;
432 #endif
433 #if CONFIG_AV1_NVDEC_HWACCEL
434  *fmtp++ = AV_PIX_FMT_CUDA;
435 #endif
436 #if CONFIG_AV1_VAAPI_HWACCEL
437  *fmtp++ = AV_PIX_FMT_VAAPI;
438 #endif
439  break;
440  case AV_PIX_FMT_GRAY8:
441 #if CONFIG_AV1_NVDEC_HWACCEL
442  *fmtp++ = AV_PIX_FMT_CUDA;
443 #endif
444  break;
445  case AV_PIX_FMT_GRAY10:
446 #if CONFIG_AV1_NVDEC_HWACCEL
447  *fmtp++ = AV_PIX_FMT_CUDA;
448 #endif
449  break;
450  }
451 
452  *fmtp++ = s->pix_fmt;
453  *fmtp = AV_PIX_FMT_NONE;
454 
456  if (ret < 0)
457  return ret;
458 
459  /**
460  * check if the HW accel is inited correctly. If not, return un-implemented.
461  * Since now the av1 decoder doesn't support native decode, if it will be
462  * implemented in the future, need remove this check.
463  */
464  if (!avctx->hwaccel) {
465  av_log(avctx, AV_LOG_ERROR, "Your platform doesn't suppport"
466  " hardware accelerated AV1 decoding.\n");
467  return AVERROR(ENOSYS);
468  }
469 
470  avctx->pix_fmt = ret;
471 
472  return 0;
473 }
474 
476 {
477  ff_thread_release_buffer(avctx, &f->tf);
478  av_buffer_unref(&f->hwaccel_priv_buf);
479  f->hwaccel_picture_private = NULL;
480  av_buffer_unref(&f->header_ref);
481  f->raw_frame_header = NULL;
482  f->spatial_id = f->temporal_id = 0;
483  memset(f->skip_mode_frame_idx, 0,
484  2 * sizeof(uint8_t));
485  memset(&f->film_grain, 0, sizeof(f->film_grain));
486  f->coded_lossless = 0;
487 }
488 
489 static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
490 {
491  int ret;
492 
493  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
494  if (ret < 0)
495  return ret;
496 
497  dst->header_ref = av_buffer_ref(src->header_ref);
498  if (!dst->header_ref)
499  goto fail;
500 
501  dst->raw_frame_header = src->raw_frame_header;
502 
503  if (src->hwaccel_picture_private) {
504  dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
505  if (!dst->hwaccel_priv_buf)
506  goto fail;
508  }
509 
510  dst->spatial_id = src->spatial_id;
511  dst->temporal_id = src->temporal_id;
512  memcpy(dst->gm_type,
513  src->gm_type,
514  AV1_NUM_REF_FRAMES * sizeof(uint8_t));
515  memcpy(dst->gm_params,
516  src->gm_params,
517  AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
518  memcpy(dst->skip_mode_frame_idx,
519  src->skip_mode_frame_idx,
520  2 * sizeof(uint8_t));
521  memcpy(&dst->film_grain,
522  &src->film_grain,
523  sizeof(dst->film_grain));
524  dst->coded_lossless = src->coded_lossless;
525 
526  return 0;
527 
528 fail:
529  av1_frame_unref(avctx, dst);
530  return AVERROR(ENOMEM);
531 }
532 
534 {
535  AV1DecContext *s = avctx->priv_data;
536 
537  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
538  av1_frame_unref(avctx, &s->ref[i]);
539  av_frame_free(&s->ref[i].tf.f);
540  }
541  av1_frame_unref(avctx, &s->cur_frame);
542  av_frame_free(&s->cur_frame.tf.f);
543 
544  av_buffer_unref(&s->seq_ref);
545  av_buffer_unref(&s->header_ref);
546  av_freep(&s->tile_group_info);
547 
548  ff_cbs_fragment_free(&s->current_obu);
549  ff_cbs_close(&s->cbc);
550 
551  return 0;
552 }
553 
555  const AV1RawSequenceHeader *seq)
556 {
557  int width = seq->max_frame_width_minus_1 + 1;
558  int height = seq->max_frame_height_minus_1 + 1;
559 
560  avctx->profile = seq->seq_profile;
561  avctx->level = seq->seq_level_idx[0];
562 
563  avctx->color_range =
568 
569  switch (seq->color_config.chroma_sample_position) {
570  case AV1_CSP_VERTICAL:
572  break;
573  case AV1_CSP_COLOCATED:
575  break;
576  }
577 
578  if (seq->film_grain_params_present)
580  else
582 
583  if (avctx->width != width || avctx->height != height) {
584  int ret = ff_set_dimensions(avctx, width, height);
585  if (ret < 0)
586  return ret;
587  }
588  avctx->sample_aspect_ratio = (AVRational) { 1, 1 };
589 
591  seq->timing_info.time_scale) {
592  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
594  seq->timing_info.time_scale,
595  INT_MAX);
598  }
599 
600  return 0;
601 }
602 
604  const AV1RawFrameHeader *header)
605 {
606  AVRational aspect_ratio;
607  int width = header->frame_width_minus_1 + 1;
608  int height = header->frame_height_minus_1 + 1;
609  int r_width = header->render_width_minus_1 + 1;
610  int r_height = header->render_height_minus_1 + 1;
611  int ret;
612 
613  if (avctx->width != width || avctx->height != height) {
614  ret = ff_set_dimensions(avctx, width, height);
615  if (ret < 0)
616  return ret;
617  }
618 
619  av_reduce(&aspect_ratio.num, &aspect_ratio.den,
620  (int64_t)height * r_width,
621  (int64_t)width * r_height,
622  INT_MAX);
623 
624  if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
625  ret = ff_set_sar(avctx, aspect_ratio);
626  if (ret < 0)
627  return ret;
628  }
629 
630  return 0;
631 }
632 
634 {
635  AV1DecContext *s = avctx->priv_data;
637  int ret;
638 
639  s->avctx = avctx;
640  s->pix_fmt = AV_PIX_FMT_NONE;
641 
642  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
643  s->ref[i].tf.f = av_frame_alloc();
644  if (!s->ref[i].tf.f) {
645  av_log(avctx, AV_LOG_ERROR,
646  "Failed to allocate reference frame buffer %d.\n", i);
647  return AVERROR(ENOMEM);
648  }
649  }
650 
651  s->cur_frame.tf.f = av_frame_alloc();
652  if (!s->cur_frame.tf.f) {
653  av_log(avctx, AV_LOG_ERROR,
654  "Failed to allocate current frame buffer.\n");
655  return AVERROR(ENOMEM);
656  }
657 
658  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
659  if (ret < 0)
660  return ret;
661 
662  av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);
663 
664  if (avctx->extradata && avctx->extradata_size) {
666  &s->current_obu,
667  avctx);
668  if (ret < 0) {
669  av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
670  return ret;
671  }
672 
673  seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
674  if (!seq) {
675  av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
676  goto end;
677  }
678 
679  ret = set_context_with_sequence(avctx, seq);
680  if (ret < 0) {
681  av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
682  goto end;
683  }
684 
685  end:
686  ff_cbs_fragment_reset(&s->current_obu);
687  }
688 
689  return ret;
690 }
691 
693 {
694  AV1DecContext *s = avctx->priv_data;
695  AV1RawFrameHeader *header= s->raw_frame_header;
696  AVFrame *frame;
697  int ret;
698 
700  if (ret < 0) {
701  av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
702  return ret;
703  }
704 
705  f->header_ref = av_buffer_ref(s->header_ref);
706  if (!f->header_ref)
707  return AVERROR(ENOMEM);
708 
709  f->raw_frame_header = s->raw_frame_header;
710 
711  if ((ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
712  goto fail;
713 
714  frame = f->tf.f;
715  frame->key_frame = header->frame_type == AV1_FRAME_KEY;
716 
717  switch (header->frame_type) {
718  case AV1_FRAME_KEY:
720  frame->pict_type = AV_PICTURE_TYPE_I;
721  break;
722  case AV1_FRAME_INTER:
723  frame->pict_type = AV_PICTURE_TYPE_P;
724  break;
725  case AV1_FRAME_SWITCH:
726  frame->pict_type = AV_PICTURE_TYPE_SP;
727  break;
728  }
729 
730  if (avctx->hwaccel) {
731  const AVHWAccel *hwaccel = avctx->hwaccel;
732  if (hwaccel->frame_priv_data_size) {
733  f->hwaccel_priv_buf =
735  if (!f->hwaccel_priv_buf) {
736  ret = AVERROR(ENOMEM);
737  goto fail;
738  }
739  f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
740  }
741  }
742  return 0;
743 
744 fail:
745  av1_frame_unref(avctx, f);
746  return ret;
747 }
748 
750 {
751  AV1DecContext *s = avctx->priv_data;
752  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
753  AVFilmGrainParams *fgp;
755 
756  if (!film_grain->apply_grain)
757  return 0;
758 
760  if (!fgp)
761  return AVERROR(ENOMEM);
762 
764  fgp->seed = film_grain->grain_seed;
765 
766  aom = &fgp->codec.aom;
768  aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;
769  aom->ar_coeff_lag = film_grain->ar_coeff_lag;
770  aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;
771  aom->grain_scale_shift = film_grain->grain_scale_shift;
772  aom->overlap_flag = film_grain->overlap_flag;
773  aom->limit_output_range = film_grain->clip_to_restricted_range;
774 
775  aom->num_y_points = film_grain->num_y_points;
776  for (int i = 0; i < film_grain->num_y_points; i++) {
777  aom->y_points[i][0] = film_grain->point_y_value[i];
778  aom->y_points[i][1] = film_grain->point_y_scaling[i];
779  }
780  aom->num_uv_points[0] = film_grain->num_cb_points;
781  for (int i = 0; i < film_grain->num_cb_points; i++) {
782  aom->uv_points[0][i][0] = film_grain->point_cb_value[i];
783  aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];
784  }
785  aom->num_uv_points[1] = film_grain->num_cr_points;
786  for (int i = 0; i < film_grain->num_cr_points; i++) {
787  aom->uv_points[1][i][0] = film_grain->point_cr_value[i];
788  aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];
789  }
790 
791  for (int i = 0; i < 24; i++) {
792  aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;
793  }
794  for (int i = 0; i < 25; i++) {
795  aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;
796  aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;
797  }
798 
799  aom->uv_mult[0] = film_grain->cb_mult;
800  aom->uv_mult[1] = film_grain->cr_mult;
801  aom->uv_mult_luma[0] = film_grain->cb_luma_mult;
802  aom->uv_mult_luma[1] = film_grain->cr_luma_mult;
803  aom->uv_offset[0] = film_grain->cb_offset;
804  aom->uv_offset[1] = film_grain->cr_offset;
805 
806  return 0;
807 }
808 
810  const AVPacket *pkt, int *got_frame)
811 {
812  AV1DecContext *s = avctx->priv_data;
813  const AVFrame *srcframe = s->cur_frame.tf.f;
814  int ret;
815 
816  // TODO: all layers
817  if (s->operating_point_idc &&
818  av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)
819  return 0;
820 
821  ret = av_frame_ref(frame, srcframe);
822  if (ret < 0)
823  return ret;
824 
826  ret = export_film_grain(avctx, frame);
827  if (ret < 0) {
829  return ret;
830  }
831  }
832 
833  frame->pts = pkt->pts;
834  frame->pkt_dts = pkt->dts;
835  frame->pkt_size = pkt->size;
836 
837  *got_frame = 1;
838 
839  return 0;
840 }
841 
843 {
844  AV1DecContext *s = avctx->priv_data;
845  const AV1RawFrameHeader *header = s->raw_frame_header;
846  int ret;
847 
848  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
849  if (header->refresh_frame_flags & (1 << i)) {
850  if (s->ref[i].tf.f->buf[0])
851  av1_frame_unref(avctx, &s->ref[i]);
852  if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
853  av_log(avctx, AV_LOG_ERROR,
854  "Failed to update frame %d in reference list\n", i);
855  return ret;
856  }
857  }
858  }
859  return 0;
860 }
861 
863 {
864  AV1DecContext *s = avctx->priv_data;
865  int ret;
866 
867  if (s->cur_frame.tf.f->buf[0])
868  av1_frame_unref(avctx, &s->cur_frame);
869 
870  ret = av1_frame_alloc(avctx, &s->cur_frame);
871  if (ret < 0) {
872  av_log(avctx, AV_LOG_ERROR,
873  "Failed to allocate space for current frame.\n");
874  return ret;
875  }
876 
877  ret = init_tile_data(s);
878  if (ret < 0) {
879  av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
880  return ret;
881  }
882 
887 
888  return ret;
889 }
890 
891 static int av1_decode_frame(AVCodecContext *avctx, void *frame,
892  int *got_frame, AVPacket *pkt)
893 {
894  AV1DecContext *s = avctx->priv_data;
895  AV1RawTileGroup *raw_tile_group = NULL;
896  int ret;
897 
898  ret = ff_cbs_read_packet(s->cbc, &s->current_obu, pkt);
899  if (ret < 0) {
900  av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
901  goto end;
902  }
903  av_log(avctx, AV_LOG_DEBUG, "Total obu for this frame:%d.\n",
904  s->current_obu.nb_units);
905 
906  for (int i = 0; i < s->current_obu.nb_units; i++) {
907  CodedBitstreamUnit *unit = &s->current_obu.units[i];
908  AV1RawOBU *obu = unit->content;
909  const AV1RawOBUHeader *header;
910 
911  if (!obu)
912  continue;
913 
914  header = &obu->header;
915  av_log(avctx, AV_LOG_DEBUG, "Obu idx:%d, obu type:%d.\n", i, unit->type);
916 
917  switch (unit->type) {
919  av_buffer_unref(&s->seq_ref);
920  s->seq_ref = av_buffer_ref(unit->content_ref);
921  if (!s->seq_ref) {
922  ret = AVERROR(ENOMEM);
923  goto end;
924  }
925 
926  s->raw_seq = &obu->obu.sequence_header;
927 
928  ret = set_context_with_sequence(avctx, s->raw_seq);
929  if (ret < 0) {
930  av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
931  s->raw_seq = NULL;
932  goto end;
933  }
934 
935  s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];
936 
937  if (s->pix_fmt == AV_PIX_FMT_NONE) {
938  ret = get_pixel_format(avctx);
939  if (ret < 0) {
940  av_log(avctx, AV_LOG_ERROR,
941  "Failed to get pixel format.\n");
942  s->raw_seq = NULL;
943  goto end;
944  }
945  }
946 
947  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
948  ret = avctx->hwaccel->decode_params(avctx, unit->type, unit->data,
949  unit->data_size);
950  if (ret < 0) {
951  av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
952  s->raw_seq = NULL;
953  goto end;
954  }
955  }
956  break;
958  if (s->raw_frame_header)
959  break;
960  // fall-through
961  case AV1_OBU_FRAME:
963  if (!s->raw_seq) {
964  av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
966  goto end;
967  }
968 
969  av_buffer_unref(&s->header_ref);
970  s->header_ref = av_buffer_ref(unit->content_ref);
971  if (!s->header_ref) {
972  ret = AVERROR(ENOMEM);
973  goto end;
974  }
975 
976  if (unit->type == AV1_OBU_FRAME)
977  s->raw_frame_header = &obu->obu.frame.header;
978  else
979  s->raw_frame_header = &obu->obu.frame_header;
980 
981  if (s->raw_frame_header->show_existing_frame) {
982  if (s->cur_frame.tf.f->buf[0])
983  av1_frame_unref(avctx, &s->cur_frame);
984 
985  ret = av1_frame_ref(avctx, &s->cur_frame,
986  &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
987  if (ret < 0) {
988  av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
989  goto end;
990  }
991 
992  ret = update_reference_list(avctx);
993  if (ret < 0) {
994  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
995  goto end;
996  }
997 
998  ret = set_output_frame(avctx, frame, pkt, got_frame);
999  if (ret < 0)
1000  av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
1001 
1002  s->raw_frame_header = NULL;
1003 
1004  goto end;
1005  }
1006 
1007  ret = get_current_frame(avctx);
1008  if (ret < 0) {
1009  av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
1010  goto end;
1011  }
1012 
1013  s->cur_frame.spatial_id = header->spatial_id;
1014  s->cur_frame.temporal_id = header->temporal_id;
1015 
1016  if (avctx->hwaccel) {
1017  ret = avctx->hwaccel->start_frame(avctx, unit->data,
1018  unit->data_size);
1019  if (ret < 0) {
1020  av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
1021  goto end;
1022  }
1023  }
1024  if (unit->type != AV1_OBU_FRAME)
1025  break;
1026  // fall-through
1027  case AV1_OBU_TILE_GROUP:
1028  if (!s->raw_frame_header) {
1029  av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
1031  goto end;
1032  }
1033 
1034  if (unit->type == AV1_OBU_FRAME)
1035  raw_tile_group = &obu->obu.frame.tile_group;
1036  else
1037  raw_tile_group = &obu->obu.tile_group;
1038 
1039  ret = get_tiles_info(avctx, raw_tile_group);
1040  if (ret < 0)
1041  goto end;
1042 
1043  if (avctx->hwaccel) {
1044  ret = avctx->hwaccel->decode_slice(avctx,
1045  raw_tile_group->tile_data.data,
1046  raw_tile_group->tile_data.data_size);
1047  if (ret < 0) {
1048  av_log(avctx, AV_LOG_ERROR,
1049  "HW accel decode slice fail.\n");
1050  goto end;
1051  }
1052  }
1053  break;
1054  case AV1_OBU_TILE_LIST:
1056  case AV1_OBU_PADDING:
1057  case AV1_OBU_METADATA:
1058  break;
1059  default:
1060  av_log(avctx, AV_LOG_DEBUG,
1061  "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
1062  unit->type, unit->data_size);
1063  }
1064 
1065  if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
1066  if (avctx->hwaccel) {
1067  ret = avctx->hwaccel->end_frame(avctx);
1068  if (ret < 0) {
1069  av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
1070  goto end;
1071  }
1072  }
1073 
1074  ret = update_reference_list(avctx);
1075  if (ret < 0) {
1076  av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
1077  goto end;
1078  }
1079 
1080  if (s->raw_frame_header->show_frame) {
1081  ret = set_output_frame(avctx, frame, pkt, got_frame);
1082  if (ret < 0) {
1083  av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
1084  goto end;
1085  }
1086  }
1087  raw_tile_group = NULL;
1088  s->raw_frame_header = NULL;
1089  }
1090  }
1091 
1092 end:
1093  ff_cbs_fragment_reset(&s->current_obu);
1094  if (ret < 0)
1095  s->raw_frame_header = NULL;
1096  return ret;
1097 }
1098 
1100 {
1101  AV1DecContext *s = avctx->priv_data;
1102 
1103  for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
1104  av1_frame_unref(avctx, &s->ref[i]);
1105 
1106  av1_frame_unref(avctx, &s->cur_frame);
1107  s->operating_point_idc = 0;
1108  s->raw_frame_header = NULL;
1109  s->raw_seq = NULL;
1110 
1111  ff_cbs_flush(s->cbc);
1112 }
1113 
1114 #define OFFSET(x) offsetof(AV1DecContext, x)
1115 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1116 static const AVOption av1_options[] = {
1117  { "operating_point", "Select an operating point of the scalable bitstream",
1118  OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },
1119  { NULL }
1120 };
1121 
1122 static const AVClass av1_class = {
1123  .class_name = "AV1 decoder",
1124  .item_name = av_default_item_name,
1125  .option = av1_options,
1126  .version = LIBAVUTIL_VERSION_INT,
1127 };
1128 
1130  .name = "av1",
1131  .long_name = NULL_IF_CONFIG_SMALL("Alliance for Open Media AV1"),
1132  .type = AVMEDIA_TYPE_VIDEO,
1133  .id = AV_CODEC_ID_AV1,
1134  .priv_data_size = sizeof(AV1DecContext),
1135  .init = av1_decode_init,
1136  .close = av1_decode_free,
1138  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
1139  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1144  .priv_class = &av1_class,
1145  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1146 #if CONFIG_AV1_DXVA2_HWACCEL
1147  HWACCEL_DXVA2(av1),
1148 #endif
1149 #if CONFIG_AV1_D3D11VA_HWACCEL
1150  HWACCEL_D3D11VA(av1),
1151 #endif
1152 #if CONFIG_AV1_D3D11VA2_HWACCEL
1153  HWACCEL_D3D11VA2(av1),
1154 #endif
1155 #if CONFIG_AV1_NVDEC_HWACCEL
1156  HWACCEL_NVDEC(av1),
1157 #endif
1158 #if CONFIG_AV1_VAAPI_HWACCEL
1159  HWACCEL_VAAPI(av1),
1160 #endif
1161  NULL
1162  },
1163 };
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:1355
AVCodec
AVCodec.
Definition: codec.h:197
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:247
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:225
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:84
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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: internal.h:57
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:633
AV1_OBU_REDUNDANT_FRAME_HEADER
@ AV1_OBU_REDUNDANT_FRAME_HEADER
Definition: av1.h:36
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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:956
AV1RawSequenceHeader
Definition: cbs_av1.h:73
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:879
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:222
GetByteContext
Definition: bytestream.h:33
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
av1_frame_alloc
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
Definition: av1dec.c:692
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:120
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
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:862
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:236
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:949
set_context_with_sequence
static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)
Definition: av1dec.c:554
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:576
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
internal.h
AV1Frame::raw_frame_header
AV1RawFrameHeader * raw_frame_header
Definition: av1dec.h:40
ff_cbs_close
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:127
AVOption
AVOption.
Definition: opt.h:247
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
b
#define b
Definition: input.c:40
AV1RawSequenceHeader::timing_info
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
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
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
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:150
AV1RawOBU::header
AV1RawOBUHeader header
Definition: cbs_av1.h:392
AV1_MAX_OPERATING_POINTS
@ AV1_MAX_OPERATING_POINTS
Definition: av1.h:73
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:228
ff_cbs_fragment_free
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
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:74
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:69
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:108
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:115
AV1RawFrame::header
AV1RawFrameHeader header
Definition: cbs_av1.h:304
AV1RawFilmGrainParams::cr_mult
uint8_t cr_mult
Definition: cbs_av1.h:158
AV1RawFilmGrainParams::chroma_scaling_from_luma
uint8_t chroma_scaling_from_luma
Definition: cbs_av1.h:141
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1706
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:2034
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
av1_options
static const AVOption av1_options[]
Definition: av1dec.c:1116
ff_cbs_flush
void ff_cbs_flush(CodedBitstreamContext *ctx)
Reset all internal state in a context.
Definition: cbs.c:121
av1_frame_ref
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
Definition: av1dec.c:489
fail
#define fail()
Definition: checkasm.h:127
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
inverse_recenter
static uint32_t inverse_recenter(int r, uint32_t v)
Definition: av1dec.c:31
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:80
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
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV1_WARPEDMODEL_PREC_BITS
@ AV1_WARPEDMODEL_PREC_BITS
Definition: av1.h:111
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:99
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
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:942
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
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:116
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
AV1RawFilmGrainParams::grain_scaling_minus_8
uint8_t grain_scaling_minus_8
Definition: cbs_av1.h:148
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:109
set_output_frame
static int set_output_frame(AVCodecContext *avctx, AVFrame *frame, const AVPacket *pkt, int *got_frame)
Definition: av1dec.c:809
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:104
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:126
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
AV1Frame::spatial_id
int spatial_id
Definition: av1dec.h:43
width
#define width
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:257
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:86
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:357
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:511
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:50
av1_decode_free
static av_cold int av1_decode_free(AVCodecContext *avctx)
Definition: av1dec.c:533
AVFilmGrainParams::codec
union AVFilmGrainParams::@291 codec
Additional fields may be added both here and in any structure included.
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
init_tile_data
static int init_tile_data(AV1DecContext *s)
Definition: av1dec.c:272
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:106
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:842
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:475
AV1RawColorConfig::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_av1.h:48
av1_decode_frame
static int av1_decode_frame(AVCodecContext *avctx, void *frame, int *got_frame, AVPacket *pkt)
Definition: av1dec.c:891
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:2110
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:290
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:105
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:68
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:88
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:114
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1821
load_grain_params
static void load_grain_params(AV1DecContext *s)
Definition: av1dec.c:252
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:370
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
AV1RawOBU::obu
union AV1RawOBU::@25 obu
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
HWACCEL_MAX
#define HWACCEL_MAX
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:62
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
AV1Frame::gm_params
int32_t gm_params[AV1_NUM_REF_FRAMES][6]
Definition: av1dec.h:46
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:963
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:279
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:597
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:110
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:599
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:235
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2135
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
src
#define src
Definition: vp8dsp.c:255
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
AV1_OBU_TILE_GROUP
@ AV1_OBU_TILE_GROUP
Definition: av1.h:33
update_context_with_frame_header
static int update_context_with_frame_header(AVCodecContext *avctx, const AV1RawFrameHeader *header)
Definition: av1dec.c:603
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
skip_mode_params
static void skip_mode_params(AV1DecContext *s)
Definition: av1dec.c:158
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AVCodecContext::level
int level
level
Definition: avcodec.h:1647
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:586
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
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1057
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
AV1Frame::tf
ThreadFrame tf
Definition: av1dec.h:34
AV1RawFilmGrainParams::point_cr_value
uint8_t point_cr_value[10]
Definition: cbs_av1.h:146
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:374
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:117
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:327
decode_unsigned_subexp_with_ref
static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp, int mx, int r)
Definition: av1dec.c:41
AV1RawTimingInfo::num_ticks_per_picture_minus_1
uint32_t num_ticks_per_picture_minus_1
Definition: cbs_av1.h:63
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:62
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:48
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:107
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
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
height
#define height
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, or free an array through a pointer to a pointer.
Definition: mem.c:230
VD
#define VD
Definition: av1dec.c:1115
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:303
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
av1_decode_flush
static void av1_decode_flush(AVCodecContext *avctx)
Definition: av1dec.c:1099
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:83
export_film_grain
static int export_film_grain(AVCodecContext *avctx, AVFrame *frame)
Definition: av1dec.c:749
i
int i
Definition: input.c:406
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1818
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:480
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2124
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: internal.h:50
AV1Frame::hwaccel_picture_private
void * hwaccel_picture_private
Definition: av1dec.h:37
AV1RawTimingInfo::equal_picture_interval
uint8_t equal_picture_interval
Definition: cbs_av1.h:62
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:437
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:204
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:970
AV1RawTileGroup::tg_start
uint16_t tg_start
Definition: cbs_av1.h:297
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:559
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
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:1122
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
ff_av1_decoder
const AVCodec ff_av1_decoder
Definition: av1dec.c:1129
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
ff_cbs_init
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
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:58
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
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:101
AVCodecContext
main external API structure.
Definition: avcodec.h:379
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:2144
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AV1RawFilmGrainParams::ar_coeff_lag
uint8_t ar_coeff_lag
Definition: cbs_av1.h:149
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1521
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:1021
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:107
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:1979
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
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:2096
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
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:86
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:51
AV1Frame::temporal_id
int temporal_id
Definition: av1dec.h:42
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
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:335
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
OFFSET
#define OFFSET(x)
Definition: av1dec.c:1114
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
AV1Frame::header_ref
AVBufferRef * header_ref
Definition: av1dec.h:39
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
TileGroupInfo
Definition: av1dec.h:55
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:28
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:113
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:139
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:91
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
AV1Frame::coded_lossless
uint8_t coded_lossless
Definition: av1dec.h:52
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:371
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
AV1Frame::gm_type
uint8_t gm_type[AV1_NUM_REF_FRAMES]
Definition: av1dec.h:45
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_OBU_METADATA
@ AV1_OBU_METADATA
Definition: av1.h:34
AV1RawFilmGrainParams::num_cr_points
uint8_t num_cr_points
Definition: cbs_av1.h:145
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:749
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:352
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:2460
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
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:127