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 void 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  predictor_reused[i] = true;
1867  for (int c = start; c < end; c++)
1868  cu->plt[c].entries[nb_predicted] = lc->ep->pp[c].entries[i];
1869  nb_predicted++;
1870  }
1871 
1872  for (int c = start; c < end; c++)
1873  cu->plt[c].size = nb_predicted;
1874 }
1875 
1876 static void palette_signaled(VVCLocalContext *lc, const bool local_dual_tree,
1877  const int start, const int end, const int max_entries)
1878 {
1879  const VVCSPS *sps = lc->fc->ps.sps;
1880  CodingUnit *cu = lc->cu;
1881  const int nb_predicted = cu->plt[start].size;
1882  const int nb_signaled = nb_predicted < max_entries ? ff_vvc_num_signalled_palette_entries(lc) : 0;
1883  const int size = nb_predicted + nb_signaled;
1884  const bool dual_tree_luma = local_dual_tree && cu->tree_type == DUAL_TREE_LUMA;
1885 
1886  for (int c = start; c < end; c++) {
1887  Palette *plt = cu->plt + c;
1888  for (int i = nb_predicted; i < size; i++) {
1889  plt->entries[i] = ff_vvc_new_palette_entries(lc, sps->bit_depth);
1890  if (dual_tree_luma) {
1891  plt[CB].entries[i] = 1 << (sps->bit_depth - 1);
1892  plt[CR].entries[i] = 1 << (sps->bit_depth - 1);
1893  }
1894  }
1895  plt->size = size;
1896  }
1897 }
1898 
1899 static void palette_update_predictor(VVCLocalContext *lc, const bool local_dual_tree, int start, int end,
1900  bool *predictor_reused, const int predictor_size)
1901 {
1902  CodingUnit *cu = lc->cu;
1903  const int max_predictor = VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE >> (cu->tree_type != SINGLE_TREE && !local_dual_tree);
1904 
1905  if (local_dual_tree) {
1906  start = LUMA;
1907  end = VVC_MAX_SAMPLE_ARRAYS;
1908  }
1909 
1910  for (int c = start; c < end; c++) {
1911  Palette *pp = lc->ep->pp + c;
1912  Palette *plt = cu->plt + c;
1913  int i = cu->plt[start].size;;
1914 
1915  // copy unused predictors to the end of plt
1916  for (int j = 0; j < predictor_size && i < max_predictor; j++) {
1917  if (!predictor_reused[j]) {
1918  plt->entries[i] = pp->entries[j];
1919  i++;
1920  }
1921  }
1922 
1923  memcpy(pp->entries, plt->entries, i * sizeof(pp->entries[0]));
1924  pp->size = i;
1925  }
1926 }
1927 
1928 static void palette_qp(VVCLocalContext *lc, VVCTreeType tree_type, const bool escape_present)
1929 {
1930  const VVCFrameContext *fc = lc->fc;
1931  const VVCPPS *pps = fc->ps.pps;
1932  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1933  const CodingUnit *cu = lc->cu;
1934 
1935  if (tree_type != DUAL_TREE_CHROMA) {
1936  const bool has_qp_delta = escape_present &&
1937  pps->r->pps_cu_qp_delta_enabled_flag && !lc->parse.is_cu_qp_delta_coded;
1938  set_qp_y(lc, cu->x0, cu->y0, has_qp_delta);
1939  }
1940 
1941  if (tree_type != DUAL_TREE_LUMA) {
1942  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && !lc->parse.is_cu_chroma_qp_offset_coded)
1943  chroma_qp_offset_decode(lc, 0, 1);
1944  set_qp_c(lc);
1945  }
1946 }
1947 
1948 #define PALETTE_SET_PIXEL(xc, yc, pix) \
1949  do { \
1950  const int off = ((xc) >> hs) + ((yc) >> vs) * tb->tb_width; \
1951  if (sps->bit_depth == 8) \
1952  u8[off] = pix; \
1953  else \
1954  u16[off] = pix; \
1955  } while (0)
1956 
1957 #define PALETTE_INDEX(x, y) index[(y) * cu->cb_width + (x)]
1958 
1959 // 6.5.3 Horizontal and vertical traverse scan order array initialization process
1960 // The hTravScan and vTravScan tables require approximately 576 KB of memory.
1961 // To save space, we use a macro to achieve the same functionality.
1962 #define TRAV_COL(p, wlog, mask) ((p & mask) ^ (-((p >> wlog) & 1) & mask))
1963 #define TRAV_ROW(p, hlog) (p >> hlog)
1964 #define TRAV(trans, p, wlog, hlog, mask) (trans ? TRAV_ROW((p), hlog) : TRAV_COL((p), wlog, mask))
1965 #define TRAV_X(pos) TRAV(transpose, pos, wlog2, hlog2, wmask)
1966 #define TRAV_Y(pos) TRAV(!transpose, pos, hlog2, wlog2, hmask)
1967 
1968 static int palette_subblock_data(VVCLocalContext *lc,
1969  const int max_index, const int subset_id, const bool transpose,
1970  uint8_t *run_type, uint8_t *index, int *prev_run_pos, bool *adjust)
1971 {
1972  const CodingUnit *cu = lc->cu;
1973  TransformUnit *tu = cu->tus.head;
1974  const VVCSPS *sps = lc->fc->ps.sps;
1975  const int min_pos = subset_id << 4;
1976  const int max_pos = FFMIN(min_pos + 16, cu->cb_width * cu->cb_height);
1977  const int wmask = cu->cb_width - 1;
1978  const int hmask = cu->cb_height - 1;
1979  const int wlog2 = av_log2(cu->cb_width);
1980  const int hlog2 = av_log2(cu->cb_height);
1981  const uint8_t esc = cu->plt[tu->tbs[0].c_idx].size;
1982  uint8_t run_copy[16] = { 0 };
1983 
1984  for (int i = min_pos; i < max_pos; i++) {
1985  const int xc = TRAV_X(i);
1986  const int yc = TRAV_Y(i);
1987 
1988  if (i > 0 && max_index > 0)
1989  run_copy[i - min_pos] = ff_vvc_run_copy_flag(lc, run_type[i - 1], *prev_run_pos, i);
1990 
1991  run_type[i] = 0;
1992  if (max_index > 0 && !run_copy[i - min_pos]) {
1993  if (((!transpose && yc > 0) || (transpose && xc > 0))
1994  && i > 0 && !run_type[i - 1]) {
1995  run_type[i] = ff_vvc_copy_above_palette_indices_flag(lc);
1996  }
1997  *prev_run_pos = i;
1998  } else if (i > 0) {
1999  run_type[i] = run_type[i - 1];
2000  }
2001  }
2002 
2003  for (int i = min_pos; i < max_pos; i++) {
2004  const int xc = TRAV_X(i);
2005  const int yc = TRAV_Y(i);
2006  const int prev_xc = i > 0 ? TRAV_X(i - 1) : 0;
2007  const int prev_yc = i > 0 ? TRAV_Y(i - 1) : 0;
2008 
2009  int idx = 0;
2010  if (max_index > 0 && !run_copy[i - min_pos] && !run_type[i]) {
2011  if (max_index - *adjust > 0)
2012  idx = ff_vvc_palette_idx_idc(lc, max_index, *adjust);
2013  if (i > 0) {
2014  const int ref_idx = !run_type[i - 1] ?
2015  PALETTE_INDEX(prev_xc, prev_yc) : PALETTE_INDEX(xc - transpose, yc - !transpose);
2016  idx += (idx >= ref_idx);
2017  }
2018  *adjust = true;
2019  } else {
2020  idx = PALETTE_INDEX(prev_xc, prev_yc);
2021  }
2022 
2023  if (!run_type[i])
2024  PALETTE_INDEX(xc, yc) = idx;
2025  else
2026  PALETTE_INDEX(xc, yc) = PALETTE_INDEX(xc - transpose, yc - !transpose);
2027  }
2028 
2029  for (int c = 0; c < tu->nb_tbs; c++) {
2030  TransformBlock *tb = &tu->tbs[c];
2031  const Palette *plt = cu->plt + tb->c_idx;
2032  const int scale = ff_vvc_palette_derive_scale(lc, tu, tb);
2033  const int hs = sps->hshift[c];
2034  const int vs = sps->vshift[c];
2035  uint8_t *u8 = (uint8_t *)tb->coeffs;
2036  uint16_t *u16 = (uint16_t *)tb->coeffs;
2037 
2038  for (int i = min_pos; i < max_pos; i++) {
2039  const int xc = TRAV_X(i);
2040  const int yc = TRAV_Y(i);
2041  if (!(xc & hs) && !(yc & vs)) {
2042  const int v = PALETTE_INDEX(xc, yc);
2043  if (v == esc) {
2044  const int coeff = ff_vvc_palette_escape_val(lc);
2045  const int pixel = av_clip_intp2(RSHIFT(coeff * scale, 6), sps->bit_depth);
2046  PALETTE_SET_PIXEL(xc, yc, pixel);
2047  } else {
2048  PALETTE_SET_PIXEL(xc, yc, plt->entries[v]);
2049  }
2050  }
2051  }
2052  }
2053 
2054  return 0;
2055 }
2056 
2057 static int hls_palette_coding(VVCLocalContext *lc, const VVCTreeType tree_type)
2058 {
2059  const VVCFrameContext *fc = lc->fc;
2060  const VVCSPS *sps = fc->ps.sps;
2061  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2062  CodingUnit *cu = lc->cu;
2063  Palette *pp = lc->ep->pp;
2064  const int max_entries = tree_type == SINGLE_TREE ? 31 : 15;
2065  const bool local_dual_tree = tree_type != SINGLE_TREE &&
2066  (!IS_I(rsh) || (IS_I(rsh) && !sps->r->sps_qtbtt_dual_tree_intra_flag));
2067  bool escape_present = false;
2068  bool transpose = false;
2069  bool adjust = false;
2070  int max_index = 0;
2071  int prev_run_pos = 0;
2072 
2073  int predictor_size, start, end;
2074  bool reused[VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE];
2075  uint8_t run_type[MAX_PALETTE_CU_SIZE * MAX_PALETTE_CU_SIZE];
2076  uint8_t index[MAX_PALETTE_CU_SIZE * MAX_PALETTE_CU_SIZE];
2077 
2078  ff_vvc_channel_range(&start, &end, tree_type, sps->r->sps_chroma_format_idc);
2079 
2080  if (!palette_add_tu(lc, start, end, tree_type))
2081  return AVERROR(ENOMEM);
2082 
2083  predictor_size = pp[start].size;
2084  memset(reused, 0, sizeof(reused[0]) * predictor_size);
2085  palette_predicted(lc, local_dual_tree, start, end, reused, predictor_size, max_entries);
2086  palette_signaled(lc, local_dual_tree, start, end, max_entries);
2087  palette_update_predictor(lc, local_dual_tree, start, end, reused, predictor_size);
2088 
2089  if (cu->plt[start].size > 0)
2090  escape_present = ff_vvc_palette_escape_val_present_flag(lc);
2091 
2092  max_index = cu->plt[start].size - 1 + escape_present;
2093  if (max_index > 0) {
2094  adjust = false;
2095  transpose = ff_vvc_palette_transpose_flag(lc);
2096  }
2097 
2098  palette_qp(lc, tree_type, escape_present);
2099 
2100  index[0] = 0;
2101  for (int i = 0; i <= (cu->cb_width * cu->cb_height - 1) >> 4; i++)
2102  palette_subblock_data(lc, max_index, i, transpose,
2103  run_type, index, &prev_run_pos, &adjust);
2104 
2105  return 0;
2106 }
2107 
2108 static int intra_data(VVCLocalContext *lc)
2109 {
2110  const VVCSPS *sps = lc->fc->ps.sps;
2111  const CodingUnit *cu = lc->cu;
2112  const VVCTreeType tree_type = cu->tree_type;
2113  const bool pred_mode_plt_flag = cu->pred_mode == MODE_PLT;
2114  int ret = 0;
2115 
2116  if (tree_type == SINGLE_TREE || tree_type == DUAL_TREE_LUMA) {
2117  if (pred_mode_plt_flag) {
2118  if ((ret = hls_palette_coding(lc, tree_type)) < 0)
2119  return ret;
2120  ff_vvc_set_intra_mvf(lc, false, PF_PLT, false);
2121  } else {
2122  intra_luma_pred_modes(lc);
2123  ff_vvc_set_intra_mvf(lc, false, PF_INTRA, cu->ciip_flag);
2124  }
2125  }
2126  if ((tree_type == SINGLE_TREE || tree_type == DUAL_TREE_CHROMA) && sps->r->sps_chroma_format_idc) {
2127  if (pred_mode_plt_flag && tree_type == DUAL_TREE_CHROMA) {
2128  if ((ret = hls_palette_coding(lc, tree_type)) < 0)
2129  return ret;
2130  } else if (!pred_mode_plt_flag) {
2131  intra_chroma_pred_modes(lc);
2132  }
2133  }
2134 
2135  return ret;
2136 }
2137 
2138 static int hls_coding_unit(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height,
2139  int cqt_depth, const VVCTreeType tree_type, VVCModeType mode_type)
2140 {
2141  const VVCFrameContext *fc = lc->fc;
2142  const VVCSPS *sps = fc->ps.sps;
2143  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2144  const int is_128 = cb_width > 64 || cb_height > 64;
2145  int ret = 0;
2146 
2147  CodingUnit *cu = add_cu(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type);
2148 
2149  if (!cu)
2150  return AVERROR(ENOMEM);
2151 
2152  ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
2153 
2154  if (IS_I(rsh) && is_128)
2155  mode_type = MODE_TYPE_INTRA;
2156  cu->pred_mode = pred_mode_decode(lc, tree_type, mode_type);
2157 
2158  if (cu->pred_mode == MODE_INTRA && sps->r->sps_act_enabled_flag && tree_type == SINGLE_TREE)
2159  cu->act_enabled_flag = ff_vvc_cu_act_enabled_flag(lc);
2160 
2161  if (cu->pred_mode == MODE_INTRA || cu->pred_mode == MODE_PLT)
2162  ret = intra_data(lc);
2163  else if (tree_type != DUAL_TREE_CHROMA) /* MODE_INTER or MODE_IBC */
2164  ret = inter_data(lc);
2165 
2166  if (ret < 0)
2167  return ret;
2168 
2169  if (cu->pred_mode != MODE_INTRA && cu->pred_mode != MODE_PLT && !lc->cu->pu.general_merge_flag)
2170  cu->coded_flag = ff_vvc_cu_coded_flag(lc);
2171  else
2172  cu->coded_flag = !(cu->skip_flag || cu->pred_mode == MODE_PLT);
2173 
2174  if (cu->coded_flag) {
2175  sbt_info(lc, sps);
2176  if (sps->r->sps_act_enabled_flag && cu->pred_mode != MODE_INTRA && tree_type == SINGLE_TREE)
2177  cu->act_enabled_flag = ff_vvc_cu_act_enabled_flag(lc);
2178  lc->parse.lfnst_dc_only = 1;
2179  lc->parse.lfnst_zero_out_sig_coeff_flag = 1;
2180  lc->parse.mts_dc_only = 1;
2181  lc->parse.mts_zero_out_sig_coeff_flag = 1;
2182  ret = hls_transform_tree(lc, x0, y0, cb_width, cb_height, cu->ch_type);
2183  if (ret < 0)
2184  return ret;
2185  cu->lfnst_idx = lfnst_idx_decode(lc);
2186  cu->mts_idx = mts_idx_decode(lc);
2187  set_qp_c(lc);
2188  } else if (cu->pred_mode != MODE_PLT) {
2189  ret = skipped_transform_tree_unit(lc);
2190  if (ret < 0)
2191  return ret;
2192  }
2193  set_cu_tabs(lc, cu);
2194 
2195  return 0;
2196 }
2197 
2198 static int derive_mode_type_condition(const VVCLocalContext *lc,
2199  const VVCSplitMode split, const int cb_width, const int cb_height, const VVCModeType mode_type_curr)
2200 {
2201  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2202  const VVCSPS *sps = lc->fc->ps.sps;
2203  const int area = cb_width * cb_height;
2204 
2205  if ((IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag) ||
2206  mode_type_curr != MODE_TYPE_ALL || !sps->r->sps_chroma_format_idc ||
2207  sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444)
2208  return 0;
2209  if ((area == 64 && (split == SPLIT_QT || split == SPLIT_TT_HOR || split == SPLIT_TT_VER)) ||
2210  (area == 32 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER)))
2211  return 1;
2212  if ((area == 64 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
2213  (area == 128 && (split == SPLIT_TT_HOR || split == SPLIT_TT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
2214  (cb_width == 8 && split == SPLIT_BT_VER) || (cb_width == 16 && split == SPLIT_TT_VER))
2215  return 1 + !IS_I(rsh);
2216 
2217  return 0;
2218 }
2219 
2220 static VVCModeType mode_type_decode(VVCLocalContext *lc, const int x0, const int y0,
2221  const int cb_width, const int cb_height, const VVCSplitMode split, const int ch_type,
2222  const VVCModeType mode_type_curr)
2223 {
2224  VVCModeType mode_type;
2225  const int mode_type_condition = derive_mode_type_condition(lc, split, cb_width, cb_height, mode_type_curr);
2226 
2227  if (mode_type_condition == 1)
2228  mode_type = MODE_TYPE_INTRA;
2229  else if (mode_type_condition == 2) {
2230  mode_type = ff_vvc_non_inter_flag(lc, x0, y0, ch_type) ? MODE_TYPE_INTRA : MODE_TYPE_INTER;
2231  } else {
2232  mode_type = mode_type_curr;
2233  }
2234 
2235  return mode_type;
2236 }
2237 
2238 static int hls_coding_tree(VVCLocalContext *lc,
2239  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2240  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
2241  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr);
2242 
2243 static int coding_tree_btv(VVCLocalContext *lc,
2244  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2245  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2246  VVCTreeType tree_type, VVCModeType mode_type)
2247 {
2248 #define CODING_TREE(x, idx) do { \
2249  ret = hls_coding_tree(lc, x, y0, cb_width / 2, cb_height, \
2250  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
2251  depth_offset, idx, SPLIT_BT_VER, tree_type, mode_type); \
2252  if (ret < 0) \
2253  return ret; \
2254 } while (0);
2255 
2256  const VVCPPS *pps = lc->fc->ps.pps;
2257  const int x1 = x0 + cb_width / 2;
2258  int ret = 0;
2259 
2260  depth_offset += (x0 + cb_width > pps->width) ? 1 : 0;
2261  CODING_TREE(x0, 0);
2262  if (x1 < pps->width)
2263  CODING_TREE(x1, 1);
2264 
2265  return 0;
2266 
2267 #undef CODING_TREE
2268 }
2269 
2270 static int coding_tree_bth(VVCLocalContext *lc,
2271  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2272  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2273  VVCTreeType tree_type, VVCModeType mode_type)
2274 {
2275 #define CODING_TREE(y, idx) do { \
2276  ret = hls_coding_tree(lc, x0, y, cb_width , cb_height / 2, \
2277  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
2278  depth_offset, idx, SPLIT_BT_HOR, tree_type, mode_type); \
2279  if (ret < 0) \
2280  return ret; \
2281  } while (0);
2282 
2283  const VVCPPS *pps = lc->fc->ps.pps;
2284  const int y1 = y0 + (cb_height / 2);
2285  int ret = 0;
2286 
2287  depth_offset += (y0 + cb_height > pps->height) ? 1 : 0;
2288  CODING_TREE(y0, 0);
2289  if (y1 < pps->height)
2290  CODING_TREE(y1, 1);
2291 
2292  return 0;
2293 
2294 #undef CODING_TREE
2295 }
2296 
2297 static int coding_tree_ttv(VVCLocalContext *lc,
2298  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2299  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2300  VVCTreeType tree_type, VVCModeType mode_type)
2301 {
2302 #define CODING_TREE(x, w, sub_div, idx) do { \
2303  ret = hls_coding_tree(lc, x, y0, w, cb_height, \
2304  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
2305  depth_offset, idx, SPLIT_TT_VER, tree_type, mode_type); \
2306  if (ret < 0) \
2307  return ret; \
2308  } while (0);
2309 
2310  const VVCSH *sh = &lc->sc->sh;
2311  const int x1 = x0 + cb_width / 4;
2312  const int x2 = x0 + cb_width * 3 / 4;
2313  int ret;
2314 
2315  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2316  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2317 
2318  CODING_TREE(x0, cb_width / 4, cb_sub_div + 2, 0);
2319  CODING_TREE(x1, cb_width / 2, cb_sub_div + 1, 1);
2320  CODING_TREE(x2, cb_width / 4, cb_sub_div + 2, 2);
2321 
2322  return 0;
2323 
2324 #undef CODING_TREE
2325 }
2326 
2327 static int coding_tree_tth(VVCLocalContext *lc,
2328  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2329  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2330  VVCTreeType tree_type, VVCModeType mode_type)
2331 {
2332 #define CODING_TREE(y, h, sub_div, idx) do { \
2333  ret = hls_coding_tree(lc, x0, y, cb_width, h, \
2334  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
2335  depth_offset, idx, SPLIT_TT_HOR, tree_type, mode_type); \
2336  if (ret < 0) \
2337  return ret; \
2338  } while (0);
2339 
2340  const VVCSH *sh = &lc->sc->sh;
2341  const int y1 = y0 + (cb_height / 4);
2342  const int y2 = y0 + (3 * cb_height / 4);
2343  int ret;
2344 
2345  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2346  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2347 
2348  CODING_TREE(y0, cb_height / 4, cb_sub_div + 2, 0);
2349  CODING_TREE(y1, cb_height / 2, cb_sub_div + 1, 1);
2350  CODING_TREE(y2, cb_height / 4, cb_sub_div + 2, 2);
2351 
2352  return 0;
2353 
2354 #undef CODING_TREE
2355 }
2356 
2357 static int coding_tree_qt(VVCLocalContext *lc,
2358  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2359  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2360  VVCTreeType tree_type, VVCModeType mode_type)
2361 {
2362 #define CODING_TREE(x, y, idx) do { \
2363  ret = hls_coding_tree(lc, x, y, cb_width / 2, cb_height / 2, \
2364  qg_on_y, qg_on_c, cb_sub_div + 2, cqt_depth + 1, 0, 0, \
2365  idx, SPLIT_QT, tree_type, mode_type); \
2366  if (ret < 0) \
2367  return ret; \
2368  } while (0);
2369 
2370  const VVCPPS *pps = lc->fc->ps.pps;
2371  const int x1 = x0 + cb_width / 2;
2372  const int y1 = y0 + cb_height / 2;
2373  int ret = 0;
2374 
2375  CODING_TREE(x0, y0, 0);
2376  if (x1 < pps->width)
2377  CODING_TREE(x1, y0, 1);
2378  if (y1 < pps->height)
2379  CODING_TREE(x0, y1, 2);
2380  if (x1 < pps->width &&
2381  y1 < pps->height)
2382  CODING_TREE(x1, y1, 3);
2383 
2384  return 0;
2385 
2386 #undef CODING_TREE
2387 }
2388 
2389 typedef int (*coding_tree_fn)(VVCLocalContext *lc,
2390  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2391  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2392  VVCTreeType tree_type, VVCModeType mode_type);
2393 
2394 const static coding_tree_fn coding_tree[] = {
2395  coding_tree_tth,
2396  coding_tree_bth,
2397  coding_tree_ttv,
2398  coding_tree_btv,
2399  coding_tree_qt,
2400 };
2401 
2402 static int hls_coding_tree(VVCLocalContext *lc,
2403  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2404  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
2405  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr)
2406 {
2407  VVCFrameContext *fc = lc->fc;
2408  const VVCPPS *pps = fc->ps.pps;
2409  const VVCSH *sh = &lc->sc->sh;
2410  const H266RawSliceHeader *rsh = sh->r;
2411  const int ch_type = tree_type_curr == DUAL_TREE_CHROMA;
2412  int ret;
2413  VVCAllowedSplit allowed;
2414 
2415  if (pps->r->pps_cu_qp_delta_enabled_flag && qg_on_y && cb_sub_div <= sh->cu_qp_delta_subdiv) {
2416  lc->parse.is_cu_qp_delta_coded = 0;
2417  lc->parse.cu_qg_top_left_x = x0;
2418  lc->parse.cu_qg_top_left_y = y0;
2419  }
2420  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && qg_on_c &&
2421  cb_sub_div <= sh->cu_chroma_qp_offset_subdiv) {
2422  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2423  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2424  }
2425 
2426  can_split(lc, x0, y0, cb_width, cb_height, mtt_depth, depth_offset, part_idx,
2427  last_split_mode, tree_type_curr, mode_type_curr, &allowed);
2428  if (ff_vvc_split_cu_flag(lc, x0, y0, cb_width, cb_height, ch_type, &allowed)) {
2429  VVCSplitMode split = ff_vvc_split_mode(lc, x0, y0, cb_width, cb_height, cqt_depth, mtt_depth, ch_type, &allowed);
2430  VVCModeType mode_type = mode_type_decode(lc, x0, y0, cb_width, cb_height, split, ch_type, mode_type_curr);
2431 
2432  VVCTreeType tree_type = (mode_type == MODE_TYPE_INTRA) ? DUAL_TREE_LUMA : tree_type_curr;
2433 
2434  if (split != SPLIT_QT) {
2435  if (!(x0 & 31) && !(y0 & 31) && mtt_depth <= 1)
2436  TAB_MSM(fc, mtt_depth, x0, y0) = split;
2437  }
2438  ret = coding_tree[split - 1](lc, x0, y0, cb_width, cb_height, qg_on_y, qg_on_c,
2439  cb_sub_div, cqt_depth, mtt_depth, depth_offset, tree_type, mode_type);
2440  if (ret < 0)
2441  return ret;
2442  if (mode_type_curr == MODE_TYPE_ALL && mode_type == MODE_TYPE_INTRA) {
2443  ret = hls_coding_tree(lc, x0, y0, cb_width, cb_height, 0, qg_on_c, cb_sub_div,
2444  cqt_depth, mtt_depth, 0, 0, split, DUAL_TREE_CHROMA, mode_type);
2445  if (ret < 0)
2446  return ret;
2447  }
2448  } else {
2449  ret = hls_coding_unit(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type_curr, mode_type_curr);
2450  if (ret < 0)
2451  return ret;
2452  }
2453 
2454  return 0;
2455 }
2456 
2457 static int dual_tree_implicit_qt_split(VVCLocalContext *lc,
2458  const int x0, const int y0, const int cb_size, const int cqt_depth)
2459 {
2460  const VVCSH *sh = &lc->sc->sh;
2461  const H266RawSliceHeader *rsh = sh->r;
2462  const VVCPPS *pps = lc->fc->ps.pps;
2463  const int cb_subdiv = 2 * cqt_depth;
2464  int ret;
2465 
2466  if (cb_size > 64) {
2467  #define DUAL_TREE(x, y) do { \
2468  ret = dual_tree_implicit_qt_split(lc, x, y, cb_size / 2, cqt_depth + 1); \
2469  if (ret < 0) \
2470  return ret; \
2471  } while (0)
2472 
2473  const int x1 = x0 + (cb_size / 2);
2474  const int y1 = y0 + (cb_size / 2);
2475  if (pps->r->pps_cu_qp_delta_enabled_flag && cb_subdiv <= sh->cu_qp_delta_subdiv) {
2476  lc->parse.is_cu_qp_delta_coded = 0;
2477  lc->parse.cu_qg_top_left_x = x0;
2478  lc->parse.cu_qg_top_left_y = y0;
2479  }
2480  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && cb_subdiv <= sh->cu_chroma_qp_offset_subdiv) {
2481  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2482  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2483  }
2484  DUAL_TREE(x0, y0);
2485  if (x1 < pps->width)
2486  DUAL_TREE(x1, y0);
2487  if (y1 < pps->height)
2488  DUAL_TREE(x0, y1);
2489  if (x1 < pps->width && y1 < pps->height)
2490  DUAL_TREE(x1, y1);
2491  #undef DUAL_TREE
2492  } else {
2493  #define CODING_TREE(tree_type) do { \
2494  const int qg_on_y = tree_type == DUAL_TREE_LUMA; \
2495  ret = hls_coding_tree(lc, x0, y0, cb_size, cb_size, qg_on_y, !qg_on_y, \
2496  cb_subdiv, cqt_depth, 0, 0, 0, SPLIT_NONE, tree_type, MODE_TYPE_ALL); \
2497  if (ret < 0) \
2498  return ret; \
2499  } while (0)
2500  CODING_TREE(DUAL_TREE_LUMA);
2501  CODING_TREE(DUAL_TREE_CHROMA);
2502  #undef CODING_TREE
2503  }
2504  return 0;
2505 }
2506 
2507 #define SET_SAO(elem, value) \
2508 do { \
2509  if (!sao_merge_up_flag && !sao_merge_left_flag) \
2510  sao->elem = value; \
2511  else if (sao_merge_left_flag) \
2512  sao->elem = CTB(fc->tab.sao, rx-1, ry).elem; \
2513  else if (sao_merge_up_flag) \
2514  sao->elem = CTB(fc->tab.sao, rx, ry-1).elem; \
2515  else \
2516  sao->elem = 0; \
2517 } while (0)
2518 
2519 static void hls_sao(VVCLocalContext *lc, const int rx, const int ry)
2520 {
2521  VVCFrameContext *fc = lc->fc;
2522  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2523  int sao_merge_left_flag = 0;
2524  int sao_merge_up_flag = 0;
2525  SAOParams *sao = &CTB(fc->tab.sao, rx, ry);
2526  int c_idx, i;
2527 
2528  if (rsh->sh_sao_luma_used_flag || rsh->sh_sao_chroma_used_flag) {
2529  if (rx > 0) {
2530  if (lc->ctb_left_flag)
2531  sao_merge_left_flag = ff_vvc_sao_merge_flag_decode(lc);
2532  }
2533  if (ry > 0 && !sao_merge_left_flag) {
2534  if (lc->ctb_up_flag)
2535  sao_merge_up_flag = ff_vvc_sao_merge_flag_decode(lc);
2536  }
2537  }
2538 
2539  for (c_idx = 0; c_idx < (fc->ps.sps->r->sps_chroma_format_idc ? 3 : 1); c_idx++) {
2540  const int sao_used_flag = !c_idx ? rsh->sh_sao_luma_used_flag : rsh->sh_sao_chroma_used_flag;
2541  if (!sao_used_flag) {
2542  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
2543  continue;
2544  }
2545 
2546  if (c_idx == 2) {
2547  sao->type_idx[2] = sao->type_idx[1];
2548  sao->eo_class[2] = sao->eo_class[1];
2549  } else {
2550  SET_SAO(type_idx[c_idx], ff_vvc_sao_type_idx_decode(lc));
2551  }
2552 
2553  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
2554  continue;
2555 
2556  for (i = 0; i < 4; i++)
2557  SET_SAO(offset_abs[c_idx][i], ff_vvc_sao_offset_abs_decode(lc));
2558 
2559  if (sao->type_idx[c_idx] == SAO_BAND) {
2560  for (i = 0; i < 4; i++) {
2561  if (sao->offset_abs[c_idx][i]) {
2562  SET_SAO(offset_sign[c_idx][i],
2563  ff_vvc_sao_offset_sign_decode(lc));
2564  } else {
2565  sao->offset_sign[c_idx][i] = 0;
2566  }
2567  }
2568  SET_SAO(band_position[c_idx], ff_vvc_sao_band_position_decode(lc));
2569  } else if (c_idx != 2) {
2570  SET_SAO(eo_class[c_idx], ff_vvc_sao_eo_class_decode(lc));
2571  }
2572 
2573  // Inferred parameters
2574  sao->offset_val[c_idx][0] = 0;
2575  for (i = 0; i < 4; i++) {
2576  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
2577  if (sao->type_idx[c_idx] == SAO_EDGE) {
2578  if (i > 1)
2579  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2580  } else if (sao->offset_sign[c_idx][i]) {
2581  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2582  }
2583  sao->offset_val[c_idx][i + 1] *= 1 << (fc->ps.sps->bit_depth - FFMIN(10, fc->ps.sps->bit_depth));
2584  }
2585  }
2586 }
2587 
2588 static void alf_params(VVCLocalContext *lc, const int rx, const int ry)
2589 {
2590  const VVCFrameContext *fc = lc->fc;
2591  const H266RawSliceHeader *sh = lc->sc->sh.r;
2592  ALFParams *alf = &CTB(fc->tab.alf, rx, ry);
2593 
2594  alf->ctb_flag[LUMA] = alf->ctb_flag[CB] = alf->ctb_flag[CR] = 0;
2595  alf->ctb_cc_idc[0] = alf->ctb_cc_idc[1] = 0;
2596  if (sh->sh_alf_enabled_flag) {
2597  alf->ctb_flag[LUMA] = ff_vvc_alf_ctb_flag(lc, rx, ry, LUMA);
2598  if (alf->ctb_flag[LUMA]) {
2599  uint8_t alf_use_aps_flag = 0;
2600  if (sh->sh_num_alf_aps_ids_luma > 0)
2601  alf_use_aps_flag = ff_vvc_alf_use_aps_flag(lc);
2602  if (alf_use_aps_flag) {
2603  alf->ctb_filt_set_idx_y = 16;
2604  if (sh->sh_num_alf_aps_ids_luma > 1)
2605  alf->ctb_filt_set_idx_y += ff_vvc_alf_luma_prev_filter_idx(lc);
2606  } else {
2607  alf->ctb_filt_set_idx_y = ff_vvc_alf_luma_fixed_filter_idx(lc);
2608  }
2609  }
2610  for (int c_idx = CB; c_idx <= CR; c_idx++) {
2611  const uint8_t alf_enabled_flag =
2612  c_idx == CB ? sh->sh_alf_cb_enabled_flag : sh->sh_alf_cr_enabled_flag;
2613  if (alf_enabled_flag) {
2614  const VVCALF *aps = fc->ps.alf_list[sh->sh_alf_aps_id_chroma];
2615  alf->ctb_flag[c_idx] = ff_vvc_alf_ctb_flag(lc, rx, ry, c_idx);
2616  alf->alf_ctb_filter_alt_idx[c_idx - 1] = 0;
2617  if (alf->ctb_flag[c_idx] && aps->num_chroma_filters > 1)
2618  alf->alf_ctb_filter_alt_idx[c_idx - 1] = ff_vvc_alf_ctb_filter_alt_idx(lc, c_idx, aps->num_chroma_filters);
2619  }
2620  }
2621  }
2622  if (fc->ps.sps->r->sps_ccalf_enabled_flag) {
2623  const uint8_t cc_enabled[] = { sh->sh_alf_cc_cb_enabled_flag, sh->sh_alf_cc_cr_enabled_flag };
2624  const uint8_t cc_aps_id[] = { sh->sh_alf_cc_cb_aps_id, sh->sh_alf_cc_cr_aps_id };
2625  for (int i = 0; i < 2; i++) {
2626  if (cc_enabled[i]) {
2627  const VVCALF *aps = fc->ps.alf_list[cc_aps_id[i]];
2628  alf->ctb_cc_idc[i] = ff_vvc_alf_ctb_cc_idc(lc, rx, ry, i, aps->num_cc_filters[i]);
2629  }
2630  }
2631  }
2632 }
2633 
2634 static void deblock_params(VVCLocalContext *lc, const int rx, const int ry)
2635 {
2636  VVCFrameContext *fc = lc->fc;
2637  const VVCSH *sh = &lc->sc->sh;
2638  CTB(fc->tab.deblock, rx, ry) = sh->deblock;
2639 }
2640 
2641 static int hls_coding_tree_unit(VVCLocalContext *lc,
2642  const int x0, const int y0, const int ctu_idx, const int rx, const int ry)
2643 {
2644  const VVCFrameContext *fc = lc->fc;
2645  const VVCSPS *sps = fc->ps.sps;
2646  const VVCPPS *pps = fc->ps.pps;
2647  const VVCSH *sh = &lc->sc->sh;
2648  const H266RawSliceHeader *rsh = sh->r;
2649  const unsigned int ctb_size = sps->ctb_size_y;
2650  int ret = 0;
2651 
2652  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2653 
2654  hls_sao(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2655  alf_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2656  deblock_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2657 
2658  if (IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag)
2659  ret = dual_tree_implicit_qt_split(lc, x0, y0, ctb_size, 0);
2660  else
2661  ret = hls_coding_tree(lc, x0, y0, ctb_size, ctb_size,
2662  1, 1, 0, 0, 0, 0, 0, SPLIT_NONE, SINGLE_TREE, MODE_TYPE_ALL);
2663  if (ret < 0)
2664  return ret;
2665 
2666  if (rx == pps->ctb_to_col_bd[rx + 1] - 1) {
2667  if (ctu_idx == sh->num_ctus_in_curr_slice - 1) {
2668  const int end_of_slice_one_bit = ff_vvc_end_of_slice_flag_decode(lc);
2669  if (!end_of_slice_one_bit)
2670  return AVERROR_INVALIDDATA;
2671  } else {
2672  if (ry == pps->ctb_to_row_bd[ry + 1] - 1) {
2673  const int end_of_tile_one_bit = ff_vvc_end_of_tile_one_bit(lc);
2674  if (!end_of_tile_one_bit)
2675  return AVERROR_INVALIDDATA;
2676  } else {
2677  if (fc->ps.sps->r->sps_entropy_coding_sync_enabled_flag) {
2678  const int end_of_subset_one_bit = ff_vvc_end_of_subset_one_bit(lc);
2679  if (!end_of_subset_one_bit)
2680  return AVERROR_INVALIDDATA;
2681  }
2682  }
2683  }
2684  }
2685 
2686  return 0;
2687 }
2688 
2689 static int has_inter_luma(const CodingUnit *cu)
2690 {
2691  return cu->pred_mode != MODE_INTRA && cu->pred_mode != MODE_PLT && cu->tree_type != DUAL_TREE_CHROMA;
2692 }
2693 
2694 static int pred_get_y(const VVCLocalContext *lc, const int y0, const Mv *mv, const int height)
2695 {
2696  const VVCPPS *pps = lc->fc->ps.pps;
2697  const int idx = lc->sc->sh.r->curr_subpic_idx;
2698  const int top = pps->subpic_y[idx];
2699  const int bottom = top + pps->subpic_height[idx];
2700 
2701  return av_clip(y0 + (mv->y >> 4) + height, top, bottom);
2702 }
2703 
2704 static void cu_get_max_y(const CodingUnit *cu, int max_y[2][VVC_MAX_REF_ENTRIES], const VVCLocalContext *lc)
2705 {
2706  const VVCFrameContext *fc = lc->fc;
2707  const PredictionUnit *pu = &cu->pu;
2708 
2709  if (pu->merge_gpm_flag) {
2710  for (int i = 0; i < FF_ARRAY_ELEMS(pu->gpm_mv); i++) {
2711  const MvField *mvf = pu->gpm_mv + i;
2712  const int lx = mvf->pred_flag - PF_L0;
2713  const int idx = mvf->ref_idx[lx];
2714  const int y = pred_get_y(lc, cu->y0, mvf->mv + lx, cu->cb_height);
2715 
2716  max_y[lx][idx] = FFMAX(max_y[lx][idx], y);
2717  }
2718  } else {
2719  const MotionInfo *mi = &pu->mi;
2720  const int max_dmvr_off = (!pu->inter_affine_flag && pu->dmvr_flag) ? 2 : 0;
2721  const int sbw = cu->cb_width / mi->num_sb_x;
2722  const int sbh = cu->cb_height / mi->num_sb_y;
2723  for (int sby = 0; sby < mi->num_sb_y; sby++) {
2724  for (int sbx = 0; sbx < mi->num_sb_x; sbx++) {
2725  const int x0 = cu->x0 + sbx * sbw;
2726  const int y0 = cu->y0 + sby * sbh;
2727  const MvField *mvf = ff_vvc_get_mvf(fc, x0, y0);
2728  for (int lx = 0; lx < 2; lx++) {
2729  const PredFlag mask = 1 << lx;
2730  if (mvf->pred_flag & mask) {
2731  const int idx = mvf->ref_idx[lx];
2732  const int y = pred_get_y(lc, y0, mvf->mv + lx, sbh);
2733 
2734  max_y[lx][idx] = FFMAX(max_y[lx][idx], y + max_dmvr_off);
2735  }
2736  }
2737  }
2738  }
2739  }
2740 }
2741 
2742 static void ctu_get_pred(VVCLocalContext *lc, const int rs)
2743 {
2744  const VVCFrameContext *fc = lc->fc;
2745  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2746  CTU *ctu = fc->tab.ctus + rs;
2747  const CodingUnit *cu = fc->tab.cus[rs];
2748 
2749  ctu->has_dmvr = 0;
2750 
2751  if (IS_I(rsh))
2752  return;
2753 
2754  for (int lx = 0; lx < 2; lx++)
2755  memset(ctu->max_y[lx], -1, sizeof(ctu->max_y[0][0]) * rsh->num_ref_idx_active[lx]);
2756 
2757  while (cu) {
2758  if (has_inter_luma(cu)) {
2759  cu_get_max_y(cu, ctu->max_y, lc);
2760  ctu->has_dmvr |= cu->pu.dmvr_flag;
2761  }
2762  cu = cu->next;
2763  }
2764  ctu->max_y_idx[0] = ctu->max_y_idx[1] = 0;
2765 }
2766 
2767 int ff_vvc_coding_tree_unit(VVCLocalContext *lc,
2768  const int ctu_idx, const int rs, const int rx, const int ry)
2769 {
2770  const VVCFrameContext *fc = lc->fc;
2771  const VVCSPS *sps = fc->ps.sps;
2772  const VVCPPS *pps = fc->ps.pps;
2773  const int x_ctb = rx << sps->ctb_log2_size_y;
2774  const int y_ctb = ry << sps->ctb_log2_size_y;
2775  const int ctb_size = 1 << sps->ctb_log2_size_y << sps->ctb_log2_size_y;
2776  EntryPoint* ep = lc->ep;
2777  int ret;
2778 
2779  if (rx == pps->ctb_to_col_bd[rx]) {
2780  ep->num_hmvp = 0;
2781  ep->num_hmvp_ibc = 0;
2782  ep->is_first_qg = ry == pps->ctb_to_row_bd[ry] || !ctu_idx;
2783  }
2784 
2785  lc->coeffs = fc->tab.coeffs + rs * ctb_size * VVC_MAX_SAMPLE_ARRAYS;
2786  lc->cu = NULL;
2787 
2788  ff_vvc_cabac_init(lc, ctu_idx, rx, ry);
2789  ff_vvc_decode_neighbour(lc, x_ctb, y_ctb, rx, ry, rs);
2790  ret = hls_coding_tree_unit(lc, x_ctb, y_ctb, ctu_idx, rx, ry);
2791  if (ret < 0)
2792  return ret;
2793  ctu_get_pred(lc, rs);
2794 
2795  return 0;
2796 }
2797 
2798 void ff_vvc_decode_neighbour(VVCLocalContext *lc, const int x_ctb, const int y_ctb,
2799  const int rx, const int ry, const int rs)
2800 {
2801  VVCFrameContext *fc = lc->fc;
2802  const int ctb_size = fc->ps.sps->ctb_size_y;
2803 
2804  lc->end_of_tiles_x = fc->ps.pps->width;
2805  lc->end_of_tiles_y = fc->ps.pps->height;
2806  if (fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx + 1])
2807  lc->end_of_tiles_x = FFMIN(x_ctb + ctb_size, lc->end_of_tiles_x);
2808  if (fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry + 1])
2809  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, lc->end_of_tiles_y);
2810 
2811  lc->boundary_flags = 0;
2812  if (rx > 0 && fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx - 1])
2813  lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2814  if (rx > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - 1])
2815  lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2816  if (ry > 0 && fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry - 1])
2817  lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2818  if (ry > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - fc->ps.pps->ctb_width])
2819  lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2820  if (fc->ps.sps->r->sps_subpic_ctu_top_left_x[lc->sc->sh.r->curr_subpic_idx] == rx)
2821  lc->boundary_flags |= BOUNDARY_LEFT_SUBPIC;
2822  if (fc->ps.sps->r->sps_subpic_ctu_top_left_y[lc->sc->sh.r->curr_subpic_idx] == ry)
2823  lc->boundary_flags |= BOUNDARY_UPPER_SUBPIC;
2824  lc->ctb_left_flag = rx > 0 && !(lc->boundary_flags & BOUNDARY_LEFT_TILE);
2825  lc->ctb_up_flag = ry > 0 && !(lc->boundary_flags & BOUNDARY_UPPER_TILE) && !(lc->boundary_flags & BOUNDARY_UPPER_SLICE);
2826  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]) &&
2827  (fc->ps.pps->ctb_to_row_bd[ry] == fc->ps.pps->ctb_to_row_bd[ry - 1]);
2828  lc->ctb_up_left_flag = lc->ctb_left_flag && lc->ctb_up_flag;
2829 }
2830 
2831 void ff_vvc_set_neighbour_available(VVCLocalContext *lc,
2832  const int x0, const int y0, const int w, const int h)
2833 {
2834  const int log2_ctb_size = lc->fc->ps.sps->ctb_log2_size_y;
2835  const int x0b = av_zero_extend(x0, log2_ctb_size);
2836  const int y0b = av_zero_extend(y0, log2_ctb_size);
2837 
2838  lc->na.cand_up = (lc->ctb_up_flag || y0b);
2839  lc->na.cand_left = (lc->ctb_left_flag || x0b);
2840  lc->na.cand_up_left = (x0b || y0b) ? lc->na.cand_left && lc->na.cand_up : lc->ctb_up_left_flag;
2841  lc->na.cand_up_right_sap =
2842  (x0b + w == 1 << log2_ctb_size) ? lc->ctb_up_right_flag && !y0b : lc->na.cand_up;
2843  lc->na.cand_up_right = lc->na.cand_up_right_sap && (x0 + w) < lc->end_of_tiles_x;
2844 }
2845 
2846 void ff_vvc_ctu_free_cus(CodingUnit **cus)
2847 {
2848  while (*cus) {
2849  CodingUnit *cu = *cus;
2850  TransformUnit **head = &cu->tus.head;
2851 
2852  *cus = cu->next;
2853 
2854  while (*head) {
2855  TransformUnit *tu = *head;
2856  *head = tu->next;
2857  av_refstruct_unref(&tu);
2858  }
2859  cu->tus.tail = NULL;
2860 
2861  av_refstruct_unref(&cu);
2862  }
2863 }
2864 
2865 int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
2866 {
2867  const int min_cb_log2_size_y = fc->ps.sps->min_cb_log2_size_y;
2868  const int x = xc >> min_cb_log2_size_y;
2869  const int y = yc >> min_cb_log2_size_y;
2870  return fc->tab.qp[LUMA][x + y * fc->ps.pps->min_cb_width];
2871 }
2872 
2873 void ff_vvc_ep_init_stat_coeff(EntryPoint *ep,
2874  const int bit_depth, const int persistent_rice_adaptation_enabled_flag)
2875 {
2876  for (size_t i = 0; i < FF_ARRAY_ELEMS(ep->stat_coeff); ++i) {
2877  ep->stat_coeff[i] =
2878  persistent_rice_adaptation_enabled_flag ? 2 * (av_log2(bit_depth - 10)) : 0;
2879  }
2880 }
2881 
2882 void ff_vvc_channel_range(int *start, int *end, const VVCTreeType tree_type, const uint8_t chroma_format_idc)
2883 {
2884  const bool has_chroma = chroma_format_idc && tree_type != DUAL_TREE_LUMA;
2885  const bool has_luma = tree_type != DUAL_TREE_CHROMA;
2886 
2887  *start = has_luma ? LUMA : CB;
2888  *end = has_chroma ? VVC_MAX_SAMPLE_ARRAYS : CB;
2889 }
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
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:2694
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:1899
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
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
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:45
PALETTE_INDEX
#define PALETTE_INDEX(x, y)
Definition: ctu.c:1957
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:2270
SPLIT_BT_HOR
@ SPLIT_BT_HOR
Definition: ctu.h:128
PALETTE_SET_PIXEL
#define PALETTE_SET_PIXEL(xc, yc, pix)
Definition: ctu.c:1948
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:1928
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:2198
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:1966
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)
VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE
@ VVC_MAX_NUM_PALETTE_PREDICTOR_SIZE
Definition: vvc.h:159
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:2108
VVCFrameContext::tab
struct VVCFrameContext::@315 tab
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:2457
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:2588
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:2882
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:2634
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:37
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:2357
MIN_PU_LOG2
#define MIN_PU_LOG2
Definition: dec.h:40
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:2767
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:2138
VVCSH::pwt
PredWeightTable pwt
Definition: ps.h:247
PredictionUnit
Definition: hevcdec.h:325
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:2742
TransformBlock::x0
int x0
Definition: ctu.h:146
SliceContext::rpl
RefPicList * rpl
Definition: dec.h:113
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:2297
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
palette_predicted
static void 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
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:2402
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:56
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:2220
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:2327
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
VVCLocalContext::parse
struct VVCLocalContext::@313 parse
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
CHROMA_FORMAT_422
@ CHROMA_FORMAT_422
Definition: ps.h:54
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:2641
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:51
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:48
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:2798
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
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:2394
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:47
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
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:2243
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
CodingUnit::tus
struct CodingUnit::@312 tus
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
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:2057
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
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:2519
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:1965
ff_vvc_get_qPy
int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
Definition: ctu.c:2865
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:2704
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
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:2831
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:35
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
CHROMA_FORMAT_420
@ CHROMA_FORMAT_420
Definition: ps.h:53
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:159
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:126
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:110
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:117
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:2389
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:2507
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
CHROMA_FORMAT_444
@ CHROMA_FORMAT_444
Definition: ps.h:55
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:2873
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
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:1968
has_inter_luma
static int has_inter_luma(const CodingUnit *cu)
Definition: ctu.c:2689
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
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:39
VVCLocalContext::is_cu_chroma_qp_offset_coded
int is_cu_chroma_qp_offset_coded
IsCuChromaQpOffsetCoded.
Definition: ctu.h:409
palette_signaled
static void palette_signaled(VVCLocalContext *lc, const bool local_dual_tree, const int start, const int end, const int max_entries)
Definition: ctu.c:1876
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:2846
Generated on Thu May 22 2025 19:22:40 for FFmpeg by   doxygen 1.8.17