FFmpeg
dec.c
Go to the documentation of this file.
1 /*
2  * VVC video decoder
3  *
4  * Copyright (C) 2021 Nuo Mi
5  * Copyright (C) 2022 Xu Mu
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
24 #include "libavcodec/decode.h"
25 #include "libavcodec/profiles.h"
26 #include "libavcodec/refstruct.h"
27 #include "libavutil/cpu.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/thread.h"
30 
31 #include "dec.h"
32 #include "ctu.h"
33 #include "data.h"
34 #include "refs.h"
35 #include "thread.h"
36 
37 #define TAB_MAX 32
38 
39 typedef struct Tab {
40  void **tab;
41  size_t size;
42 } Tab;
43 
44 typedef struct TabList {
46  int nb_tabs;
47 
48  int zero;
49  int realloc;
50 } TabList;
51 
52 #define TL_ADD(t, s) do { \
53  av_assert0(l->nb_tabs < TAB_MAX); \
54  l->tabs[l->nb_tabs].tab = (void**)&fc->tab.t; \
55  l->tabs[l->nb_tabs].size = sizeof(*fc->tab.t) * (s); \
56  l->nb_tabs++; \
57 } while (0)
58 
59 static void tl_init(TabList *l, const int zero, const int realloc)
60 {
61  l->nb_tabs = 0;
62  l->zero = zero;
63  l->realloc = realloc;
64 }
65 
66 static int tl_free(TabList *l)
67 {
68  for (int i = 0; i < l->nb_tabs; i++)
69  av_freep(l->tabs[i].tab);
70 
71  return 0;
72 }
73 
74 static int tl_create(TabList *l)
75 {
76  if (l->realloc) {
77  tl_free(l);
78 
79  for (int i = 0; i < l->nb_tabs; i++) {
80  Tab *t = l->tabs + i;
81  *t->tab = l->zero ? av_mallocz(t->size) : av_malloc(t->size);
82  if (!*t->tab)
83  return AVERROR(ENOMEM);
84  }
85  } else if (l->zero) {
86  for (int i = 0; i < l->nb_tabs; i++) {
87  Tab *t = l->tabs + i;
88  memset(*t->tab, 0, t->size);
89  }
90  }
91  return 0;
92 }
93 
95 {
96  const VVCPPS *pps = fc->ps.pps;
97  const int ctu_count = pps ? pps->ctb_count : 0;
98  const int changed = fc->tab.sz.ctu_count != ctu_count;
99 
100  tl_init(l, 1, changed);
101 
102  TL_ADD(deblock, ctu_count);
103  TL_ADD(sao, ctu_count);
104  TL_ADD(alf, ctu_count);
105  TL_ADD(ctus, ctu_count);
106 }
107 
109 {
110  const VVCSPS *sps = fc->ps.sps;
111  const VVCPPS *pps = fc->ps.pps;
112  const int ctu_size = sps ? (1 << sps->ctb_log2_size_y << sps->ctb_log2_size_y) : 0;
113  const int ctu_count = pps ? pps->ctb_count : 0;
114  const int changed = fc->tab.sz.ctu_count != ctu_count || fc->tab.sz.ctu_size != ctu_size;
115 
116  tl_init(l, 0, changed);
117  TL_ADD(slice_idx, ctu_count);
118  TL_ADD(coeffs, ctu_count * ctu_size * VVC_MAX_SAMPLE_ARRAYS);
119 }
120 
122 {
123  const VVCPPS *pps = fc->ps.pps;
124  const int pic_size_in_min_cb = pps ? pps->min_cb_width * pps->min_cb_height : 0;
125  const int changed = fc->tab.sz.pic_size_in_min_cb != pic_size_in_min_cb;
126 
127  tl_init(l, 1, changed);
128 
129  TL_ADD(skip, pic_size_in_min_cb);
130  TL_ADD(imf, pic_size_in_min_cb);
131  TL_ADD(imtf, pic_size_in_min_cb);
132  TL_ADD(imm, pic_size_in_min_cb);
133  TL_ADD(ipm, pic_size_in_min_cb);
134 
135  for (int i = LUMA; i <= CHROMA; i++) {
136  TL_ADD(cb_pos_x[i], pic_size_in_min_cb);
137  TL_ADD(cb_pos_y[i], pic_size_in_min_cb);
138  TL_ADD(cb_width[i], pic_size_in_min_cb);
139  TL_ADD(cb_height[i], pic_size_in_min_cb);
140  TL_ADD(cqt_depth[i], pic_size_in_min_cb);
141  TL_ADD(cpm[i], pic_size_in_min_cb);
142  TL_ADD(cp_mv[i], pic_size_in_min_cb * MAX_CONTROL_POINTS);
143  };
144 }
145 
147 {
148  const VVCPPS *pps = fc->ps.pps;
149  const int pic_size_in_min_pu = pps ? pps->min_pu_width * pps->min_pu_height : 0;
150  const int changed = fc->tab.sz.pic_size_in_min_pu != pic_size_in_min_pu;
151 
152  tl_init(l, 1, changed);
153 
154  TL_ADD(msf, pic_size_in_min_pu);
155  TL_ADD(iaf, pic_size_in_min_pu);
156  TL_ADD(mmi, pic_size_in_min_pu);
157  TL_ADD(mvf, pic_size_in_min_pu);
158 }
159 
161 {
162  const VVCPPS *pps = fc->ps.pps;
163  const int pic_size_in_min_tu = pps ? pps->min_tu_width * pps->min_tu_height : 0;
164  const int changed = fc->tab.sz.pic_size_in_min_tu != pic_size_in_min_tu;
165 
166  tl_init(l, 1, changed);
167 
168  TL_ADD(tu_joint_cbcr_residual_flag, pic_size_in_min_tu);
169  for (int i = LUMA; i <= CHROMA; i++) {
170  TL_ADD(tb_pos_x0[i], pic_size_in_min_tu);
171  TL_ADD(tb_pos_y0[i], pic_size_in_min_tu);
172  TL_ADD(tb_width[i], pic_size_in_min_tu);
173  TL_ADD(tb_height[i], pic_size_in_min_tu);
174  TL_ADD(pcmf[i], pic_size_in_min_tu);
175  }
176 
177  for (int i = 0; i < VVC_MAX_SAMPLE_ARRAYS; i++) {
178  TL_ADD(tu_coded_flag[i], pic_size_in_min_tu);
179  TL_ADD(qp[i], pic_size_in_min_tu);
180  }
181 }
182 
184 {
185  const VVCPPS *pps = fc->ps.pps;
186  const int bs_width = pps ? (pps->width >> 2) + 1 : 0;
187  const int bs_height = pps ? (pps->height >> 2) + 1 : 0;
188  const int bs_count = bs_width * bs_height;
189  const int changed = fc->tab.sz.bs_width != bs_width ||
190  fc->tab.sz.bs_height != bs_height;
191 
192  tl_init(l, 1, changed);
193 
194  for (int i = 0; i < VVC_MAX_SAMPLE_ARRAYS; i++) {
195  TL_ADD(horizontal_bs[i], bs_count);
196  TL_ADD(vertical_bs[i], bs_count);
197  }
198  TL_ADD(horizontal_q, bs_count);
199  TL_ADD(horizontal_p, bs_count);
200  TL_ADD(vertical_p, bs_count);
201  TL_ADD(vertical_q, bs_count);
202 }
203 
205 {
206  const VVCSPS *sps = fc->ps.sps;
207  const VVCPPS *pps = fc->ps.pps;
208  const int width = pps ? pps->width : 0;
209  const int height = pps ? pps->height : 0;
210  const int ctu_width = pps ? pps->ctb_width : 0;
211  const int ctu_height = pps ? pps->ctb_height : 0;
212  const int chroma_idc = sps ? sps->r->sps_chroma_format_idc : 0;
213  const int ps = sps ? sps->pixel_shift : 0;
214  const int c_end = chroma_idc ? VVC_MAX_SAMPLE_ARRAYS : 1;
215  const int changed = fc->tab.sz.chroma_format_idc != chroma_idc ||
216  fc->tab.sz.width != width || fc->tab.sz.height != height ||
217  fc->tab.sz.ctu_width != ctu_width || fc->tab.sz.ctu_height != ctu_height ||
218  fc->tab.sz.pixel_shift != ps;
219 
220  tl_init(l, 0, changed);
221 
222  for (int c_idx = 0; c_idx < c_end; c_idx++) {
223  const int w = width >> (sps ? sps->hshift[c_idx] : 0);
224  const int h = height >> (sps ? sps->vshift[c_idx] : 0);
225  TL_ADD(sao_pixel_buffer_h[c_idx], (w * 2 * ctu_height) << ps);
226  TL_ADD(sao_pixel_buffer_v[c_idx], (h * 2 * ctu_width) << ps);
227  }
228 
229  for (int c_idx = 0; c_idx < c_end; c_idx++) {
230  const int w = width >> (sps ? sps->hshift[c_idx] : 0);
231  const int h = height >> (sps ? sps->vshift[c_idx] : 0);
232  const int border_pixels = c_idx ? ALF_BORDER_CHROMA : ALF_BORDER_LUMA;
233  for (int i = 0; i < 2; i++) {
234  TL_ADD(alf_pixel_buffer_h[c_idx][i], (w * border_pixels * ctu_height) << ps);
235  TL_ADD(alf_pixel_buffer_v[c_idx][i], h * ALF_PADDING_SIZE * ctu_width);
236  }
237  }
238 }
239 
241 {
242  const VVCPPS *pps = fc->ps.pps;
243  const int w32 = pps ? AV_CEIL_RSHIFT(pps->width, 5) : 0;
244  const int h32 = pps ? AV_CEIL_RSHIFT(pps->height, 5) : 0;
245  const int changed = AV_CEIL_RSHIFT(fc->tab.sz.width, 5) != w32 ||
246  AV_CEIL_RSHIFT(fc->tab.sz.height, 5) != h32;
247 
248  tl_init(l, 1, changed);
249 
250  for (int i = LUMA; i <= CHROMA; i++)
251  TL_ADD(msm[i], w32 * h32);
252 }
253 
255 {
256  const VVCPPS *pps = fc->ps.pps;
257  const int w64 = pps ? AV_CEIL_RSHIFT(pps->width, 6) : 0;
258  const int h64 = pps ? AV_CEIL_RSHIFT(pps->height, 6) : 0;
259  const int changed = AV_CEIL_RSHIFT(fc->tab.sz.width, 6) != w64 ||
260  AV_CEIL_RSHIFT(fc->tab.sz.height, 6) != h64;
261 
262  tl_init(l, 1, changed);
263 
264  TL_ADD(ispmf, w64 * h64);
265 }
266 
268 {
269  const VVCSPS *sps = fc->ps.sps;
270  const VVCPPS *pps = fc->ps.pps;
271  const int ctu_height = pps ? pps->ctb_height : 0;
272  const int ctu_size = sps ? sps->ctb_size_y : 0;
273  const int ps = sps ? sps->pixel_shift : 0;
274  const int chroma_idc = sps ? sps->r->sps_chroma_format_idc : 0;
275  const int has_ibc = sps ? sps->r->sps_ibc_enabled_flag : 0;
276  const int changed = fc->tab.sz.chroma_format_idc != chroma_idc ||
277  fc->tab.sz.ctu_height != ctu_height ||
278  fc->tab.sz.ctu_size != ctu_size ||
279  fc->tab.sz.pixel_shift != ps;
280 
281  fc->tab.sz.ibc_buffer_width = ctu_size ? 2 * MAX_CTU_SIZE * MAX_CTU_SIZE / ctu_size : 0;
282 
283  tl_init(l, has_ibc, changed);
284 
285  for (int i = LUMA; i < VVC_MAX_SAMPLE_ARRAYS; i++) {
286  const int hs = sps ? sps->hshift[i] : 0;
287  const int vs = sps ? sps->vshift[i] : 0;
288  TL_ADD(ibc_vir_buf[i], fc->tab.sz.ibc_buffer_width * ctu_size * ctu_height << ps >> hs >> vs);
289  }
290 }
291 
292 typedef void (*tl_init_fn)(TabList *l, VVCFrameContext *fc);
293 
294 static int frame_context_for_each_tl(VVCFrameContext *fc, int (*unary_fn)(TabList *l))
295 {
296  const tl_init_fn init[] = {
297  ctu_tl_init,
302  bs_tl_init,
304  msm_tl_init,
306  ibc_tl_init,
307  };
308 
309  for (int i = 0; i < FF_ARRAY_ELEMS(init); i++) {
310  TabList l;
311  int ret;
312 
313  init[i](&l, fc);
314  ret = unary_fn(&l);
315  if (ret < 0)
316  return ret;
317  }
318  return 0;
319 }
320 
322 {
323  if (fc->tab.ctus) {
324  for (int i = 0; i < fc->tab.sz.ctu_count; i++)
325  ff_vvc_ctu_free_cus(fc->tab.ctus + i);
326  }
327 }
328 
330 {
331  free_cus(fc);
333  ff_refstruct_pool_uninit(&fc->rpl_tab_pool);
334  ff_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
335 
336  memset(&fc->tab.sz, 0, sizeof(fc->tab.sz));
337 }
338 
340 {
341  const VVCSPS *sps = fc->ps.sps;
342  const VVCPPS *pps = fc->ps.pps;
343  const int ctu_count = pps->ctb_count;
344  const int pic_size_in_min_pu = pps->min_pu_width * pps->min_pu_height;
345  int ret;
346 
347  free_cus(fc);
348 
350  if (ret < 0)
351  return ret;
352 
353  memset(fc->tab.slice_idx, -1, sizeof(*fc->tab.slice_idx) * ctu_count);
354 
355  if (fc->tab.sz.ctu_count != ctu_count) {
356  ff_refstruct_pool_uninit(&fc->rpl_tab_pool);
357  fc->rpl_tab_pool = ff_refstruct_pool_alloc(ctu_count * sizeof(RefPicListTab), 0);
358  if (!fc->rpl_tab_pool)
359  return AVERROR(ENOMEM);
360  }
361 
362  if (fc->tab.sz.pic_size_in_min_pu != pic_size_in_min_pu) {
363  ff_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
364  fc->tab_dmvr_mvf_pool = ff_refstruct_pool_alloc(
365  pic_size_in_min_pu * sizeof(MvField), FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
366  if (!fc->tab_dmvr_mvf_pool)
367  return AVERROR(ENOMEM);
368  }
369 
370  fc->tab.sz.ctu_count = pps->ctb_count;
371  fc->tab.sz.ctu_size = 1 << sps->ctb_log2_size_y << sps->ctb_log2_size_y;
372  fc->tab.sz.pic_size_in_min_cb = pps->min_cb_width * pps->min_cb_height;
373  fc->tab.sz.pic_size_in_min_pu = pic_size_in_min_pu;
374  fc->tab.sz.pic_size_in_min_tu = pps->min_tu_width * pps->min_tu_height;
375  fc->tab.sz.width = pps->width;
376  fc->tab.sz.height = pps->height;
377  fc->tab.sz.ctu_width = pps->ctb_width;
378  fc->tab.sz.ctu_height = pps->ctb_height;
379  fc->tab.sz.chroma_format_idc = sps->r->sps_chroma_format_idc;
380  fc->tab.sz.pixel_shift = sps->pixel_shift;
381  fc->tab.sz.bs_width = (fc->ps.pps->width >> 2) + 1;
382  fc->tab.sz.bs_height = (fc->ps.pps->height >> 2) + 1;
383 
384  return 0;
385 }
386 
387 static int min_positive(const int idx, const int diff, const int min_diff)
388 {
389  return diff > 0 && (idx < 0 || diff < min_diff);
390 }
391 
392 static int max_negtive(const int idx, const int diff, const int max_diff)
393 {
394  return diff < 0 && (idx < 0 || diff > max_diff);
395 }
396 
397 typedef int (*smvd_find_fxn)(const int idx, const int diff, const int old_diff);
398 
399 static int8_t smvd_find(const VVCFrameContext *fc, const SliceContext *sc, int lx, smvd_find_fxn find)
400 {
401  const H266RawSliceHeader *rsh = sc->sh.r;
402  const RefPicList *rpl = sc->rpl + lx;
403  const int poc = fc->ref->poc;
404  int8_t idx = -1;
405  int old_diff = -1;
406  for (int i = 0; i < rsh->num_ref_idx_active[lx]; i++) {
407  if (!rpl->refs[i].is_lt) {
408  int diff = poc - rpl->refs[i].poc;
409  if (find(idx, diff, old_diff)) {
410  idx = i;
411  old_diff = diff;
412  }
413  }
414  }
415  return idx;
416 }
417 
418 static void smvd_ref_idx(const VVCFrameContext *fc, SliceContext *sc)
419 {
420  VVCSH *sh = &sc->sh;
421  if (IS_B(sh->r)) {
422  sh->ref_idx_sym[0] = smvd_find(fc, sc, 0, min_positive);
423  sh->ref_idx_sym[1] = smvd_find(fc, sc, 1, max_negtive);
424  if (sh->ref_idx_sym[0] == -1 || sh->ref_idx_sym[1] == -1) {
425  sh->ref_idx_sym[0] = smvd_find(fc, sc, 0, max_negtive);
426  sh->ref_idx_sym[1] = smvd_find(fc, sc, 1, min_positive);
427  }
428  }
429 }
430 
431 static void eps_free(SliceContext *slice)
432 {
433  av_freep(&slice->eps);
434  slice->nb_eps = 0;
435 }
436 
438 {
439  if (fc->slices) {
440  for (int i = 0; i < fc->nb_slices_allocated; i++) {
441  SliceContext *slice = fc->slices[i];
442  if (slice) {
443  ff_refstruct_unref(&slice->ref);
444  ff_refstruct_unref(&slice->sh.r);
445  eps_free(slice);
446  av_free(slice);
447  }
448  }
449  av_freep(&fc->slices);
450  }
451  fc->nb_slices_allocated = 0;
452  fc->nb_slices = 0;
453 }
454 
456 {
457  void *p;
458  const int size = (fc->nb_slices_allocated + 1) * 3 / 2;
459 
460  if (fc->nb_slices < fc->nb_slices_allocated)
461  return 0;
462 
463  p = av_realloc_array(fc->slices, size, sizeof(*fc->slices));
464  if (!p)
465  return AVERROR(ENOMEM);
466 
467  fc->slices = p;
468  for (int i = fc->nb_slices_allocated; i < size; i++) {
469  fc->slices[i] = av_mallocz(sizeof(*fc->slices[0]));
470  if (!fc->slices[i]) {
471  fc->nb_slices_allocated = i;
472  return AVERROR(ENOMEM);
473  }
474  fc->slices[i]->slice_idx = i;
475  }
476  fc->nb_slices_allocated = size;
477 
478  return 0;
479 }
480 
481 static void ep_init_cabac_decoder(SliceContext *sc, const int index,
482  const H2645NAL *nal, GetBitContext *gb, const CodedBitstreamUnit *unit)
483 {
484  const H266RawSlice *slice = unit->content_ref;
485  const H266RawSliceHeader *rsh = sc->sh.r;
486  EntryPoint *ep = sc->eps + index;
487  int size;
488 
489  if (index < rsh->num_entry_points) {
490  int skipped = 0;
491  int64_t start = (gb->index >> 3);
492  int64_t end = start + rsh->sh_entry_point_offset_minus1[index] + 1;
493  while (skipped < nal->skipped_bytes && nal->skipped_bytes_pos[skipped] <= start + slice->header_size) {
494  skipped++;
495  }
496  while (skipped < nal->skipped_bytes && nal->skipped_bytes_pos[skipped] <= end + slice->header_size) {
497  end--;
498  skipped++;
499  }
500  size = end - start;
501  size = av_clip(size, 0, get_bits_left(gb) / 8);
502  } else {
503  size = get_bits_left(gb) / 8;
504  }
505  av_assert0(gb->buffer + get_bits_count(gb) / 8 + size <= gb->buffer_end);
506  ff_init_cabac_decoder (&ep->cc, gb->buffer + get_bits_count(gb) / 8, size);
507  skip_bits(gb, size * 8);
508 }
509 
511  VVCFrameContext *fc, const H2645NAL *nal, const CodedBitstreamUnit *unit)
512 {
513  const VVCSH *sh = &sc->sh;
514  const H266RawSlice *slice = unit->content_ref;
515  int nb_eps = sh->r->num_entry_points + 1;
516  int ctu_addr = 0;
517  GetBitContext gb;
518  int ret;
519 
520  if (sc->nb_eps != nb_eps) {
521  eps_free(sc);
522  sc->eps = av_calloc(nb_eps, sizeof(*sc->eps));
523  if (!sc->eps)
524  return AVERROR(ENOMEM);
525  sc->nb_eps = nb_eps;
526  }
527 
528  ret = init_get_bits8(&gb, slice->data, slice->data_size);
529  if (ret < 0)
530  return ret;
531  for (int i = 0; i < sc->nb_eps; i++)
532  {
533  EntryPoint *ep = sc->eps + i;
534 
535  ep->ctu_start = ctu_addr;
536  ep->ctu_end = (i + 1 == sc->nb_eps ? sh->num_ctus_in_curr_slice : sh->entry_point_start_ctu[i]);
537 
538  for (int j = ep->ctu_start; j < ep->ctu_end; j++) {
539  const int rs = sc->sh.ctb_addr_in_curr_slice[j];
540  fc->tab.slice_idx[rs] = sc->slice_idx;
541  }
542 
543  ep_init_cabac_decoder(sc, i, nal, &gb, unit);
544 
545  if (i + 1 < sc->nb_eps)
546  ctu_addr = sh->entry_point_start_ctu[i];
547  }
548 
549  return 0;
550 }
551 
553 {
554  const int size = s->nb_fcs;
555  const int idx = (fc - s->fcs + delta + size) % size;
556  return s->fcs + idx;
557 }
558 
559 static int ref_frame(VVCFrame *dst, const VVCFrame *src)
560 {
561  int ret;
562 
563  ret = av_frame_ref(dst->frame, src->frame);
564  if (ret < 0)
565  return ret;
566 
567  ff_refstruct_replace(&dst->sps, src->sps);
568  ff_refstruct_replace(&dst->pps, src->pps);
569 
570  ff_refstruct_replace(&dst->progress, src->progress);
571 
572  ff_refstruct_replace(&dst->tab_dmvr_mvf, src->tab_dmvr_mvf);
573 
574  ff_refstruct_replace(&dst->rpl_tab, src->rpl_tab);
575  ff_refstruct_replace(&dst->rpl, src->rpl);
576  dst->nb_rpl_elems = src->nb_rpl_elems;
577 
578  dst->poc = src->poc;
579  dst->ctb_count = src->ctb_count;
580 
581  dst->scaling_win = src->scaling_win;
582  dst->ref_width = src->ref_width;
583  dst->ref_height = src->ref_height;
584 
585  dst->flags = src->flags;
586  dst->sequence = src->sequence;
587 
588  return 0;
589 }
590 
592 {
593  slices_free(fc);
594 
595  ff_refstruct_pool_uninit(&fc->tu_pool);
596  ff_refstruct_pool_uninit(&fc->cu_pool);
597 
598  for (int i = 0; i < FF_ARRAY_ELEMS(fc->DPB); i++) {
599  ff_vvc_unref_frame(fc, &fc->DPB[i], ~0);
600  av_frame_free(&fc->DPB[i].frame);
601  }
602 
605  av_frame_free(&fc->output_frame);
606  ff_vvc_frame_ps_free(&fc->ps);
607 }
608 
610 {
611 
612  fc->log_ctx = avctx;
613 
614  fc->output_frame = av_frame_alloc();
615  if (!fc->output_frame)
616  return AVERROR(ENOMEM);
617 
618  for (int j = 0; j < FF_ARRAY_ELEMS(fc->DPB); j++) {
619  fc->DPB[j].frame = av_frame_alloc();
620  if (!fc->DPB[j].frame)
621  return AVERROR(ENOMEM);
622  }
623  fc->cu_pool = ff_refstruct_pool_alloc(sizeof(CodingUnit), 0);
624  if (!fc->cu_pool)
625  return AVERROR(ENOMEM);
626 
627  fc->tu_pool = ff_refstruct_pool_alloc(sizeof(TransformUnit), 0);
628  if (!fc->tu_pool)
629  return AVERROR(ENOMEM);
630 
631  return 0;
632 }
633 
635 {
636  int ret;
637 
638  fc->ref = NULL;
639 
640  // copy refs from the last frame
641  if (s->nb_frames && s->nb_fcs > 1) {
642  VVCFrameContext *prev = get_frame_context(s, fc, -1);
643  for (int i = 0; i < FF_ARRAY_ELEMS(fc->DPB); i++) {
644  ff_vvc_unref_frame(fc, &fc->DPB[i], ~0);
645  if (prev->DPB[i].frame->buf[0]) {
646  ret = ref_frame(&fc->DPB[i], &prev->DPB[i]);
647  if (ret < 0)
648  return ret;
649  }
650  }
651  }
652 
653  if (IS_IDR(s)) {
654  s->seq_decode = (s->seq_decode + 1) & 0xff;
656  }
657 
658  ret = pic_arrays_init(s, fc);
659  if (ret < 0)
660  return ret;
661  ff_vvc_dsp_init(&fc->vvcdsp, fc->ps.sps->bit_depth);
662  ff_videodsp_init(&fc->vdsp, fc->ps.sps->bit_depth);
663  return 0;
664 }
665 
667 {
668  const VVCPH *ph = &fc->ps.ph;
669  const H266RawSliceHeader *rsh = sc->sh.r;
670  int ret;
671 
672  // 8.3.1 Decoding process for picture order count
673  if (!s->temporal_id && !ph->r->ph_non_ref_pic_flag && !(IS_RASL(s) || IS_RADL(s)))
674  s->poc_tid0 = ph->poc;
675 
676  if ((ret = ff_vvc_set_new_ref(s, fc, &fc->frame)) < 0)
677  goto fail;
678 
679  if (!IS_IDR(s))
681 
682  av_frame_unref(fc->output_frame);
683 
684  if ((ret = ff_vvc_output_frame(s, fc, fc->output_frame,rsh->sh_no_output_of_prior_pics_flag, 0)) < 0)
685  goto fail;
686 
687  if ((ret = ff_vvc_frame_rpl(s, fc, sc)) < 0)
688  goto fail;
689 
690  if ((ret = ff_vvc_frame_thread_init(fc)) < 0)
691  goto fail;
692  return 0;
693 fail:
694  if (fc->ref)
695  ff_vvc_unref_frame(fc, fc->ref, ~0);
696  fc->ref = NULL;
697  return ret;
698 }
699 
701  const CodedBitstreamUnit *unit, const int is_first_slice)
702 {
703  VVCSH *sh = &sc->sh;
704  int ret;
705 
706  ret = ff_vvc_decode_sh(sh, &fc->ps, unit);
707  if (ret < 0)
708  return ret;
709 
710  ff_refstruct_replace(&sc->ref, unit->content_ref);
711 
712  if (is_first_slice) {
713  ret = frame_start(s, fc, sc);
714  if (ret < 0)
715  return ret;
716  } else if (fc->ref) {
717  if (!IS_I(sh->r)) {
718  ret = ff_vvc_slice_rpl(s, fc, sc);
719  if (ret < 0) {
720  av_log(fc->log_ctx, AV_LOG_WARNING,
721  "Error constructing the reference lists for the current slice.\n");
722  return ret;
723  }
724  }
725  } else {
726  av_log(fc->log_ctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
727  return ret;
728  }
729 
730  if (!IS_I(sh->r))
731  smvd_ref_idx(fc, sc);
732 
733  return 0;
734 }
735 
737 {
738  AVCodecContext *c = s->avctx;
739  const VVCSPS *sps = fc->ps.sps;
740  const VVCPPS *pps = fc->ps.pps;
741 
742  c->pix_fmt = sps->pix_fmt;
743  c->coded_width = pps->width;
744  c->coded_height = pps->height;
745  c->width = pps->width - ((pps->r->pps_conf_win_left_offset + pps->r->pps_conf_win_right_offset) << sps->hshift[CHROMA]);
746  c->height = pps->height - ((pps->r->pps_conf_win_top_offset + pps->r->pps_conf_win_bottom_offset) << sps->vshift[CHROMA]);
747 }
748 
750 {
751  int ret = ff_vvc_decode_frame_ps(&fc->ps, s);
752  if (ret < 0)
753  return ret;
754 
756  if (ret < 0)
757  return ret;
758 
760  return ret;
761 }
762 
763 static int decode_slice(VVCContext *s, VVCFrameContext *fc, const H2645NAL *nal, const CodedBitstreamUnit *unit)
764 {
765  int ret;
766  SliceContext *sc;
767  const int is_first_slice = !fc->nb_slices;
768 
769  ret = slices_realloc(fc);
770  if (ret < 0)
771  return ret;
772 
773  sc = fc->slices[fc->nb_slices];
774 
775  s->vcl_unit_type = nal->type;
776  if (is_first_slice) {
777  ret = frame_setup(fc, s);
778  if (ret < 0)
779  return ret;
780  }
781 
782  ret = slice_start(sc, s, fc, unit, is_first_slice);
783  if (ret < 0)
784  return ret;
785 
786  ret = slice_init_entry_points(sc, fc, nal, unit);
787  if (ret < 0)
788  return ret;
789  fc->nb_slices++;
790 
791  return 0;
792 }
793 
795 {
796  int ret;
797 
798  s->temporal_id = nal->temporal_id;
799 
800  if (nal->nuh_layer_id > 0) {
802  "Decoding of multilayer bitstreams");
803  return AVERROR_PATCHWELCOME;
804  }
805 
806  switch (unit->type) {
807  case VVC_VPS_NUT:
808  case VVC_SPS_NUT:
809  case VVC_PPS_NUT:
810  /* vps, sps, sps cached by s->cbc */
811  break;
812  case VVC_TRAIL_NUT:
813  case VVC_STSA_NUT:
814  case VVC_RADL_NUT:
815  case VVC_RASL_NUT:
816  case VVC_IDR_W_RADL:
817  case VVC_IDR_N_LP:
818  case VVC_CRA_NUT:
819  case VVC_GDR_NUT:
820  ret = decode_slice(s, fc, nal, unit);
821  if (ret < 0)
822  return ret;
823  break;
824  case VVC_PREFIX_APS_NUT:
825  case VVC_SUFFIX_APS_NUT:
826  ret = ff_vvc_decode_aps(&s->ps, unit);
827  if (ret < 0)
828  return ret;
829  break;
830  }
831 
832  return 0;
833 }
834 
836 {
837  const CodedBitstreamH266Context *h266 = s->cbc->priv_data;
838  CodedBitstreamFragment *frame = &s->current_frame;
839  int ret = 0;
840  int eos_at_start = 1;
841  s->last_eos = s->eos;
842  s->eos = 0;
843 
845  ret = ff_cbs_read_packet(s->cbc, frame, avpkt);
846  if (ret < 0) {
847  av_log(s->avctx, AV_LOG_ERROR, "Failed to read packet.\n");
848  return ret;
849  }
850  /* decode the NAL units */
851  for (int i = 0; i < frame->nb_units; i++) {
852  const H2645NAL *nal = h266->common.read_packet.nals + i;
853  const CodedBitstreamUnit *unit = frame->units + i;
854 
855  if (unit->type == VVC_EOB_NUT || unit->type == VVC_EOS_NUT) {
856  if (eos_at_start)
857  s->last_eos = 1;
858  else
859  s->eos = 1;
860  } else {
861  ret = decode_nal_unit(s, fc, nal, unit);
862  if (ret < 0) {
863  av_log(s->avctx, AV_LOG_WARNING,
864  "Error parsing NAL unit #%d.\n", i);
865  goto fail;
866  }
867  }
868  }
869  return 0;
870 
871 fail:
872  if (fc->ref)
874  return ret;
875 }
876 
877 static int set_output_format(const VVCContext *s, const AVFrame *output)
878 {
879  AVCodecContext *c = s->avctx;
880  int ret;
881 
882  if (output->width != c->width || output->height != c->height) {
883  if ((ret = ff_set_dimensions(c, output->width, output->height)) < 0)
884  return ret;
885  }
886  c->pix_fmt = output->format;
887  return 0;
888 }
889 
890 static int wait_delayed_frame(VVCContext *s, AVFrame *output, int *got_output)
891 {
892  VVCFrameContext *delayed = get_frame_context(s, s->fcs, s->nb_frames - s->nb_delayed);
893  int ret = ff_vvc_frame_wait(s, delayed);
894 
895  if (!ret && delayed->output_frame->buf[0] && output) {
898  if (!ret)
899  *got_output = 1;
900  }
901  s->nb_delayed--;
902 
903  return ret;
904 }
905 
906 static int submit_frame(VVCContext *s, VVCFrameContext *fc, AVFrame *output, int *got_output)
907 {
908  int ret = ff_vvc_frame_submit(s, fc);
909 
910  if (ret < 0) {
912  return ret;
913  }
914 
915  s->nb_frames++;
916  s->nb_delayed++;
917 
918  if (s->nb_delayed >= s->nb_fcs) {
919  if ((ret = wait_delayed_frame(s, output, got_output)) < 0)
920  return ret;
921  }
922  return 0;
923 }
924 
925 static int get_decoded_frame(VVCContext *s, AVFrame *output, int *got_output)
926 {
927  int ret;
928  while (s->nb_delayed) {
929  if ((ret = wait_delayed_frame(s, output, got_output)) < 0)
930  return ret;
931  if (*got_output)
932  return 0;
933  }
934  if (s->nb_frames) {
935  //we still have frames cached in dpb.
936  VVCFrameContext *last = get_frame_context(s, s->fcs, s->nb_frames - 1);
937 
938  ret = ff_vvc_output_frame(s, last, output, 0, 1);
939  if (ret < 0)
940  return ret;
941  if (ret) {
942  *got_output = ret;
943  if ((ret = set_output_format(s, output)) < 0)
944  return ret;
945  }
946  }
947  return 0;
948 }
949 
951  int *got_output, AVPacket *avpkt)
952 {
953  VVCContext *s = avctx->priv_data;
955  int ret;
956 
957  if (!avpkt->size)
958  return get_decoded_frame(s, output, got_output);
959 
960  fc = get_frame_context(s, s->fcs, s->nb_frames);
961 
962  fc->nb_slices = 0;
963  fc->decode_order = s->nb_frames;
964 
965  ret = decode_nal_units(s, fc, avpkt);
966  if (ret < 0)
967  return ret;
968 
969  if (!fc->ft)
970  return avpkt->size;
971 
972  ret = submit_frame(s, fc, output, got_output);
973  if (ret < 0)
974  return ret;
975 
976  return avpkt->size;
977 }
978 
980 {
981  VVCContext *s = avctx->priv_data;
982  int got_output = 0;
983 
984  while (s->nb_delayed)
985  wait_delayed_frame(s, NULL, &got_output);
986 
987  if (s->fcs) {
988  VVCFrameContext *last = get_frame_context(s, s->fcs, s->nb_frames - 1);
989  ff_vvc_flush_dpb(last);
990  }
991 
992  s->ps.sps_id_used = 0;
993 
994  s->eos = 1;
995 }
996 
998 {
999  VVCContext *s = avctx->priv_data;
1000 
1001  ff_cbs_fragment_free(&s->current_frame);
1002  vvc_decode_flush(avctx);
1003  ff_vvc_executor_free(&s->executor);
1004  if (s->fcs) {
1005  for (int i = 0; i < s->nb_fcs; i++)
1006  frame_context_free(s->fcs + i);
1007  av_free(s->fcs);
1008  }
1009  ff_vvc_ps_uninit(&s->ps);
1010  ff_cbs_close(&s->cbc);
1011 
1012  return 0;
1013 }
1014 
1016 {
1017  memset(&ff_vvc_default_scale_m, 16, sizeof(ff_vvc_default_scale_m));
1018 }
1019 
1020 #define VVC_MAX_DELAYED_FRAMES 16
1022 {
1023  VVCContext *s = avctx->priv_data;
1024  static AVOnce init_static_once = AV_ONCE_INIT;
1025  const int cpu_count = av_cpu_count();
1026  const int delayed = FFMIN(cpu_count, VVC_MAX_DELAYED_FRAMES);
1027  const int thread_count = avctx->thread_count ? avctx->thread_count : delayed;
1028  int ret;
1029 
1030  s->avctx = avctx;
1031 
1032  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_VVC, avctx);
1033  if (ret)
1034  return ret;
1035 
1036  if (avctx->extradata_size > 0 && avctx->extradata) {
1037  ret = ff_cbs_read_extradata_from_codec(s->cbc, &s->current_frame, avctx);
1038  if (ret < 0)
1039  return ret;
1040  }
1041 
1042  s->nb_fcs = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 1 : delayed;
1043  s->fcs = av_calloc(s->nb_fcs, sizeof(*s->fcs));
1044  if (!s->fcs)
1045  return AVERROR(ENOMEM);
1046 
1047  for (int i = 0; i < s->nb_fcs; i++) {
1048  VVCFrameContext *fc = s->fcs + i;
1049  ret = frame_context_init(fc, avctx);
1050  if (ret < 0)
1051  return ret;
1052  }
1053 
1054  s->executor = ff_vvc_executor_alloc(s, thread_count);
1055  if (!s->executor)
1056  return AVERROR(ENOMEM);
1057 
1058  s->eos = 1;
1060  ff_thread_once(&init_static_once, init_default_scale_m);
1061 
1062  return 0;
1063 }
1064 
1066  .p.name = "vvc",
1067  .p.long_name = NULL_IF_CONFIG_SMALL("VVC (Versatile Video Coding)"),
1068  .p.type = AVMEDIA_TYPE_VIDEO,
1069  .p.id = AV_CODEC_ID_VVC,
1070  .priv_data_size = sizeof(VVCContext),
1071  .init = vvc_decode_init,
1072  .close = vvc_decode_free,
1074  .flush = vvc_decode_flush,
1079  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vvc_profiles),
1080 };
VVC_RADL_NUT
@ VVC_RADL_NUT
Definition: vvc.h:31
VVC_RASL_NUT
@ VVC_RASL_NUT
Definition: vvc.h:32
VVC_GDR_NUT
@ VVC_GDR_NUT
Definition: vvc.h:39
VVC_STSA_NUT
@ VVC_STSA_NUT
Definition: vvc.h:30
VVCSPS
Definition: ps.h:58
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ALF_BORDER_LUMA
#define ALF_BORDER_LUMA
Definition: ctu.h:76
CodedBitstreamUnit::content_ref
void * content_ref
If content is reference counted, a RefStruct reference backing content.
Definition: cbs.h:112
slices_realloc
static int slices_realloc(VVCFrameContext *fc)
Definition: dec.c:455
VVCSH::num_ctus_in_curr_slice
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
Definition: ps.h:236
VVCPH
Definition: ps.h:147
VVCFrameContext::output_frame
struct AVFrame * output_frame
Definition: dec.h:122
decode_slice
static int decode_slice(VVCContext *s, VVCFrameContext *fc, const H2645NAL *nal, const CodedBitstreamUnit *unit)
Definition: dec.c:763
bs_tl_init
static void bs_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:183
VVCPPS
Definition: ps.h:92
av_clip
#define av_clip
Definition: common.h:100
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
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
LUMA
#define LUMA
Definition: filter.c:31
cpu_count
static atomic_int cpu_count
Definition: cpu.c:53
VVCFrame::pps
const VVCPPS * pps
RefStruct reference.
Definition: dec.h:75
ff_vvc_decode_frame_ps
int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
Definition: ps.c:882
VVCSH::entry_point_start_ctu
uint32_t entry_point_start_ctu[VVC_MAX_ENTRY_POINTS]
entry point start in ctu_addr
Definition: ps.h:258
ff_refstruct_pool_alloc
FFRefStructPool * ff_refstruct_pool_alloc(size_t size, unsigned flags)
Equivalent to ff_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
Definition: refstruct.c:335
set_output_format
static int set_output_format(const VVCContext *s, const AVFrame *output)
Definition: dec.c:877
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
thread.h
TL_ADD
#define TL_ADD(t, s)
Definition: dec.c:52
ff_vvc_report_frame_finished
void ff_vvc_report_frame_finished(VVCFrame *frame)
Definition: refs.c:545
CodingUnit
Definition: hevcdec.h:285
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
H266RawSliceHeader::sh_no_output_of_prior_pics_flag
uint8_t sh_no_output_of_prior_pics_flag
Definition: cbs_h266.h:779
VVCFrameContext::DPB
VVCFrame DPB[VVC_MAX_DPB_SIZE+1]
Definition: dec.h:119
pixel_buffer_nz_tl_init
static void pixel_buffer_nz_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:204
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
ep_init_cabac_decoder
static void ep_init_cabac_decoder(SliceContext *sc, const int index, const H2645NAL *nal, GetBitContext *gb, const CodedBitstreamUnit *unit)
Definition: dec.c:481
data.h
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3005
H2645NAL::nuh_layer_id
int nuh_layer_id
Definition: h2645_parse.h:67
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
w
uint8_t w
Definition: llviddspenc.c:38
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
VVCSH::r
const H266RawSliceHeader * r
RefStruct reference.
Definition: ps.h:232
FFCodec
Definition: codec_internal.h:126
IS_RADL
#define IS_RADL(s)
Definition: ps.h:36
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:464
ctu_tl_init
static void ctu_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:94
ff_vvc_slice_rpl
int ff_vvc_slice_rpl(VVCContext *s, VVCFrameContext *fc, SliceContext *sc)
Definition: refs.c:462
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:587
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
H2645NAL::temporal_id
int temporal_id
HEVC only, nuh_temporal_id_plus_1 - 1.
Definition: h2645_parse.h:62
RefPicList
Definition: hevcdec.h:190
min_tu_tl_init
static void min_tu_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:160
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
smvd_find
static int8_t smvd_find(const VVCFrameContext *fc, const SliceContext *sc, int lx, smvd_find_fxn find)
Definition: dec.c:399
frame_setup
static int frame_setup(VVCFrameContext *fc, VVCContext *s)
Definition: dec.c:749
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
ref_frame
static int ref_frame(VVCFrame *dst, const VVCFrame *src)
Definition: dec.c:559
fail
#define fail()
Definition: checkasm.h:185
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1583
ff_refstruct_pool_uninit
static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
VVCFrame::rpl
RefPicListTab * rpl
RefStruct reference.
Definition: dec.h:78
tl_init_fn
void(* tl_init_fn)(TabList *l, VVCFrameContext *fc)
Definition: dec.c:292
get_frame_context
static VVCFrameContext * get_frame_context(const VVCContext *s, const VVCFrameContext *fc, const int delta)
Definition: dec.c:552
VVCFrame::ref_height
int ref_height
CurrPicScalWinHeightL.
Definition: dec.h:89
IS_B
#define IS_B(rsh)
Definition: ps.h:40
GetBitContext
Definition: get_bits.h:108
ff_vvc_decode_sh
int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
Definition: ps.c:1289
export_frame_params
static void export_frame_params(VVCContext *s, const VVCFrameContext *fc)
Definition: dec.c:736
min_cb_tl_init
static void min_cb_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:121
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:334
SliceContext::rpl
RefPicList * rpl
Definition: dec.h:111
eps_free
static void eps_free(SliceContext *slice)
Definition: dec.c:431
VVC_IDR_W_RADL
@ VVC_IDR_W_RADL
Definition: vvc.h:36
frame_context_setup
static int frame_context_setup(VVCFrameContext *fc, VVCContext *s)
Definition: dec.c:634
vvc_decode_free
static av_cold int vvc_decode_free(AVCodecContext *avctx)
Definition: dec.c:997
ff_vvc_decoder
const FFCodec ff_vvc_decoder
Definition: dec.c:1065
refstruct.h
ff_vvc_frame_ps_free
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
Definition: ps.c:901
VVC_EOS_NUT
@ VVC_EOS_NUT
Definition: vvc.h:50
ff_vvc_frame_submit
int ff_vvc_frame_submit(VVCContext *s, VVCFrameContext *fc)
Definition: thread.c:771
GDR_SET_RECOVERED
#define GDR_SET_RECOVERED(s)
Definition: ps.h:44
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
VVCFrame::scaling_win
VVCWindow scaling_win
pps_scaling_win_left_offset * SubWithC, pps_scaling_win_right_offset * SubWithC, pps_scaling_win_top_...
Definition: dec.h:86
H266RawSliceHeader::num_ref_idx_active
uint8_t num_ref_idx_active[2]
NumRefIdxActive[].
Definition: cbs_h266.h:837
frame_context_init
static av_cold int frame_context_init(VVCFrameContext *fc, AVCodecContext *avctx)
Definition: dec.c:609
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H266RawSlice::data
uint8_t * data
Definition: cbs_h266.h:844
free_cus
static void free_cus(VVCFrameContext *fc)
Definition: dec.c:321
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:102
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
slice_init_entry_points
static int slice_init_entry_points(SliceContext *sc, VVCFrameContext *fc, const H2645NAL *nal, const CodedBitstreamUnit *unit)
Definition: dec.c:510
RefPicList::refs
VVCRefPic refs[VVC_MAX_REF_ENTRIES]
Definition: dec.h:56
VVCFrame::flags
uint8_t flags
A combination of VVC_FRAME_FLAG_*.
Definition: dec.h:103
VVC_MAX_DELAYED_FRAMES
#define VVC_MAX_DELAYED_FRAMES
Definition: dec.c:1020
ff_vvc_unref_frame
void ff_vvc_unref_frame(VVCFrameContext *fc, VVCFrame *frame, int flags)
Definition: refs.c:46
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
ff_vvc_frame_wait
int ff_vvc_frame_wait(VVCContext *s, VVCFrameContext *fc)
Definition: thread.c:802
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
ff_vvc_executor_free
void ff_vvc_executor_free(AVExecutor **e)
Definition: thread.c:636
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
SliceContext::slice_idx
int slice_idx
Definition: dec.h:107
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
tl_create
static int tl_create(TabList *l)
Definition: dec.c:74
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
VVCSH
Definition: ps.h:231
ff_vvc_clear_refs
void ff_vvc_clear_refs(VVCFrameContext *fc)
Definition: refs.c:79
decode.h
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:76
H2645NAL::skipped_bytes_pos
int * skipped_bytes_pos
Definition: h2645_parse.h:71
TabList::tabs
Tab tabs[TAB_MAX]
Definition: dec.c:45
ispmf_tl_init
static void ispmf_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:254
ff_vvc_default_scale_m
uint8_t ff_vvc_default_scale_m[64 *64]
Definition: data.c:1641
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
decode_nal_unit
static int decode_nal_unit(VVCContext *s, VVCFrameContext *fc, const H2645NAL *nal, const CodedBitstreamUnit *unit)
Definition: dec.c:794
slices_free
static void slices_free(VVCFrameContext *fc)
Definition: dec.c:437
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
smvd_ref_idx
static void smvd_ref_idx(const VVCFrameContext *fc, SliceContext *sc)
Definition: dec.c:418
NULL
#define NULL
Definition: coverity.c:32
ff_vvc_frame_thread_init
int ff_vvc_frame_thread_init(VVCFrameContext *fc)
Definition: thread.c:681
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
TabList
Definition: dec.c:44
VVCSH::ref_idx_sym
int8_t ref_idx_sym[2]
RefIdxSymL0, RefIdxSymL1.
Definition: ps.h:241
SliceContext::eps
struct EntryPoint * eps
Definition: dec.h:109
profiles.h
CodedBitstreamH266Context::common
CodedBitstreamH2645Context common
Definition: cbs_h266.h:868
CodedBitstreamH2645Context::read_packet
H2645Packet read_packet
Definition: cbs_h2645.h:32
RefPicListTab
Definition: hevcdec.h:197
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
MAX_CTU_SIZE
#define MAX_CTU_SIZE
Definition: ctu.h:31
VVCRefPic::is_lt
int is_lt
Definition: dec.h:48
smvd_find_fxn
int(* smvd_find_fxn)(const int idx, const int diff, const int old_diff)
Definition: dec.c:397
submit_frame
static int submit_frame(VVCContext *s, VVCFrameContext *fc, AVFrame *output, int *got_output)
Definition: dec.c:906
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
IS_RASL
#define IS_RASL(s)
Definition: ps.h:35
TransformUnit
Definition: hevcdec.h:328
VVCFrame::sequence
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: dec.h:99
SliceContext
Definition: mss12.h:70
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:211
ff_vvc_flush_dpb
void ff_vvc_flush_dpb(VVCFrameContext *fc)
Definition: refs.c:86
H266RawSliceHeader::sh_entry_point_offset_minus1
uint32_t sh_entry_point_offset_minus1[VVC_MAX_ENTRY_POINTS]
Definition: cbs_h266.h:832
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
TabList::nb_tabs
int nb_tabs
Definition: dec.c:46
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
ibc_tl_init
static void ibc_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:267
AVPacket::size
int size
Definition: packet.h:521
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
Tab
Definition: dec.c:39
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:384
codec_internal.h
VVC_VPS_NUT
@ VVC_VPS_NUT
Definition: vvc.h:43
ALF_PADDING_SIZE
#define ALF_PADDING_SIZE
Definition: ctu.h:73
cpu.h
pic_arrays_init
static int pic_arrays_init(VVCContext *s, VVCFrameContext *fc)
Definition: dec.c:339
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:60
ff_vvc_frame_thread_free
void ff_vvc_frame_thread_free(VVCFrameContext *fc)
Definition: thread.c:641
size
int size
Definition: twinvq_data.h:10344
EntryPoint::cc
CABACContext cc
Definition: ctu.h:358
EntryPoint::ctu_end
int ctu_end
Definition: ctu.h:361
get_decoded_frame
static int get_decoded_frame(VVCContext *s, AVFrame *output, int *got_output)
Definition: dec.c:925
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
H2645NAL
Definition: h2645_parse.h:34
VVCRefPic::poc
int poc
Definition: dec.h:47
GetBitContext::index
int index
Definition: get_bits.h:110
SliceContext::ref
void * ref
RefStruct reference, backing slice data.
Definition: dec.h:112
MvField
Definition: hevcdec.h:303
pic_arrays_free
static void pic_arrays_free(VVCFrameContext *fc)
Definition: dec.c:329
refs.h
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
VVCFrame
Definition: dec.h:71
ff_vvc_dsp_init
void ff_vvc_dsp_init(VVCDSPContext *vvcdsp, int bit_depth)
Definition: dsp.c:98
height
#define height
VVCFrame::tab_dmvr_mvf
struct MvField * tab_dmvr_mvf
RefStruct reference.
Definition: dec.h:76
CodedBitstreamH266Context
Definition: cbs_h266.h:866
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:250
MAX_CONTROL_POINTS
#define MAX_CONTROL_POINTS
Definition: ctu.h:64
VVCSH::ctb_addr_in_curr_slice
const uint32_t * ctb_addr_in_curr_slice
CtbAddrInCurrSlice.
Definition: ps.h:237
VVC_TRAIL_NUT
@ VVC_TRAIL_NUT
Definition: vvc.h:29
tl_free
static int tl_free(TabList *l)
Definition: dec.c:66
VVC_SPS_NUT
@ VVC_SPS_NUT
Definition: vvc.h:44
zero
static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:121
ff_cbs_read_extradata_from_codec
int ff_cbs_read_extradata_from_codec(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecContext *avctx)
Definition: cbs.c:295
ctu_nz_tl_init
static void ctu_nz_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:108
ff_vvc_output_frame
int ff_vvc_output_frame(VVCContext *s, VVCFrameContext *fc, AVFrame *out, const int no_output_of_prior_pics_flag, int flush)
Definition: refs.c:211
ff_init_cabac_decoder
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:162
H2645Packet::nals
H2645NAL * nals
Definition: h2645_parse.h:83
H266RawSliceHeader
Definition: cbs_h266.h:769
min_pu_tl_init
static void min_pu_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:146
H266RawSliceHeader::num_entry_points
uint32_t num_entry_points
NumEntryPoints.
Definition: cbs_h266.h:836
FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
#define FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
If this flag is set, the entries will be zeroed before being returned to the user (after the init or ...
Definition: refstruct.h:221
TabList::realloc
int realloc
Definition: dec.c:49
SliceContext::nb_eps
int nb_eps
Definition: dec.h:110
VVCFrame::nb_rpl_elems
int nb_rpl_elems
Definition: dec.h:79
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
vvc_decode_init
static av_cold int vvc_decode_init(AVCodecContext *avctx)
Definition: dec.c:1021
VVCFrame::progress
struct FrameProgress * progress
RefStruct reference.
Definition: dec.h:93
delta
float delta
Definition: vorbis_enc_data.h:430
ff_vvc_decode_aps
int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
Definition: ps.c:1100
H266RawSlice::header_size
size_t header_size
Definition: cbs_h266.h:846
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
init_default_scale_m
static av_cold void init_default_scale_m(void)
Definition: dec.c:1015
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:633
VVC_IDR_N_LP
@ VVC_IDR_N_LP
Definition: vvc.h:37
H266RawSlice::data_size
size_t data_size
Definition: cbs_h266.h:847
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
EntryPoint
Definition: ctu.h:352
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
wait_delayed_frame
static int wait_delayed_frame(VVCContext *s, AVFrame *output, int *got_output)
Definition: dec.c:890
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
ff_vvc_ps_uninit
void ff_vvc_ps_uninit(VVCParamSets *ps)
Definition: ps.c:911
ret
ret
Definition: filter_design.txt:187
VVCFrame::frame
struct AVFrame * frame
Definition: dec.h:72
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
vvc_decode_flush
static av_cold void vvc_decode_flush(AVCodecContext *avctx)
Definition: dec.c:979
vvc_decode_frame
static int vvc_decode_frame(AVCodecContext *avctx, AVFrame *output, int *got_output, AVPacket *avpkt)
Definition: dec.c:950
CHROMA
@ CHROMA
Definition: vf_waveform.c:49
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
msm_tl_init
static void msm_tl_init(TabList *l, VVCFrameContext *fc)
Definition: dec.c:240
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
VVC_PPS_NUT
@ VVC_PPS_NUT
Definition: vvc.h:45
ff_vvc_executor_alloc
AVExecutor * ff_vvc_executor_alloc(VVCContext *s, const int thread_count)
Definition: thread.c:624
AVCodecContext
main external API structure.
Definition: avcodec.h:445
VVC_PREFIX_APS_NUT
@ VVC_PREFIX_APS_NUT
Definition: vvc.h:46
VVCFrame::poc
int poc
Definition: dec.h:83
TabList::zero
int zero
Definition: dec.c:48
VVC_SUFFIX_APS_NUT
@ VVC_SUFFIX_APS_NUT
Definition: vvc.h:47
Tab::size
size_t size
Definition: dec.c:41
slice_start
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
Definition: dec.c:700
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
imf
#define imf
Definition: vf_colormatrix.c:113
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
VVC_CRA_NUT
@ VVC_CRA_NUT
Definition: vvc.h:38
ff_vvc_set_new_ref
int ff_vvc_set_new_ref(VVCContext *s, VVCFrameContext *fc, AVFrame **frame)
Definition: refs.c:169
ff_cbs_read_packet
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:304
frame_start
static int frame_start(VVCContext *s, VVCFrameContext *fc, SliceContext *sc)
Definition: dec.c:666
ALF_BORDER_CHROMA
#define ALF_BORDER_CHROMA
Definition: ctu.h:77
ff_vvc_frame_rpl
int ff_vvc_frame_rpl(VVCContext *s, VVCFrameContext *fc, SliceContext *sc)
Definition: refs.c:521
ff_vvc_profiles
const AVProfile ff_vvc_profiles[]
Definition: profiles.c:91
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:72
tl_init
static void tl_init(TabList *l, const int zero, const int realloc)
Definition: dec.c:59
ff_vvc_ctu_free_cus
void ff_vvc_ctu_free_cus(CTU *ctu)
Definition: ctu.c:2522
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:90
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
frame_context_for_each_tl
static int frame_context_for_each_tl(VVCFrameContext *fc, int(*unary_fn)(TabList *l))
Definition: dec.c:294
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:497
decode_nal_units
static int decode_nal_units(VVCContext *s, VVCFrameContext *fc, AVPacket *avpkt)
Definition: dec.c:835
SliceContext::sh
VVCSH sh
Definition: dec.h:108
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
VVCFrameContext
Definition: dec.h:115
min_positive
static int min_positive(const int idx, const int diff, const int min_diff)
Definition: dec.c:387
EntryPoint::ctu_start
int ctu_start
Definition: ctu.h:360
IS_I
#define IS_I(rsh)
Definition: ps.h:38
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
thread.h
TAB_MAX
#define TAB_MAX
Definition: dec.c:37
VVC_EOB_NUT
@ VVC_EOB_NUT
Definition: vvc.h:51
frame_context_free
static av_cold void frame_context_free(VVCFrameContext *fc)
Definition: dec.c:591
h
h
Definition: vp9dsp_template.c:2038
ctu.h
VVCFrame::ctb_count
int ctb_count
Definition: dec.h:81
VVCFrame::rpl_tab
RefPicListTab ** rpl_tab
RefStruct reference.
Definition: dec.h:77
VVCFrame::ref_width
int ref_width
CurrPicScalWinWidthL.
Definition: dec.h:88
int
int
Definition: ffmpeg_filter.c:424
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
VVCFrame::sps
const VVCSPS * sps
RefStruct reference.
Definition: dec.h:74
ff_vvc_bump_frame
void ff_vvc_bump_frame(VVCContext *s, VVCFrameContext *fc)
Definition: refs.c:270
H266RawSlice
Definition: cbs_h266.h:841
VVCContext
Definition: dec.h:218
dec.h
max_negtive
static int max_negtive(const int idx, const int diff, const int max_diff)
Definition: dec.c:392
Tab::tab
void ** tab
Definition: dec.c:40