FFmpeg
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
ctu.c
Go to the documentation of this file.
1 /*
2  * VVC CTU(Coding Tree Unit) parser
3  *
4  * Copyright (C) 2022 Nuo Mi
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/refstruct.h"
24 
25 #include "cabac.h"
26 #include "ctu.h"
27 #include "inter.h"
28 #include "intra.h"
29 #include "mvs.h"
30 
31 #define PROF_TEMP_SIZE (PROF_BLOCK_SIZE) * sizeof(int16_t)
32 
33 #define TAB_MSM(fc, depth, x, y) fc->tab.msm[(depth)][((y) >> 5) * fc->ps.pps->width32 + ((x) >> 5)]
34 #define TAB_ISPMF(fc, x, y) fc->tab.ispmf[((y) >> 6) * fc->ps.pps->width64 + ((x) >> 6)]
35 
36 typedef enum VVCModeType {
37  MODE_TYPE_ALL,
38  MODE_TYPE_INTER,
39  MODE_TYPE_INTRA,
40 } VVCModeType;
41 
42 static void set_tb_size(const VVCFrameContext *fc, const TransformBlock *tb)
43 {
44  const int x_tb = tb->x0 >> MIN_TU_LOG2;
45  const int y_tb = tb->y0 >> MIN_TU_LOG2;
46  const int hs = fc->ps.sps->hshift[tb->c_idx];
47  const int vs = fc->ps.sps->vshift[tb->c_idx];
48  const int is_chroma = tb->c_idx != 0;
49  const int width = FFMAX(1, tb->tb_width >> (MIN_TU_LOG2 - hs));
50  const int end = y_tb + FFMAX(1, tb->tb_height >> (MIN_TU_LOG2 - vs));
51 
52  for (int y = y_tb; y < end; y++) {
53  const int off = y * fc->ps.pps->min_tu_width + x_tb;
54  memset(fc->tab.tb_width [is_chroma] + off, tb->tb_width, width);
55  memset(fc->tab.tb_height[is_chroma] + off, tb->tb_height, width);
56  }
57 }
58 
59 static void set_tb_tab(uint8_t *tab, uint8_t v, const VVCFrameContext *fc,
60  const TransformBlock *tb)
61 {
62  const int width = tb->tb_width << fc->ps.sps->hshift[tb->c_idx];
63  const int height = tb->tb_height << fc->ps.sps->vshift[tb->c_idx];
64 
65  for (int h = 0; h < height; h += MIN_TU_SIZE) {
66  const int y = (tb->y0 + h) >> MIN_TU_LOG2;
67  const int off = y * fc->ps.pps->min_tu_width + (tb->x0 >> MIN_TU_LOG2);
68  const int w = FFMAX(1, width >> MIN_TU_LOG2);
69  memset(tab + off, v, w);
70  }
71 }
72 
73 // 8.7.1 Derivation process for quantization parameters
74 static int get_qp_y_pred(const VVCLocalContext *lc)
75 {
76  const VVCFrameContext *fc = lc->fc;
77  const VVCSPS *sps = fc->ps.sps;
78  const VVCPPS *pps = fc->ps.pps;
79  const CodingUnit *cu = lc->cu;
80  const int ctb_log2_size = sps->ctb_log2_size_y;
81  const int ctb_size_mask = (1 << ctb_log2_size) - 1;
82  const int xQg = lc->parse.cu_qg_top_left_x;
83  const int yQg = lc->parse.cu_qg_top_left_y;
84  const int min_cb_width = fc->ps.pps->min_cb_width;
85  const int x_cb = cu->x0 >> sps->min_cb_log2_size_y;
86  const int y_cb = cu->y0 >> sps->min_cb_log2_size_y;
87  const int rx = cu->x0 >> ctb_log2_size;
88  const int ry = cu->y0 >> ctb_log2_size;
89  const int in_same_ctb_a = ((xQg - 1) >> ctb_log2_size) == rx && (yQg >> ctb_log2_size) == ry;
90  const int in_same_ctb_b = (xQg >> ctb_log2_size) == rx && ((yQg - 1) >> ctb_log2_size) == ry;
91  int qPy_pred, qPy_a, qPy_b;
92 
93  if (lc->na.cand_up) {
94  const int first_qg_in_ctu = !(xQg & ctb_size_mask) && !(yQg & ctb_size_mask);
95  const int qPy_up = fc->tab.qp[LUMA][x_cb + (y_cb - 1) * min_cb_width];
96  if (first_qg_in_ctu && pps->ctb_to_col_bd[xQg >> ctb_log2_size] == xQg >> ctb_log2_size)
97  return qPy_up;
98  }
99 
100  // qPy_pred
101  qPy_pred = lc->ep->is_first_qg ? lc->sc->sh.slice_qp_y : lc->ep->qp_y;
102 
103  // qPy_b
104  if (!lc->na.cand_up || !in_same_ctb_b)
105  qPy_b = qPy_pred;
106  else
107  qPy_b = fc->tab.qp[LUMA][x_cb + (y_cb - 1) * min_cb_width];
108 
109  // qPy_a
110  if (!lc->na.cand_left || !in_same_ctb_a)
111  qPy_a = qPy_pred;
112  else
113  qPy_a = fc->tab.qp[LUMA][(x_cb - 1) + y_cb * min_cb_width];
114 
115  av_assert2(qPy_a >= -fc->ps.sps->qp_bd_offset && qPy_a <= 63);
116  av_assert2(qPy_b >= -fc->ps.sps->qp_bd_offset && qPy_b <= 63);
117 
118  return (qPy_a + qPy_b + 1) >> 1;
119 }
120 
121 static void set_cb_tab(const VVCLocalContext *lc, uint8_t *tab, const uint8_t v)
122 {
123  const VVCFrameContext *fc = lc->fc;
124  const VVCPPS *pps = fc->ps.pps;
125  const CodingUnit *cu = lc->cu;
126  const int log2_min_cb_size = fc->ps.sps->min_cb_log2_size_y;
127  const int x_cb = cu->x0 >> log2_min_cb_size;
128  const int y_cb = cu->y0 >> log2_min_cb_size;
129  const int cb_width = cu->cb_width;
130  const int cb_height = cu->cb_height;
131  int x = y_cb * pps->min_cb_width + x_cb;
132 
133  for (int y = 0; y < (cb_height >> log2_min_cb_size); y++) {
134  const int width = cb_width >> log2_min_cb_size;
135 
136  memset(&tab[x], v, width);
137  x += pps->min_cb_width;
138  }
139 }
140 
141 static int set_qp_y(VVCLocalContext *lc, const int x0, const int y0, const int has_qp_delta)
142 {
143  const VVCSPS *sps = lc->fc->ps.sps;
144  EntryPoint *ep = lc->ep;
145  CodingUnit *cu = lc->cu;
146  int cu_qp_delta = 0;
147 
148  if (!lc->fc->ps.pps->r->pps_cu_qp_delta_enabled_flag) {
149  ep->qp_y = lc->sc->sh.slice_qp_y;
150  } else if (ep->is_first_qg || (lc->parse.cu_qg_top_left_x == x0 && lc->parse.cu_qg_top_left_y == y0)) {
151  ep->qp_y = get_qp_y_pred(lc);
152  ep->is_first_qg = 0;
153  }
154 
155  if (has_qp_delta) {
156  const int cu_qp_delta_abs = ff_vvc_cu_qp_delta_abs(lc);
157 
158  if (cu_qp_delta_abs)
159  cu_qp_delta = ff_vvc_cu_qp_delta_sign_flag(lc) ? -cu_qp_delta_abs : cu_qp_delta_abs;
160  if (cu_qp_delta > (31 + sps->qp_bd_offset / 2) || cu_qp_delta < -(32 + sps->qp_bd_offset / 2))
161  return AVERROR_INVALIDDATA;
162  lc->parse.is_cu_qp_delta_coded = 1;
163 
164  if (cu_qp_delta) {
165  int off = sps->qp_bd_offset;
166  ep->qp_y = FFUMOD(ep->qp_y + cu_qp_delta + 64 + 2 * off, 64 + off) - off;
167  }
168  }
169 
170  set_cb_tab(lc, lc->fc->tab.qp[LUMA], ep->qp_y);
171  cu->qp[LUMA] = ep->qp_y;
172 
173  return 0;
174 }
175 
176 static void set_qp_c_tab(const VVCLocalContext *lc, const TransformUnit *tu, const TransformBlock *tb)
177 {
178  const int is_jcbcr = tu->joint_cbcr_residual_flag && tu->coded_flag[CB] && tu->coded_flag[CR];
179  const int idx = is_jcbcr ? JCBCR : tb->c_idx;
180 
181  set_tb_tab(lc->fc->tab.qp[tb->c_idx], lc->cu->qp[idx], lc->fc, tb);
182 }
183 
184 static void set_qp_c(VVCLocalContext *lc)
185 {
186  const VVCFrameContext *fc = lc->fc;
187  const VVCSPS *sps = fc->ps.sps;
188  const VVCPPS *pps = fc->ps.pps;
189  const H266RawSliceHeader *rsh = lc->sc->sh.r;
190  CodingUnit *cu = lc->cu;
191  const int x_center = cu->x0 + cu->cb_width / 2;
192  const int y_center = cu->y0 + cu->cb_height / 2;
193  const int single_tree = cu->tree_type == SINGLE_TREE;
194  const int qp_luma = (single_tree ? lc->ep->qp_y : ff_vvc_get_qPy(fc, x_center, y_center)) + sps->qp_bd_offset;
195  const int qp_chroma = av_clip(qp_luma, 0, MAX_QP + sps->qp_bd_offset);
196  const int sh_chroma_qp_offset[] = {
197  rsh->sh_cb_qp_offset,
198  rsh->sh_cr_qp_offset,
199  rsh->sh_joint_cbcr_qp_offset,
200  };
201  int qp;
202 
203  for (int i = CB - 1; i < CR + sps->r->sps_joint_cbcr_enabled_flag; i++) {
204  qp = sps->chroma_qp_table[i][qp_chroma];
205  qp = qp + pps->chroma_qp_offset[i] + sh_chroma_qp_offset[i] + lc->parse.chroma_qp_offset[i];
206  qp = av_clip(qp, -sps->qp_bd_offset, MAX_QP) + sps->qp_bd_offset;
207  cu->qp[i + 1] = qp;
208  }
209 }
210 
211 static TransformUnit* alloc_tu(VVCFrameContext *fc, CodingUnit *cu)
212 {
213  TransformUnit *tu = av_refstruct_pool_get(fc->tu_pool);
214  if (!tu)
215  return NULL;
216 
217  tu->next = NULL;
218 
219  if (cu->tus.tail)
220  cu->tus.tail->next = tu;
221  else
222  cu->tus.head = tu;
223  cu->tus.tail = tu;
224 
225  return tu;
226 }
227 
228 static TransformUnit* add_tu(VVCFrameContext *fc, CodingUnit *cu, const int x0, const int y0, const int tu_width, const int tu_height)
229 {
230  TransformUnit *tu = alloc_tu(fc, cu);
231 
232  if (!tu)
233  return NULL;
234 
235  tu->x0 = x0;
236  tu->y0 = y0;
237  tu->width = tu_width;
238  tu->height = tu_height;
239  tu->joint_cbcr_residual_flag = 0;
240  memset(tu->coded_flag, 0, sizeof(tu->coded_flag));
241  tu->avail[LUMA] = tu->avail[CHROMA] = 0;
242  tu->nb_tbs = 0;
243 
244  return tu;
245 }
246 
247 static TransformBlock* add_tb(TransformUnit *tu, VVCLocalContext *lc,
248  const int x0, const int y0, const int tb_width, const int tb_height, const int c_idx)
249 {
250  TransformBlock *tb;
251 
252  tb = &tu->tbs[tu->nb_tbs++];
253  tb->has_coeffs = 0;
254  tb->x0 = x0;
255  tb->y0 = y0;
256  tb->tb_width = tb_width;
257  tb->tb_height = tb_height;
258  tb->log2_tb_width = av_log2(tb_width);
259  tb->log2_tb_height = av_log2(tb_height);
260 
261  tb->max_scan_x = tb->max_scan_y = 0;
262  tb->min_scan_x = tb->min_scan_y = 0;
263 
264  tb->c_idx = c_idx;
265  tb->ts = 0;
266  tb->coeffs = lc->coeffs;
267  lc->coeffs += tb_width * tb_height;
268  tu->avail[!!c_idx] = true;
269  return tb;
270 }
271 
272 static uint8_t tu_y_coded_flag_decode(VVCLocalContext *lc, const int is_sbt_not_coded,
273  const int sub_tu_index, const int is_isp, const int is_chroma_coded)
274 {
275  uint8_t tu_y_coded_flag = 0;
276  const VVCSPS *sps = lc->fc->ps.sps;
277  CodingUnit *cu = lc->cu;
278 
279  if (!is_sbt_not_coded) {
280  int has_y_coded_flag = sub_tu_index < cu->num_intra_subpartitions - 1 || !lc->parse.infer_tu_cbf_luma;
281  if (!is_isp) {
282  const int is_large = cu->cb_width > sps->max_tb_size_y || cu->cb_height > sps->max_tb_size_y;
283  has_y_coded_flag = (cu->pred_mode == MODE_INTRA && !cu->act_enabled_flag) || is_chroma_coded || is_large;
284  }
285  tu_y_coded_flag = has_y_coded_flag ? ff_vvc_tu_y_coded_flag(lc) : 1;
286  }
287  if (is_isp)
288  lc->parse.infer_tu_cbf_luma = lc->parse.infer_tu_cbf_luma && !tu_y_coded_flag;
289  return tu_y_coded_flag;
290 }
291 
292 static void chroma_qp_offset_decode(VVCLocalContext *lc, const int is_128, const int is_chroma_coded)
293 {
294  const VVCPPS *pps = lc->fc->ps.pps;
295  const H266RawSliceHeader *rsh = lc->sc->sh.r;
296 
297  if ((is_128 || is_chroma_coded) &&
298  rsh->sh_cu_chroma_qp_offset_enabled_flag && !lc->parse.is_cu_chroma_qp_offset_coded) {
299  const int cu_chroma_qp_offset_flag = ff_vvc_cu_chroma_qp_offset_flag(lc);
300  if (cu_chroma_qp_offset_flag) {
301  int cu_chroma_qp_offset_idx = 0;
302  if (pps->r->pps_chroma_qp_offset_list_len_minus1 > 0)
303  cu_chroma_qp_offset_idx = ff_vvc_cu_chroma_qp_offset_idx(lc);
304  for (int i = CB - 1; i < JCBCR; i++)
305  lc->parse.chroma_qp_offset[i] = pps->chroma_qp_offset_list[cu_chroma_qp_offset_idx][i];
306  } else {
307  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
308  }
309  lc->parse.is_cu_chroma_qp_offset_coded = 1;
310  }
311 }
312 
313 static int hls_transform_unit(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height, int sub_tu_index, int ch_type)
314 {
315  VVCFrameContext *fc = lc->fc;
316  const VVCSPS *sps = fc->ps.sps;
317  const VVCPPS *pps = fc->ps.pps;
318  CodingUnit *cu = lc->cu;
319  TransformUnit *tu = add_tu(fc, cu, x0, y0, tu_width, tu_height);
320  const int min_cb_width = pps->min_cb_width;
321  const VVCTreeType tree_type = cu->tree_type;
322  const int is_128 = cu->cb_width > 64 || cu->cb_height > 64;
323  const int is_isp = cu->isp_split_type != ISP_NO_SPLIT;
324  const int is_isp_last_tu = is_isp && (sub_tu_index == cu->num_intra_subpartitions - 1);
325  const int is_sbt_not_coded = cu->sbt_flag &&
326  ((sub_tu_index == 0 && cu->sbt_pos_flag) || (sub_tu_index == 1 && !cu->sbt_pos_flag));
327  const int chroma_available = tree_type != DUAL_TREE_LUMA && sps->r->sps_chroma_format_idc &&
328  (!is_isp || is_isp_last_tu);
329  int ret, xc, yc, wc, hc, is_chroma_coded;
330 
331  if (!tu)
332  return AVERROR_INVALIDDATA;
333 
334  if (tree_type == SINGLE_TREE && is_isp_last_tu) {
335  const int x_cu = x0 >> fc->ps.sps->min_cb_log2_size_y;
336  const int y_cu = y0 >> fc->ps.sps->min_cb_log2_size_y;
337  xc = SAMPLE_CTB(fc->tab.cb_pos_x[ch_type], x_cu, y_cu);
338  yc = SAMPLE_CTB(fc->tab.cb_pos_y[ch_type], x_cu, y_cu);
339  wc = SAMPLE_CTB(fc->tab.cb_width[ch_type], x_cu, y_cu);
340  hc = SAMPLE_CTB(fc->tab.cb_height[ch_type], x_cu, y_cu);
341  } else {
342  xc = x0, yc = y0, wc = tu_width, hc = tu_height;
343  }
344 
345  if (chroma_available && !is_sbt_not_coded) {
346  tu->coded_flag[CB] = ff_vvc_tu_cb_coded_flag(lc);
347  tu->coded_flag[CR] = ff_vvc_tu_cr_coded_flag(lc, tu->coded_flag[CB]);
348  }
349 
350  is_chroma_coded = chroma_available && (tu->coded_flag[CB] || tu->coded_flag[CR]);
351 
352  if (tree_type != DUAL_TREE_CHROMA) {
353  int has_qp_delta;
354  tu->coded_flag[LUMA] = tu_y_coded_flag_decode(lc, is_sbt_not_coded, sub_tu_index, is_isp, is_chroma_coded);
355  has_qp_delta = (is_128 || tu->coded_flag[LUMA] || is_chroma_coded) &&
356  pps->r->pps_cu_qp_delta_enabled_flag && !lc->parse.is_cu_qp_delta_coded;
357  ret = set_qp_y(lc, x0, y0, has_qp_delta);
358  if (ret < 0)
359  return ret;
360  add_tb(tu, lc, x0, y0, tu_width, tu_height, LUMA);
361  }
362  if (tree_type != DUAL_TREE_LUMA) {
363  chroma_qp_offset_decode(lc, is_128, is_chroma_coded);
364  if (chroma_available) {
365  const int hs = sps->hshift[CHROMA];
366  const int vs = sps->vshift[CHROMA];
367  add_tb(tu, lc, xc, yc, wc >> hs, hc >> vs, CB);
368  add_tb(tu, lc, xc, yc, wc >> hs, hc >> vs, CR);
369  }
370  }
371  if (sps->r->sps_joint_cbcr_enabled_flag && ((cu->pred_mode == MODE_INTRA &&
372  (tu->coded_flag[CB] || tu->coded_flag[CR])) ||
373  (tu->coded_flag[CB] && tu->coded_flag[CR])) &&
374  chroma_available) {
375  tu->joint_cbcr_residual_flag = ff_vvc_tu_joint_cbcr_residual_flag(lc, tu->coded_flag[1], tu->coded_flag[2]);
376  }
377 
378  for (int i = 0; i < tu->nb_tbs; i++) {
379  TransformBlock *tb = &tu->tbs[i];
380  const int is_chroma = tb->c_idx != LUMA;
381  tb->has_coeffs = tu->coded_flag[tb->c_idx];
382  if (tb->has_coeffs && is_chroma)
383  tb->has_coeffs = tb->c_idx == CB ? 1 : !(tu->coded_flag[CB] && tu->joint_cbcr_residual_flag);
384  if (tb->has_coeffs) {
385  tb->ts = cu->bdpcm_flag[tb->c_idx];
386  if (sps->r->sps_transform_skip_enabled_flag && !cu->bdpcm_flag[tb->c_idx] &&
387  tb->tb_width <= sps->max_ts_size && tb->tb_height <= sps->max_ts_size &&
388  !cu->sbt_flag && (is_chroma || !is_isp)) {
389  tb->ts = ff_vvc_transform_skip_flag(lc, is_chroma);
390  }
391  ret = ff_vvc_residual_coding(lc, tb);
392  if (ret < 0)
393  return ret;
394  set_tb_tab(fc->tab.tu_coded_flag[tb->c_idx], tu->coded_flag[tb->c_idx], fc, tb);
395  } else if (cu->act_enabled_flag) {
396  memset(tb->coeffs, 0, tb->tb_width * tb->tb_height * sizeof(*tb->coeffs));
397  }
398  if (tb->c_idx != CR)
399  set_tb_size(fc, tb);
400  if (tb->c_idx == CB)
401  set_tb_tab(fc->tab.tu_joint_cbcr_residual_flag, tu->joint_cbcr_residual_flag, fc, tb);
402  }
403 
404  return 0;
405 }
406 
407 static int hls_transform_tree(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height, int ch_type)
408 {
409  const CodingUnit *cu = lc->cu;
410  const VVCSPS *sps = lc->fc->ps.sps;
411  int ret;
412 
413  lc->parse.infer_tu_cbf_luma = 1;
414  if (cu->isp_split_type == ISP_NO_SPLIT && !cu->sbt_flag) {
415  if (tu_width > sps->max_tb_size_y || tu_height > sps->max_tb_size_y) {
416  const int ver_split_first = tu_width > sps->max_tb_size_y && tu_width > tu_height;
417  const int trafo_width = ver_split_first ? (tu_width / 2) : tu_width;
418  const int trafo_height = !ver_split_first ? (tu_height / 2) : tu_height;
419 
420  #define TRANSFORM_TREE(x, y) do { \
421  ret = hls_transform_tree(lc, x, y, trafo_width, trafo_height, ch_type); \
422  if (ret < 0) \
423  return ret; \
424  } while (0)
425 
426  TRANSFORM_TREE(x0, y0);
427  if (ver_split_first)
428  TRANSFORM_TREE(x0 + trafo_width, y0);
429  else
430  TRANSFORM_TREE(x0, y0 + trafo_height);
431 
432  } else {
433  ret = hls_transform_unit(lc, x0, y0, tu_width, tu_height, 0, ch_type);
434  if (ret < 0)
435  return ret;
436 
437  }
438  } else if (cu->sbt_flag) {
439  if (!cu->sbt_horizontal_flag) {
440  #define TRANSFORM_UNIT(x, width, idx) do { \
441  ret = hls_transform_unit(lc, x, y0, width, tu_height, idx, ch_type); \
442  if (ret < 0) \
443  return ret; \
444  } while (0)
445 
446  const int trafo_width = tu_width * lc->parse.sbt_num_fourths_tb0 / 4;
447  TRANSFORM_UNIT(x0, trafo_width, 0);
448  TRANSFORM_UNIT(x0 + trafo_width, tu_width - trafo_width, 1);
449 
450  #undef TRANSFORM_UNIT
451  } else {
452  #define TRANSFORM_UNIT(y, height, idx) do { \
453  ret = hls_transform_unit(lc, x0, y, tu_width, height, idx, ch_type); \
454  if (ret < 0) \
455  return ret; \
456  } while (0)
457 
458  const int trafo_height = tu_height * lc->parse.sbt_num_fourths_tb0 / 4;
459  TRANSFORM_UNIT(y0, trafo_height, 0);
460  TRANSFORM_UNIT(y0 + trafo_height, tu_height - trafo_height, 1);
461 
462  #undef TRANSFORM_UNIT
463  }
464  } else if (cu->isp_split_type == ISP_HOR_SPLIT) {
465  const int trafo_height = tu_height / cu->num_intra_subpartitions;
466  for (int i = 0; i < cu->num_intra_subpartitions; i++) {
467  ret = hls_transform_unit(lc, x0, y0 + trafo_height * i, tu_width, trafo_height, i, 0);
468  if (ret < 0)
469  return ret;
470  }
471  } else if (cu->isp_split_type == ISP_VER_SPLIT) {
472  const int trafo_width = tu_width / cu->num_intra_subpartitions;
473  for (int i = 0; i < cu->num_intra_subpartitions; i++) {
474  ret = hls_transform_unit(lc, x0 + trafo_width * i , y0, trafo_width, tu_height, i, 0);
475  if (ret < 0)
476  return ret;
477  }
478  }
479 
480  return 0;
481 }
482 
483 static int skipped_transform_tree(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height)
484 {
485  VVCFrameContext *fc = lc->fc;
486  const CodingUnit *cu = lc->cu;
487  const VVCSPS *sps = fc->ps.sps;
488 
489  if (tu_width > sps->max_tb_size_y || tu_height > sps->max_tb_size_y) {
490  const int ver_split_first = tu_width > sps->max_tb_size_y && tu_width > tu_height;
491  const int trafo_width = ver_split_first ? (tu_width / 2) : tu_width;
492  const int trafo_height = !ver_split_first ? (tu_height / 2) : tu_height;
493 
494  #define SKIPPED_TRANSFORM_TREE(x, y) do { \
495  int ret = skipped_transform_tree(lc, x, y, trafo_width, trafo_height); \
496  if (ret < 0) \
497  return ret; \
498  } while (0)
499 
500  SKIPPED_TRANSFORM_TREE(x0, y0);
501  if (ver_split_first)
502  SKIPPED_TRANSFORM_TREE(x0 + trafo_width, y0);
503  else
504  SKIPPED_TRANSFORM_TREE(x0, y0 + trafo_height);
505  } else {
506  TransformUnit *tu = add_tu(fc, lc->cu, x0, y0, tu_width, tu_height);
507  int start, end;
508 
509  if (!tu)
510  return AVERROR_INVALIDDATA;
511  ff_vvc_channel_range(&start, &end, cu->tree_type, sps->r->sps_chroma_format_idc);
512  for (int i = start; i < end; i++) {
513  TransformBlock *tb = add_tb(tu, lc, x0, y0, tu_width >> sps->hshift[i], tu_height >> sps->vshift[i], i);
514  if (i != CR)
515  set_tb_size(fc, tb);
516  }
517  }
518 
519  return 0;
520 }
521 
522 //6.4.1 Allowed quad split process
523 //6.4.2 Allowed binary split process
524 //6.4.3 Allowed ternary split process
525 static void can_split(const VVCLocalContext *lc, int x0, int y0,int cb_width, int cb_height,
526  int mtt_depth, int depth_offset, int part_idx, VVCSplitMode last_split_mode,
527  VVCTreeType tree_type, VVCModeType mode_type, VVCAllowedSplit* split)
528 {
529  int min_qt_size, max_bt_size, max_tt_size, max_mtt_depth;
530  const VVCFrameContext *fc = lc->fc;
531  const VVCSH *sh = &lc->sc->sh;
532  const VVCSPS *sps = fc->ps.sps;
533  const VVCPPS *pps = fc->ps.pps;
534  const int chroma = tree_type == DUAL_TREE_CHROMA;
535  int min_cb_size_y = sps->min_cb_size_y;
536  int *qt = &split->qt;
537  int *btv = &split->btv;
538  int *bth = &split->bth;
539  int *ttv = &split->ttv;
540  int *tth = &split->tth;
541 
542  *qt = *bth = *btv = *tth = *ttv = 1;
543 
544  if (mtt_depth)
545  *qt = 0;
546 
547  min_qt_size = sh->min_qt_size[chroma];
548  if (cb_width <= min_qt_size)
549  *qt = 0;
550 
551  if (chroma) {
552  int chroma_area = (cb_width >> sps->hshift[1]) * (cb_height >> sps->vshift[1]);
553  int chroma_width = cb_width >> sps->hshift[1];
554 
555  if (chroma_width == 8)
556  *ttv = 0;
557  else if (chroma_width <= 4) {
558  if (chroma_width == 4)
559  *btv = 0;
560  *qt = 0;
561  }
562  if (mode_type == MODE_TYPE_INTRA)
563  *qt = *btv = *bth = *ttv = *tth = 0;
564  if (chroma_area <= 32) {
565  *ttv = *tth = 0;
566  if (chroma_area <= 16)
567  *btv = *bth = 0;
568  }
569  }
570  max_bt_size = sh->max_bt_size[chroma];
571  max_tt_size = sh->max_tt_size[chroma];
572  max_mtt_depth = sh->max_mtt_depth[chroma] + depth_offset;
573 
574  if (mode_type == MODE_TYPE_INTER) {
575  int area = cb_width * cb_height;
576  if (area == 32)
577  *btv = *bth = 0;
578  else if (area == 64)
579  *ttv = *tth = 0;
580  }
581  if (cb_width <= 2 * min_cb_size_y) {
582  *ttv = 0;
583  if (cb_width <= min_cb_size_y)
584  *btv = 0;
585  }
586  if (cb_height <= 2 * min_cb_size_y) {
587  *tth = 0;
588  if (cb_height <= min_cb_size_y)
589  *bth = 0;
590  }
591  if (cb_width > max_bt_size || cb_height > max_bt_size)
592  *btv = *bth = 0;
593  max_tt_size = FFMIN(64, max_tt_size);
594  if (cb_width > max_tt_size || cb_height > max_tt_size)
595  *ttv = *tth = 0;
596  if (mtt_depth >= max_mtt_depth)
597  *btv = *bth = *ttv = *tth = 0;
598  if (x0 + cb_width > pps->width) {
599  *ttv = *tth = 0;
600  if (cb_height > 64)
601  *btv = 0;
602  if (y0 + cb_height <= pps->height)
603  *bth = 0;
604  else if (cb_width > min_qt_size)
605  *btv = *bth = 0;
606  }
607  if (y0 + cb_height > pps->height) {
608  *btv = *ttv = *tth = 0;
609  if (cb_width > 64)
610  *bth = 0;
611  }
612  if (mtt_depth > 0 && part_idx == 1) {
613  if (last_split_mode == SPLIT_TT_VER)
614  *btv = 0;
615  else if (last_split_mode == SPLIT_TT_HOR)
616  *bth = 0;
617  }
618  if (cb_width <= 64 && cb_height > 64)
619  *btv = 0;
620  if (cb_width > 64 && cb_height <= 64)
621  *bth = 0;
622 }
623 
624 static int get_num_intra_subpartitions(enum IspType isp_split_type, int cb_width, int cb_height)
625 {
626  if (isp_split_type == ISP_NO_SPLIT)
627  return 1;
628  if ((cb_width == 4 && cb_height == 8) || (cb_width == 8 && cb_height == 4))
629  return 2;
630  return 4;
631 }
632 
633 static int get_cclm_enabled(const VVCLocalContext *lc, const int x0, const int y0)
634 {
635  const VVCFrameContext *fc = lc->fc;
636  const VVCSPS *sps = fc->ps.sps;
637  int enabled = 0;
638 
639  if (!sps->r->sps_cclm_enabled_flag)
640  return 0;
641  if (!sps->r->sps_qtbtt_dual_tree_intra_flag || !IS_I(lc->sc->sh.r) || sps->ctb_log2_size_y < 6)
642  return 1;
643  else {
644  const int x64 = x0 >> 6 << 6;
645  const int y64 = y0 >> 6 << 6;
646  const int y32 = y0 >> 5 << 5;
647  const int x64_cu = x64 >> fc->ps.sps->min_cb_log2_size_y;
648  const int y64_cu = y64 >> fc->ps.sps->min_cb_log2_size_y;
649  const int y32_cu = y32 >> fc->ps.sps->min_cb_log2_size_y;
650  const int min_cb_width = fc->ps.pps->min_cb_width;
651  const int depth = SAMPLE_CTB(fc->tab.cqt_depth[1], x64_cu, y64_cu);
652  const int min_depth = fc->ps.sps->ctb_log2_size_y - 6;
653  const VVCSplitMode msm64 = (VVCSplitMode)TAB_MSM(fc, 0, x64, y64);
654  const VVCSplitMode msm32 = (VVCSplitMode)TAB_MSM(fc, 1, x64, y32);
655 
656  enabled = SAMPLE_CTB(fc->tab.cb_width[1], x64_cu, y64_cu) == 64 &&
657  SAMPLE_CTB(fc->tab.cb_height[1], x64_cu, y64_cu) == 64;
658  enabled |= depth == min_depth && msm64 == SPLIT_BT_HOR &&
659  SAMPLE_CTB(fc->tab.cb_width[1], x64_cu, y32_cu) == 64 &&
660  SAMPLE_CTB(fc->tab.cb_height[1], x64_cu, y32_cu) == 32;
661  enabled |= depth > min_depth;
662  enabled |= depth == min_depth && msm64 == SPLIT_BT_HOR && msm32 == SPLIT_BT_VER;
663 
664  if (enabled) {
665  const int w = SAMPLE_CTB(fc->tab.cb_width[0], x64_cu, y64_cu);
666  const int h = SAMPLE_CTB(fc->tab.cb_height[0], x64_cu, y64_cu);
667  const int depth0 = SAMPLE_CTB(fc->tab.cqt_depth[0], x64_cu, y64_cu);
668  if ((w == 64 && h == 64 && TAB_ISPMF(fc, x64, y64)) ||
669  ((w < 64 || h < 64) && depth0 == min_depth))
670  return 0;
671  }
672 
673  }
674 
675  return enabled;
676 }
677 
678 static int less(const void *a, const void *b)
679 {
680  return *(const int*)a - *(const int*)b;
681 }
682 
683 //8.4.2 Derivation process for luma intra prediction mode
684 static enum IntraPredMode luma_intra_pred_mode(VVCLocalContext* lc, const int intra_subpartitions_mode_flag)
685 {
686  VVCFrameContext *fc = lc->fc;
687  CodingUnit *cu = lc->cu;
688  const int x0 = cu->x0;
689  const int y0 = cu->y0;
690  enum IntraPredMode pred;
691  int intra_luma_not_planar_flag = 1;
692  int intra_luma_mpm_remainder = 0;
693  int intra_luma_mpm_flag = 1;
694  int intra_luma_mpm_idx = 0;
695 
696  if (!cu->intra_luma_ref_idx)
697  intra_luma_mpm_flag = ff_vvc_intra_luma_mpm_flag(lc);
698  if (intra_luma_mpm_flag) {
699  if (!cu->intra_luma_ref_idx)
700  intra_luma_not_planar_flag = ff_vvc_intra_luma_not_planar_flag(lc, intra_subpartitions_mode_flag);
701  if (intra_luma_not_planar_flag)
702  intra_luma_mpm_idx = ff_vvc_intra_luma_mpm_idx(lc);
703  } else {
704  intra_luma_mpm_remainder = ff_vvc_intra_luma_mpm_remainder(lc);
705  }
706 
707  if (!intra_luma_not_planar_flag) {
708  pred = INTRA_PLANAR;
709  } else {
710  const VVCSPS *sps = fc->ps.sps;
711  const int x_a = (x0 - 1) >> sps->min_cb_log2_size_y;
712  const int y_a = (y0 + cu->cb_height - 1) >> sps->min_cb_log2_size_y;
713  const int x_b = (x0 + cu->cb_width - 1) >> sps->min_cb_log2_size_y;
714  const int y_b = (y0 - 1) >> sps->min_cb_log2_size_y;
715  int min_cb_width = fc->ps.pps->min_cb_width;
716  int x0b = av_zero_extend(x0, sps->ctb_log2_size_y);
717  int y0b = av_zero_extend(y0, sps->ctb_log2_size_y);
718  const int available_l = lc->ctb_left_flag || x0b;
719  const int available_u = lc->ctb_up_flag || y0b;
720 
721  int a, b, cand[5];
722 
723  if (!available_l || (SAMPLE_CTB(fc->tab.cpm[0], x_a, y_a) != MODE_INTRA) ||
724  SAMPLE_CTB(fc->tab.imf, x_a, y_a)) {
725  a = INTRA_PLANAR;
726  } else {
727  a = SAMPLE_CTB(fc->tab.ipm, x_a, y_a);
728  }
729 
730  if (!available_u || (SAMPLE_CTB(fc->tab.cpm[0], x_b, y_b) != MODE_INTRA) ||
731  SAMPLE_CTB(fc->tab.imf, x_b, y_b) || !y0b) {
732  b = INTRA_PLANAR;
733  } else {
734  b = SAMPLE_CTB(fc->tab.ipm, x_b, y_b);
735  }
736 
737  if (a == b && a > INTRA_DC) {
738  cand[0] = a;
739  cand[1] = 2 + ((a + 61) % 64);
740  cand[2] = 2 + ((a - 1) % 64);
741  cand[3] = 2 + ((a + 60) % 64);
742  cand[4] = 2 + (a % 64);
743  } else {
744  const int minab = FFMIN(a, b);
745  const int maxab = FFMAX(a, b);
746  if (a > INTRA_DC && b > INTRA_DC) {
747  const int diff = maxab - minab;
748  cand[0] = a;
749  cand[1] = b;
750  if (diff == 1) {
751  cand[2] = 2 + ((minab + 61) % 64);
752  cand[3] = 2 + ((maxab - 1) % 64);
753  cand[4] = 2 + ((minab + 60) % 64);
754  } else if (diff >= 62) {
755  cand[2] = 2 + ((minab - 1) % 64);
756  cand[3] = 2 + ((maxab + 61) % 64);
757  cand[4] = 2 + (minab % 64);
758  } else if (diff == 2) {
759  cand[2] = 2 + ((minab - 1) % 64);
760  cand[3] = 2 + ((minab + 61) % 64);
761  cand[4] = 2 + ((maxab - 1) % 64);
762  } else {
763  cand[2] = 2 + ((minab + 61) % 64);
764  cand[3] = 2 + ((minab - 1) % 64);
765  cand[4] = 2 + ((maxab + 61) % 64);
766  }
767  } else if (a > INTRA_DC || b > INTRA_DC) {
768  cand[0] = maxab;
769  cand[1] = 2 + ((maxab + 61 ) % 64);
770  cand[2] = 2 + ((maxab - 1) % 64);
771  cand[3] = 2 + ((maxab + 60 ) % 64);
772  cand[4] = 2 + (maxab % 64);
773  } else {
774  cand[0] = INTRA_DC;
775  cand[1] = INTRA_VERT;
776  cand[2] = INTRA_HORZ;
777  cand[3] = INTRA_VERT - 4;
778  cand[4] = INTRA_VERT + 4;
779  }
780  }
781  if (intra_luma_mpm_flag) {
782  pred = cand[intra_luma_mpm_idx];
783  } else {
784  qsort(cand, FF_ARRAY_ELEMS(cand), sizeof(cand[0]), less);
785  pred = intra_luma_mpm_remainder + 1;
786  for (int i = 0; i < FF_ARRAY_ELEMS(cand); i++) {
787  if (pred >= cand[i])
788  pred++;
789  }
790  }
791  }
792  return pred;
793 }
794 
795 static int lfnst_idx_decode(VVCLocalContext *lc)
796 {
797  CodingUnit *cu = lc->cu;
798  const VVCTreeType tree_type = cu->tree_type;
799  const VVCSPS *sps = lc->fc->ps.sps;
800  const int cb_width = cu->cb_width;
801  const int cb_height = cu->cb_height;
802  const TransformUnit *tu = cu->tus.head;
803  int lfnst_width, lfnst_height, min_lfnst;
804  int lfnst_idx = 0;
805 
806  memset(cu->apply_lfnst_flag, 0, sizeof(cu->apply_lfnst_flag));
807 
808  if (!sps->r->sps_lfnst_enabled_flag || cu->pred_mode != MODE_INTRA || FFMAX(cb_width, cb_height) > sps->max_tb_size_y)
809  return 0;
810 
811  while (tu) {
812  for (int j = 0; j < tu->nb_tbs; j++) {
813  const TransformBlock *tb = tu->tbs + j;
814  if (tu->coded_flag[tb->c_idx] && tb->ts)
815  return 0;
816  }
817  tu = tu->next;
818  }
819 
820  if (tree_type == DUAL_TREE_CHROMA) {
821  lfnst_width = cb_width >> sps->hshift[1];
822  lfnst_height = cb_height >> sps->vshift[1];
823  } else {
824  const int vs = cu->isp_split_type == ISP_VER_SPLIT;
825  const int hs = cu->isp_split_type == ISP_HOR_SPLIT;
826  lfnst_width = vs ? cb_width / cu->num_intra_subpartitions : cb_width;
827  lfnst_height = hs ? cb_height / cu->num_intra_subpartitions : cb_height;
828  }
829  min_lfnst = FFMIN(lfnst_width, lfnst_height);
830  if (tree_type != DUAL_TREE_CHROMA && cu->intra_mip_flag && min_lfnst < 16)
831  return 0;
832 
833  if (min_lfnst >= 4) {
834  if ((cu->isp_split_type != ISP_NO_SPLIT || !lc->parse.lfnst_dc_only) && lc->parse.lfnst_zero_out_sig_coeff_flag)
835  lfnst_idx = ff_vvc_lfnst_idx(lc, tree_type != SINGLE_TREE);
836  }
837 
838  if (lfnst_idx) {
839  cu->apply_lfnst_flag[LUMA] = tree_type != DUAL_TREE_CHROMA;
840  cu->apply_lfnst_flag[CB] = cu->apply_lfnst_flag[CR] = tree_type == DUAL_TREE_CHROMA;
841  }
842 
843  return lfnst_idx;
844 }
845 
846 static MtsIdx mts_idx_decode(VVCLocalContext *lc)
847 {
848  const CodingUnit *cu = lc->cu;
849  const VVCSPS *sps = lc->fc->ps.sps;
850  const int cb_width = cu->cb_width;
851  const int cb_height = cu->cb_height;
852  const uint8_t transform_skip_flag = cu->tus.head->tbs[0].ts; //fix me
853  int mts_idx = MTS_DCT2_DCT2;
854  if (cu->tree_type != DUAL_TREE_CHROMA && !cu->lfnst_idx &&
855  !transform_skip_flag && FFMAX(cb_width, cb_height) <= 32 &&
856  cu->isp_split_type == ISP_NO_SPLIT && !cu->sbt_flag &&
857  lc->parse.mts_zero_out_sig_coeff_flag && !lc->parse.mts_dc_only) {
858  if ((cu->pred_mode == MODE_INTER && sps->r->sps_explicit_mts_inter_enabled_flag) ||
859  (cu->pred_mode == MODE_INTRA && sps->r->sps_explicit_mts_intra_enabled_flag)) {
860  mts_idx = ff_vvc_mts_idx(lc);
861  }
862  }
863 
864  return mts_idx;
865 }
866 
867 static enum IntraPredMode derive_center_luma_intra_pred_mode(const VVCFrameContext *fc, const VVCSPS *sps, const VVCPPS *pps, const CodingUnit *cu)
868 {
869  const int x_center = (cu->x0 + cu->cb_width / 2) >> sps->min_cb_log2_size_y;
870  const int y_center = (cu->y0 + cu->cb_height / 2) >> sps->min_cb_log2_size_y;
871  const int min_cb_width = pps->min_cb_width;
872  const int intra_mip_flag = SAMPLE_CTB(fc->tab.imf, x_center, y_center);
873  const int cu_pred_mode = SAMPLE_CTB(fc->tab.cpm[0], x_center, y_center);
874  const int intra_pred_mode_y = SAMPLE_CTB(fc->tab.ipm, x_center, y_center);
875 
876  if (intra_mip_flag) {
877  if (cu->tree_type == SINGLE_TREE && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444)
878  return INTRA_INVALID;
879  return INTRA_PLANAR;
880  }
881  if (cu_pred_mode == MODE_IBC || cu_pred_mode == MODE_PLT)
882  return INTRA_DC;
883  return intra_pred_mode_y;
884 }
885 
886 static void derive_chroma_intra_pred_mode(VVCLocalContext *lc,
887  const int cclm_mode_flag, const int cclm_mode_idx, const int intra_chroma_pred_mode)
888 {
889  const VVCFrameContext *fc = lc->fc;
890  CodingUnit *cu = lc->cu;
891  const VVCSPS *sps = fc->ps.sps;
892  const VVCPPS *pps = fc->ps.pps;
893  const int x_cb = cu->x0 >> sps->min_cb_log2_size_y;
894  const int y_cb = cu->y0 >> sps->min_cb_log2_size_y;
895  const int min_cb_width = pps->min_cb_width;
896  const int intra_mip_flag = SAMPLE_CTB(fc->tab.imf, x_cb, y_cb);
897  enum IntraPredMode luma_intra_pred_mode = SAMPLE_CTB(fc->tab.ipm, x_cb, y_cb);
898 
899  if (cu->tree_type == SINGLE_TREE && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444 &&
900  (intra_chroma_pred_mode == 4 || cu->act_enabled_flag) && intra_mip_flag) {
901  cu->mip_chroma_direct_flag = 1;
902  cu->intra_pred_mode_c = luma_intra_pred_mode;
903  return;
904  }
905  luma_intra_pred_mode = derive_center_luma_intra_pred_mode(fc, sps, pps, cu);
906 
907  if (cu->act_enabled_flag) {
908  cu->intra_pred_mode_c = luma_intra_pred_mode;
909  return;
910  }
911  if (cclm_mode_flag) {
912  cu->intra_pred_mode_c = INTRA_LT_CCLM + cclm_mode_idx;
913  } else if (intra_chroma_pred_mode == 4){
914  cu->intra_pred_mode_c = luma_intra_pred_mode;
915  } else {
916  const static IntraPredMode pred_mode_c[][4 + 1] = {
917  {INTRA_VDIAG, INTRA_PLANAR, INTRA_PLANAR, INTRA_PLANAR, INTRA_PLANAR},
918  {INTRA_VERT, INTRA_VDIAG, INTRA_VERT, INTRA_VERT, INTRA_VERT},
919  {INTRA_HORZ, INTRA_HORZ, INTRA_VDIAG, INTRA_HORZ, INTRA_HORZ},
920  {INTRA_DC, INTRA_DC, INTRA_DC, INTRA_VDIAG, INTRA_DC},
921  };
922  const int modes[4] = {INTRA_PLANAR, INTRA_VERT, INTRA_HORZ, INTRA_DC};
923  int idx;
924 
925  // This workaround is necessary to have 4:4:4 video decode correctly
926  // See VVC ticket https://jvet.hhi.fraunhofer.de/trac/vvc/ticket/1602
927  // and VTM source https://vcgit.hhi.fraunhofer.de/jvet/VVCSoftware_VTM/-/blob/master/source/Lib/CommonLib/UnitTools.cpp#L736
928  if (cu->tree_type == SINGLE_TREE && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444 && intra_mip_flag) {
929  idx = 4;
930  } else {
931  for (idx = 0; idx < FF_ARRAY_ELEMS(modes); idx++) {
932  if (modes[idx] == luma_intra_pred_mode)
933  break;
934  }
935  }
936 
937  cu->intra_pred_mode_c = pred_mode_c[intra_chroma_pred_mode][idx];
938  }
939  if (sps->r->sps_chroma_format_idc == CHROMA_FORMAT_422 && cu->intra_pred_mode_c <= INTRA_VDIAG) {
940  const static int mode_map_422[INTRA_VDIAG + 1] = {
941  0, 1, 61, 62, 63, 64, 65, 66, 2, 3, 5, 6, 8, 10, 12, 13,
942  14, 16, 18, 20, 22, 23, 24, 26, 28, 30, 31, 33, 34, 35, 36, 37,
943  38, 39, 40, 41, 41, 42, 43, 43, 44, 44, 45, 45, 46, 47, 48, 48,
944  49, 49, 50, 51, 51, 52, 52, 53, 54, 55, 55, 56, 56, 57, 57, 58,
945  59, 59, 60,
946  };
947  cu->intra_pred_mode_c = mode_map_422[cu->intra_pred_mode_c];
948  }
949 }
950 
951 static av_always_inline uint8_t pack_mip_info(int intra_mip_flag,
952  int intra_mip_transposed_flag, int intra_mip_mode)
953 {
954  return (intra_mip_mode << 2) | (intra_mip_transposed_flag << 1) | intra_mip_flag;
955 }
956 
957 static void intra_luma_pred_modes(VVCLocalContext *lc)
958 {
959  VVCFrameContext *fc = lc->fc;
960  const VVCSPS *sps = fc->ps.sps;
961  const VVCPPS *pps = fc->ps.pps;
962  CodingUnit *cu = lc->cu;
963  const int log2_min_cb_size = sps->min_cb_log2_size_y;
964  const int x0 = cu->x0;
965  const int y0 = cu->y0;
966  const int x_cb = x0 >> log2_min_cb_size;
967  const int y_cb = y0 >> log2_min_cb_size;
968  const int cb_width = cu->cb_width;
969  const int cb_height = cu->cb_height;
970 
971  cu->intra_luma_ref_idx = 0;
972  if (sps->r->sps_bdpcm_enabled_flag && cb_width <= sps->max_ts_size && cb_height <= sps->max_ts_size)
973  cu->bdpcm_flag[LUMA] = ff_vvc_intra_bdpcm_luma_flag(lc);
974  if (cu->bdpcm_flag[LUMA]) {
975  cu->intra_pred_mode_y = ff_vvc_intra_bdpcm_luma_dir_flag(lc) ? INTRA_VERT : INTRA_HORZ;
976  } else {
977  if (sps->r->sps_mip_enabled_flag)
978  cu->intra_mip_flag = ff_vvc_intra_mip_flag(lc, fc->tab.imf);
979  if (cu->intra_mip_flag) {
980  int intra_mip_transposed_flag = ff_vvc_intra_mip_transposed_flag(lc);
981  int intra_mip_mode = ff_vvc_intra_mip_mode(lc);
982  int x = y_cb * pps->min_cb_width + x_cb;
983  for (int y = 0; y < (cb_height>>log2_min_cb_size); y++) {
984  int width = cb_width>>log2_min_cb_size;
985  const uint8_t mip_info = pack_mip_info(cu->intra_mip_flag,
986  intra_mip_transposed_flag, intra_mip_mode);
987  memset(&fc->tab.imf[x], mip_info, width);
988  x += pps->min_cb_width;
989  }
990  cu->intra_pred_mode_y = intra_mip_mode;
991  } else {
992  int intra_subpartitions_mode_flag = 0;
993  if (sps->r->sps_mrl_enabled_flag && ((y0 % sps->ctb_size_y) > 0))
994  cu->intra_luma_ref_idx = ff_vvc_intra_luma_ref_idx(lc);
995  if (sps->r->sps_isp_enabled_flag && !cu->intra_luma_ref_idx &&
996  (cb_width <= sps->max_tb_size_y && cb_height <= sps->max_tb_size_y) &&
997  (cb_width * cb_height > MIN_TU_SIZE * MIN_TU_SIZE) &&
998  !cu->act_enabled_flag)
999  intra_subpartitions_mode_flag = ff_vvc_intra_subpartitions_mode_flag(lc);
1000  if (!(x0 & 63) && !(y0 & 63))
1001  TAB_ISPMF(fc, x0, y0) = intra_subpartitions_mode_flag;
1002  cu->isp_split_type = ff_vvc_isp_split_type(lc, intra_subpartitions_mode_flag);
1003  cu->num_intra_subpartitions = get_num_intra_subpartitions(cu->isp_split_type, cb_width, cb_height);
1004  cu->intra_pred_mode_y = luma_intra_pred_mode(lc, intra_subpartitions_mode_flag);
1005  }
1006  }
1007  set_cb_tab(lc, fc->tab.ipm, cu->intra_pred_mode_y);
1008 }
1009 
1010 static void intra_chroma_pred_modes(VVCLocalContext *lc)
1011 {
1012  const VVCSPS *sps = lc->fc->ps.sps;
1013  CodingUnit *cu = lc->cu;
1014  const int hs = sps->hshift[CHROMA];
1015  const int vs = sps->vshift[CHROMA];
1016  int cclm_mode_flag = 0;
1017  int cclm_mode_idx = 0;
1018  int intra_chroma_pred_mode = 0;
1019 
1020  if (!cu->act_enabled_flag) {
1021  cu->mip_chroma_direct_flag = 0;
1022  if (sps->r->sps_bdpcm_enabled_flag &&
1023  (cu->cb_width >> hs) <= sps->max_ts_size &&
1024  (cu->cb_height >> vs) <= sps->max_ts_size) {
1025  cu->bdpcm_flag[CB] = cu->bdpcm_flag[CR] = ff_vvc_intra_bdpcm_chroma_flag(lc);
1026  }
1027  if (cu->bdpcm_flag[CHROMA]) {
1028  cu->intra_pred_mode_c = ff_vvc_intra_bdpcm_chroma_dir_flag(lc) ? INTRA_VERT : INTRA_HORZ;
1029  } else {
1030  const int cclm_enabled = get_cclm_enabled(lc, cu->x0, cu->y0);
1031 
1032  if (cclm_enabled)
1033  cclm_mode_flag = ff_vvc_cclm_mode_flag(lc);
1034 
1035  if (cclm_mode_flag)
1036  cclm_mode_idx = ff_vvc_cclm_mode_idx(lc);
1037  else
1038  intra_chroma_pred_mode = ff_vvc_intra_chroma_pred_mode(lc);
1039  }
1040  }
1041 
1042  if (!cu->bdpcm_flag[CHROMA])
1043  derive_chroma_intra_pred_mode(lc, cclm_mode_flag, cclm_mode_idx, intra_chroma_pred_mode);
1044 }
1045 
1046 static PredMode pred_mode_decode(VVCLocalContext *lc,
1047  const VVCTreeType tree_type,
1048  const VVCModeType mode_type)
1049 {
1050  const VVCFrameContext *fc = lc->fc;
1051  CodingUnit *cu = lc->cu;
1052  const VVCSPS *sps = fc->ps.sps;
1053  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1054  const int ch_type = tree_type == DUAL_TREE_CHROMA ? 1 : 0;
1055  const int is_4x4 = cu->cb_width == 4 && cu->cb_height == 4;
1056  const int is_128 = cu->cb_width == 128 || cu->cb_height == 128;
1057  const int hs = sps->hshift[CHROMA];
1058  const int vs = sps->vshift[CHROMA];
1059  int pred_mode_flag;
1060  int pred_mode_ibc_flag;
1061  PredMode pred_mode;
1062 
1063  cu->skip_flag = 0;
1064  if (!IS_I(rsh) || sps->r->sps_ibc_enabled_flag) {
1065  if (tree_type != DUAL_TREE_CHROMA &&
1066  ((!is_4x4 && mode_type != MODE_TYPE_INTRA) ||
1067  (sps->r->sps_ibc_enabled_flag && !is_128))) {
1068  cu->skip_flag = ff_vvc_cu_skip_flag(lc, fc->tab.skip);
1069  }
1070 
1071  if (is_4x4 || mode_type == MODE_TYPE_INTRA || IS_I(rsh)) {
1072  pred_mode_flag = 1;
1073  } else if (mode_type == MODE_TYPE_INTER || cu->skip_flag) {
1074  pred_mode_flag = 0;
1075  } else {
1076  pred_mode_flag = ff_vvc_pred_mode_flag(lc, ch_type);
1077  }
1078  pred_mode = pred_mode_flag ? MODE_INTRA : MODE_INTER;
1079 
1080  if (((IS_I(rsh) && !cu->skip_flag) ||
1081  (!IS_I(rsh) && (pred_mode != MODE_INTRA ||
1082  ((is_4x4 || mode_type == MODE_TYPE_INTRA) && !cu->skip_flag)))) &&
1083  !is_128 && mode_type != MODE_TYPE_INTER && sps->r->sps_ibc_enabled_flag &&
1084  tree_type != DUAL_TREE_CHROMA) {
1085  pred_mode_ibc_flag = ff_vvc_pred_mode_ibc_flag(lc, ch_type);
1086  } else if (cu->skip_flag && (is_4x4 || mode_type == MODE_TYPE_INTRA)) {
1087  pred_mode_ibc_flag = 1;
1088  } else if (is_128 || mode_type == MODE_TYPE_INTER || tree_type == DUAL_TREE_CHROMA) {
1089  pred_mode_ibc_flag = 0;
1090  } else {
1091  pred_mode_ibc_flag = (IS_I(rsh)) ? sps->r->sps_ibc_enabled_flag : 0;
1092  }
1093  if (pred_mode_ibc_flag)
1094  pred_mode = MODE_IBC;
1095  } else {
1096  pred_mode = MODE_INTRA;
1097  }
1098 
1099  if (pred_mode == MODE_INTRA && sps->r->sps_palette_enabled_flag && !is_128 && !cu->skip_flag &&
1100  mode_type != MODE_TYPE_INTER && ((cu->cb_width * cu->cb_height) >
1101  (tree_type != DUAL_TREE_CHROMA ? 16 : (16 << hs << vs))) &&
1102  (mode_type != MODE_TYPE_INTRA || tree_type != DUAL_TREE_CHROMA)) {
1103  if (ff_vvc_pred_mode_plt_flag(lc))
1104  pred_mode = MODE_PLT;
1105  }
1106 
1107  set_cb_tab(lc, fc->tab.cpm[cu->ch_type], pred_mode);
1108  if (tree_type == SINGLE_TREE)
1109  set_cb_tab(lc, fc->tab.cpm[CHROMA], pred_mode);
1110 
1111  return pred_mode;
1112 }
1113 
1114 static void sbt_info(VVCLocalContext *lc, const VVCSPS *sps)
1115 {
1116  CodingUnit *cu = lc->cu;
1117  const int cb_width = cu->cb_width;
1118  const int cb_height = cu->cb_height;
1119 
1120  if (cu->pred_mode == MODE_INTER && sps->r->sps_sbt_enabled_flag && !cu->ciip_flag
1121  && cb_width <= sps->max_tb_size_y && cb_height <= sps->max_tb_size_y) {
1122  const int sbt_ver_h = cb_width >= 8;
1123  const int sbt_hor_h = cb_height >= 8;
1124  cu->sbt_flag = 0;
1125  if (sbt_ver_h || sbt_hor_h)
1126  cu->sbt_flag = ff_vvc_sbt_flag(lc);
1127  if (cu->sbt_flag) {
1128  const int sbt_ver_q = cb_width >= 16;
1129  const int sbt_hor_q = cb_height >= 16;
1130  int cu_sbt_quad_flag = 0;
1131 
1132  if ((sbt_ver_h || sbt_hor_h) && (sbt_ver_q || sbt_hor_q))
1133  cu_sbt_quad_flag = ff_vvc_sbt_quad_flag(lc);
1134  if (cu_sbt_quad_flag) {
1135  cu->sbt_horizontal_flag = sbt_hor_q;
1136  if (sbt_ver_q && sbt_hor_q)
1137  cu->sbt_horizontal_flag = ff_vvc_sbt_horizontal_flag(lc);
1138  } else {
1139  cu->sbt_horizontal_flag = sbt_hor_h;
1140  if (sbt_ver_h && sbt_hor_h)
1141  cu->sbt_horizontal_flag = ff_vvc_sbt_horizontal_flag(lc);
1142  }
1143  cu->sbt_pos_flag = ff_vvc_sbt_pos_flag(lc);
1144 
1145  {
1146  const int sbt_min = cu_sbt_quad_flag ? 1 : 2;
1147  lc->parse.sbt_num_fourths_tb0 = cu->sbt_pos_flag ? (4 - sbt_min) : sbt_min;
1148  }
1149  }
1150  }
1151 }
1152 
1153 static int skipped_transform_tree_unit(VVCLocalContext *lc)
1154 {
1155  const H266RawSPS *rsps = lc->fc->ps.sps->r;
1156  const CodingUnit *cu = lc->cu;
1157  int ret;
1158 
1159  if (cu->tree_type != DUAL_TREE_CHROMA)
1160  set_qp_y(lc, cu->x0, cu->y0, 0);
1161  if (rsps->sps_chroma_format_idc && cu->tree_type != DUAL_TREE_LUMA)
1162  set_qp_c(lc);
1163  ret = skipped_transform_tree(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
1164  if (ret < 0)
1165  return ret;
1166  return 0;
1167 }
1168 
1169 static void set_cb_pos(const VVCFrameContext *fc, const CodingUnit *cu)
1170 {
1171  const VVCSPS *sps = fc->ps.sps;
1172  const VVCPPS *pps = fc->ps.pps;
1173  const int log2_min_cb_size = sps->min_cb_log2_size_y;
1174  const int x_cb = cu->x0 >> log2_min_cb_size;
1175  const int y_cb = cu->y0 >> log2_min_cb_size;
1176  const int ch_type = cu->ch_type;
1177  int x, y;
1178 
1179  x = y_cb * pps->min_cb_width + x_cb;
1180  for (y = 0; y < (cu->cb_height >> log2_min_cb_size); y++) {
1181  const int width = cu->cb_width >> log2_min_cb_size;
1182 
1183  for (int i = 0; i < width; i++) {
1184  fc->tab.cb_pos_x[ch_type][x + i] = cu->x0;
1185  fc->tab.cb_pos_y[ch_type][x + i] = cu->y0;
1186  }
1187  memset(&fc->tab.cb_width[ch_type][x], cu->cb_width, width);
1188  memset(&fc->tab.cb_height[ch_type][x], cu->cb_height, width);
1189  memset(&fc->tab.cqt_depth[ch_type][x], cu->cqt_depth, width);
1190 
1191  x += pps->min_cb_width;
1192  }
1193 }
1194 
1195 static CodingUnit* alloc_cu(VVCLocalContext *lc, const int x0, const int y0)
1196 {
1197  VVCFrameContext *fc = lc->fc;
1198  const VVCSPS *sps = fc->ps.sps;
1199  const VVCPPS *pps = fc->ps.pps;
1200  const int rx = x0 >> sps->ctb_log2_size_y;
1201  const int ry = y0 >> sps->ctb_log2_size_y;
1202  CodingUnit **cus = fc->tab.cus + ry * pps->ctb_width + rx;
1203  CodingUnit *cu = av_refstruct_pool_get(fc->cu_pool);
1204 
1205  if (!cu)
1206  return NULL;
1207  cu->next = NULL;
1208 
1209  if (lc->cu)
1210  lc->cu->next = cu;
1211  else
1212  *cus = cu;
1213  lc->cu = cu;
1214 
1215  return cu;
1216 }
1217 
1218 static CodingUnit* add_cu(VVCLocalContext *lc, const int x0, const int y0,
1219  const int cb_width, const int cb_height, const int cqt_depth, const VVCTreeType tree_type)
1220 {
1221  VVCFrameContext *fc = lc->fc;
1222  const int ch_type = tree_type == DUAL_TREE_CHROMA ? 1 : 0;
1223  CodingUnit *cu = alloc_cu(lc, x0, y0);
1224 
1225  if (!cu)
1226  return NULL;
1227 
1228  memset(&cu->pu, 0, sizeof(cu->pu));
1229 
1230  lc->parse.prev_tu_cbf_y = 0;
1231 
1232  cu->sbt_flag = 0;
1233  cu->act_enabled_flag = 0;
1234 
1235  cu->tree_type = tree_type;
1236  cu->x0 = x0;
1237  cu->y0 = y0;
1238  cu->cb_width = cb_width;
1239  cu->cb_height = cb_height;
1240  cu->ch_type = ch_type;
1241  cu->cqt_depth = cqt_depth;
1242  cu->tus.head = cu->tus.tail = NULL;
1243  cu->bdpcm_flag[LUMA] = cu->bdpcm_flag[CB] = cu->bdpcm_flag[CR] = 0;
1244  cu->isp_split_type = ISP_NO_SPLIT;
1245  cu->intra_mip_flag = 0;
1246  cu->ciip_flag = 0;
1247  cu->coded_flag = 1;
1248  cu->num_intra_subpartitions = 1;
1249  cu->pu.dmvr_flag = 0;
1250 
1251  set_cb_pos(fc, cu);
1252  return cu;
1253 }
1254 
1255 static void set_cu_tabs(const VVCLocalContext *lc, const CodingUnit *cu)
1256 {
1257  const VVCFrameContext *fc = lc->fc;
1258  const PredictionUnit *pu = &cu->pu;
1259  const TransformUnit *tu = cu->tus.head;
1260 
1261  set_cb_tab(lc, fc->tab.mmi, pu->mi.motion_model_idc);
1262  set_cb_tab(lc, fc->tab.msf, pu->merge_subblock_flag);
1263  if (cu->tree_type != DUAL_TREE_CHROMA) {
1264  set_cb_tab(lc, fc->tab.skip, cu->skip_flag);
1265  set_cb_tab(lc, fc->tab.pcmf[LUMA], cu->bdpcm_flag[LUMA]);
1266  }
1267  if (cu->tree_type != DUAL_TREE_LUMA)
1268  set_cb_tab(lc, fc->tab.pcmf[CHROMA], cu->bdpcm_flag[CHROMA]);
1269 
1270  while (tu) {
1271  for (int j = 0; j < tu->nb_tbs; j++) {
1272  const TransformBlock *tb = tu->tbs + j;
1273  if (tb->c_idx != LUMA)
1274  set_qp_c_tab(lc, tu, tb);
1275  }
1276  tu = tu->next;
1277  }
1278 }
1279 
1280 //8.5.2.7 Derivation process for merge motion vector difference
1281 static void derive_mmvd(const VVCLocalContext *lc, MvField *mvf, const Mv *mmvd_offset)
1282 {
1283  const SliceContext *sc = lc->sc;
1284  Mv mmvd[2];
1285 
1286  if (mvf->pred_flag == PF_BI) {
1287  const RefPicList *rpl = sc->rpl;
1288  const int poc = lc->fc->ps.ph.poc;
1289  const int diff[] = {
1290  poc - rpl[L0].refs[mvf->ref_idx[L0]].poc,
1291  poc - rpl[L1].refs[mvf->ref_idx[L1]].poc
1292  };
1293  const int sign = FFSIGN(diff[0]) != FFSIGN(diff[1]);
1294 
1295  if (diff[0] == diff[1]) {
1296  mmvd[1] = mmvd[0] = *mmvd_offset;
1297  }
1298  else {
1299  const int i = FFABS(diff[0]) < FFABS(diff[1]);
1300  const int o = !i;
1301  mmvd[i] = *mmvd_offset;
1302  if (!rpl[L0].refs[mvf->ref_idx[L0]].is_lt && !rpl[L1].refs[mvf->ref_idx[L1]].is_lt) {
1303  ff_vvc_mv_scale(&mmvd[o], mmvd_offset, diff[i], diff[o]);
1304  }
1305  else {
1306  mmvd[o].x = sign ? -mmvd[i].x : mmvd[i].x;
1307  mmvd[o].y = sign ? -mmvd[i].y : mmvd[i].y;
1308  }
1309  }
1310  mvf->mv[0].x += mmvd[0].x;
1311  mvf->mv[0].y += mmvd[0].y;
1312  mvf->mv[1].x += mmvd[1].x;
1313  mvf->mv[1].y += mmvd[1].y;
1314  } else {
1315  const int idx = mvf->pred_flag - PF_L0;
1316  mvf->mv[idx].x += mmvd_offset->x;
1317  mvf->mv[idx].y += mmvd_offset->y;
1318  }
1319 
1320 }
1321 
1322 static void mvf_to_mi(const MvField *mvf, MotionInfo *mi)
1323 {
1324  mi->pred_flag = mvf->pred_flag;
1325  mi->bcw_idx = mvf->bcw_idx;
1326  mi->hpel_if_idx = mvf->hpel_if_idx;
1327  for (int i = 0; i < 2; i++) {
1328  const PredFlag mask = i + 1;
1329  if (mvf->pred_flag & mask) {
1330  mi->mv[i][0] = mvf->mv[i];
1331  mi->ref_idx[i] = mvf->ref_idx[i];
1332  }
1333  }
1334 }
1335 
1336 static void mv_merge_refine_pred_flag(MvField *mvf, const int width, const int height)
1337 {
1338  if (mvf->pred_flag == PF_BI && (width + height) == 12) {
1339  mvf->pred_flag = PF_L0;
1340  mvf->bcw_idx = 0;
1341  }
1342 }
1343 
1344 // subblock-based inter prediction data
1345 static void merge_data_subblock(VVCLocalContext *lc)
1346 {
1347  const VVCFrameContext *fc = lc->fc;
1348  const VVCPH *ph = &fc->ps.ph;
1349  CodingUnit* cu = lc->cu;
1350  PredictionUnit *pu = &cu->pu;
1351  int merge_subblock_idx = 0;
1352 
1353  if (ph->max_num_subblock_merge_cand > 1) {
1354  merge_subblock_idx = ff_vvc_merge_subblock_idx(lc, ph->max_num_subblock_merge_cand);
1355  }
1356  ff_vvc_sb_mv_merge_mode(lc, merge_subblock_idx, pu);
1357 }
1358 
1359 static void merge_data_regular(VVCLocalContext *lc)
1360 {
1361  const VVCFrameContext *fc = lc->fc;
1362  const VVCSPS *sps = fc->ps.sps;
1363  const VVCPH *ph = &fc->ps.ph;
1364  const CodingUnit* cu = lc->cu;
1365  PredictionUnit *pu = &lc->cu->pu;
1366  int merge_idx = 0;
1367  Mv mmvd_offset;
1368  MvField mvf;
1369 
1370  if (sps->r->sps_mmvd_enabled_flag)
1371  pu->mmvd_merge_flag = ff_vvc_mmvd_merge_flag(lc);
1372  if (pu->mmvd_merge_flag) {
1373  int mmvd_cand_flag = 0;
1374  if (sps->max_num_merge_cand > 1)
1375  mmvd_cand_flag = ff_vvc_mmvd_cand_flag(lc);
1376  ff_vvc_mmvd_offset_coding(lc, &mmvd_offset, ph->r->ph_mmvd_fullpel_only_flag);
1377  merge_idx = mmvd_cand_flag;
1378  } else if (sps->max_num_merge_cand > 1) {
1379  merge_idx = ff_vvc_merge_idx(lc);
1380  }
1381  ff_vvc_luma_mv_merge_mode(lc, merge_idx, 0, &mvf);
1382  if (pu->mmvd_merge_flag)
1383  derive_mmvd(lc, &mvf, &mmvd_offset);
1384  mv_merge_refine_pred_flag(&mvf, cu->cb_width, cu->cb_height);
1385  ff_vvc_store_mvf(lc, &mvf);
1386  mvf_to_mi(&mvf, &pu->mi);
1387 }
1388 
1389 static int ciip_flag_decode(VVCLocalContext *lc, const int ciip_avaiable, const int gpm_avaiable, const int is_128)
1390 {
1391  const VVCFrameContext *fc = lc->fc;
1392  const VVCSPS *sps = fc->ps.sps;
1393  const CodingUnit *cu = lc->cu;
1394 
1395  if (ciip_avaiable && gpm_avaiable)
1396  return ff_vvc_ciip_flag(lc);
1397  return sps->r->sps_ciip_enabled_flag && !cu->skip_flag &&
1398  !is_128 && (cu->cb_width * cu->cb_height >= 64);
1399 }
1400 
1401 static void merge_data_gpm(VVCLocalContext *lc)
1402 {
1403  const VVCFrameContext *fc = lc->fc;
1404  const VVCSPS *sps = fc->ps.sps;
1405  PredictionUnit *pu = &lc->cu->pu;
1406  int merge_gpm_idx[2];
1407 
1408  pu->merge_gpm_flag = 1;
1409  pu->gpm_partition_idx = ff_vvc_merge_gpm_partition_idx(lc);
1410  merge_gpm_idx[0] = ff_vvc_merge_gpm_idx(lc, 0);
1411  merge_gpm_idx[1] = 0;
1412  if (sps->max_num_gpm_merge_cand > 2)
1413  merge_gpm_idx[1] = ff_vvc_merge_gpm_idx(lc, 1);
1414 
1415  ff_vvc_luma_mv_merge_gpm(lc, merge_gpm_idx, pu->gpm_mv);
1416  ff_vvc_store_gpm_mvf(lc, pu);
1417 }
1418 
1419 static void merge_data_ciip(VVCLocalContext *lc)
1420 {
1421  const VVCFrameContext* fc = lc->fc;
1422  const VVCSPS* sps = fc->ps.sps;
1423  CodingUnit *cu = lc->cu;
1424  MotionInfo *mi = &cu->pu.mi;
1425  int merge_idx = 0;
1426  MvField mvf;
1427 
1428  if (sps->max_num_merge_cand > 1)
1429  merge_idx = ff_vvc_merge_idx(lc);
1430  ff_vvc_luma_mv_merge_mode(lc, merge_idx, 1, &mvf);
1431  mv_merge_refine_pred_flag(&mvf, cu->cb_width, cu->cb_height);
1432  ff_vvc_store_mvf(lc, &mvf);
1433  mvf_to_mi(&mvf, mi);
1434  cu->intra_pred_mode_y = cu->intra_pred_mode_c = INTRA_PLANAR;
1435  cu->intra_luma_ref_idx = 0;
1436  cu->intra_mip_flag = 0;
1437 }
1438 
1439 // block-based inter prediction data
1440 static void merge_data_block(VVCLocalContext *lc)
1441 {
1442  const VVCFrameContext* fc = lc->fc;
1443  const VVCSPS *sps = fc->ps.sps;
1444  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1445  CodingUnit *cu = lc->cu;
1446  const int cb_width = cu->cb_width;
1447  const int cb_height = cu->cb_height;
1448  const int is_128 = cb_width == 128 || cb_height == 128;
1449  const int ciip_avaiable = sps->r->sps_ciip_enabled_flag &&
1450  !cu->skip_flag && (cb_width * cb_height >= 64);
1451  const int gpm_avaiable = sps->r->sps_gpm_enabled_flag && IS_B(rsh) &&
1452  (cb_width >= 8) && (cb_height >=8) &&
1453  (cb_width < 8 * cb_height) && (cb_height < 8 *cb_width);
1454 
1455  int regular_merge_flag = 1;
1456 
1457  if (!is_128 && (ciip_avaiable || gpm_avaiable))
1458  regular_merge_flag = ff_vvc_regular_merge_flag(lc, cu->skip_flag);
1459  if (regular_merge_flag) {
1460  merge_data_regular(lc);
1461  } else {
1462  cu->ciip_flag = ciip_flag_decode(lc, ciip_avaiable, gpm_avaiable, is_128);
1463  if (cu->ciip_flag)
1464  merge_data_ciip(lc);
1465  else
1466  merge_data_gpm(lc);
1467  }
1468 }
1469 
1470 static int merge_data_ibc(VVCLocalContext *lc)
1471 {
1472  const VVCFrameContext* fc = lc->fc;
1473  const VVCSPS* sps = fc->ps.sps;
1474  MotionInfo *mi = &lc->cu->pu.mi;
1475  int merge_idx = 0;
1476  int ret;
1477 
1478  mi->pred_flag = PF_IBC;
1479 
1480  if (sps->max_num_ibc_merge_cand > 1)
1481  merge_idx = ff_vvc_merge_idx(lc);
1482 
1483  ret = ff_vvc_luma_mv_merge_ibc(lc, merge_idx, &mi->mv[L0][0]);
1484  if (ret)
1485  return ret;
1486  ff_vvc_store_mv(lc, mi);
1487 
1488  return 0;
1489 }
1490 
1491 static int hls_merge_data(VVCLocalContext *lc)
1492 {
1493  const VVCFrameContext *fc = lc->fc;
1494  const VVCPH *ph = &fc->ps.ph;
1495  const CodingUnit *cu = lc->cu;
1496  PredictionUnit *pu = &lc->cu->pu;
1497  int ret;
1498 
1499  pu->merge_gpm_flag = 0;
1500  pu->mi.num_sb_x = pu->mi.num_sb_y = 1;
1501  if (cu->pred_mode == MODE_IBC) {
1502  ret = merge_data_ibc(lc);
1503  if (ret)
1504  return ret;
1505  } else {
1506  if (ph->max_num_subblock_merge_cand > 0 && cu->cb_width >= 8 && cu->cb_height >= 8)
1507  pu->merge_subblock_flag = ff_vvc_merge_subblock_flag(lc);
1508  if (pu->merge_subblock_flag)
1509  merge_data_subblock(lc);
1510  else
1511  merge_data_block(lc);
1512  }
1513  return 0;
1514 }
1515 
1516 static void hls_mvd_coding(VVCLocalContext *lc, Mv* mvd)
1517 {
1518  int32_t mv[2];
1519 
1520  for (int i = 0; i < 2; i++) {
1521  mv[i] = ff_vvc_abs_mvd_greater0_flag(lc);
1522  }
1523 
1524  for (int i = 0; i < 2; i++) {
1525  if (mv[i])
1526  mv[i] += ff_vvc_abs_mvd_greater1_flag(lc);
1527  }
1528 
1529  for (int i = 0; i < 2; i++) {
1530  if (mv[i] > 0) {
1531  if (mv[i] == 2)
1532  mv[i] += ff_vvc_abs_mvd_minus2(lc);
1533  mv[i] = (1 - 2 * ff_vvc_mvd_sign_flag(lc)) * mv[i];
1534  }
1535  }
1536  mvd->x = mv[0];
1537  mvd->y = mv[1];
1538 }
1539 
1540 static int bcw_idx_decode(VVCLocalContext *lc, const MotionInfo *mi, const int cb_width, const int cb_height)
1541 {
1542  const VVCFrameContext *fc = lc->fc;
1543  const VVCSPS *sps = fc->ps.sps;
1544  const VVCPPS *pps = fc->ps.pps;
1545  const VVCPH *ph = &fc->ps.ph;
1546  const VVCSH *sh = &lc->sc->sh;
1547  const PredWeightTable *w = pps->r->pps_wp_info_in_ph_flag ? &ph->pwt : &sh->pwt;
1548  int bcw_idx = 0;
1549 
1550  if (sps->r->sps_bcw_enabled_flag && mi->pred_flag == PF_BI &&
1551  !w->weight_flag[L0][LUMA][mi->ref_idx[0]] &&
1552  !w->weight_flag[L1][LUMA][mi->ref_idx[1]] &&
1553  !w->weight_flag[L0][CHROMA][mi->ref_idx[0]] &&
1554  !w->weight_flag[L1][CHROMA][mi->ref_idx[1]] &&
1555  cb_width * cb_height >= 256) {
1556  bcw_idx = ff_vvc_bcw_idx(lc, ff_vvc_no_backward_pred_flag(lc));
1557  }
1558  return bcw_idx;
1559 }
1560 
1561 static int8_t ref_idx_decode(VVCLocalContext *lc, const VVCSH *sh, const int sym_mvd_flag, const int lx)
1562 {
1563  const H266RawSliceHeader *rsh = sh->r;
1564  int ref_idx = 0;
1565 
1566  if (rsh->num_ref_idx_active[lx] > 1 && !sym_mvd_flag)
1567  ref_idx = ff_vvc_ref_idx_lx(lc, rsh->num_ref_idx_active[lx]);
1568  else if (sym_mvd_flag)
1569  ref_idx = sh->ref_idx_sym[lx];
1570  return ref_idx;
1571 }
1572 
1573 static int mvds_decode(VVCLocalContext *lc, Mv mvds[2][MAX_CONTROL_POINTS],
1574  const int num_cp_mv, const int lx)
1575 {
1576  const VVCFrameContext *fc = lc->fc;
1577  const VVCPH *ph = &fc->ps.ph;
1578  const PredictionUnit *pu = &lc->cu->pu;
1579  const MotionInfo *mi = &pu->mi;
1580  int has_no_zero_mvd = 0;
1581 
1582  if (lx == L1 && ph->r->ph_mvd_l1_zero_flag && mi->pred_flag == PF_BI) {
1583  for (int j = 0; j < num_cp_mv; j++)
1584  AV_ZERO64(&mvds[lx][j]);
1585  } else {
1586  Mv *mvd0 = &mvds[lx][0];
1587  if (lx == L1 && pu->sym_mvd_flag) {
1588  mvd0->x = -mvds[L0][0].x;
1589  mvd0->y = -mvds[L0][0].y;
1590  } else {
1591  hls_mvd_coding(lc, mvd0);
1592  }
1593  has_no_zero_mvd |= (mvd0->x || mvd0->y);
1594  for (int j = 1; j < num_cp_mv; j++) {
1595  Mv *mvd = &mvds[lx][j];
1596  hls_mvd_coding(lc, mvd);
1597  mvd->x += mvd0->x;
1598  mvd->y += mvd0->y;
1599  has_no_zero_mvd |= (mvd->x || mvd->y);
1600  }
1601  }
1602  return has_no_zero_mvd;
1603 }
1604 
1605 static void mvp_add_difference(MotionInfo *mi, const int num_cp_mv,
1606  const Mv mvds[2][MAX_CONTROL_POINTS], const int amvr_shift)
1607 {
1608  for (int i = 0; i < 2; i++) {
1609  const PredFlag mask = i + PF_L0;
1610  if (mi->pred_flag & mask) {
1611  for (int j = 0; j < num_cp_mv; j++) {
1612  const Mv *mvd = &mvds[i][j];
1613  mi->mv[i][j].x += mvd->x * (1 << amvr_shift);
1614  mi->mv[i][j].y += mvd->y * (1 << amvr_shift);
1615  }
1616  }
1617  }
1618 }
1619 
1620 static int mvp_data_ibc(VVCLocalContext *lc)
1621 {
1622  const VVCFrameContext *fc = lc->fc;
1623  const CodingUnit *cu = lc->cu;
1624  const PredictionUnit *pu = &lc->cu->pu;
1625  const VVCSPS *sps = fc->ps.sps;
1626  MotionInfo *mi = &lc->cu->pu.mi;
1627  int mvp_l0_flag = 0;
1628  int amvr_shift = 4;
1629  Mv *mv = &mi->mv[L0][0];
1630  int ret;
1631 
1632  mi->pred_flag = PF_IBC;
1633  mi->num_sb_x = 1;
1634  mi->num_sb_y = 1;
1635 
1636  hls_mvd_coding(lc, mv);
1637  if (sps->max_num_ibc_merge_cand > 1)
1638  mvp_l0_flag = ff_vvc_mvp_lx_flag(lc);
1639  if (sps->r->sps_amvr_enabled_flag && (mv->x || mv->y))
1640  amvr_shift = ff_vvc_amvr_shift(lc, pu->inter_affine_flag, cu->pred_mode, 1);
1641 
1642  ret = ff_vvc_mvp_ibc(lc, mvp_l0_flag, amvr_shift, mv);
1643  if (ret)
1644  return ret;
1645  ff_vvc_store_mv(lc, mi);
1646 
1647  return 0;
1648 }
1649 
1650 static int mvp_data(VVCLocalContext *lc)
1651 {
1652  const VVCFrameContext *fc = lc->fc;
1653  const CodingUnit *cu = lc->cu;
1654  PredictionUnit *pu = &lc->cu->pu;
1655  const VVCSPS *sps = fc->ps.sps;
1656  const VVCPH *ph = &fc->ps.ph;
1657  const VVCSH *sh = &lc->sc->sh;
1658  const H266RawSliceHeader *rsh = sh->r;
1659  MotionInfo *mi = &pu->mi;
1660  const int cb_width = cu->cb_width;
1661  const int cb_height = cu->cb_height;
1662 
1663  int mvp_lx_flag[2] = {0};
1664  int cu_affine_type_flag = 0;
1665  int num_cp_mv;
1666  int amvr_enabled, has_no_zero_mvd = 0, amvr_shift;
1667  Mv mvds[2][MAX_CONTROL_POINTS];
1668 
1669  mi->pred_flag = ff_vvc_pred_flag(lc, IS_B(rsh));
1670  if (sps->r->sps_affine_enabled_flag && cb_width >= 16 && cb_height >= 16) {
1671  pu->inter_affine_flag = ff_vvc_inter_affine_flag(lc);
1672  set_cb_tab(lc, fc->tab.iaf, pu->inter_affine_flag);
1673  if (sps->r->sps_6param_affine_enabled_flag && pu->inter_affine_flag)
1674  cu_affine_type_flag = ff_vvc_cu_affine_type_flag(lc);
1675  }
1676  mi->motion_model_idc = pu->inter_affine_flag + cu_affine_type_flag;
1677  num_cp_mv = mi->motion_model_idc + 1;
1678 
1679  if (sps->r->sps_smvd_enabled_flag && !ph->r->ph_mvd_l1_zero_flag &&
1680  mi->pred_flag == PF_BI && !pu->inter_affine_flag &&
1681  sh->ref_idx_sym[0] > -1 && sh->ref_idx_sym[1] > -1)
1682  pu->sym_mvd_flag = ff_vvc_sym_mvd_flag(lc);
1683 
1684  for (int i = L0; i <= L1; i++) {
1685  const PredFlag pred_flag = PF_L0 + !i;
1686  if (mi->pred_flag != pred_flag) {
1687  mi->ref_idx[i] = ref_idx_decode(lc, sh, pu->sym_mvd_flag, i);
1688  has_no_zero_mvd |= mvds_decode(lc, mvds, num_cp_mv, i);
1689  mvp_lx_flag[i] = ff_vvc_mvp_lx_flag(lc);
1690  }
1691  }
1692 
1693  amvr_enabled = mi->motion_model_idc == MOTION_TRANSLATION ?
1694  sps->r->sps_amvr_enabled_flag : sps->r->sps_affine_amvr_enabled_flag;
1695  amvr_enabled &= has_no_zero_mvd;
1696 
1697  amvr_shift = ff_vvc_amvr_shift(lc, pu->inter_affine_flag, cu->pred_mode, amvr_enabled);
1698 
1699  mi->hpel_if_idx = amvr_shift == 3;
1700  mi->bcw_idx = bcw_idx_decode(lc, mi, cb_width, cb_height);
1701 
1702  if (mi->motion_model_idc)
1703  ff_vvc_affine_mvp(lc, mvp_lx_flag, amvr_shift, mi);
1704  else
1705  ff_vvc_mvp(lc, mvp_lx_flag, amvr_shift, mi);
1706 
1707  mvp_add_difference(mi, num_cp_mv, mvds, amvr_shift);
1708 
1709  if (mi->motion_model_idc)
1710  ff_vvc_store_sb_mvs(lc, pu);
1711  else
1712  ff_vvc_store_mv(lc, &pu->mi);
1713 
1714  return 0;
1715 }
1716 
1717 // derive bdofFlag from 8.5.6 Decoding process for inter blocks
1718 // derive dmvr from 8.5.1 General decoding process for coding units coded in inter prediction mode
1719 static void derive_dmvr_bdof_flag(const VVCLocalContext *lc, PredictionUnit *pu)
1720 {
1721  const VVCFrameContext *fc = lc->fc;
1722  const VVCPPS *pps = fc->ps.pps;
1723  const VVCPH *ph = &fc->ps.ph;
1724  const VVCSH *sh = &lc->sc->sh;
1725  const int poc = ph->poc;
1726  const MotionInfo *mi = &pu->mi;
1727  const int8_t *ref_idx = mi->ref_idx;
1728  const VVCRefPic *rp0 = &lc->sc->rpl[L0].refs[ref_idx[L0]];
1729  const VVCRefPic *rp1 = &lc->sc->rpl[L1].refs[ref_idx[L1]];
1730  const CodingUnit *cu = lc->cu;
1731  const PredWeightTable *w = pps->r->pps_wp_info_in_ph_flag ? &fc->ps.ph.pwt : &sh->pwt;
1732 
1733  pu->bdof_flag = 0;
1734 
1735  if (mi->pred_flag == PF_BI &&
1736  (poc - rp0->poc == rp1->poc - poc) &&
1737  !rp0->is_lt && !rp1->is_lt &&
1738  !cu->ciip_flag &&
1739  !mi->bcw_idx &&
1740  !w->weight_flag[L0][LUMA][ref_idx[L0]] && !w->weight_flag[L1][LUMA][ref_idx[L1]] &&
1741  !w->weight_flag[L0][CHROMA][ref_idx[L0]] && !w->weight_flag[L1][CHROMA][ref_idx[L1]] &&
1742  cu->cb_width >= 8 && cu->cb_height >= 8 &&
1743  (cu->cb_width * cu->cb_height >= 128) &&
1744  !rp0->is_scaled && !rp1->is_scaled) {
1745  if (!ph->r->ph_bdof_disabled_flag &&
1746  mi->motion_model_idc == MOTION_TRANSLATION &&
1747  !pu->merge_subblock_flag &&
1748  !pu->sym_mvd_flag)
1749  pu->bdof_flag = 1;
1750  if (!ph->r->ph_dmvr_disabled_flag &&
1751  pu->general_merge_flag &&
1752  !pu->mmvd_merge_flag)
1753  pu->dmvr_flag = 1;
1754  }
1755 }
1756 
1757 // part of 8.5.1 General decoding process for coding units coded in inter prediction mode
1758 static void refine_regular_subblock(const VVCLocalContext *lc)
1759 {
1760  const CodingUnit *cu = lc->cu;
1761  PredictionUnit *pu = &lc->cu->pu;
1762 
1763  derive_dmvr_bdof_flag(lc, pu);
1764  if (pu->dmvr_flag || pu->bdof_flag) {
1765  pu->mi.num_sb_x = (cu->cb_width > 16) ? (cu->cb_width >> 4) : 1;
1766  pu->mi.num_sb_y = (cu->cb_height > 16) ? (cu->cb_height >> 4) : 1;
1767  }
1768 }
1769 
1770 static void fill_dmvr_info(const VVCLocalContext *lc)
1771 {
1772  const VVCFrameContext *fc = lc->fc;
1773  const CodingUnit *cu = lc->cu;
1774 
1775  if (cu->pred_mode == MODE_IBC || cu->pred_mode == MODE_PLT) {
1776  ff_vvc_set_intra_mvf(lc, true, cu->pred_mode == MODE_IBC ? PF_IBC : PF_PLT, false);
1777  } else {
1778  const VVCPPS *pps = fc->ps.pps;
1779  const int w = cu->cb_width >> MIN_PU_LOG2;
1780 
1781  for (int y = cu->y0 >> MIN_PU_LOG2; y < (cu->y0 + cu->cb_height) >> MIN_PU_LOG2; y++) {
1782  const int idx = pps->min_pu_width * y + (cu->x0 >> MIN_PU_LOG2);
1783  const MvField *mvf = fc->tab.mvf + idx;
1784  MvField *dmvr_mvf = fc->ref->tab_dmvr_mvf + idx;
1785 
1786  memcpy(dmvr_mvf, mvf, sizeof(MvField) * w);
1787  }
1788  }
1789 }
1790 
1791 static int inter_data(VVCLocalContext *lc)
1792 {
1793  const CodingUnit *cu = lc->cu;
1794  PredictionUnit *pu = &lc->cu->pu;
1795  const MotionInfo *mi = &pu->mi;
1796  int ret = 0;
1797 
1798  pu->general_merge_flag = 1;
1799  if (!cu->skip_flag)
1800  pu->general_merge_flag = ff_vvc_general_merge_flag(lc);
1801 
1802  if (pu->general_merge_flag) {
1803  ret = hls_merge_data(lc);
1804  } else if (cu->pred_mode == MODE_IBC) {
1805  ret = mvp_data_ibc(lc);
1806  } else {
1807  ret = mvp_data(lc);
1808  }
1809 
1810  if (ret)
1811  return ret;
1812 
1813  if (cu->pred_mode == MODE_IBC) {
1814  ff_vvc_update_hmvp(lc, mi);
1815  } else if (!pu->merge_gpm_flag && !pu->inter_affine_flag && !pu->merge_subblock_flag) {
1816  refine_regular_subblock(lc);
1817  ff_vvc_update_hmvp(lc, mi);
1818  }
1819 
1820  if (!pu->dmvr_flag)
1821  fill_dmvr_info(lc);
1822  return ret;
1823 }
1824 
1825 static TransformUnit* palette_add_tu(VVCLocalContext *lc, const int start, const int end, const VVCTreeType tree_type)
1826 {
1827  CodingUnit *cu = lc->cu;
1828  const VVCSPS *sps = lc->fc->ps.sps;
1829  TransformUnit *tu = add_tu(lc->fc, cu, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
1830 
1831  if (!tu)
1832  return NULL;
1833 
1834  for (int c = start; c < end; c++) {
1835  const int w = tu->width >> sps->hshift[c];
1836  const int h = tu->height >> sps->vshift[c];
1837  TransformBlock *tb = add_tb(tu, lc, tu->x0, tu->y0, w, h, c);
1838  if (c != CR)
1839  set_tb_size(lc->fc, tb);
1840  }
1841 
1842  for (int i = 0; i < FF_ARRAY_ELEMS(cu->plt); i++)
1843  cu->plt[i].size = 0;
1844 
1845  return tu;
1846 }
1847 
1848 static int palette_predicted(VVCLocalContext *lc, const bool local_dual_tree, int start, int end,
1849  bool *predictor_reused, const int predictor_size, const int max_entries)
1850 {
1851  CodingUnit *cu = lc->cu;
1852  int nb_predicted = 0;
1853 
1854  if (local_dual_tree) {
1855  start = LUMA;
1856  end = VVC_MAX_SAMPLE_ARRAYS;
1857  }
1858 
1859  for (int i = 0; i < predictor_size && nb_predicted < max_entries; i++) {
1860  const int run = ff_vvc_palette_predictor_run(lc);
1861  if (run == 1)
1862  break;
1863 
1864  if (run > 1)
1865  i += run - 1;
1866 
1867  if (i >= predictor_size)
1868  return AVERROR_INVALIDDATA;
1869 
1870  predictor_reused[i] = true;
1871  for (int c = start; c < end; c++)
1872  cu->plt[c].entries[nb_predicted] = lc->ep->pp[c].entries[i];
1873  nb_predicted++;
1874  }
1875 
1876  for (int c = start; c < end; c++)
1877  cu->plt[c].size = nb_predicted;
1878 
1879  return 0;
1880 }
1881 
1882 static int palette_signaled(VVCLocalContext *lc, const bool local_dual_tree,
1883  const int start, const int end, const int max_entries)
1884 {
1885  const VVCSPS *sps = lc->fc->ps.sps;
1886  CodingUnit *cu = lc->cu;
1887  const int nb_predicted = cu->plt[start].size;
1888  const int nb_signaled = nb_predicted < max_entries ? ff_vvc_num_signalled_palette_entries(lc) : 0;
1889  const int size = nb_predicted + nb_signaled;
1890  const bool dual_tree_luma = local_dual_tree && cu->tree_type == DUAL_TREE_LUMA;
1891 
1892  if (size > max_entries || nb_signaled < 0)
1893  return AVERROR_INVALIDDATA;
1894 
1895  for (int c = start; c < end; c++) {
1896  Palette *plt = cu->plt + c;
1897  for (int i = nb_predicted; i < size; i++) {
1898  plt->entries[i] = ff_vvc_new_palette_entries(lc, sps->bit_depth);
1899  if (dual_tree_luma) {
1900  plt[CB].entries[i] = 1 << (sps->bit_depth - 1);
1901  plt[CR].entries[i] = 1 << (sps->bit_depth - 1);
1902  }
1903  }
1904  plt->size = size;
1905  }
1906 
1907  return 0;
1908 }
1909 
1910 static void palette_update_predictor(VVCLocalContext *lc, const bool local_dual_tree, int start, int end,
1911  bool *predictor_reused, const int predictor_size)
1912 {
1913  CodingUnit *cu = lc->cu;
1914  const int max_predictor = VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE >> (cu->tree_type != SINGLE_TREE && !local_dual_tree);
1915 
1916  if (local_dual_tree) {
1917  start = LUMA;
1918  end = VVC_MAX_SAMPLE_ARRAYS;
1919  }
1920 
1921  for (int c = start; c < end; c++) {
1922  Palette *pp = lc->ep->pp + c;
1923  Palette *plt = cu->plt + c;
1924  int i = cu->plt[start].size;;
1925 
1926  // copy unused predictors to the end of plt
1927  for (int j = 0; j < predictor_size && i < max_predictor; j++) {
1928  if (!predictor_reused[j]) {
1929  plt->entries[i] = pp->entries[j];
1930  i++;
1931  }
1932  }
1933 
1934  memcpy(pp->entries, plt->entries, i * sizeof(pp->entries[0]));
1935  pp->size = i;
1936  }
1937 }
1938 
1939 static void palette_qp(VVCLocalContext *lc, VVCTreeType tree_type, const bool escape_present)
1940 {
1941  const VVCFrameContext *fc = lc->fc;
1942  const VVCPPS *pps = fc->ps.pps;
1943  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1944  const CodingUnit *cu = lc->cu;
1945 
1946  if (tree_type != DUAL_TREE_CHROMA) {
1947  const bool has_qp_delta = escape_present &&
1948  pps->r->pps_cu_qp_delta_enabled_flag && !lc->parse.is_cu_qp_delta_coded;
1949  set_qp_y(lc, cu->x0, cu->y0, has_qp_delta);
1950  }
1951 
1952  if (tree_type != DUAL_TREE_LUMA) {
1953  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && !lc->parse.is_cu_chroma_qp_offset_coded)
1954  chroma_qp_offset_decode(lc, 0, 1);
1955  set_qp_c(lc);
1956  }
1957 }
1958 
1959 #define PALETTE_SET_PIXEL(xc, yc, pix) \
1960  do { \
1961  const int off = ((xc) >> hs) + ((yc) >> vs) * tb->tb_width; \
1962  if (sps->bit_depth == 8) \
1963  u8[off] = pix; \
1964  else \
1965  u16[off] = pix; \
1966  } while (0)
1967 
1968 #define PALETTE_INDEX(x, y) index[(y) * cu->cb_width + (x)]
1969 
1970 // 6.5.3 Horizontal and vertical traverse scan order array initialization process
1971 // The hTravScan and vTravScan tables require approximately 576 KB of memory.
1972 // To save space, we use a macro to achieve the same functionality.
1973 #define TRAV_COL(p, wlog, mask) ((p & mask) ^ (-((p >> wlog) & 1) & mask))
1974 #define TRAV_ROW(p, hlog) (p >> hlog)
1975 #define TRAV(trans, p, wlog, hlog, mask) (trans ? TRAV_ROW((p), hlog) : TRAV_COL((p), wlog, mask))
1976 #define TRAV_X(pos) TRAV(transpose, pos, wlog2, hlog2, wmask)
1977 #define TRAV_Y(pos) TRAV(!transpose, pos, hlog2, wlog2, hmask)
1978 
1979 static int palette_subblock_data(VVCLocalContext *lc,
1980  const int max_index, const int subset_id, const bool transpose,
1981  uint8_t *run_type, uint8_t *index, int *prev_run_pos, bool *adjust)
1982 {
1983  const CodingUnit *cu = lc->cu;
1984  TransformUnit *tu = cu->tus.head;
1985  const VVCSPS *sps = lc->fc->ps.sps;
1986  const int min_pos = subset_id << 4;
1987  const int max_pos = FFMIN(min_pos + 16, cu->cb_width * cu->cb_height);
1988  const int wmask = cu->cb_width - 1;
1989  const int hmask = cu->cb_height - 1;
1990  const int wlog2 = av_log2(cu->cb_width);
1991  const int hlog2 = av_log2(cu->cb_height);
1992  const uint8_t esc = cu->plt[tu->tbs[0].c_idx].size;
1993  uint8_t run_copy[16] = { 0 };
1994 
1995  for (int i = min_pos; i < max_pos; i++) {
1996  const int xc = TRAV_X(i);
1997  const int yc = TRAV_Y(i);
1998 
1999  if (i > 0 && max_index > 0)
2000  run_copy[i - min_pos] = ff_vvc_run_copy_flag(lc, run_type[i - 1], *prev_run_pos, i);
2001 
2002  run_type[i] = 0;
2003  if (max_index > 0 && !run_copy[i - min_pos]) {
2004  if (((!transpose && yc > 0) || (transpose && xc > 0))
2005  && i > 0 && !run_type[i - 1]) {
2006  run_type[i] = ff_vvc_copy_above_palette_indices_flag(lc);
2007  }
2008  *prev_run_pos = i;
2009  } else if (i > 0) {
2010  run_type[i] = run_type[i - 1];
2011  }
2012  }
2013 
2014  for (int i = min_pos; i < max_pos; i++) {
2015  const int xc = TRAV_X(i);
2016  const int yc = TRAV_Y(i);
2017  const int prev_xc = i > 0 ? TRAV_X(i - 1) : 0;
2018  const int prev_yc = i > 0 ? TRAV_Y(i - 1) : 0;
2019 
2020  int idx = 0;
2021  if (max_index > 0 && !run_copy[i - min_pos] && !run_type[i]) {
2022  if (max_index - *adjust > 0)
2023  idx = ff_vvc_palette_idx_idc(lc, max_index, *adjust);
2024  if (i > 0) {
2025  const int ref_idx = !run_type[i - 1] ?
2026  PALETTE_INDEX(prev_xc, prev_yc) : PALETTE_INDEX(xc - transpose, yc - !transpose);
2027  idx += (idx >= ref_idx);
2028  }
2029  *adjust = true;
2030  } else {
2031  idx = PALETTE_INDEX(prev_xc, prev_yc);
2032  }
2033 
2034  if (!run_type[i])
2035  PALETTE_INDEX(xc, yc) = idx;
2036  else
2037  PALETTE_INDEX(xc, yc) = PALETTE_INDEX(xc - transpose, yc - !transpose);
2038  }
2039 
2040  for (int c = 0; c < tu->nb_tbs; c++) {
2041  TransformBlock *tb = &tu->tbs[c];
2042  const Palette *plt = cu->plt + tb->c_idx;
2043  const int scale = ff_vvc_palette_derive_scale(lc, tu, tb);
2044  const int hs = sps->hshift[c];
2045  const int vs = sps->vshift[c];
2046  uint8_t *u8 = (uint8_t *)tb->coeffs;
2047  uint16_t *u16 = (uint16_t *)tb->coeffs;
2048 
2049  for (int i = min_pos; i < max_pos; i++) {
2050  const int xc = TRAV_X(i);
2051  const int yc = TRAV_Y(i);
2052  if (!(xc & hs) && !(yc & vs)) {
2053  const int v = PALETTE_INDEX(xc, yc);
2054  if (v == esc) {
2055  const int coeff = ff_vvc_palette_escape_val(lc);
2056  if (coeff >= (1U << sps->bit_depth))
2057  return AVERROR_INVALIDDATA;
2058  const int pixel = av_clip_intp2(RSHIFT(coeff * scale, 6), sps->bit_depth);
2059  PALETTE_SET_PIXEL(xc, yc, pixel);
2060  } else {
2061  PALETTE_SET_PIXEL(xc, yc, plt->entries[v]);
2062  }
2063  }
2064  }
2065  }
2066 
2067  return 0;
2068 }
2069 
2070 static int hls_palette_coding(VVCLocalContext *lc, const VVCTreeType tree_type)
2071 {
2072  const VVCFrameContext *fc = lc->fc;
2073  const VVCSPS *sps = fc->ps.sps;
2074  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2075  CodingUnit *cu = lc->cu;
2076  Palette *pp = lc->ep->pp;
2077  const int max_entries = tree_type == SINGLE_TREE ? 31 : 15;
2078  const bool local_dual_tree = tree_type != SINGLE_TREE &&
2079  (!IS_I(rsh) || (IS_I(rsh) && !sps->r->sps_qtbtt_dual_tree_intra_flag));
2080  bool escape_present = false;
2081  bool transpose = false;
2082  bool adjust = false;
2083  int max_index = 0;
2084  int prev_run_pos = 0;
2085 
2086  int predictor_size, start, end, ret;
2087  bool reused[VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE];
2088  uint8_t run_type[MAX_PALETTE_CU_SIZE * MAX_PALETTE_CU_SIZE];
2089  uint8_t index[MAX_PALETTE_CU_SIZE * MAX_PALETTE_CU_SIZE];
2090 
2091  ff_vvc_channel_range(&start, &end, tree_type, sps->r->sps_chroma_format_idc);
2092 
2093  if (!palette_add_tu(lc, start, end, tree_type))
2094  return AVERROR(ENOMEM);
2095 
2096  predictor_size = pp[start].size;
2097  memset(reused, 0, sizeof(reused[0]) * predictor_size);
2098 
2099  ret = palette_predicted(lc, local_dual_tree, start, end, reused, predictor_size, max_entries);
2100  if (ret < 0)
2101  return ret;
2102 
2103  ret = palette_signaled(lc, local_dual_tree, start, end, max_entries);
2104  if (ret < 0)
2105  return ret;
2106 
2107  palette_update_predictor(lc, local_dual_tree, start, end, reused, predictor_size);
2108 
2109  if (cu->plt[start].size > 0)
2110  escape_present = ff_vvc_palette_escape_val_present_flag(lc);
2111 
2112  max_index = cu->plt[start].size - 1 + escape_present;
2113  if (max_index > 0) {
2114  adjust = false;
2115  transpose = ff_vvc_palette_transpose_flag(lc);
2116  }
2117 
2118  palette_qp(lc, tree_type, escape_present);
2119 
2120  index[0] = 0;
2121  for (int i = 0; i <= (cu->cb_width * cu->cb_height - 1) >> 4; i++)
2122  palette_subblock_data(lc, max_index, i, transpose,
2123  run_type, index, &prev_run_pos, &adjust);
2124 
2125  return 0;
2126 }
2127 
2128 static int intra_data(VVCLocalContext *lc)
2129 {
2130  const VVCSPS *sps = lc->fc->ps.sps;
2131  const CodingUnit *cu = lc->cu;
2132  const VVCTreeType tree_type = cu->tree_type;
2133  const bool pred_mode_plt_flag = cu->pred_mode == MODE_PLT;
2134  int ret = 0;
2135 
2136  if (tree_type == SINGLE_TREE || tree_type == DUAL_TREE_LUMA) {
2137  if (pred_mode_plt_flag) {
2138  if ((ret = hls_palette_coding(lc, tree_type)) < 0)
2139  return ret;
2140  ff_vvc_set_intra_mvf(lc, false, PF_PLT, false);
2141  } else {
2142  intra_luma_pred_modes(lc);
2143  ff_vvc_set_intra_mvf(lc, false, PF_INTRA, cu->ciip_flag);
2144  }
2145  }
2146  if ((tree_type == SINGLE_TREE || tree_type == DUAL_TREE_CHROMA) && sps->r->sps_chroma_format_idc) {
2147  if (pred_mode_plt_flag && tree_type == DUAL_TREE_CHROMA) {
2148  if ((ret = hls_palette_coding(lc, tree_type)) < 0)
2149  return ret;
2150  } else if (!pred_mode_plt_flag) {
2151  intra_chroma_pred_modes(lc);
2152  }
2153  }
2154 
2155  return ret;
2156 }
2157 
2158 static int hls_coding_unit(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height,
2159  int cqt_depth, const VVCTreeType tree_type, VVCModeType mode_type)
2160 {
2161  const VVCFrameContext *fc = lc->fc;
2162  const VVCSPS *sps = fc->ps.sps;
2163  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2164  const int is_128 = cb_width > 64 || cb_height > 64;
2165  int ret = 0;
2166 
2167  CodingUnit *cu = add_cu(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type);
2168 
2169  if (!cu)
2170  return AVERROR(ENOMEM);
2171 
2172  ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
2173 
2174  if (IS_I(rsh) && is_128)
2175  mode_type = MODE_TYPE_INTRA;
2176  cu->pred_mode = pred_mode_decode(lc, tree_type, mode_type);
2177 
2178  if (cu->pred_mode == MODE_INTRA && sps->r->sps_act_enabled_flag && tree_type == SINGLE_TREE)
2179  cu->act_enabled_flag = ff_vvc_cu_act_enabled_flag(lc);
2180 
2181  if (cu->pred_mode == MODE_INTRA || cu->pred_mode == MODE_PLT)
2182  ret = intra_data(lc);
2183  else if (tree_type != DUAL_TREE_CHROMA) /* MODE_INTER or MODE_IBC */
2184  ret = inter_data(lc);
2185 
2186  if (ret < 0)
2187  return ret;
2188 
2189  if (cu->pred_mode != MODE_INTRA && cu->pred_mode != MODE_PLT && !lc->cu->pu.general_merge_flag)
2190  cu->coded_flag = ff_vvc_cu_coded_flag(lc);
2191  else
2192  cu->coded_flag = !(cu->skip_flag || cu->pred_mode == MODE_PLT);
2193 
2194  if (cu->coded_flag) {
2195  sbt_info(lc, sps);
2196  if (sps->r->sps_act_enabled_flag && cu->pred_mode != MODE_INTRA && tree_type == SINGLE_TREE)
2197  cu->act_enabled_flag = ff_vvc_cu_act_enabled_flag(lc);
2198  lc->parse.lfnst_dc_only = 1;
2199  lc->parse.lfnst_zero_out_sig_coeff_flag = 1;
2200  lc->parse.mts_dc_only = 1;
2201  lc->parse.mts_zero_out_sig_coeff_flag = 1;
2202  ret = hls_transform_tree(lc, x0, y0, cb_width, cb_height, cu->ch_type);
2203  if (ret < 0)
2204  return ret;
2205  cu->lfnst_idx = lfnst_idx_decode(lc);
2206  cu->mts_idx = mts_idx_decode(lc);
2207  set_qp_c(lc);
2208  } else if (cu->pred_mode != MODE_PLT) {
2209  ret = skipped_transform_tree_unit(lc);
2210  if (ret < 0)
2211  return ret;
2212  }
2213  set_cu_tabs(lc, cu);
2214 
2215  return 0;
2216 }
2217 
2218 static int derive_mode_type_condition(const VVCLocalContext *lc,
2219  const VVCSplitMode split, const int cb_width, const int cb_height, const VVCModeType mode_type_curr)
2220 {
2221  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2222  const VVCSPS *sps = lc->fc->ps.sps;
2223  const int area = cb_width * cb_height;
2224 
2225  if ((IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag) ||
2226  mode_type_curr != MODE_TYPE_ALL || !sps->r->sps_chroma_format_idc ||
2227  sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444)
2228  return 0;
2229  if ((area == 64 && (split == SPLIT_QT || split == SPLIT_TT_HOR || split == SPLIT_TT_VER)) ||
2230  (area == 32 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER)))
2231  return 1;
2232  if ((area == 64 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
2233  (area == 128 && (split == SPLIT_TT_HOR || split == SPLIT_TT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
2234  (cb_width == 8 && split == SPLIT_BT_VER) || (cb_width == 16 && split == SPLIT_TT_VER))
2235  return 1 + !IS_I(rsh);
2236 
2237  return 0;
2238 }
2239 
2240 static VVCModeType mode_type_decode(VVCLocalContext *lc, const int x0, const int y0,
2241  const int cb_width, const int cb_height, const VVCSplitMode split, const int ch_type,
2242  const VVCModeType mode_type_curr)
2243 {
2244  VVCModeType mode_type;
2245  const int mode_type_condition = derive_mode_type_condition(lc, split, cb_width, cb_height, mode_type_curr);
2246 
2247  if (mode_type_condition == 1)
2248  mode_type = MODE_TYPE_INTRA;
2249  else if (mode_type_condition == 2) {
2250  mode_type = ff_vvc_non_inter_flag(lc, x0, y0, ch_type) ? MODE_TYPE_INTRA : MODE_TYPE_INTER;
2251  } else {
2252  mode_type = mode_type_curr;
2253  }
2254 
2255  return mode_type;
2256 }
2257 
2258 static int hls_coding_tree(VVCLocalContext *lc,
2259  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2260  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
2261  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr);
2262 
2263 static int coding_tree_btv(VVCLocalContext *lc,
2264  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2265  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2266  VVCTreeType tree_type, VVCModeType mode_type)
2267 {
2268 #define CODING_TREE(x, idx) do { \
2269  ret = hls_coding_tree(lc, x, y0, cb_width / 2, cb_height, \
2270  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
2271  depth_offset, idx, SPLIT_BT_VER, tree_type, mode_type); \
2272  if (ret < 0) \
2273  return ret; \
2274 } while (0);
2275 
2276  const VVCPPS *pps = lc->fc->ps.pps;
2277  const int x1 = x0 + cb_width / 2;
2278  int ret = 0;
2279 
2280  depth_offset += (x0 + cb_width > pps->width) ? 1 : 0;
2281  CODING_TREE(x0, 0);
2282  if (x1 < pps->width)
2283  CODING_TREE(x1, 1);
2284 
2285  return 0;
2286 
2287 #undef CODING_TREE
2288 }
2289 
2290 static int coding_tree_bth(VVCLocalContext *lc,
2291  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2292  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2293  VVCTreeType tree_type, VVCModeType mode_type)
2294 {
2295 #define CODING_TREE(y, idx) do { \
2296  ret = hls_coding_tree(lc, x0, y, cb_width , cb_height / 2, \
2297  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
2298  depth_offset, idx, SPLIT_BT_HOR, tree_type, mode_type); \
2299  if (ret < 0) \
2300  return ret; \
2301  } while (0);
2302 
2303  const VVCPPS *pps = lc->fc->ps.pps;
2304  const int y1 = y0 + (cb_height / 2);
2305  int ret = 0;
2306 
2307  depth_offset += (y0 + cb_height > pps->height) ? 1 : 0;
2308  CODING_TREE(y0, 0);
2309  if (y1 < pps->height)
2310  CODING_TREE(y1, 1);
2311 
2312  return 0;
2313 
2314 #undef CODING_TREE
2315 }
2316 
2317 static int coding_tree_ttv(VVCLocalContext *lc,
2318  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2319  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2320  VVCTreeType tree_type, VVCModeType mode_type)
2321 {
2322 #define CODING_TREE(x, w, sub_div, idx) do { \
2323  ret = hls_coding_tree(lc, x, y0, w, cb_height, \
2324  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
2325  depth_offset, idx, SPLIT_TT_VER, tree_type, mode_type); \
2326  if (ret < 0) \
2327  return ret; \
2328  } while (0);
2329 
2330  const VVCSH *sh = &lc->sc->sh;
2331  const int x1 = x0 + cb_width / 4;
2332  const int x2 = x0 + cb_width * 3 / 4;
2333  int ret;
2334 
2335  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2336  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2337 
2338  CODING_TREE(x0, cb_width / 4, cb_sub_div + 2, 0);
2339  CODING_TREE(x1, cb_width / 2, cb_sub_div + 1, 1);
2340  CODING_TREE(x2, cb_width / 4, cb_sub_div + 2, 2);
2341 
2342  return 0;
2343 
2344 #undef CODING_TREE
2345 }
2346 
2347 static int coding_tree_tth(VVCLocalContext *lc,
2348  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2349  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2350  VVCTreeType tree_type, VVCModeType mode_type)
2351 {
2352 #define CODING_TREE(y, h, sub_div, idx) do { \
2353  ret = hls_coding_tree(lc, x0, y, cb_width, h, \
2354  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
2355  depth_offset, idx, SPLIT_TT_HOR, tree_type, mode_type); \
2356  if (ret < 0) \
2357  return ret; \
2358  } while (0);
2359 
2360  const VVCSH *sh = &lc->sc->sh;
2361  const int y1 = y0 + (cb_height / 4);
2362  const int y2 = y0 + (3 * cb_height / 4);
2363  int ret;
2364 
2365  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2366  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2367 
2368  CODING_TREE(y0, cb_height / 4, cb_sub_div + 2, 0);
2369  CODING_TREE(y1, cb_height / 2, cb_sub_div + 1, 1);
2370  CODING_TREE(y2, cb_height / 4, cb_sub_div + 2, 2);
2371 
2372  return 0;
2373 
2374 #undef CODING_TREE
2375 }
2376 
2377 static int coding_tree_qt(VVCLocalContext *lc,
2378  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2379  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2380  VVCTreeType tree_type, VVCModeType mode_type)
2381 {
2382 #define CODING_TREE(x, y, idx) do { \
2383  ret = hls_coding_tree(lc, x, y, cb_width / 2, cb_height / 2, \
2384  qg_on_y, qg_on_c, cb_sub_div + 2, cqt_depth + 1, 0, 0, \
2385  idx, SPLIT_QT, tree_type, mode_type); \
2386  if (ret < 0) \
2387  return ret; \
2388  } while (0);
2389 
2390  const VVCPPS *pps = lc->fc->ps.pps;
2391  const int x1 = x0 + cb_width / 2;
2392  const int y1 = y0 + cb_height / 2;
2393  int ret = 0;
2394 
2395  CODING_TREE(x0, y0, 0);
2396  if (x1 < pps->width)
2397  CODING_TREE(x1, y0, 1);
2398  if (y1 < pps->height)
2399  CODING_TREE(x0, y1, 2);
2400  if (x1 < pps->width &&
2401  y1 < pps->height)
2402  CODING_TREE(x1, y1, 3);
2403 
2404  return 0;
2405 
2406 #undef CODING_TREE
2407 }
2408 
2409 typedef int (*coding_tree_fn)(VVCLocalContext *lc,
2410  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2411  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2412  VVCTreeType tree_type, VVCModeType mode_type);
2413 
2414 const static coding_tree_fn coding_tree[] = {
2415  coding_tree_tth,
2416  coding_tree_bth,
2417  coding_tree_ttv,
2418  coding_tree_btv,
2419  coding_tree_qt,
2420 };
2421 
2422 static int hls_coding_tree(VVCLocalContext *lc,
2423  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2424  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
2425  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr)
2426 {
2427  VVCFrameContext *fc = lc->fc;
2428  const VVCPPS *pps = fc->ps.pps;
2429  const VVCSH *sh = &lc->sc->sh;
2430  const H266RawSliceHeader *rsh = sh->r;
2431  const int ch_type = tree_type_curr == DUAL_TREE_CHROMA;
2432  int ret;
2433  VVCAllowedSplit allowed;
2434 
2435  if (pps->r->pps_cu_qp_delta_enabled_flag && qg_on_y && cb_sub_div <= sh->cu_qp_delta_subdiv) {
2436  lc->parse.is_cu_qp_delta_coded = 0;
2437  lc->parse.cu_qg_top_left_x = x0;
2438  lc->parse.cu_qg_top_left_y = y0;
2439  }
2440  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && qg_on_c &&
2441  cb_sub_div <= sh->cu_chroma_qp_offset_subdiv) {
2442  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2443  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2444  }
2445 
2446  can_split(lc, x0, y0, cb_width, cb_height, mtt_depth, depth_offset, part_idx,
2447  last_split_mode, tree_type_curr, mode_type_curr, &allowed);
2448  if (ff_vvc_split_cu_flag(lc, x0, y0, cb_width, cb_height, ch_type, &allowed)) {
2449  VVCSplitMode split = ff_vvc_split_mode(lc, x0, y0, cb_width, cb_height, cqt_depth, mtt_depth, ch_type, &allowed);
2450  VVCModeType mode_type = mode_type_decode(lc, x0, y0, cb_width, cb_height, split, ch_type, mode_type_curr);
2451 
2452  VVCTreeType tree_type = (mode_type == MODE_TYPE_INTRA) ? DUAL_TREE_LUMA : tree_type_curr;
2453 
2454  if (split != SPLIT_QT) {
2455  if (!(x0 & 31) && !(y0 & 31) && mtt_depth <= 1)
2456  TAB_MSM(fc, mtt_depth, x0, y0) = split;
2457  }
2458  ret = coding_tree[split - 1](lc, x0, y0, cb_width, cb_height, qg_on_y, qg_on_c,
2459  cb_sub_div, cqt_depth, mtt_depth, depth_offset, tree_type, mode_type);
2460  if (ret < 0)
2461  return ret;
2462  if (mode_type_curr == MODE_TYPE_ALL && mode_type == MODE_TYPE_INTRA) {
2463  ret = hls_coding_tree(lc, x0, y0, cb_width, cb_height, 0, qg_on_c, cb_sub_div,
2464  cqt_depth, mtt_depth, 0, 0, split, DUAL_TREE_CHROMA, mode_type);
2465  if (ret < 0)
2466  return ret;
2467  }
2468  } else {
2469  ret = hls_coding_unit(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type_curr, mode_type_curr);
2470  if (ret < 0)
2471  return ret;
2472  }
2473 
2474  return 0;
2475 }
2476 
2477 static int dual_tree_implicit_qt_split(VVCLocalContext *lc,
2478  const int x0, const int y0, const int cb_size, const int cqt_depth)
2479 {
2480  const VVCSH *sh = &lc->sc->sh;
2481  const H266RawSliceHeader *rsh = sh->r;
2482  const VVCPPS *pps = lc->fc->ps.pps;
2483  const int cb_subdiv = 2 * cqt_depth;
2484  int ret;
2485 
2486  if (cb_size > 64) {
2487  #define DUAL_TREE(x, y) do { \
2488  ret = dual_tree_implicit_qt_split(lc, x, y, cb_size / 2, cqt_depth + 1); \
2489  if (ret < 0) \
2490  return ret; \
2491  } while (0)
2492 
2493  const int x1 = x0 + (cb_size / 2);
2494  const int y1 = y0 + (cb_size / 2);
2495  if (pps->r->pps_cu_qp_delta_enabled_flag && cb_subdiv <= sh->cu_qp_delta_subdiv) {
2496  lc->parse.is_cu_qp_delta_coded = 0;
2497  lc->parse.cu_qg_top_left_x = x0;
2498  lc->parse.cu_qg_top_left_y = y0;
2499  }
2500  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && cb_subdiv <= sh->cu_chroma_qp_offset_subdiv) {
2501  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2502  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2503  }
2504  DUAL_TREE(x0, y0);
2505  if (x1 < pps->width)
2506  DUAL_TREE(x1, y0);
2507  if (y1 < pps->height)
2508  DUAL_TREE(x0, y1);
2509  if (x1 < pps->width && y1 < pps->height)
2510  DUAL_TREE(x1, y1);
2511  #undef DUAL_TREE
2512  } else {
2513  #define CODING_TREE(tree_type) do { \
2514  const int qg_on_y = tree_type == DUAL_TREE_LUMA; \
2515  ret = hls_coding_tree(lc, x0, y0, cb_size, cb_size, qg_on_y, !qg_on_y, \
2516  cb_subdiv, cqt_depth, 0, 0, 0, SPLIT_NONE, tree_type, MODE_TYPE_ALL); \
2517  if (ret < 0) \
2518  return ret; \
2519  } while (0)
2520  CODING_TREE(DUAL_TREE_LUMA);
2521  CODING_TREE(DUAL_TREE_CHROMA);
2522  #undef CODING_TREE
2523  }
2524  return 0;
2525 }
2526 
2527 #define SET_SAO(elem, value) \
2528 do { \
2529  if (!sao_merge_up_flag && !sao_merge_left_flag) \
2530  sao->elem = value; \
2531  else if (sao_merge_left_flag) \
2532  sao->elem = CTB(fc->tab.sao, rx-1, ry).elem; \
2533  else if (sao_merge_up_flag) \
2534  sao->elem = CTB(fc->tab.sao, rx, ry-1).elem; \
2535  else \
2536  sao->elem = 0; \
2537 } while (0)
2538 
2539 static void hls_sao(VVCLocalContext *lc, const int rx, const int ry)
2540 {
2541  VVCFrameContext *fc = lc->fc;
2542  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2543  int sao_merge_left_flag = 0;
2544  int sao_merge_up_flag = 0;
2545  SAOParams *sao = &CTB(fc->tab.sao, rx, ry);
2546  int c_idx, i;
2547 
2548  if (rsh->sh_sao_luma_used_flag || rsh->sh_sao_chroma_used_flag) {
2549  if (rx > 0) {
2550  if (lc->ctb_left_flag)
2551  sao_merge_left_flag = ff_vvc_sao_merge_flag_decode(lc);
2552  }
2553  if (ry > 0 && !sao_merge_left_flag) {
2554  if (lc->ctb_up_flag)
2555  sao_merge_up_flag = ff_vvc_sao_merge_flag_decode(lc);
2556  }
2557  }
2558 
2559  for (c_idx = 0; c_idx < (fc->ps.sps->r->sps_chroma_format_idc ? 3 : 1); c_idx++) {
2560  const int sao_used_flag = !c_idx ? rsh->sh_sao_luma_used_flag : rsh->sh_sao_chroma_used_flag;
2561  if (!sao_used_flag) {
2562  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
2563  continue;
2564  }
2565 
2566  if (c_idx == 2) {
2567  sao->type_idx[2] = sao->type_idx[1];
2568  sao->eo_class[2] = sao->eo_class[1];
2569  } else {
2570  SET_SAO(type_idx[c_idx], ff_vvc_sao_type_idx_decode(lc));
2571  }
2572 
2573  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
2574  continue;
2575 
2576  for (i = 0; i < 4; i++)
2577  SET_SAO(offset_abs[c_idx][i], ff_vvc_sao_offset_abs_decode(lc));
2578 
2579  if (sao->type_idx[c_idx] == SAO_BAND) {
2580  for (i = 0; i < 4; i++) {
2581  if (sao->offset_abs[c_idx][i]) {
2582  SET_SAO(offset_sign[c_idx][i],
2583  ff_vvc_sao_offset_sign_decode(lc));
2584  } else {
2585  sao->offset_sign[c_idx][i] = 0;
2586  }
2587  }
2588  SET_SAO(band_position[c_idx], ff_vvc_sao_band_position_decode(lc));
2589  } else if (c_idx != 2) {
2590  SET_SAO(eo_class[c_idx], ff_vvc_sao_eo_class_decode(lc));
2591  }
2592 
2593  // Inferred parameters
2594  sao->offset_val[c_idx][0] = 0;
2595  for (i = 0; i < 4; i++) {
2596  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
2597  if (sao->type_idx[c_idx] == SAO_EDGE) {
2598  if (i > 1)
2599  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2600  } else if (sao->offset_sign[c_idx][i]) {
2601  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2602  }
2603  sao->offset_val[c_idx][i + 1] *= 1 << (fc->ps.sps->bit_depth - FFMIN(10, fc->ps.sps->bit_depth));
2604  }
2605  }
2606 }
2607 
2608 static void alf_params(VVCLocalContext *lc, const int rx, const int ry)
2609 {
2610  const VVCFrameContext *fc = lc->fc;
2611  const H266RawSliceHeader *sh = lc->sc->sh.r;
2612  ALFParams *alf = &CTB(fc->tab.alf, rx, ry);
2613 
2614  alf->ctb_flag[LUMA] = alf->ctb_flag[CB] = alf->ctb_flag[CR] = 0;
2615  alf->ctb_cc_idc[0] = alf->ctb_cc_idc[1] = 0;
2616  if (sh->sh_alf_enabled_flag) {
2617  alf->ctb_flag[LUMA] = ff_vvc_alf_ctb_flag(lc, rx, ry, LUMA);
2618  if (alf->ctb_flag[LUMA]) {
2619  uint8_t alf_use_aps_flag = 0;
2620  if (sh->sh_num_alf_aps_ids_luma > 0)
2621  alf_use_aps_flag = ff_vvc_alf_use_aps_flag(lc);
2622  if (alf_use_aps_flag) {
2623  alf->ctb_filt_set_idx_y = 16;
2624  if (sh->sh_num_alf_aps_ids_luma > 1)
2625  alf->ctb_filt_set_idx_y += ff_vvc_alf_luma_prev_filter_idx(lc);
2626  } else {
2627  alf->ctb_filt_set_idx_y = ff_vvc_alf_luma_fixed_filter_idx(lc);
2628  }
2629  }
2630  for (int c_idx = CB; c_idx <= CR; c_idx++) {
2631  const uint8_t alf_enabled_flag =
2632  c_idx == CB ? sh->sh_alf_cb_enabled_flag : sh->sh_alf_cr_enabled_flag;
2633  if (alf_enabled_flag) {
2634  const VVCALF *aps = fc->ps.alf_list[sh->sh_alf_aps_id_chroma];
2635  alf->ctb_flag[c_idx] = ff_vvc_alf_ctb_flag(lc, rx, ry, c_idx);
2636  alf->alf_ctb_filter_alt_idx[c_idx - 1] = 0;
2637  if (alf->ctb_flag[c_idx] && aps->num_chroma_filters > 1)
2638  alf->alf_ctb_filter_alt_idx[c_idx - 1] = ff_vvc_alf_ctb_filter_alt_idx(lc, c_idx, aps->num_chroma_filters);
2639  }
2640  }
2641  }
2642  if (fc->ps.sps->r->sps_ccalf_enabled_flag) {
2643  const uint8_t cc_enabled[] = { sh->sh_alf_cc_cb_enabled_flag, sh->sh_alf_cc_cr_enabled_flag };
2644  const uint8_t cc_aps_id[] = { sh->sh_alf_cc_cb_aps_id, sh->sh_alf_cc_cr_aps_id };
2645  for (int i = 0; i < 2; i++) {
2646  if (cc_enabled[i]) {
2647  const VVCALF *aps = fc->ps.alf_list[cc_aps_id[i]];
2648  alf->ctb_cc_idc[i] = ff_vvc_alf_ctb_cc_idc(lc, rx, ry, i, aps->num_cc_filters[i]);
2649  }
2650  }
2651  }
2652 }
2653 
2654 static void deblock_params(VVCLocalContext *lc, const int rx, const int ry)
2655 {
2656  VVCFrameContext *fc = lc->fc;
2657  const VVCSH *sh = &lc->sc->sh;
2658  CTB(fc->tab.deblock, rx, ry) = sh->deblock;
2659 }
2660 
2661 static int hls_coding_tree_unit(VVCLocalContext *lc,
2662  const int x0, const int y0, const int ctu_idx, const int rx, const int ry)
2663 {
2664  const VVCFrameContext *fc = lc->fc;
2665  const VVCSPS *sps = fc->ps.sps;
2666  const VVCPPS *pps = fc->ps.pps;
2667  const VVCSH *sh = &lc->sc->sh;
2668  const H266RawSliceHeader *rsh = sh->r;
2669  const unsigned int ctb_size = sps->ctb_size_y;
2670  int ret = 0;
2671 
2672  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2673 
2674  hls_sao(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2675  alf_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2676  deblock_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2677 
2678  if (IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag)
2679  ret = dual_tree_implicit_qt_split(lc, x0, y0, ctb_size, 0);
2680  else
2681  ret = hls_coding_tree(lc, x0, y0, ctb_size, ctb_size,
2682  1, 1, 0, 0, 0, 0, 0, SPLIT_NONE, SINGLE_TREE, MODE_TYPE_ALL);
2683  if (ret < 0)
2684  return ret;
2685 
2686  if (rx == pps->ctb_to_col_bd[rx + 1] - 1) {
2687  if (ctu_idx == sh->num_ctus_in_curr_slice - 1) {
2688  const int end_of_slice_one_bit = ff_vvc_end_of_slice_flag_decode(lc);
2689  if (!end_of_slice_one_bit)
2690  return AVERROR_INVALIDDATA;
2691  } else {
2692  if (ry == pps->ctb_to_row_bd[ry + 1] - 1) {
2693  const int end_of_tile_one_bit = ff_vvc_end_of_tile_one_bit(lc);
2694  if (!end_of_tile_one_bit)
2695  return AVERROR_INVALIDDATA;
2696  } else {
2697  if (fc->ps.sps->r->sps_entropy_coding_sync_enabled_flag) {
2698  const int end_of_subset_one_bit = ff_vvc_end_of_subset_one_bit(lc);
2699  if (!end_of_subset_one_bit)
2700  return AVERROR_INVALIDDATA;
2701  }
2702  }
2703  }
2704  }
2705 
2706  return 0;
2707 }
2708 
2709 static int has_inter_luma(const CodingUnit *cu)
2710 {
2711  return cu->pred_mode != MODE_INTRA && cu->pred_mode != MODE_PLT && cu->tree_type != DUAL_TREE_CHROMA;
2712 }
2713 
2714 static int pred_get_y(const VVCLocalContext *lc, const int y0, const Mv *mv, const int height)
2715 {
2716  const VVCPPS *pps = lc->fc->ps.pps;
2717  const int idx = lc->sc->sh.r->curr_subpic_idx;
2718  const int top = pps->subpic_y[idx];
2719  const int bottom = top + pps->subpic_height[idx];
2720 
2721  return av_clip(y0 + (mv->y >> 4) + height, top, bottom);
2722 }
2723 
2724 static void cu_get_max_y(const CodingUnit *cu, int max_y[2][VVC_MAX_REF_ENTRIES], const VVCLocalContext *lc)
2725 {
2726  const VVCFrameContext *fc = lc->fc;
2727  const PredictionUnit *pu = &cu->pu;
2728 
2729  if (pu->merge_gpm_flag) {
2730  for (int i = 0; i < FF_ARRAY_ELEMS(pu->gpm_mv); i++) {
2731  const MvField *mvf = pu->gpm_mv + i;
2732  const int lx = mvf->pred_flag - PF_L0;
2733  const int idx = mvf->ref_idx[lx];
2734  const int y = pred_get_y(lc, cu->y0, mvf->mv + lx, cu->cb_height);
2735 
2736  max_y[lx][idx] = FFMAX(max_y[lx][idx], y);
2737  }
2738  } else {
2739  const MotionInfo *mi = &pu->mi;
2740  const int max_dmvr_off = (!pu->inter_affine_flag && pu->dmvr_flag) ? 2 : 0;
2741  const int sbw = cu->cb_width / mi->num_sb_x;
2742  const int sbh = cu->cb_height / mi->num_sb_y;
2743  for (int sby = 0; sby < mi->num_sb_y; sby++) {
2744  for (int sbx = 0; sbx < mi->num_sb_x; sbx++) {
2745  const int x0 = cu->x0 + sbx * sbw;
2746  const int y0 = cu->y0 + sby * sbh;
2747  const MvField *mvf = ff_vvc_get_mvf(fc, x0, y0);
2748  for (int lx = 0; lx < 2; lx++) {
2749  const PredFlag mask = 1 << lx;
2750  if (mvf->pred_flag & mask) {
2751  const int idx = mvf->ref_idx[lx];
2752  const int y = pred_get_y(lc, y0, mvf->mv + lx, sbh);
2753 
2754  max_y[lx][idx] = FFMAX(max_y[lx][idx], y + max_dmvr_off);
2755  }
2756  }
2757  }
2758  }
2759  }
2760 }
2761 
2762 static void ctu_get_pred(VVCLocalContext *lc, const int rs)
2763 {
2764  const VVCFrameContext *fc = lc->fc;
2765  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2766  CTU *ctu = fc->tab.ctus + rs;
2767  const CodingUnit *cu = fc->tab.cus[rs];
2768 
2769  ctu->has_dmvr = 0;
2770 
2771  if (IS_I(rsh))
2772  return;
2773 
2774  for (int lx = 0; lx < 2; lx++)
2775  memset(ctu->max_y[lx], -1, sizeof(ctu->max_y[0][0]) * rsh->num_ref_idx_active[lx]);
2776 
2777  while (cu) {
2778  if (has_inter_luma(cu)) {
2779  cu_get_max_y(cu, ctu->max_y, lc);
2780  ctu->has_dmvr |= cu->pu.dmvr_flag;
2781  }
2782  cu = cu->next;
2783  }
2784  ctu->max_y_idx[0] = ctu->max_y_idx[1] = 0;
2785 }
2786 
2787 int ff_vvc_coding_tree_unit(VVCLocalContext *lc,
2788  const int ctu_idx, const int rs, const int rx, const int ry)
2789 {
2790  const VVCFrameContext *fc = lc->fc;
2791  const VVCSPS *sps = fc->ps.sps;
2792  const VVCPPS *pps = fc->ps.pps;
2793  const int x_ctb = rx << sps->ctb_log2_size_y;
2794  const int y_ctb = ry << sps->ctb_log2_size_y;
2795  const int ctb_size = 1 << sps->ctb_log2_size_y << sps->ctb_log2_size_y;
2796  EntryPoint* ep = lc->ep;
2797  int ret;
2798 
2799  if (rx == pps->ctb_to_col_bd[rx]) {
2800  ep->num_hmvp = 0;
2801  ep->num_hmvp_ibc = 0;
2802  ep->is_first_qg = ry == pps->ctb_to_row_bd[ry] || !ctu_idx;
2803  }
2804 
2805  lc->coeffs = fc->tab.coeffs + rs * ctb_size * VVC_MAX_SAMPLE_ARRAYS;
2806  lc->cu = NULL;
2807 
2808  ff_vvc_cabac_init(lc, ctu_idx, rx, ry);
2809  ff_vvc_decode_neighbour(lc, x_ctb, y_ctb, rx, ry, rs);
2810  ret = hls_coding_tree_unit(lc, x_ctb, y_ctb, ctu_idx, rx, ry);
2811  if (ret < 0)
2812  return ret;
2813  ctu_get_pred(lc, rs);
2814 
2815  return 0;
2816 }
2817 
2818 void ff_vvc_decode_neighbour(VVCLocalContext *lc, const int x_ctb, const int y_ctb,
2819  const int rx, const int ry, const int rs)
2820 {
2821  VVCFrameContext *fc = lc->fc;
2822  const int ctb_size = fc->ps.sps->ctb_size_y;
2823 
2824  lc->end_of_tiles_x = fc->ps.pps->width;
2825  lc->end_of_tiles_y = fc->ps.pps->height;
2826  if (fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx + 1])
2827  lc->end_of_tiles_x = FFMIN(x_ctb + ctb_size, lc->end_of_tiles_x);
2828  if (fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry + 1])
2829  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, lc->end_of_tiles_y);
2830 
2831  lc->boundary_flags = 0;
2832  if (rx > 0 && fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx - 1])
2833  lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2834  if (rx > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - 1])
2835  lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2836  if (ry > 0 && fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry - 1])
2837  lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2838  if (ry > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - fc->ps.pps->ctb_width])
2839  lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2840  if (fc->ps.sps->r->sps_subpic_ctu_top_left_x[lc->sc->sh.r->curr_subpic_idx] == rx)
2841  lc->boundary_flags |= BOUNDARY_LEFT_SUBPIC;
2842  if (fc->ps.sps->r->sps_subpic_ctu_top_left_y[lc->sc->sh.r->curr_subpic_idx] == ry)
2843  lc->boundary_flags |= BOUNDARY_UPPER_SUBPIC;
2844  lc->ctb_left_flag = rx > 0 && !(lc->boundary_flags & BOUNDARY_LEFT_TILE);
2845  lc->ctb_up_flag = ry > 0 && !(lc->boundary_flags & BOUNDARY_UPPER_TILE) && !(lc->boundary_flags & BOUNDARY_UPPER_SLICE);
2846  lc->ctb_up_right_flag = lc->ctb_up_flag && (fc->ps.pps->ctb_to_col_bd[rx] == fc->ps.pps->ctb_to_col_bd[rx + 1]) &&
2847  (fc->ps.pps->ctb_to_row_bd[ry] == fc->ps.pps->ctb_to_row_bd[ry - 1]);
2848  lc->ctb_up_left_flag = lc->ctb_left_flag && lc->ctb_up_flag;
2849 }
2850 
2851 void ff_vvc_set_neighbour_available(VVCLocalContext *lc,
2852  const int x0, const int y0, const int w, const int h)
2853 {
2854  const int log2_ctb_size = lc->fc->ps.sps->ctb_log2_size_y;
2855  const int x0b = av_zero_extend(x0, log2_ctb_size);
2856  const int y0b = av_zero_extend(y0, log2_ctb_size);
2857 
2858  lc->na.cand_up = (lc->ctb_up_flag || y0b);
2859  lc->na.cand_left = (lc->ctb_left_flag || x0b);
2860  lc->na.cand_up_left = (x0b || y0b) ? lc->na.cand_left && lc->na.cand_up : lc->ctb_up_left_flag;
2861  lc->na.cand_up_right_sap =
2862  (x0b + w == 1 << log2_ctb_size) ? lc->ctb_up_right_flag && !y0b : lc->na.cand_up;
2863  lc->na.cand_up_right = lc->na.cand_up_right_sap && (x0 + w) < lc->end_of_tiles_x;
2864 }
2865 
2866 void ff_vvc_ctu_free_cus(CodingUnit **cus)
2867 {
2868  while (*cus) {
2869  CodingUnit *cu = *cus;
2870  TransformUnit **head = &cu->tus.head;
2871 
2872  *cus = cu->next;
2873 
2874  while (*head) {
2875  TransformUnit *tu = *head;
2876  *head = tu->next;
2877  av_refstruct_unref(&tu);
2878  }
2879  cu->tus.tail = NULL;
2880 
2881  av_refstruct_unref(&cu);
2882  }
2883 }
2884 
2885 int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
2886 {
2887  const int min_cb_log2_size_y = fc->ps.sps->min_cb_log2_size_y;
2888  const int x = xc >> min_cb_log2_size_y;
2889  const int y = yc >> min_cb_log2_size_y;
2890  return fc->tab.qp[LUMA][x + y * fc->ps.pps->min_cb_width];
2891 }
2892 
2893 void ff_vvc_ep_init_stat_coeff(EntryPoint *ep,
2894  const int bit_depth, const int persistent_rice_adaptation_enabled_flag)
2895 {
2896  for (size_t i = 0; i < FF_ARRAY_ELEMS(ep->stat_coeff); ++i) {
2897  ep->stat_coeff[i] =
2898  persistent_rice_adaptation_enabled_flag ? 2 * (av_log2(bit_depth - 10)) : 0;
2899  }
2900 }
2901 
2902 void ff_vvc_channel_range(int *start, int *end, const VVCTreeType tree_type, const uint8_t chroma_format_idc)
2903 {
2904  const bool has_chroma = chroma_format_idc && tree_type != DUAL_TREE_LUMA;
2905  const bool has_luma = tree_type != DUAL_TREE_CHROMA;
2906 
2907  *start = has_luma ? LUMA : CB;
2908  *end = has_chroma ? VVC_MAX_SAMPLE_ARRAYS : CB;
2909 }
VVCSPS
Definition: ps.h:58
ff_vvc_residual_coding
int ff_vvc_residual_coding(VVCLocalContext *lc, TransformBlock *tb)
Definition: cabac.c:2493
FFUMOD
#define FFUMOD(a, b)
Definition: common.h:66
L1
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L1
Definition: snow.txt:554
VVCSH::cu_qp_delta_subdiv
uint8_t cu_qp_delta_subdiv
CuQpDeltaSubdiv.
Definition: ps.h:261
ff_vvc_cu_chroma_qp_offset_idx
int ff_vvc_cu_chroma_qp_offset_idx(VVCLocalContext *lc)
Definition: cabac.c:1749
H266RawSliceHeader::sh_alf_cc_cr_enabled_flag
uint8_t sh_alf_cc_cr_enabled_flag
Definition: cbs_h266.h:791
VVCSH::num_ctus_in_curr_slice
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
Definition: ps.h:243
ff_vvc_mmvd_offset_coding
void ff_vvc_mmvd_offset_coding(VVCLocalContext *lc, Mv *mmvd_offset, const int ph_mmvd_fullpel_only_flag)
Definition: cabac.c:1495
VVCPH
Definition: ps.h:147
ff_vvc_update_hmvp
void ff_vvc_update_hmvp(VVCLocalContext *lc, const MotionInfo *mi)
Definition: mvs.c:1941
VVCPPS
Definition: ps.h:92
ff_vvc_sao_eo_class_decode
int ff_vvc_sao_eo_class_decode(VVCLocalContext *lc)
Definition: cabac.c:1043
av_clip
#define av_clip
Definition: common.h:100
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
less
static int less(const void *a, const void *b)
Definition: ctu.c:678
LUMA
#define LUMA
Definition: filter.c:31
skipped_transform_tree
static int skipped_transform_tree(VVCLocalContext *lc, int x0, int y0, int tu_width, int tu_height)
Definition: ctu.c:483
VVCLocalContext::mts_zero_out_sig_coeff_flag
int mts_zero_out_sig_coeff_flag
MtsZeroOutSigCoeffFlag;.
Definition: ctu.h:419
TransformBlock::tb_width
int tb_width
Definition: ctu.h:149
ff_vvc_new_palette_entries
int ff_vvc_new_palette_entries(VVCLocalContext *lc, const int bit_depth)
Definition: cabac.c:1390
ff_vvc_num_signalled_palette_entries
int ff_vvc_num_signalled_palette_entries(VVCLocalContext *lc)
Definition: cabac.c:1385
VVCPPS::r
const H266RawPPS * r
RefStruct reference.
Definition: ps.h:93
MOTION_TRANSLATION
@ MOTION_TRANSLATION
Definition: ctu.h:217
CODING_TREE
#define CODING_TREE(x, idx)
CTU::max_y_idx
int max_y_idx[2]
Definition: ctu.h:345
ff_vvc_affine_mvp
void ff_vvc_affine_mvp(VVCLocalContext *lc, const int *mvp_lx_flag, const int amvr_shift, MotionInfo *mi)
Definition: mvs.c:1873
MotionInfo
Definition: ctu.h:244
SAO_BAND
@ SAO_BAND
Definition: hevcdec.h:166
set_cb_pos
static void set_cb_pos(const VVCFrameContext *fc, const CodingUnit *cu)
Definition: ctu.c:1169
TransformUnit::height
int height
Definition: ctu.h:177
CB
#define CB
Definition: filter.c:32
ff_vvc_regular_merge_flag
int ff_vvc_regular_merge_flag(VVCLocalContext *lc, const int cu_skip_flag)
Definition: cabac.c:1464
CHROMA_FORMAT_420
@ CHROMA_FORMAT_420
Definition: ps.h:53
intra_chroma_pred_modes
static void intra_chroma_pred_modes(VVCLocalContext *lc)
Definition: ctu.c:1010
add_tu
static TransformUnit * add_tu(VVCFrameContext *fc, CodingUnit *cu, const int x0, const int y0, const int tu_width, const int tu_height)
Definition: ctu.c:228
PF_IBC
@ PF_IBC
Definition: ctu.h:227
mts_idx_decode
static MtsIdx mts_idx_decode(VVCLocalContext *lc)
Definition: ctu.c:846
VVCSH::cu_chroma_qp_offset_subdiv
uint8_t cu_chroma_qp_offset_subdiv
CuChromaQpOffsetSubdiv.
Definition: ps.h:262
CodingUnit
Definition: hevcdec.h:292
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
CodingUnit::act_enabled_flag
uint8_t act_enabled_flag
Definition: ctu.h:305
pred_get_y
static int pred_get_y(const VVCLocalContext *lc, const int y0, const Mv *mv, const int height)
Definition: ctu.c:2714
PredictionUnit::gpm_partition_idx
uint8_t gpm_partition_idx
Definition: ctu.h:266
palette_update_predictor
static void palette_update_predictor(VVCLocalContext *lc, const bool local_dual_tree, int start, int end, bool *predictor_reused, const int predictor_size)
Definition: ctu.c:1910
ff_vvc_ref_idx_lx
int ff_vvc_ref_idx_lx(VVCLocalContext *lc, const uint8_t nb_refs)
Definition: cabac.c:1592
CodingUnit::head
TransformUnit * head
RefStruct reference.
Definition: ctu.h:330
TransformUnit::nb_tbs
uint8_t nb_tbs
Definition: ctu.h:183
CodingUnit::bdpcm_flag
int bdpcm_flag[VVC_MAX_SAMPLE_ARRAYS]
BdpcmFlag.
Definition: ctu.h:325
ff_vvc_end_of_slice_flag_decode
int ff_vvc_end_of_slice_flag_decode(VVCLocalContext *lc)
Definition: cabac.c:2551
mask
int mask
Definition: mediacodecdec_common.c:154
MODE_IBC
@ MODE_IBC
Definition: ctu.h:194
TransformBlock::min_scan_y
int min_scan_y
Definition: ctu.h:157
ff_vvc_intra_luma_ref_idx
int ff_vvc_intra_luma_ref_idx(VVCLocalContext *lc)
Definition: cabac.c:1316
ff_vvc_inter_affine_flag
int ff_vvc_inter_affine_flag(VVCLocalContext *lc)
Definition: cabac.c:1576
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3043
VVCRefPic
Definition: dec.h:47
PALETTE_INDEX
#define PALETTE_INDEX(x, y)
Definition: ctu.c:1968
w
uint8_t w
Definition: llviddspenc.c:38
VVCLocalContext::mts_dc_only
int mts_dc_only
MtsDcOnly.
Definition: ctu.h:418
NeighbourAvailable::cand_left
int cand_left
Definition: hevcdec.h:318
CodingUnit::intra_mip_flag
uint8_t intra_mip_flag
intra_mip_flag
Definition: ctu.h:308
NeighbourAvailable::cand_up
int cand_up
Definition: hevcdec.h:319
ff_vvc_intra_mip_flag
int ff_vvc_intra_mip_flag(VVCLocalContext *lc, const uint8_t *intra_mip_flag)
Definition: cabac.c:1294
VVCLocalContext::sc
SliceContext * sc
Definition: ctu.h:445
SAOParams::offset_sign
int offset_sign[3][4]
sao_offset_sign
Definition: dsp.h:36
TRANSFORM_UNIT
#define TRANSFORM_UNIT(x, width, idx)
add_cu
static CodingUnit * add_cu(VVCLocalContext *lc, const int x0, const int y0, const int cb_width, const int cb_height, const int cqt_depth, const VVCTreeType tree_type)
Definition: ctu.c:1218
INTRA_DC
@ INTRA_DC
Definition: hevcdec.h:128
ff_vvc_lfnst_idx
int ff_vvc_lfnst_idx(VVCLocalContext *lc, const int inc)
Definition: cabac.c:2532
b
#define b
Definition: input.c:42
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
H266RawSliceHeader::sh_sao_luma_used_flag
uint8_t sh_sao_luma_used_flag
Definition: cbs_h266.h:813
VVCModeType
VVCModeType
Definition: ctu.c:36
coding_tree_bth
static int coding_tree_bth(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2290
SPLIT_BT_HOR
@ SPLIT_BT_HOR
Definition: ctu.h:128
PALETTE_SET_PIXEL
#define PALETTE_SET_PIXEL(xc, yc, pix)
Definition: ctu.c:1959
NeighbourAvailable::cand_up_right
int cand_up_right
Definition: hevcdec.h:321
palette_qp
static void palette_qp(VVCLocalContext *lc, VVCTreeType tree_type, const bool escape_present)
Definition: ctu.c:1939
Mv::y
int16_t y
vertical component of motion vector
Definition: hevcdec.h:307
derive_mode_type_condition
static int derive_mode_type_condition(const VVCLocalContext *lc, const VVCSplitMode split, const int cb_width, const int cb_height, const VVCModeType mode_type_curr)
Definition: ctu.c:2218
ff_vvc_cu_affine_type_flag
int ff_vvc_cu_affine_type_flag(VVCLocalContext *lc)
Definition: cabac.c:1582
SAO_EDGE
@ SAO_EDGE
Definition: hevcdec.h:167
TransformUnit::x0
int x0
Definition: ctu.h:174
INTRA_VDIAG
@ INTRA_VDIAG
Definition: ctu.h:238
VVCSH::r
const H266RawSliceHeader * r
RefStruct reference.
Definition: ps.h:239
ff_vvc_mmvd_merge_flag
int ff_vvc_mmvd_merge_flag(VVCLocalContext *lc)
Definition: cabac.c:1470
ff_vvc_palette_escape_val_present_flag
bool ff_vvc_palette_escape_val_present_flag(VVCLocalContext *lc)
Definition: cabac.c:1395
TransformBlock::min_scan_x
int min_scan_x
Definition: ctu.h:156
TRAV_Y
#define TRAV_Y(pos)
Definition: ctu.c:1977
derive_center_luma_intra_pred_mode
static enum IntraPredMode derive_center_luma_intra_pred_mode(const VVCFrameContext *fc, const VVCSPS *sps, const VVCPPS *pps, const CodingUnit *cu)
Definition: ctu.c:867
VVCSplitMode
VVCSplitMode
Definition: ctu.h:125
ff_vvc_ciip_flag
int ff_vvc_ciip_flag(VVCLocalContext *lc)
Definition: cabac.c:1556
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
DUAL_TREE
#define DUAL_TREE(x, y)
ff_vvc_intra_luma_mpm_idx
int ff_vvc_intra_luma_mpm_idx(VVCLocalContext *lc)
Definition: cabac.c:1348
mv_merge_refine_pred_flag
static void mv_merge_refine_pred_flag(MvField *mvf, const int width, const int height)
Definition: ctu.c:1336
intra_data
static int intra_data(VVCLocalContext *lc)
Definition: ctu.c:2128
derive_chroma_intra_pred_mode
static void derive_chroma_intra_pred_mode(VVCLocalContext *lc, const int cclm_mode_flag, const int cclm_mode_idx, const int intra_chroma_pred_mode)
Definition: ctu.c:886
MAX_PALETTE_CU_SIZE
#define MAX_PALETTE_CU_SIZE
Definition: ctu.h:39
TransformBlock::max_scan_y
int max_scan_y
Definition: ctu.h:155
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
dual_tree_implicit_qt_split
static int dual_tree_implicit_qt_split(VVCLocalContext *lc, const int x0, const int y0, const int cb_size, const int cqt_depth)
Definition: ctu.c:2477
ff_vvc_abs_mvd_greater0_flag
int ff_vvc_abs_mvd_greater0_flag(VVCLocalContext *lc)
Definition: cabac.c:1607
RefPicList
Definition: hevcdec.h:196
alf_params
static void alf_params(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2608
ff_vvc_isp_split_type
enum IspType ff_vvc_isp_split_type(VVCLocalContext *lc, const int intra_subpartitions_mode_flag)
Definition: cabac.c:1331
VVCLocalContext::ctb_up_right_flag
uint8_t ctb_up_right_flag
Definition: ctu.h:387
ff_vvc_channel_range
void ff_vvc_channel_range(int *start, int *end, const VVCTreeType tree_type, const uint8_t chroma_format_idc)
Definition: ctu.c:2902
ff_vvc_sbt_quad_flag
int ff_vvc_sbt_quad_flag(VVCLocalContext *lc)
Definition: cabac.c:2514
alloc_tu
static TransformUnit * alloc_tu(VVCFrameContext *fc, CodingUnit *cu)
Definition: ctu.c:211
VVCLocalContext::coeffs
int * coeffs
Definition: ctu.h:448
PF_INTRA
@ PF_INTRA
Definition: hevcdec.h:120
VVCLocalContext::lfnst_zero_out_sig_coeff_flag
int lfnst_zero_out_sig_coeff_flag
LfnstZeroOutSigCoeffFlag.
Definition: ctu.h:416
deblock_params
static void deblock_params(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2654
TransformBlock::max_scan_x
int max_scan_x
Definition: ctu.h:154
SPLIT_QT
@ SPLIT_QT
Definition: ctu.h:131
ref_idx_decode
static int8_t ref_idx_decode(VVCLocalContext *lc, const VVCSH *sh, const int sym_mvd_flag, const int lx)
Definition: ctu.c:1561
VVCLocalContext::lfnst_dc_only
int lfnst_dc_only
LfnstDcOnly.
Definition: ctu.h:415
ff_vvc_intra_mip_transposed_flag
int ff_vvc_intra_mip_transposed_flag(VVCLocalContext *lc)
Definition: cabac.c:1302
ff_vvc_palette_idx_idc
int ff_vvc_palette_idx_idc(VVCLocalContext *lc, const int max_palette_index, const bool adjust)
Definition: cabac.c:1422
TRANSFORM_TREE
#define TRANSFORM_TREE(x, y)
ff_vvc_sb_mv_merge_mode
void ff_vvc_sb_mv_merge_mode(VVCLocalContext *lc, const int merge_subblock_idx, PredictionUnit *pu)
Definition: mvs.c:1424
BOUNDARY_LEFT_TILE
#define BOUNDARY_LEFT_TILE
Definition: hevcdec.h:442
H266RawPPS::pps_cu_qp_delta_enabled_flag
uint8_t pps_cu_qp_delta_enabled_flag
Definition: cbs_h266.h:552
pred_mode_decode
static PredMode pred_mode_decode(VVCLocalContext *lc, const VVCTreeType tree_type, const VVCModeType mode_type)
Definition: ctu.c:1046
JCBCR
#define JCBCR
Definition: dec.h:39
ff_vvc_sao_offset_sign_decode
int ff_vvc_sao_offset_sign_decode(VVCLocalContext *lc)
Definition: cabac.c:1038
SPLIT_BT_VER
@ SPLIT_BT_VER
Definition: ctu.h:130
coding_tree_qt
static int coding_tree_qt(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2377
MIN_PU_LOG2
#define MIN_PU_LOG2
Definition: dec.h:42
CodingUnit::ch_type
int ch_type
Definition: ctu.h:293
H266RawSliceHeader::sh_alf_cc_cr_aps_id
uint8_t sh_alf_cc_cr_aps_id
Definition: cbs_h266.h:792
H266RawSliceHeader::sh_cb_qp_offset
int8_t sh_cb_qp_offset
Definition: cbs_h266.h:808
ff_vvc_intra_mip_mode
int ff_vvc_intra_mip_mode(VVCLocalContext *lc)
Definition: cabac.c:1307
VVCFrameParamSets::sps
const VVCSPS * sps
RefStruct reference.
Definition: ps.h:230
ff_vvc_coding_tree_unit
int ff_vvc_coding_tree_unit(VVCLocalContext *lc, const int ctu_idx, const int rs, const int rx, const int ry)
parse a CTU
Definition: ctu.c:2787
PredictionUnit::gpm_mv
MvField gpm_mv[2]
Definition: ctu.h:267
CodingUnit::plt
Palette plt[VVC_MAX_SAMPLE_ARRAYS]
Definition: ctu.h:336
merge_data_regular
static void merge_data_regular(VVCLocalContext *lc)
Definition: ctu.c:1359
VVCLocalContext::fc
VVCFrameContext * fc
Definition: ctu.h:446
hls_coding_unit
static int hls_coding_unit(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int cqt_depth, const VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2158
VVCSH::pwt
PredWeightTable pwt
Definition: ps.h:247
PredictionUnit
Definition: hevcdec.h:325
VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE
@ VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE
Definition: vvc.h:159
EntryPoint::stat_coeff
int stat_coeff[VVC_MAX_SAMPLE_ARRAYS]
StatCoeff.
Definition: ctu.h:366
MODE_INTER
@ MODE_INTER
Definition: hevcdec.h:108
FFSIGN
#define FFSIGN(a)
Definition: common.h:75
CodingUnit::apply_lfnst_flag
int apply_lfnst_flag[VVC_MAX_SAMPLE_ARRAYS]
ApplyLfnstFlag[].
Definition: ctu.h:327
IS_B
#define IS_B(rsh)
Definition: ps.h:40
derive_dmvr_bdof_flag
static void derive_dmvr_bdof_flag(const VVCLocalContext *lc, PredictionUnit *pu)
Definition: ctu.c:1719
ff_vvc_cu_coded_flag
int ff_vvc_cu_coded_flag(VVCLocalContext *lc)
Definition: cabac.c:2501
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
TransformBlock::c_idx
uint8_t c_idx
Definition: ctu.h:144
SPLIT_TT_VER
@ SPLIT_TT_VER
Definition: ctu.h:129
CodingUnit::sbt_pos_flag
uint8_t sbt_pos_flag
Definition: ctu.h:300
VVCLocalContext::ctb_up_left_flag
uint8_t ctb_up_left_flag
Definition: ctu.h:388
alloc_cu
static CodingUnit * alloc_cu(VVCLocalContext *lc, const int x0, const int y0)
Definition: ctu.c:1195
ctu_get_pred
static void ctu_get_pred(VVCLocalContext *lc, const int rs)
Definition: ctu.c:2762
TransformBlock::x0
int x0
Definition: ctu.h:146
SliceContext::rpl
RefPicList * rpl
Definition: dec.h:118
VVCALF
Definition: ps.h:171
MODE_TYPE_ALL
@ MODE_TYPE_ALL
Definition: ctu.c:37
ff_vvc_mvp_lx_flag
int ff_vvc_mvp_lx_flag(VVCLocalContext *lc)
Definition: cabac.c:1627
H266RawSliceHeader::sh_alf_enabled_flag
uint8_t sh_alf_enabled_flag
Definition: cbs_h266.h:783
refstruct.h
ISP_VER_SPLIT
@ ISP_VER_SPLIT
Definition: ctu.h:122
CodingUnit::cb_width
int cb_width
Definition: ctu.h:291
coding_tree_ttv
static int coding_tree_ttv(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2317
merge_data_subblock
static void merge_data_subblock(VVCLocalContext *lc)
Definition: ctu.c:1345
ff_vvc_split_cu_flag
int ff_vvc_split_cu_flag(VVCLocalContext *lc, const int x0, const int y0, const int cb_width, const int cb_height, const int is_chroma, const VVCAllowedSplit *a)
Definition: cabac.c:1110
H266RawSliceHeader::num_ref_idx_active
uint8_t num_ref_idx_active[2]
NumRefIdxActive[].
Definition: cbs_h266.h:839
merge_data_ciip
static void merge_data_ciip(VVCLocalContext *lc)
Definition: ctu.c:1419
CodingUnit::pu
PredictionUnit pu
Definition: ctu.h:338
ff_vvc_merge_gpm_idx
int ff_vvc_merge_gpm_idx(VVCLocalContext *lc, const int idx)
Definition: cabac.c:1542
H266RawSPS::sps_chroma_format_idc
uint8_t sps_chroma_format_idc
Definition: cbs_h266.h:314
hls_coding_tree
static int hls_coding_tree(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx, VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr)
Definition: ctu.c:2422
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
CHROMA_FORMAT_422
@ CHROMA_FORMAT_422
Definition: ps.h:54
VVCLocalContext::parse
struct VVCLocalContext::@322 parse
ff_vvc_store_gpm_mvf
void ff_vvc_store_gpm_mvf(const VVCLocalContext *lc, const PredictionUnit *pu)
Definition: mvs.c:457
MTS_DCT2_DCT2
@ MTS_DCT2_DCT2
Definition: ctu.h:135
add_tb
static TransformBlock * add_tb(TransformUnit *tu, VVCLocalContext *lc, const int x0, const int y0, const int tb_width, const int tb_height, const int c_idx)
Definition: ctu.c:247
RefPicList::refs
VVCRefPic refs[VVC_MAX_REF_ENTRIES]
Definition: dec.h:58
mode_type_decode
static VVCModeType mode_type_decode(VVCLocalContext *lc, const int x0, const int y0, const int cb_width, const int cb_height, const VVCSplitMode split, const int ch_type, const VVCModeType mode_type_curr)
Definition: ctu.c:2240
ff_vvc_tu_y_coded_flag
int ff_vvc_tu_y_coded_flag(VVCLocalContext *lc)
Definition: cabac.c:1692
ff_vvc_store_mv
void ff_vvc_store_mv(const VVCLocalContext *lc, const MotionInfo *mi)
Definition: mvs.c:508
TransformUnit::avail
bool avail[CHROMA+1]
Definition: ctu.h:178
SAO_NOT_APPLIED
@ SAO_NOT_APPLIED
Definition: hevcdec.h:165
ISP_HOR_SPLIT
@ ISP_HOR_SPLIT
Definition: ctu.h:121
coding_tree_tth
static int coding_tree_tth(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2347
bcw_idx_decode
static int bcw_idx_decode(VVCLocalContext *lc, const MotionInfo *mi, const int cb_width, const int cb_height)
Definition: ctu.c:1540
AV_ZERO64
#define AV_ZERO64(d)
Definition: intreadwrite.h:666
mi
#define mi
Definition: vf_colormatrix.c:106
adjust
static int adjust(int x, int size)
Definition: mobiclip.c:513
TransformBlock::y0
int y0
Definition: ctu.h:147
TransformUnit::next
struct TransformUnit * next
RefStruct reference.
Definition: ctu.h:186
set_cu_tabs
static void set_cu_tabs(const VVCLocalContext *lc, const CodingUnit *cu)
Definition: ctu.c:1255
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:493
merge_data_ibc
static int merge_data_ibc(VVCLocalContext *lc)
Definition: ctu.c:1470
CodingUnit::cqt_depth
int cqt_depth
Definition: ctu.h:294
VVCSH
Definition: ps.h:238
mvp_add_difference
static void mvp_add_difference(MotionInfo *mi, const int num_cp_mv, const Mv mvds[2][MAX_CONTROL_POINTS], const int amvr_shift)
Definition: ctu.c:1605
ff_vvc_bcw_idx
int ff_vvc_bcw_idx(VVCLocalContext *lc, const int no_backward_pred_flag)
Definition: cabac.c:1671
PredWeightTable
Definition: ps.h:137
CodingUnit::tree_type
VVCTreeType tree_type
Definition: ctu.h:288
Palette::size
uint8_t size
Definition: ctu.h:283
VVCFrameParamSets::ph
VVCPH ph
Definition: ps.h:232
PredictionUnit::bdof_flag
uint8_t bdof_flag
Definition: ctu.h:275
ff_vvc_sbt_pos_flag
int ff_vvc_sbt_pos_flag(VVCLocalContext *lc)
Definition: cabac.c:2527
CodingUnit::mts_idx
MtsIdx mts_idx
Definition: ctu.h:303
ff_vvc_intra_luma_not_planar_flag
int ff_vvc_intra_luma_not_planar_flag(VVCLocalContext *lc, const int intra_subpartitions_mode_flag)
Definition: cabac.c:1343
TransformUnit::coded_flag
uint8_t coded_flag[VVC_MAX_SAMPLE_ARRAYS]
tu_y_coded_flag, tu_cb_coded_flag, tu_cr_coded_flag
Definition: ctu.h:182
RSHIFT
#define RSHIFT(a, b)
Definition: common.h:56
NeighbourAvailable::cand_up_right_sap
int cand_up_right_sap
Definition: hevcdec.h:322
ff_vvc_cu_skip_flag
int ff_vvc_cu_skip_flag(VVCLocalContext *lc, const uint8_t *cu_skip_flag)
Definition: cabac.c:1268
hls_merge_data
static int hls_merge_data(VVCLocalContext *lc)
Definition: ctu.c:1491
set_qp_y
static int set_qp_y(VVCLocalContext *lc, const int x0, const int y0, const int has_qp_delta)
Definition: ctu.c:141
ciip_flag_decode
static int ciip_flag_decode(VVCLocalContext *lc, const int ciip_avaiable, const int gpm_avaiable, const int is_128)
Definition: ctu.c:1389
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
H266RawSliceHeader::sh_cu_chroma_qp_offset_enabled_flag
uint8_t sh_cu_chroma_qp_offset_enabled_flag
Definition: cbs_h266.h:811
H266RawSPS
Definition: cbs_h266.h:308
CTU
Definition: ctu.h:343
hls_transform_unit
static int hls_transform_unit(VVCLocalContext *lc, int x0, int y0, int tu_width, int tu_height, int sub_tu_index, int ch_type)
Definition: ctu.c:313
aps
static int FUNC() aps(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current, int prefix)
Definition: cbs_h266_syntax_template.c:2501
EntryPoint::is_first_qg
uint8_t is_first_qg
Definition: ctu.h:376
VVCSPS::ctb_log2_size_y
uint8_t ctb_log2_size_y
CtbLog2SizeY.
Definition: ps.h:71
ff_vvc_palette_derive_scale
int ff_vvc_palette_derive_scale(VVCLocalContext *lc, const TransformUnit *tu, TransformBlock *tb)
Definition: intra.c:672
CodingUnit::sbt_flag
uint8_t sbt_flag
Definition: ctu.h:298
inter.h
VVCTreeType
VVCTreeType
Definition: ctu.h:167
IspType
IspType
Definition: ctu.h:119
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:121
SAOParams::offset_abs
int offset_abs[3][4]
sao_offset_abs
Definition: dsp.h:35
ff_vvc_mvp
void ff_vvc_mvp(VVCLocalContext *lc, const int *mvp_lx_flag, const int amvr_shift, MotionInfo *mi)
Definition: mvs.c:1614
run
uint8_t run
Definition: svq3.c:207
ff_vvc_pred_mode_plt_flag
int ff_vvc_pred_mode_plt_flag(VVCLocalContext *lc)
Definition: cabac.c:1243
pixel
uint8_t pixel
Definition: tiny_ssim.c:41
VVCLocalContext
Definition: ctu.h:384
VVCSH::ref_idx_sym
int8_t ref_idx_sym[2]
RefIdxSymL0, RefIdxSymL1.
Definition: ps.h:248
H266RawSliceHeader::curr_subpic_idx
uint16_t curr_subpic_idx
CurrSubpicIdx.
Definition: cbs_h266.h:837
INTRA_HORZ
@ INTRA_HORZ
Definition: ctu.h:235
VVCSH::max_tt_size
uint8_t max_tt_size[2]
MaxTtSizeY, MaxTtSizeC.
Definition: ps.h:259
EntryPoint::qp_y
int8_t qp_y
QpY.
Definition: ctu.h:364
ff_vvc_cu_act_enabled_flag
int ff_vvc_cu_act_enabled_flag(VVCLocalContext *lc)
Definition: cabac.c:1706
ff_vvc_cu_chroma_qp_offset_flag
int ff_vvc_cu_chroma_qp_offset_flag(VVCLocalContext *lc)
Definition: cabac.c:1744
TransformBlock::log2_tb_width
int log2_tb_width
Definition: ctu.h:151
CodingUnit::intra_luma_ref_idx
uint8_t intra_luma_ref_idx
IntraLumaRefLineIdx[][].
Definition: ctu.h:307
mvp_data_ibc
static int mvp_data_ibc(VVCLocalContext *lc)
Definition: ctu.c:1620
L0
#define L0
Definition: hevcdec.h:58
ff_vvc_sbt_horizontal_flag
int ff_vvc_sbt_horizontal_flag(VVCLocalContext *lc)
Definition: cabac.c:2519
ff_vvc_alf_ctb_filter_alt_idx
int ff_vvc_alf_ctb_filter_alt_idx(VVCLocalContext *lc, const int c_idx, const int num_chroma_filters)
Definition: cabac.c:1078
av_refstruct_pool_get
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
ff_vvc_palette_transpose_flag
bool ff_vvc_palette_transpose_flag(VVCLocalContext *lc)
Definition: cabac.c:1400
hls_coding_tree_unit
static int hls_coding_tree_unit(VVCLocalContext *lc, const int x0, const int y0, const int ctu_idx, const int rx, const int ry)
Definition: ctu.c:2661
BOUNDARY_UPPER_TILE
#define BOUNDARY_UPPER_TILE
Definition: hevcdec.h:444
MODE_TYPE_INTRA
@ MODE_TYPE_INTRA
Definition: ctu.c:39
H266RawSliceHeader::sh_joint_cbcr_qp_offset
int8_t sh_joint_cbcr_qp_offset
Definition: cbs_h266.h:810
skipped_transform_tree_unit
static int skipped_transform_tree_unit(VVCLocalContext *lc)
Definition: ctu.c:1153
SPLIT_NONE
@ SPLIT_NONE
Definition: mss12.c:37
VVCRefPic::is_scaled
int is_scaled
RprConstraintsActiveFlag.
Definition: dec.h:53
SPLIT_TT_HOR
@ SPLIT_TT_HOR
Definition: ctu.h:127
MotionInfo::motion_model_idc
MotionModelIdc motion_model_idc
MotionModelIdc.
Definition: ctu.h:245
Mv::x
int16_t x
horizontal component of motion vector
Definition: hevcdec.h:306
CTB
#define CTB(tab, x, y)
Definition: filter.c:267
VVCRefPic::is_lt
int is_lt
Definition: dec.h:50
ff_vvc_alf_use_aps_flag
int ff_vvc_alf_use_aps_flag(VVCLocalContext *lc)
Definition: cabac.c:1063
PF_BI
@ PF_BI
Definition: hevcdec.h:123
MotionInfo::num_sb_y
int num_sb_y
Definition: ctu.h:253
ff_vvc_abs_mvd_minus2
int ff_vvc_abs_mvd_minus2(VVCLocalContext *lc)
Definition: cabac.c:1617
ff_vvc_tu_joint_cbcr_residual_flag
int ff_vvc_tu_joint_cbcr_residual_flag(VVCLocalContext *lc, const int tu_cb_coded_flag, const int tu_cr_coded_flag)
Definition: cabac.c:1803
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
SAMPLE_CTB
#define SAMPLE_CTB(tab, x, y)
Definition: hevcdec.h:74
ff_vvc_alf_luma_prev_filter_idx
int ff_vvc_alf_luma_prev_filter_idx(VVCLocalContext *lc)
Definition: cabac.c:1068
cabac.h
TransformUnit
Definition: hevcdec.h:335
ff_vvc_pred_mode_ibc_flag
int ff_vvc_pred_mode_ibc_flag(VVCLocalContext *lc, const int is_chroma)
Definition: cabac.c:1274
DUAL_TREE_LUMA
@ DUAL_TREE_LUMA
Definition: ctu.h:169
SliceContext
Definition: mss12.h:70
SAOParams::offset_val
int16_t offset_val[3][5]
SaoOffsetVal.
Definition: dsp.h:42
VVCFrameParamSets::pps
const VVCPPS * pps
RefStruct reference.
Definition: ps.h:231
PredictionUnit::mmvd_merge_flag
uint8_t mmvd_merge_flag
Definition: ctu.h:258
ff_vvc_luma_mv_merge_mode
void ff_vvc_luma_mv_merge_mode(VVCLocalContext *lc, const int merge_idx, const int ciip_flag, MvField *mv)
Definition: mvs.c:829
VVCSH::max_mtt_depth
uint8_t max_mtt_depth[2]
MaxMttDepthY, MaxMttDepthC.
Definition: ps.h:260
ff_vvc_decode_neighbour
void ff_vvc_decode_neighbour(VVCLocalContext *lc, const int x_ctb, const int y_ctb, const int rx, const int ry, const int rs)
Definition: ctu.c:2818
Palette::entries
uint16_t entries[VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE]
Definition: ctu.h:284
TransformBlock::tb_height
int tb_height
Definition: ctu.h:150
ff_vvc_intra_luma_mpm_remainder
int ff_vvc_intra_luma_mpm_remainder(VVCLocalContext *lc)
Definition: cabac.c:1356
EntryPoint::num_hmvp_ibc
int num_hmvp_ibc
NumHmvpIbcCand.
Definition: ctu.h:381
VVCFrameContext::tab
struct VVCFrameContext::@324 tab
TransformBlock::ts
uint8_t ts
transform_skip_flag
Definition: ctu.h:145
ff_vvc_intra_bdpcm_chroma_dir_flag
int ff_vvc_intra_bdpcm_chroma_dir_flag(VVCLocalContext *lc)
Definition: cabac.c:1263
mvs.h
BOUNDARY_UPPER_SLICE
#define BOUNDARY_UPPER_SLICE
Definition: hevcdec.h:443
mvf_to_mi
static void mvf_to_mi(const MvField *mvf, MotionInfo *mi)
Definition: ctu.c:1322
CodingUnit::intra_pred_mode_y
IntraPredMode intra_pred_mode_y
IntraPredModeY.
Definition: ctu.h:321
ff_vvc_pred_flag
PredFlag ff_vvc_pred_flag(VVCLocalContext *lc, const int is_b)
Definition: cabac.c:1561
height
#define height
Definition: dsp.h:89
INTRA_PLANAR
@ INTRA_PLANAR
Definition: hevcdec.h:127
size
int size
Definition: twinvq_data.h:10344
coding_tree
const static coding_tree_fn coding_tree[]
Definition: ctu.c:2414
refine_regular_subblock
static void refine_regular_subblock(const VVCLocalContext *lc)
Definition: ctu.c:1758
ff_vvc_merge_subblock_idx
int ff_vvc_merge_subblock_idx(VVCLocalContext *lc, const int max_num_subblock_merge_cand)
Definition: cabac.c:1454
PredictionUnit::merge_gpm_flag
uint8_t merge_gpm_flag
Definition: ctu.h:265
VVCRefPic::poc
int poc
Definition: dec.h:49
CodingUnit::sbt_horizontal_flag
uint8_t sbt_horizontal_flag
Definition: ctu.h:299
ff_vvc_merge_gpm_partition_idx
int ff_vvc_merge_gpm_partition_idx(VVCLocalContext *lc)
Definition: cabac.c:1537
intra.h
H266RawSliceHeader::sh_alf_aps_id_chroma
uint8_t sh_alf_aps_id_chroma
Definition: cbs_h266.h:788
VVCLocalContext::infer_tu_cbf_luma
int infer_tu_cbf_luma
InferTuCbfLuma.
Definition: ctu.h:412
MvField
Definition: hevcdec.h:310
VVCLocalContext::end_of_tiles_x
int end_of_tiles_x
Definition: ctu.h:389
INTRA_INVALID
@ INTRA_INVALID
Definition: ctu.h:232
ff_vvc_luma_mv_merge_gpm
void ff_vvc_luma_mv_merge_gpm(VVCLocalContext *lc, const int merge_gpm_idx[2], MvField *mv)
Definition: mvs.c:842
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:166
ff_vvc_sym_mvd_flag
int ff_vvc_sym_mvd_flag(VVCLocalContext *lc)
Definition: cabac.c:1587
CodingUnit::coded_flag
uint8_t coded_flag
Definition: ctu.h:296
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:89
VVCLocalContext::ctb_up_flag
uint8_t ctb_up_flag
Definition: ctu.h:386
ff_vvc_end_of_tile_one_bit
int ff_vvc_end_of_tile_one_bit(VVCLocalContext *lc)
Definition: cabac.c:2556
CHROMA_FORMAT_444
@ CHROMA_FORMAT_444
Definition: ps.h:55
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
ff_vvc_intra_subpartitions_mode_flag
int ff_vvc_intra_subpartitions_mode_flag(VVCLocalContext *lc)
Definition: cabac.c:1326
CTU::has_dmvr
int has_dmvr
Definition: ctu.h:346
CodingUnit::lfnst_idx
int lfnst_idx
Definition: ctu.h:302
VVCSH::deblock
DBParams deblock
Definition: ps.h:254
MAX_CONTROL_POINTS
#define MAX_CONTROL_POINTS
Definition: ctu.h:67
H266RawSliceHeader::sh_cr_qp_offset
int8_t sh_cr_qp_offset
Definition: cbs_h266.h:809
H266RawSliceHeader::sh_alf_cb_enabled_flag
uint8_t sh_alf_cb_enabled_flag
Definition: cbs_h266.h:786
coding_tree_btv
static int coding_tree_btv(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2263
av_zero_extend
#define av_zero_extend
Definition: common.h:151
VVCLocalContext::na
NeighbourAvailable na
Definition: ctu.h:433
CodingUnit::intra_pred_mode_c
IntraPredMode intra_pred_mode_c
IntraPredModeC.
Definition: ctu.h:322
ff_vvc_sao_band_position_decode
int ff_vvc_sao_band_position_decode(VVCLocalContext *lc)
Definition: cabac.c:1023
MODE_TYPE_INTER
@ MODE_TYPE_INTER
Definition: ctu.c:38
MvField::pred_flag
int8_t pred_flag
Definition: hevcdec.h:313
MvField::hpel_if_idx
uint8_t hpel_if_idx
hpelIfIdx
Definition: ctu.h:205
SAOParams::eo_class
int eo_class[3]
sao_eo_class
Definition: dsp.h:40
ff_vvc_merge_idx
int ff_vvc_merge_idx(VVCLocalContext *lc)
Definition: cabac.c:1522
ff_vvc_merge_subblock_flag
int ff_vvc_merge_subblock_flag(VVCLocalContext *lc)
Definition: cabac.c:1448
ALFParams::ctb_cc_idc
uint8_t ctb_cc_idc[2]
alf_ctb_cc_cb_idc, alf_ctb_cc_cr_idc
Definition: ctu.h:476
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
ff_vvc_split_mode
VVCSplitMode ff_vvc_split_mode(VVCLocalContext *lc, const int x0, const int y0, const int cb_width, const int cb_height, const int cqt_depth, const int mtt_depth, const int ch_type, const VVCAllowedSplit *a)
Definition: cabac.c:1188
CTU::max_y
int max_y[2][VVC_MAX_REF_ENTRIES]
Definition: ctu.h:344
H266RawSliceHeader
Definition: cbs_h266.h:771
get_cclm_enabled
static int get_cclm_enabled(const VVCLocalContext *lc, const int x0, const int y0)
Definition: ctu.c:633
set_cb_tab
static void set_cb_tab(const VVCLocalContext *lc, uint8_t *tab, const uint8_t v)
Definition: ctu.c:121
VVCLocalContext::boundary_flags
int boundary_flags
Definition: ctu.h:443
PredictionUnit::mi
MotionInfo mi
Definition: ctu.h:271
MODE_INTRA
#define MODE_INTRA
Definition: vp3.c:84
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
CR
#define CR
Definition: filter.c:33
tu_y_coded_flag_decode
static uint8_t tu_y_coded_flag_decode(VVCLocalContext *lc, const int is_sbt_not_coded, const int sub_tu_index, const int is_isp, const int is_chroma_coded)
Definition: ctu.c:272
VVCAllowedSplit
Definition: ctu.h:451
BOUNDARY_LEFT_SUBPIC
#define BOUNDARY_LEFT_SUBPIC
Definition: ctu.h:437
MODE_PLT
@ MODE_PLT
Definition: ctu.h:193
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ISP_NO_SPLIT
@ ISP_NO_SPLIT
Definition: ctu.h:120
luma_intra_pred_mode
static enum IntraPredMode luma_intra_pred_mode(VVCLocalContext *lc, const int intra_subpartitions_mode_flag)
Definition: ctu.c:684
pack_mip_info
static av_always_inline uint8_t pack_mip_info(int intra_mip_flag, int intra_mip_transposed_flag, int intra_mip_mode)
Definition: ctu.c:951
NeighbourAvailable::cand_up_left
int cand_up_left
Definition: hevcdec.h:320
ff_vvc_alf_ctb_flag
int ff_vvc_alf_ctb_flag(VVCLocalContext *lc, const int rx, const int ry, const int c_idx)
Definition: cabac.c:1048
ff_vvc_abs_mvd_greater1_flag
int ff_vvc_abs_mvd_greater1_flag(VVCLocalContext *lc)
Definition: cabac.c:1612
ff_vvc_transform_skip_flag
int ff_vvc_transform_skip_flag(VVCLocalContext *lc, const int inc)
Definition: cabac.c:1808
modes
static const SiprModeParam modes[MODE_COUNT]
Definition: sipr.c:70
derive_mmvd
static void derive_mmvd(const VVCLocalContext *lc, MvField *mvf, const Mv *mmvd_offset)
Definition: ctu.c:1281
ff_vvc_set_intra_mvf
void ff_vvc_set_intra_mvf(const VVCLocalContext *lc, const bool dmvr, const PredFlag pf, const bool ciip_flag)
Definition: mvs.c:271
palette_signaled
static int palette_signaled(VVCLocalContext *lc, const bool local_dual_tree, const int start, const int end, const int max_entries)
Definition: ctu.c:1882
av_always_inline
#define av_always_inline
Definition: attributes.h:49
hls_palette_coding
static int hls_palette_coding(VVCLocalContext *lc, const VVCTreeType tree_type)
Definition: ctu.c:2070
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vvc_tu_cb_coded_flag
int ff_vvc_tu_cb_coded_flag(VVCLocalContext *lc)
Definition: cabac.c:1682
PF_L0
@ PF_L0
Definition: hevcdec.h:121
VVCLocalContext::prev_tu_cbf_y
int prev_tu_cbf_y
prevTuCbfY;
Definition: ctu.h:413
VVCLocalContext::cu_qg_top_left_x
int cu_qg_top_left_x
CuQgTopLeftX.
Definition: ctu.h:407
get_num_intra_subpartitions
static int get_num_intra_subpartitions(enum IspType isp_split_type, int cb_width, int cb_height)
Definition: ctu.c:624
CodingUnit::x0
int x0
Definition: ctu.h:289
TransformUnit::tbs
TransformBlock tbs[VVC_MAX_SAMPLE_ARRAYS]
Definition: ctu.h:184
H266RawSliceHeader::sh_sao_chroma_used_flag
uint8_t sh_sao_chroma_used_flag
Definition: cbs_h266.h:814
VVCPH::poc
int32_t poc
PicOrderCntVal.
Definition: ps.h:153
EntryPoint
Definition: ctu.h:363
TransformBlock::coeffs
int * coeffs
Definition: ctu.h:164
ff_vvc_store_sb_mvs
void ff_vvc_store_sb_mvs(const VVCLocalContext *lc, PredictionUnit *pu)
Definition: mvs.c:412
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
run_copy
static void run_copy(const SwsImg *out_base, const SwsImg *in_base, int y, int h, const SwsPass *pass)
Definition: graph.c:97
ff_vvc_end_of_subset_one_bit
int ff_vvc_end_of_subset_one_bit(VVCLocalContext *lc)
Definition: cabac.c:2561
set_qp_c
static void set_qp_c(VVCLocalContext *lc)
Definition: ctu.c:184
H266RawSliceHeader::sh_alf_cc_cb_aps_id
uint8_t sh_alf_cc_cb_aps_id
Definition: cbs_h266.h:790
ff_vvc_no_backward_pred_flag
int ff_vvc_no_backward_pred_flag(const VVCLocalContext *lc)
Definition: mvs.c:121
TransformUnit::width
int width
Definition: ctu.h:176
hls_sao
static void hls_sao(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2539
SAOParams
Definition: dsp.h:34
chroma_qp_offset_decode
static void chroma_qp_offset_decode(VVCLocalContext *lc, const int is_128, const int is_chroma_coded)
Definition: ctu.c:292
VVCLocalContext::cu
CodingUnit * cu
Definition: ctu.h:429
EntryPoint::pp
Palette pp[VVC_MAX_SAMPLE_ARRAYS]
Definition: ctu.h:368
ff_vvc_sbt_flag
int ff_vvc_sbt_flag(VVCLocalContext *lc)
Definition: cabac.c:2506
TRAV_X
#define TRAV_X(pos)
Definition: ctu.c:1976
ff_vvc_get_qPy
int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
Definition: ctu.c:2885
ff_vvc_cu_qp_delta_abs
int ff_vvc_cu_qp_delta_abs(VVCLocalContext *lc)
Definition: cabac.c:1711
INTRA_VERT
@ INTRA_VERT
Definition: ctu.h:237
BOUNDARY_UPPER_SUBPIC
#define BOUNDARY_UPPER_SUBPIC
Definition: ctu.h:440
PredictionUnit::dmvr_flag
uint8_t dmvr_flag
Definition: ctu.h:274
hls_transform_tree
static int hls_transform_tree(VVCLocalContext *lc, int x0, int y0, int tu_width, int tu_height, int ch_type)
Definition: ctu.c:407
ret
ret
Definition: filter_design.txt:187
VVCLocalContext::chroma_qp_offset
int chroma_qp_offset[3]
CuQpOffsetCb, CuQpOffsetCr, CuQpOffsetCbCr.
Definition: ctu.h:410
pred
static const float pred[4]
Definition: siprdata.h:259
ff_vvc_pred_mode_flag
int ff_vvc_pred_mode_flag(VVCLocalContext *lc, const int is_chroma)
Definition: cabac.c:1232
IntraPredMode
IntraPredMode
Definition: hevcdec.h:126
ff_vvc_alf_luma_fixed_filter_idx
int ff_vvc_alf_luma_fixed_filter_idx(VVCLocalContext *lc)
Definition: cabac.c:1073
hls_mvd_coding
static void hls_mvd_coding(VVCLocalContext *lc, Mv *mvd)
Definition: ctu.c:1516
VVCLocalContext::sbt_num_fourths_tb0
int sbt_num_fourths_tb0
SbtNumFourthsTb0.
Definition: ctu.h:404
cu_get_max_y
static void cu_get_max_y(const CodingUnit *cu, int max_y[2][VVC_MAX_REF_ENTRIES], const VVCLocalContext *lc)
Definition: ctu.c:2724
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
ff_vvc_mvd_sign_flag
int ff_vvc_mvd_sign_flag(VVCLocalContext *lc)
Definition: cabac.c:1622
ff_vvc_mvp_ibc
int ff_vvc_mvp_ibc(VVCLocalContext *lc, const int mvp_l0_flag, const int amvr_shift, Mv *mv)
Definition: mvs.c:1735
H266RawSliceHeader::sh_alf_cc_cb_enabled_flag
uint8_t sh_alf_cc_cb_enabled_flag
Definition: cbs_h266.h:789
ALFParams::alf_ctb_filter_alt_idx
uint8_t alf_ctb_filter_alt_idx[2]
alf_ctb_filter_alt_idx[]
Definition: ctu.h:475
PredictionUnit::inter_affine_flag
uint8_t inter_affine_flag
Definition: ctu.h:260
ff_vvc_get_mvf
MvField * ff_vvc_get_mvf(const VVCFrameContext *fc, const int x0, const int y0)
Definition: mvs.c:1960
SKIPPED_TRANSFORM_TREE
#define SKIPPED_TRANSFORM_TREE(x, y)
CodingUnit::cb_height
int cb_height
Definition: ctu.h:292
ff_vvc_cu_qp_delta_sign_flag
int ff_vvc_cu_qp_delta_sign_flag(VVCLocalContext *lc)
Definition: cabac.c:1739
U
#define U(x)
Definition: vpx_arith.h:37
TransformBlock::log2_tb_height
int log2_tb_height
Definition: ctu.h:152
CodingUnit::tail
TransformUnit * tail
RefStruct reference.
Definition: ctu.h:331
ff_vvc_set_neighbour_available
void ff_vvc_set_neighbour_available(VVCLocalContext *lc, const int x0, const int y0, const int w, const int h)
Definition: ctu.c:2851
inter_data
static int inter_data(VVCLocalContext *lc)
Definition: ctu.c:1791
DUAL_TREE_CHROMA
@ DUAL_TREE_CHROMA
Definition: ctu.h:170
can_split
static void can_split(const VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int mtt_depth, int depth_offset, int part_idx, VVCSplitMode last_split_mode, VVCTreeType tree_type, VVCModeType mode_type, VVCAllowedSplit *split)
Definition: ctu.c:525
TransformBlock::has_coeffs
uint8_t has_coeffs
Definition: ctu.h:143
PredMode
PredMode
Definition: hevcdec.h:107
MotionInfo::num_sb_x
int num_sb_x
Definition: ctu.h:253
PredictionUnit::sym_mvd_flag
int sym_mvd_flag
Definition: ctu.h:269
ff_vvc_cclm_mode_idx
int ff_vvc_cclm_mode_idx(VVCLocalContext *lc)
Definition: cabac.c:1366
ff_vvc_luma_mv_merge_ibc
int ff_vvc_luma_mv_merge_ibc(VVCLocalContext *lc, const int merge_idx, Mv *mv)
Definition: mvs.c:1744
fill_dmvr_info
static void fill_dmvr_info(const VVCLocalContext *lc)
Definition: ctu.c:1770
TransformBlock
Definition: ctu.h:142
intra_luma_pred_modes
static void intra_luma_pred_modes(VVCLocalContext *lc)
Definition: ctu.c:957
TAB_MSM
#define TAB_MSM(fc, depth, x, y)
Definition: ctu.c:33
VVCSH::slice_qp_y
int8_t slice_qp_y
SliceQpY.
Definition: ps.h:251
CodingUnit::pred_mode
enum PredMode pred_mode
PredMode.
Definition: hevcdec.h:296
ff_vvc_sao_type_idx_decode
int ff_vvc_sao_type_idx_decode(VVCLocalContext *lc)
Definition: cabac.c:1013
ALFParams::ctb_filt_set_idx_y
uint8_t ctb_filt_set_idx_y
AlfCtbFiltSetIdxY.
Definition: ctu.h:474
ff_vvc_cabac_init
int ff_vvc_cabac_init(VVCLocalContext *lc, const int ctu_idx, const int rx, const int ry)
Definition: cabac.c:842
ff_vvc_run_copy_flag
bool ff_vvc_run_copy_flag(VVCLocalContext *lc, const int prev_run_type, const int prev_run_position, const int cur_pos)
Definition: cabac.c:1405
MIN_TU_SIZE
#define MIN_TU_SIZE
Definition: ctu.h:46
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
SAOParams::type_idx
uint8_t type_idx[3]
sao_type_idx
Definition: dsp.h:44
palette_add_tu
static TransformUnit * palette_add_tu(VVCLocalContext *lc, const int start, const int end, const VVCTreeType tree_type)
Definition: ctu.c:1825
mvp_data
static int mvp_data(VVCLocalContext *lc)
Definition: ctu.c:1650
EntryPoint::num_hmvp
int num_hmvp
NumHmvpCand.
Definition: ctu.h:379
get_qp_y_pred
static int get_qp_y_pred(const VVCLocalContext *lc)
Definition: ctu.c:74
PredictionUnit::general_merge_flag
uint8_t general_merge_flag
Definition: ctu.h:257
VVCLocalContext::end_of_tiles_y
int end_of_tiles_y
Definition: ctu.h:390
sbt_info
static void sbt_info(VVCLocalContext *lc, const VVCSPS *sps)
Definition: ctu.c:1114
MAX_QP
#define MAX_QP
Definition: hevcdec.h:50
TransformUnit::y0
int y0
Definition: ctu.h:175
VVCFrameContext::qp
int8_t * qp[VVC_MAX_SAMPLE_ARRAYS]
Definition: dec.h:165
CodingUnit::next
struct CodingUnit * next
RefStruct reference.
Definition: ctu.h:340
MvField::mv
Mv mv[2]
mvL0, vvL1
Definition: hevcdec.h:311
ALFParams
Definition: ctu.h:472
ff_vvc_sao_merge_flag_decode
int ff_vvc_sao_merge_flag_decode(VVCLocalContext *lc)
Definition: cabac.c:1008
Mv
Definition: hevcdec.h:305
merge_data_block
static void merge_data_block(VVCLocalContext *lc)
Definition: ctu.c:1440
MvField::ref_idx
int8_t ref_idx[2]
refIdxL0, refIdxL1
Definition: hevcdec.h:312
set_tb_tab
static void set_tb_tab(uint8_t *tab, uint8_t v, const VVCFrameContext *fc, const TransformBlock *tb)
Definition: ctu.c:59
set_tb_size
static void set_tb_size(const VVCFrameContext *fc, const TransformBlock *tb)
Definition: ctu.c:42
PF_PLT
@ PF_PLT
Definition: ctu.h:228
lfnst_idx_decode
static int lfnst_idx_decode(VVCLocalContext *lc)
Definition: ctu.c:795
ff_vvc_mts_idx
int ff_vvc_mts_idx(VVCLocalContext *lc)
Definition: cabac.c:2541
ff_vvc_general_merge_flag
int ff_vvc_general_merge_flag(VVCLocalContext *lc)
Definition: cabac.c:1432
VVCFrameContext::ps
VVCFrameParamSets ps
Definition: dec.h:131
VVCSH::max_bt_size
uint8_t max_bt_size[2]
MaxBtSizeY, MaxBtSizeC.
Definition: ps.h:258
TAB_ISPMF
#define TAB_ISPMF(fc, x, y)
Definition: ctu.c:34
SINGLE_TREE
@ SINGLE_TREE
Definition: ctu.h:168
ff_vvc_intra_chroma_pred_mode
int ff_vvc_intra_chroma_pred_mode(VVCLocalContext *lc)
Definition: cabac.c:1373
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
VVCSPS::r
const H266RawSPS * r
RefStruct reference.
Definition: ps.h:59
PredFlag
PredFlag
Definition: hevcdec.h:119
H266RawSliceHeader::sh_num_alf_aps_ids_luma
uint8_t sh_num_alf_aps_ids_luma
Definition: cbs_h266.h:784
SliceContext::sh
VVCSH sh
Definition: dec.h:115
ff_vvc_tu_cr_coded_flag
int ff_vvc_tu_cr_coded_flag(VVCLocalContext *lc, int tu_cb_coded_flag)
Definition: cabac.c:1687
ff_vvc_alf_ctb_cc_idc
int ff_vvc_alf_ctb_cc_idc(VVCLocalContext *lc, const int rx, const int ry, const int idx, const int cc_filters_signalled)
Definition: cabac.c:1088
CodingUnit::isp_split_type
enum IspType isp_split_type
IntraSubPartitionsSplitType.
Definition: ctu.h:315
VVCFrameContext
Definition: dec.h:122
coding_tree_fn
int(* coding_tree_fn)(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c, int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, VVCTreeType tree_type, VVCModeType mode_type)
Definition: ctu.c:2409
ff_vvc_intra_luma_mpm_flag
int ff_vvc_intra_luma_mpm_flag(VVCLocalContext *lc)
Definition: cabac.c:1338
CodingUnit::mip_chroma_direct_flag
int mip_chroma_direct_flag
MipChromaDirectFlag.
Definition: ctu.h:323
Palette
Definition: flashsv2enc.c:83
ALFParams::ctb_flag
uint8_t ctb_flag[3]
alf_ctb_flag[]
Definition: ctu.h:473
MvField::bcw_idx
uint8_t bcw_idx
bcwIdx
Definition: ctu.h:206
ff_vvc_sao_offset_abs_decode
int ff_vvc_sao_offset_abs_decode(VVCLocalContext *lc)
Definition: cabac.c:1028
int32_t
int32_t
Definition: audioconvert.c:56
CodingUnit::skip_flag
uint8_t skip_flag
cu_skip_flag;
Definition: ctu.h:309
IS_I
#define IS_I(rsh)
Definition: ps.h:38
ff_vvc_mmvd_cand_flag
int ff_vvc_mmvd_cand_flag(VVCLocalContext *lc)
Definition: cabac.c:1475
ff_vvc_store_mvf
void ff_vvc_store_mvf(const VVCLocalContext *lc, const MvField *mvf)
Definition: mvs.c:502
SET_SAO
#define SET_SAO(elem, value)
Definition: ctu.c:2527
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
VVCSH::min_qt_size
uint8_t min_qt_size[2]
MinQtSizeY, MinQtSizeC.
Definition: ps.h:257
mvds_decode
static int mvds_decode(VVCLocalContext *lc, Mv mvds[2][MAX_CONTROL_POINTS], const int num_cp_mv, const int lx)
Definition: ctu.c:1573
ff_vvc_amvr_shift
int ff_vvc_amvr_shift(VVCLocalContext *lc, const int inter_affine_flag, const PredMode pred_mode, const int has_amvr_flag)
Definition: cabac.c:1648
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
TransformUnit::joint_cbcr_residual_flag
uint8_t joint_cbcr_residual_flag
tu_joint_cbcr_residual_flag
Definition: ctu.h:180
ff_vvc_intra_bdpcm_luma_dir_flag
int ff_vvc_intra_bdpcm_luma_dir_flag(VVCLocalContext *lc)
Definition: cabac.c:1253
ff_vvc_intra_bdpcm_luma_flag
int ff_vvc_intra_bdpcm_luma_flag(VVCLocalContext *lc)
Definition: cabac.c:1248
h
h
Definition: vp9dsp_template.c:2070
ctu.h
BOUNDARY_LEFT_SLICE
#define BOUNDARY_LEFT_SLICE
Definition: hevcdec.h:441
VVCLocalContext::ep
EntryPoint * ep
Definition: ctu.h:447
width
#define width
Definition: dsp.h:89
ff_vvc_palette_predictor_run
int ff_vvc_palette_predictor_run(VVCLocalContext *lc)
Definition: cabac.c:1380
transpose
#define transpose(x)
set_qp_c_tab
static void set_qp_c_tab(const VVCLocalContext *lc, const TransformUnit *tu, const TransformBlock *tb)
Definition: ctu.c:176
VVCLocalContext::cu_qg_top_left_y
int cu_qg_top_left_y
CuQgTopLeftY.
Definition: ctu.h:408
ff_vvc_ep_init_stat_coeff
void ff_vvc_ep_init_stat_coeff(EntryPoint *ep, const int bit_depth, const int persistent_rice_adaptation_enabled_flag)
Definition: ctu.c:2893
INTRA_LT_CCLM
@ INTRA_LT_CCLM
Definition: ctu.h:239
H266RawSliceHeader::sh_alf_cr_enabled_flag
uint8_t sh_alf_cr_enabled_flag
Definition: cbs_h266.h:787
CodingUnit::ciip_flag
uint8_t ciip_flag
Definition: ctu.h:312
ff_vvc_non_inter_flag
int ff_vvc_non_inter_flag(VVCLocalContext *lc, const int x0, const int y0, const int ch_type)
Definition: cabac.c:1222
ff_vvc_cclm_mode_flag
int ff_vvc_cclm_mode_flag(VVCLocalContext *lc)
Definition: cabac.c:1361
palette_predicted
static int palette_predicted(VVCLocalContext *lc, const bool local_dual_tree, int start, int end, bool *predictor_reused, const int predictor_size, const int max_entries)
Definition: ctu.c:1848
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
PredictionUnit::merge_subblock_flag
uint8_t merge_subblock_flag
Definition: ctu.h:263
ff_vvc_palette_escape_val
int ff_vvc_palette_escape_val(VVCLocalContext *lc)
Definition: cabac.c:1427
max_pos
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1dec.c:97
palette_subblock_data
static int palette_subblock_data(VVCLocalContext *lc, const int max_index, const int subset_id, const bool transpose, uint8_t *run_type, uint8_t *index, int *prev_run_pos, bool *adjust)
Definition: ctu.c:1979
has_inter_luma
static int has_inter_luma(const CodingUnit *cu)
Definition: ctu.c:2709
CodingUnit::num_intra_subpartitions
int num_intra_subpartitions
Definition: ctu.h:319
VVCLocalContext::ctb_left_flag
uint8_t ctb_left_flag
Definition: ctu.h:385
ff_vvc_mv_scale
void ff_vvc_mv_scale(Mv *dst, const Mv *src, int td, int tb)
Definition: mvs.c:71
MtsIdx
MtsIdx
Definition: ctu.h:134
MIN_TU_LOG2
#define MIN_TU_LOG2
MinTbLog2SizeY.
Definition: dec.h:41
VVCLocalContext::is_cu_chroma_qp_offset_coded
int is_cu_chroma_qp_offset_coded
IsCuChromaQpOffsetCoded.
Definition: ctu.h:409
VVCLocalContext::is_cu_qp_delta_coded
uint8_t is_cu_qp_delta_coded
IsCuQpDeltaCoded.
Definition: ctu.h:406
merge_data_gpm
static void merge_data_gpm(VVCLocalContext *lc)
Definition: ctu.c:1401
CodingUnit::y0
int y0
Definition: ctu.h:290
CodingUnit::qp
int8_t qp[4]
QpY, Qp′Cb, Qp′Cr, Qp′CbCr.
Definition: ctu.h:334
ff_vvc_intra_bdpcm_chroma_flag
int ff_vvc_intra_bdpcm_chroma_flag(VVCLocalContext *lc)
Definition: cabac.c:1258
ff_vvc_copy_above_palette_indices_flag
bool ff_vvc_copy_above_palette_indices_flag(VVCLocalContext *lc)
Definition: cabac.c:1417
ff_vvc_ctu_free_cus
void ff_vvc_ctu_free_cus(CodingUnit **cus)
Definition: ctu.c:2866
CodingUnit::tus
struct CodingUnit::@321 tus
Generated on Wed Jul 9 2025 19:22:48 for FFmpeg by   doxygen 1.8.17