FFmpeg
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 "libavcodec/refstruct.h"
24 
25 #include "cabac.h"
26 #include "ctu.h"
27 #include "inter.h"
28 #include "mvs.h"
29 
30 #define PROF_TEMP_SIZE (PROF_BLOCK_SIZE) * sizeof(int16_t)
31 
32 #define TAB_MSM(fc, depth, x, y) fc->tab.msm[(depth)][((y) >> 5) * fc->ps.pps->width32 + ((x) >> 5)]
33 #define TAB_ISPMF(fc, x, y) fc->tab.ispmf[((y) >> 6) * fc->ps.pps->width64 + ((x) >> 6)]
34 
35 typedef enum VVCModeType {
36  MODE_TYPE_ALL,
37  MODE_TYPE_INTER,
38  MODE_TYPE_INTRA,
39 } VVCModeType;
40 
41 static void set_tb_pos(const VVCFrameContext *fc, const TransformBlock *tb)
42 {
43  const int x_tb = tb->x0 >> MIN_TU_LOG2;
44  const int y_tb = tb->y0 >> MIN_TU_LOG2;
45  const int hs = fc->ps.sps->hshift[tb->c_idx];
46  const int vs = fc->ps.sps->vshift[tb->c_idx];
47  const int is_chroma = tb->c_idx != 0;
48  const int width = FFMAX(1, tb->tb_width >> (MIN_TU_LOG2 - hs));
49  const int end = y_tb + FFMAX(1, tb->tb_height >> (MIN_TU_LOG2 - vs));
50 
51  for (int y = y_tb; y < end; y++) {
52  const int off = y * fc->ps.pps->min_tu_width + x_tb;
53  for (int i = 0; i < width; i++) {
54  fc->tab.tb_pos_x0[is_chroma][off + i] = tb->x0;
55  fc->tab.tb_pos_y0[is_chroma][off + i] = tb->y0;
56  }
57  memset(fc->tab.tb_width [is_chroma] + off, tb->tb_width, width);
58  memset(fc->tab.tb_height[is_chroma] + off, tb->tb_height, width);
59  }
60 }
61 
62 static void set_tb_tab(uint8_t *tab, uint8_t v, const VVCFrameContext *fc,
63  const TransformBlock *tb)
64 {
65  const int width = tb->tb_width << fc->ps.sps->hshift[tb->c_idx];
66  const int height = tb->tb_height << fc->ps.sps->vshift[tb->c_idx];
67 
68  for (int h = 0; h < height; h += MIN_TU_SIZE) {
69  const int y = (tb->y0 + h) >> MIN_TU_LOG2;
70  const int off = y * fc->ps.pps->min_tu_width + (tb->x0 >> MIN_TU_LOG2);
71  const int w = FFMAX(1, width >> MIN_TU_LOG2);
72  memset(tab + off, v, w);
73  }
74 }
75 
76 // 8.7.1 Derivation process for quantization parameters
77 static int get_qp_y_pred(const VVCLocalContext *lc)
78 {
79  const VVCFrameContext *fc = lc->fc;
80  const VVCSPS *sps = fc->ps.sps;
81  const VVCPPS *pps = fc->ps.pps;
82  const CodingUnit *cu = lc->cu;
83  const int ctb_log2_size = sps->ctb_log2_size_y;
84  const int ctb_size_mask = (1 << ctb_log2_size) - 1;
85  const int xQg = lc->parse.cu_qg_top_left_x;
86  const int yQg = lc->parse.cu_qg_top_left_y;
87  const int min_cb_width = fc->ps.pps->min_cb_width;
88  const int x_cb = cu->x0 >> sps->min_cb_log2_size_y;
89  const int y_cb = cu->y0 >> sps->min_cb_log2_size_y;
90  const int rx = cu->x0 >> ctb_log2_size;
91  const int ry = cu->y0 >> ctb_log2_size;
92  const int in_same_ctb_a = ((xQg - 1) >> ctb_log2_size) == rx && (yQg >> ctb_log2_size) == ry;
93  const int in_same_ctb_b = (xQg >> ctb_log2_size) == rx && ((yQg - 1) >> ctb_log2_size) == ry;
94  int qPy_pred, qPy_a, qPy_b;
95 
96  if (lc->na.cand_up) {
97  const int first_qg_in_ctu = !(xQg & ctb_size_mask) && !(yQg & ctb_size_mask);
98  const int qPy_up = fc->tab.qp[LUMA][x_cb + (y_cb - 1) * min_cb_width];
99  if (first_qg_in_ctu && pps->ctb_to_col_bd[xQg >> ctb_log2_size] == xQg >> ctb_log2_size)
100  return qPy_up;
101  }
102 
103  // qPy_pred
104  qPy_pred = lc->ep->is_first_qg ? lc->sc->sh.slice_qp_y : lc->ep->qp_y;
105 
106  // qPy_b
107  if (!lc->na.cand_up || !in_same_ctb_b)
108  qPy_b = qPy_pred;
109  else
110  qPy_b = fc->tab.qp[LUMA][x_cb + (y_cb - 1) * min_cb_width];
111 
112  // qPy_a
113  if (!lc->na.cand_left || !in_same_ctb_a)
114  qPy_a = qPy_pred;
115  else
116  qPy_a = fc->tab.qp[LUMA][(x_cb - 1) + y_cb * min_cb_width];
117 
118  av_assert2(qPy_a >= -fc->ps.sps->qp_bd_offset && qPy_a < 63);
119  av_assert2(qPy_b >= -fc->ps.sps->qp_bd_offset && qPy_b < 63);
120 
121  return (qPy_a + qPy_b + 1) >> 1;
122 }
123 
124 static void set_cb_tab(const VVCLocalContext *lc, uint8_t *tab, const uint8_t v)
125 {
126  const VVCFrameContext *fc = lc->fc;
127  const VVCPPS *pps = fc->ps.pps;
128  const CodingUnit *cu = lc->cu;
129  const int log2_min_cb_size = fc->ps.sps->min_cb_log2_size_y;
130  const int x_cb = cu->x0 >> log2_min_cb_size;
131  const int y_cb = cu->y0 >> log2_min_cb_size;
132  const int cb_width = cu->cb_width;
133  const int cb_height = cu->cb_height;
134  int x = y_cb * pps->min_cb_width + x_cb;
135 
136  for (int y = 0; y < (cb_height >> log2_min_cb_size); y++) {
137  const int width = cb_width >> log2_min_cb_size;
138 
139  memset(&tab[x], v, width);
140  x += pps->min_cb_width;
141  }
142 }
143 
144 static int set_qp_y(VVCLocalContext *lc, const int x0, const int y0, const int has_qp_delta)
145 {
146  const VVCSPS *sps = lc->fc->ps.sps;
147  EntryPoint *ep = lc->ep;
148  CodingUnit *cu = lc->cu;
149  int cu_qp_delta = 0;
150 
151  if (!lc->fc->ps.pps->r->pps_cu_qp_delta_enabled_flag) {
152  ep->qp_y = lc->sc->sh.slice_qp_y;
153  } else if (ep->is_first_qg || (lc->parse.cu_qg_top_left_x == x0 && lc->parse.cu_qg_top_left_y == y0)) {
154  ep->qp_y = get_qp_y_pred(lc);
155  ep->is_first_qg = 0;
156  }
157 
158  if (has_qp_delta) {
159  const int cu_qp_delta_abs = ff_vvc_cu_qp_delta_abs(lc);
160 
161  if (cu_qp_delta_abs)
162  cu_qp_delta = ff_vvc_cu_qp_delta_sign_flag(lc) ? -cu_qp_delta_abs : cu_qp_delta_abs;
163  if (cu_qp_delta > (31 + sps->qp_bd_offset / 2) || cu_qp_delta < -(32 + sps->qp_bd_offset / 2))
164  return AVERROR_INVALIDDATA;
165  lc->parse.is_cu_qp_delta_coded = 1;
166 
167  if (cu_qp_delta) {
168  int off = sps->qp_bd_offset;
169  ep->qp_y = FFUMOD(ep->qp_y + cu_qp_delta + 64 + 2 * off, 64 + off) - off;
170  }
171  }
172 
173  set_cb_tab(lc, lc->fc->tab.qp[LUMA], ep->qp_y);
174  cu->qp[LUMA] = ep->qp_y;
175 
176  return 0;
177 }
178 
179 static void set_qp_c_tab(const VVCLocalContext *lc, const TransformUnit *tu, const TransformBlock *tb)
180 {
181  const int is_jcbcr = tu->joint_cbcr_residual_flag && tu->coded_flag[CB] && tu->coded_flag[CR];
182  const int idx = is_jcbcr ? JCBCR : tb->c_idx;
183 
184  set_tb_tab(lc->fc->tab.qp[tb->c_idx], lc->cu->qp[idx], lc->fc, tb);
185 }
186 
187 static void set_qp_c(VVCLocalContext *lc)
188 {
189  const VVCFrameContext *fc = lc->fc;
190  const VVCSPS *sps = fc->ps.sps;
191  const VVCPPS *pps = fc->ps.pps;
192  const H266RawSliceHeader *rsh = lc->sc->sh.r;
193  CodingUnit *cu = lc->cu;
194  const int x_center = cu->x0 + cu->cb_width / 2;
195  const int y_center = cu->y0 + cu->cb_height / 2;
196  const int single_tree = cu->tree_type == SINGLE_TREE;
197  const int qp_luma = (single_tree ? lc->ep->qp_y : ff_vvc_get_qPy(fc, x_center, y_center)) + sps->qp_bd_offset;
198  const int qp_chroma = av_clip(qp_luma, 0, MAX_QP + sps->qp_bd_offset);
199  const int sh_chroma_qp_offset[] = {
200  rsh->sh_cb_qp_offset,
201  rsh->sh_cr_qp_offset,
202  rsh->sh_joint_cbcr_qp_offset,
203  };
204  int qp;
205 
206  for (int i = CB - 1; i < CR + sps->r->sps_joint_cbcr_enabled_flag; i++) {
207  qp = sps->chroma_qp_table[i][qp_chroma];
208  qp = qp + pps->chroma_qp_offset[i] + sh_chroma_qp_offset[i] + lc->parse.chroma_qp_offset[i];
209  qp = av_clip(qp, -sps->qp_bd_offset, MAX_QP) + sps->qp_bd_offset;
210  cu->qp[i + 1] = qp;
211  }
212 }
213 
214 static TransformUnit* alloc_tu(VVCFrameContext *fc, CodingUnit *cu)
215 {
216  TransformUnit *tu = ff_refstruct_pool_get(fc->tu_pool);
217  if (!tu)
218  return NULL;
219 
220  tu->next = NULL;
221 
222  if (cu->tus.tail)
223  cu->tus.tail->next = tu;
224  else
225  cu->tus.head = tu;
226  cu->tus.tail = tu;
227 
228  return tu;
229 }
230 
231 static TransformUnit* add_tu(VVCFrameContext *fc, CodingUnit *cu, const int x0, const int y0, const int tu_width, const int tu_height)
232 {
233  TransformUnit *tu = alloc_tu(fc, cu);
234 
235  if (!tu)
236  return NULL;
237 
238  tu->x0 = x0;
239  tu->y0 = y0;
240  tu->width = tu_width;
241  tu->height = tu_height;
242  tu->joint_cbcr_residual_flag = 0;
243  memset(tu->coded_flag, 0, sizeof(tu->coded_flag));
244  tu->nb_tbs = 0;
245 
246  return tu;
247 }
248 
249 static TransformBlock* add_tb(TransformUnit *tu, VVCLocalContext *lc,
250  const int x0, const int y0, const int tb_width, const int tb_height, const int c_idx)
251 {
252  TransformBlock *tb;
253 
254  tb = &tu->tbs[tu->nb_tbs++];
255  tb->has_coeffs = 0;
256  tb->x0 = x0;
257  tb->y0 = y0;
258  tb->tb_width = tb_width;
259  tb->tb_height = tb_height;
260  tb->log2_tb_width = av_log2(tb_width);
261  tb->log2_tb_height = av_log2(tb_height);
262 
263  tb->max_scan_x = tb->max_scan_y = 0;
264  tb->min_scan_x = tb->min_scan_y = 0;
265 
266  tb->c_idx = c_idx;
267  tb->ts = 0;
268  tb->coeffs = lc->coeffs;
269  lc->coeffs += tb_width * tb_height;
270  return tb;
271 }
272 
273 static uint8_t tu_y_coded_flag_decode(VVCLocalContext *lc, const int is_sbt_not_coded,
274  const int sub_tu_index, const int is_isp, const int is_chroma_coded)
275 {
276  uint8_t tu_y_coded_flag = 0;
277  const VVCSPS *sps = lc->fc->ps.sps;
278  CodingUnit *cu = lc->cu;
279 
280  if (!is_sbt_not_coded) {
281  int has_y_coded_flag = sub_tu_index < cu->num_intra_subpartitions - 1 || !lc->parse.infer_tu_cbf_luma;
282  if (!is_isp) {
283  const int is_large = cu->cb_width > sps->max_tb_size_y || cu->cb_height > sps->max_tb_size_y;
284  has_y_coded_flag = (cu->pred_mode == MODE_INTRA && !cu->act_enabled_flag) || is_chroma_coded || is_large;
285  }
286  tu_y_coded_flag = has_y_coded_flag ? ff_vvc_tu_y_coded_flag(lc) : 1;
287  }
288  if (is_isp)
289  lc->parse.infer_tu_cbf_luma = lc->parse.infer_tu_cbf_luma && !tu_y_coded_flag;
290  return tu_y_coded_flag;
291 }
292 
293 static void chroma_qp_offset_decode(VVCLocalContext *lc, const int is_128, const int is_chroma_coded)
294 {
295  const VVCPPS *pps = lc->fc->ps.pps;
296  const H266RawSliceHeader *rsh = lc->sc->sh.r;
297 
298  if ((is_128 || is_chroma_coded) &&
299  rsh->sh_cu_chroma_qp_offset_enabled_flag && !lc->parse.is_cu_chroma_qp_offset_coded) {
300  const int cu_chroma_qp_offset_flag = ff_vvc_cu_chroma_qp_offset_flag(lc);
301  if (cu_chroma_qp_offset_flag) {
302  int cu_chroma_qp_offset_idx = 0;
303  if (pps->r->pps_chroma_qp_offset_list_len_minus1 > 0)
304  cu_chroma_qp_offset_idx = ff_vvc_cu_chroma_qp_offset_idx(lc);
305  for (int i = CB - 1; i < JCBCR; i++)
306  lc->parse.chroma_qp_offset[i] = pps->chroma_qp_offset_list[cu_chroma_qp_offset_idx][i];
307  } else {
308  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
309  }
310  lc->parse.is_cu_chroma_qp_offset_coded = 1;
311  }
312 }
313 
314 static int hls_transform_unit(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height, int sub_tu_index, int ch_type)
315 {
316  VVCFrameContext *fc = lc->fc;
317  const VVCSPS *sps = fc->ps.sps;
318  const VVCPPS *pps = fc->ps.pps;
319  CodingUnit *cu = lc->cu;
320  TransformUnit *tu = add_tu(fc, cu, x0, y0, tu_width, tu_height);
321  const int min_cb_width = pps->min_cb_width;
322  const VVCTreeType tree_type = cu->tree_type;
323  const int is_128 = cu->cb_width > 64 || cu->cb_height > 64;
324  const int is_isp = cu->isp_split_type != ISP_NO_SPLIT;
325  const int is_isp_last_tu = is_isp && (sub_tu_index == cu->num_intra_subpartitions - 1);
326  const int is_sbt_not_coded = cu->sbt_flag &&
327  ((sub_tu_index == 0 && cu->sbt_pos_flag) || (sub_tu_index == 1 && !cu->sbt_pos_flag));
328  const int chroma_available = tree_type != DUAL_TREE_LUMA && sps->r->sps_chroma_format_idc &&
329  (!is_isp || is_isp_last_tu);
330  int ret, xc, yc, wc, hc, is_chroma_coded;
331 
332  if (!tu)
333  return AVERROR_INVALIDDATA;
334 
335  if (tree_type == SINGLE_TREE && is_isp_last_tu) {
336  const int x_cu = x0 >> fc->ps.sps->min_cb_log2_size_y;
337  const int y_cu = y0 >> fc->ps.sps->min_cb_log2_size_y;
338  xc = SAMPLE_CTB(fc->tab.cb_pos_x[ch_type], x_cu, y_cu);
339  yc = SAMPLE_CTB(fc->tab.cb_pos_y[ch_type], x_cu, y_cu);
340  wc = SAMPLE_CTB(fc->tab.cb_width[ch_type], x_cu, y_cu);
341  hc = SAMPLE_CTB(fc->tab.cb_height[ch_type], x_cu, y_cu);
342  } else {
343  xc = x0, yc = y0, wc = tu_width, hc = tu_height;
344  }
345 
346  if (chroma_available && !is_sbt_not_coded) {
347  tu->coded_flag[CB] = ff_vvc_tu_cb_coded_flag(lc);
348  tu->coded_flag[CR] = ff_vvc_tu_cr_coded_flag(lc, tu->coded_flag[CB]);
349  }
350 
351  is_chroma_coded = chroma_available && (tu->coded_flag[CB] || tu->coded_flag[CR]);
352 
353  if (tree_type != DUAL_TREE_CHROMA) {
354  int has_qp_delta;
355  tu->coded_flag[LUMA] = tu_y_coded_flag_decode(lc, is_sbt_not_coded, sub_tu_index, is_isp, is_chroma_coded);
356  has_qp_delta = (is_128 || tu->coded_flag[LUMA] || is_chroma_coded) &&
357  pps->r->pps_cu_qp_delta_enabled_flag && !lc->parse.is_cu_qp_delta_coded;
358  ret = set_qp_y(lc, x0, y0, has_qp_delta);
359  if (ret < 0)
360  return ret;
361  add_tb(tu, lc, x0, y0, tu_width, tu_height, LUMA);
362  }
363  if (tree_type != DUAL_TREE_LUMA) {
364  chroma_qp_offset_decode(lc, is_128, is_chroma_coded);
365  if (chroma_available) {
366  const int hs = sps->hshift[CHROMA];
367  const int vs = sps->vshift[CHROMA];
368  add_tb(tu, lc, xc, yc, wc >> hs, hc >> vs, CB);
369  add_tb(tu, lc, xc, yc, wc >> hs, hc >> vs, CR);
370  }
371  }
372  if (sps->r->sps_joint_cbcr_enabled_flag && ((cu->pred_mode == MODE_INTRA &&
373  (tu->coded_flag[CB] || tu->coded_flag[CR])) ||
374  (tu->coded_flag[CB] && tu->coded_flag[CR])) &&
375  chroma_available) {
376  tu->joint_cbcr_residual_flag = ff_vvc_tu_joint_cbcr_residual_flag(lc, tu->coded_flag[1], tu->coded_flag[2]);
377  }
378 
379  for (int i = 0; i < tu->nb_tbs; i++) {
380  TransformBlock *tb = &tu->tbs[i];
381  const int is_chroma = tb->c_idx != LUMA;
382  tb->has_coeffs = tu->coded_flag[tb->c_idx];
383  if (tb->has_coeffs && is_chroma)
384  tb->has_coeffs = tb->c_idx == CB ? 1 : !(tu->coded_flag[CB] && tu->joint_cbcr_residual_flag);
385  if (tb->has_coeffs) {
386  tb->ts = cu->bdpcm_flag[tb->c_idx];
387  if (sps->r->sps_transform_skip_enabled_flag && !cu->bdpcm_flag[tb->c_idx] &&
388  tb->tb_width <= sps->max_ts_size && tb->tb_height <= sps->max_ts_size &&
389  !cu->sbt_flag && (is_chroma || !is_isp)) {
390  tb->ts = ff_vvc_transform_skip_flag(lc, is_chroma);
391  }
392  ret = ff_vvc_residual_coding(lc, tb);
393  if (ret < 0)
394  return ret;
395  set_tb_tab(fc->tab.tu_coded_flag[tb->c_idx], tu->coded_flag[tb->c_idx], fc, tb);
396  }
397  if (tb->c_idx != CR)
398  set_tb_pos(fc, tb);
399  if (tb->c_idx == CB)
400  set_tb_tab(fc->tab.tu_joint_cbcr_residual_flag, tu->joint_cbcr_residual_flag, fc, tb);
401  }
402 
403  return 0;
404 }
405 
406 static int hls_transform_tree(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height, int ch_type)
407 {
408  const CodingUnit *cu = lc->cu;
409  const VVCSPS *sps = lc->fc->ps.sps;
410  int ret;
411 
412  lc->parse.infer_tu_cbf_luma = 1;
413  if (cu->isp_split_type == ISP_NO_SPLIT && !cu->sbt_flag) {
414  if (tu_width > sps->max_tb_size_y || tu_height > sps->max_tb_size_y) {
415  const int ver_split_first = tu_width > sps->max_tb_size_y && tu_width > tu_height;
416  const int trafo_width = ver_split_first ? (tu_width / 2) : tu_width;
417  const int trafo_height = !ver_split_first ? (tu_height / 2) : tu_height;
418 
419  #define TRANSFORM_TREE(x, y) do { \
420  ret = hls_transform_tree(lc, x, y, trafo_width, trafo_height, ch_type); \
421  if (ret < 0) \
422  return ret; \
423  } while (0)
424 
425  TRANSFORM_TREE(x0, y0);
426  if (ver_split_first)
427  TRANSFORM_TREE(x0 + trafo_width, y0);
428  else
429  TRANSFORM_TREE(x0, y0 + trafo_height);
430 
431  } else {
432  ret = hls_transform_unit(lc, x0, y0, tu_width, tu_height, 0, ch_type);
433  if (ret < 0)
434  return ret;
435 
436  }
437  } else if (cu->sbt_flag) {
438  if (!cu->sbt_horizontal_flag) {
439  #define TRANSFORM_UNIT(x, width, idx) do { \
440  ret = hls_transform_unit(lc, x, y0, width, tu_height, idx, ch_type); \
441  if (ret < 0) \
442  return ret; \
443  } while (0)
444 
445  const int trafo_width = tu_width * lc->parse.sbt_num_fourths_tb0 / 4;
446  TRANSFORM_UNIT(x0, trafo_width, 0);
447  TRANSFORM_UNIT(x0 + trafo_width, tu_width - trafo_width, 1);
448 
449  #undef TRANSFORM_UNIT
450  } else {
451  #define TRANSFORM_UNIT(y, height, idx) do { \
452  ret = hls_transform_unit(lc, x0, y, tu_width, height, idx, ch_type); \
453  if (ret < 0) \
454  return ret; \
455  } while (0)
456 
457  const int trafo_height = tu_height * lc->parse.sbt_num_fourths_tb0 / 4;
458  TRANSFORM_UNIT(y0, trafo_height, 0);
459  TRANSFORM_UNIT(y0 + trafo_height, tu_height - trafo_height, 1);
460 
461  #undef TRANSFORM_UNIT
462  }
463  } else if (cu->isp_split_type == ISP_HOR_SPLIT) {
464  const int trafo_height = tu_height / cu->num_intra_subpartitions;
465  for (int i = 0; i < cu->num_intra_subpartitions; i++) {
466  ret = hls_transform_unit(lc, x0, y0 + trafo_height * i, tu_width, trafo_height, i, 0);
467  if (ret < 0)
468  return ret;
469  }
470  } else if (cu->isp_split_type == ISP_VER_SPLIT) {
471  const int trafo_width = tu_width / cu->num_intra_subpartitions;
472  for (int i = 0; i < cu->num_intra_subpartitions; i++) {
473  ret = hls_transform_unit(lc, x0 + trafo_width * i , y0, trafo_width, tu_height, i, 0);
474  if (ret < 0)
475  return ret;
476  }
477  }
478 
479  return 0;
480 }
481 
482 static int skipped_transform_tree(VVCLocalContext *lc, int x0, int y0,int tu_width, int tu_height)
483 {
484  VVCFrameContext *fc = lc->fc;
485  const CodingUnit *cu = lc->cu;
486  const VVCSPS *sps = fc->ps.sps;
487 
488  if (tu_width > sps->max_tb_size_y || tu_height > sps->max_tb_size_y) {
489  const int ver_split_first = tu_width > sps->max_tb_size_y && tu_width > tu_height;
490  const int trafo_width = ver_split_first ? (tu_width / 2) : tu_width;
491  const int trafo_height = !ver_split_first ? (tu_height / 2) : tu_height;
492 
493  #define SKIPPED_TRANSFORM_TREE(x, y) do { \
494  int ret = skipped_transform_tree(lc, x, y, trafo_width, trafo_height); \
495  if (ret < 0) \
496  return ret; \
497  } while (0)
498 
499  SKIPPED_TRANSFORM_TREE(x0, y0);
500  if (ver_split_first)
501  SKIPPED_TRANSFORM_TREE(x0 + trafo_width, y0);
502  else
503  SKIPPED_TRANSFORM_TREE(x0, y0 + trafo_height);
504  } else {
505  TransformUnit *tu = add_tu(fc, lc->cu, x0, y0, tu_width, tu_height);
506  const int has_chroma = sps->r->sps_chroma_format_idc && cu->tree_type != DUAL_TREE_LUMA;
507  const int c_start = cu->tree_type == DUAL_TREE_CHROMA ? CB : LUMA;
508  const int c_end = has_chroma ? VVC_MAX_SAMPLE_ARRAYS : CB;
509 
510  if (!tu)
511  return AVERROR_INVALIDDATA;
512  for (int i = c_start; i < c_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_pos(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 && 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 void intra_luma_pred_modes(VVCLocalContext *lc)
952 {
953  VVCFrameContext *fc = lc->fc;
954  const VVCSPS *sps = fc->ps.sps;
955  const VVCPPS *pps = fc->ps.pps;
956  CodingUnit *cu = lc->cu;
957  const int log2_min_cb_size = sps->min_cb_log2_size_y;
958  const int x0 = cu->x0;
959  const int y0 = cu->y0;
960  const int x_cb = x0 >> log2_min_cb_size;
961  const int y_cb = y0 >> log2_min_cb_size;
962  const int cb_width = cu->cb_width;
963  const int cb_height = cu->cb_height;
964 
965  cu->intra_luma_ref_idx = 0;
966  if (sps->r->sps_bdpcm_enabled_flag && cb_width <= sps->max_ts_size && cb_height <= sps->max_ts_size)
967  cu->bdpcm_flag[LUMA] = ff_vvc_intra_bdpcm_luma_flag(lc);
968  if (cu->bdpcm_flag[LUMA]) {
969  cu->intra_pred_mode_y = ff_vvc_intra_bdpcm_luma_dir_flag(lc) ? INTRA_VERT : INTRA_HORZ;
970  } else {
971  if (sps->r->sps_mip_enabled_flag)
972  cu->intra_mip_flag = ff_vvc_intra_mip_flag(lc, fc->tab.imf);
973  if (cu->intra_mip_flag) {
974  int intra_mip_transposed_flag = ff_vvc_intra_mip_transposed_flag(lc);
975  int intra_mip_mode = ff_vvc_intra_mip_mode(lc);
976  int x = y_cb * pps->min_cb_width + x_cb;
977  for (int y = 0; y < (cb_height>>log2_min_cb_size); y++) {
978  int width = cb_width>>log2_min_cb_size;
979  memset(&fc->tab.imf[x], cu->intra_mip_flag, width);
980  fc->tab.imtf[x] = intra_mip_transposed_flag;
981  fc->tab.imm[x] = intra_mip_mode;
982  x += pps->min_cb_width;
983  }
984  cu->intra_pred_mode_y = intra_mip_mode;
985  } else {
986  int intra_subpartitions_mode_flag = 0;
987  if (sps->r->sps_mrl_enabled_flag && ((y0 % sps->ctb_size_y) > 0))
988  cu->intra_luma_ref_idx = ff_vvc_intra_luma_ref_idx(lc);
989  if (sps->r->sps_isp_enabled_flag && !cu->intra_luma_ref_idx &&
990  (cb_width <= sps->max_tb_size_y && cb_height <= sps->max_tb_size_y) &&
991  (cb_width * cb_height > MIN_TU_SIZE * MIN_TU_SIZE) &&
992  !cu->act_enabled_flag)
993  intra_subpartitions_mode_flag = ff_vvc_intra_subpartitions_mode_flag(lc);
994  if (!(x0 & 63) && !(y0 & 63))
995  TAB_ISPMF(fc, x0, y0) = intra_subpartitions_mode_flag;
996  cu->isp_split_type = ff_vvc_isp_split_type(lc, intra_subpartitions_mode_flag);
997  cu->num_intra_subpartitions = get_num_intra_subpartitions(cu->isp_split_type, cb_width, cb_height);
998  cu->intra_pred_mode_y = luma_intra_pred_mode(lc, intra_subpartitions_mode_flag);
999  }
1000  }
1001  set_cb_tab(lc, fc->tab.ipm, cu->intra_pred_mode_y);
1002 }
1003 
1004 static void intra_chroma_pred_modes(VVCLocalContext *lc)
1005 {
1006  const VVCSPS *sps = lc->fc->ps.sps;
1007  CodingUnit *cu = lc->cu;
1008  const int hs = sps->hshift[CHROMA];
1009  const int vs = sps->vshift[CHROMA];
1010 
1011  cu->mip_chroma_direct_flag = 0;
1012  if (sps->r->sps_bdpcm_enabled_flag &&
1013  (cu->cb_width >> hs) <= sps->max_ts_size &&
1014  (cu->cb_height >> vs) <= sps->max_ts_size) {
1015  cu->bdpcm_flag[CB] = cu->bdpcm_flag[CR] = ff_vvc_intra_bdpcm_chroma_flag(lc);
1016  }
1017  if (cu->bdpcm_flag[CHROMA]) {
1018  cu->intra_pred_mode_c = ff_vvc_intra_bdpcm_chroma_dir_flag(lc) ? INTRA_VERT : INTRA_HORZ;
1019  } else {
1020  const int cclm_enabled = get_cclm_enabled(lc, cu->x0, cu->y0);
1021  int cclm_mode_flag = 0;
1022  int cclm_mode_idx = 0;
1023  int intra_chroma_pred_mode = 0;
1024 
1025  if (cclm_enabled)
1026  cclm_mode_flag = ff_vvc_cclm_mode_flag(lc);
1027 
1028  if (cclm_mode_flag)
1029  cclm_mode_idx = ff_vvc_cclm_mode_idx(lc);
1030  else
1031  intra_chroma_pred_mode = ff_vvc_intra_chroma_pred_mode(lc);
1032  derive_chroma_intra_pred_mode(lc, cclm_mode_flag, cclm_mode_idx, intra_chroma_pred_mode);
1033  }
1034 }
1035 
1036 static PredMode pred_mode_decode(VVCLocalContext *lc,
1037  const VVCTreeType tree_type,
1038  const VVCModeType mode_type)
1039 {
1040  const VVCFrameContext *fc = lc->fc;
1041  CodingUnit *cu = lc->cu;
1042  const VVCSPS *sps = fc->ps.sps;
1043  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1044  const int ch_type = tree_type == DUAL_TREE_CHROMA ? 1 : 0;
1045  const int is_4x4 = cu->cb_width == 4 && cu->cb_height == 4;
1046  int pred_mode_flag;
1047  int pred_mode_ibc_flag;
1048  PredMode pred_mode;
1049 
1050  cu->skip_flag = 0;
1051  if (!IS_I(rsh) || sps->r->sps_ibc_enabled_flag) {
1052  const int is_128 = cu->cb_width == 128 || cu->cb_height == 128;
1053  if (tree_type != DUAL_TREE_CHROMA &&
1054  ((!is_4x4 && mode_type != MODE_TYPE_INTRA) ||
1055  (sps->r->sps_ibc_enabled_flag && !is_128))) {
1056  cu->skip_flag = ff_vvc_cu_skip_flag(lc, fc->tab.skip);
1057  }
1058 
1059  if (is_4x4 || mode_type == MODE_TYPE_INTRA || IS_I(rsh)) {
1060  pred_mode_flag = 1;
1061  } else if (mode_type == MODE_TYPE_INTER || cu->skip_flag) {
1062  pred_mode_flag = 0;
1063  } else {
1064  pred_mode_flag = ff_vvc_pred_mode_flag(lc, ch_type);
1065  }
1066  pred_mode = pred_mode_flag ? MODE_INTRA : MODE_INTER;
1067 
1068  if (((IS_I(rsh) && !cu->skip_flag) ||
1069  (!IS_I(rsh) && (pred_mode != MODE_INTRA ||
1070  ((is_4x4 || mode_type == MODE_TYPE_INTRA) && !cu->skip_flag)))) &&
1071  !is_128 && mode_type != MODE_TYPE_INTER && sps->r->sps_ibc_enabled_flag &&
1072  tree_type != DUAL_TREE_CHROMA) {
1073  pred_mode_ibc_flag = ff_vvc_pred_mode_ibc_flag(lc, ch_type);
1074  } else if (cu->skip_flag && (is_4x4 || mode_type == MODE_TYPE_INTRA)) {
1075  pred_mode_ibc_flag = 1;
1076  } else if (is_128 || mode_type == MODE_TYPE_INTER || tree_type == DUAL_TREE_CHROMA) {
1077  pred_mode_ibc_flag = 0;
1078  } else {
1079  pred_mode_ibc_flag = (IS_I(rsh)) ? sps->r->sps_ibc_enabled_flag : 0;
1080  }
1081  if (pred_mode_ibc_flag)
1082  pred_mode = MODE_IBC;
1083  return pred_mode;
1084  } else {
1085  return MODE_INTRA;
1086  }
1087 }
1088 
1089 static void sbt_info(VVCLocalContext *lc, const VVCSPS *sps)
1090 {
1091  CodingUnit *cu = lc->cu;
1092  const int cb_width = cu->cb_width;
1093  const int cb_height = cu->cb_height;
1094 
1095  if (cu->pred_mode == MODE_INTER && sps->r->sps_sbt_enabled_flag && !cu->ciip_flag
1096  && cb_width <= sps->max_tb_size_y && cb_height <= sps->max_tb_size_y) {
1097  const int sbt_ver_h = cb_width >= 8;
1098  const int sbt_hor_h = cb_height >= 8;
1099  cu->sbt_flag = 0;
1100  if (sbt_ver_h || sbt_hor_h)
1101  cu->sbt_flag = ff_vvc_sbt_flag(lc);
1102  if (cu->sbt_flag) {
1103  const int sbt_ver_q = cb_width >= 16;
1104  const int sbt_hor_q = cb_height >= 16;
1105  int cu_sbt_quad_flag = 0;
1106 
1107  if ((sbt_ver_h || sbt_hor_h) && (sbt_ver_q || sbt_hor_q))
1108  cu_sbt_quad_flag = ff_vvc_sbt_quad_flag(lc);
1109  if (cu_sbt_quad_flag) {
1110  cu->sbt_horizontal_flag = sbt_hor_q;
1111  if (sbt_ver_q && sbt_hor_q)
1112  cu->sbt_horizontal_flag = ff_vvc_sbt_horizontal_flag(lc);
1113  } else {
1114  cu->sbt_horizontal_flag = sbt_hor_h;
1115  if (sbt_ver_h && sbt_hor_h)
1116  cu->sbt_horizontal_flag = ff_vvc_sbt_horizontal_flag(lc);
1117  }
1118  cu->sbt_pos_flag = ff_vvc_sbt_pos_flag(lc);
1119 
1120  {
1121  const int sbt_min = cu_sbt_quad_flag ? 1 : 2;
1122  lc->parse.sbt_num_fourths_tb0 = cu->sbt_pos_flag ? (4 - sbt_min) : sbt_min;
1123  }
1124  }
1125  }
1126 }
1127 
1128 static int skipped_transform_tree_unit(VVCLocalContext *lc)
1129 {
1130  const H266RawSPS *rsps = lc->fc->ps.sps->r;
1131  const CodingUnit *cu = lc->cu;
1132  int ret;
1133 
1134  if (cu->tree_type != DUAL_TREE_CHROMA)
1135  set_qp_y(lc, cu->x0, cu->y0, 0);
1136  if (rsps->sps_chroma_format_idc && cu->tree_type != DUAL_TREE_LUMA)
1137  set_qp_c(lc);
1138  ret = skipped_transform_tree(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
1139  if (ret < 0)
1140  return ret;
1141  return 0;
1142 }
1143 
1144 static void set_cb_pos(const VVCFrameContext *fc, const CodingUnit *cu)
1145 {
1146  const VVCSPS *sps = fc->ps.sps;
1147  const VVCPPS *pps = fc->ps.pps;
1148  const int log2_min_cb_size = sps->min_cb_log2_size_y;
1149  const int x_cb = cu->x0 >> log2_min_cb_size;
1150  const int y_cb = cu->y0 >> log2_min_cb_size;
1151  const int ch_type = cu->ch_type;
1152  int x, y;
1153 
1154  x = y_cb * pps->min_cb_width + x_cb;
1155  for (y = 0; y < (cu->cb_height >> log2_min_cb_size); y++) {
1156  const int width = cu->cb_width >> log2_min_cb_size;
1157 
1158  for (int i = 0; i < width; i++) {
1159  fc->tab.cb_pos_x[ch_type][x + i] = cu->x0;
1160  fc->tab.cb_pos_y[ch_type][x + i] = cu->y0;
1161  }
1162  memset(&fc->tab.cb_width[ch_type][x], cu->cb_width, width);
1163  memset(&fc->tab.cb_height[ch_type][x], cu->cb_height, width);
1164  memset(&fc->tab.cqt_depth[ch_type][x], cu->cqt_depth, width);
1165 
1166  x += pps->min_cb_width;
1167  }
1168 }
1169 
1170 static CodingUnit* alloc_cu(VVCLocalContext *lc, const int x0, const int y0)
1171 {
1172  VVCFrameContext *fc = lc->fc;
1173  const VVCSPS *sps = fc->ps.sps;
1174  const VVCPPS *pps = fc->ps.pps;
1175  const int rx = x0 >> sps->ctb_log2_size_y;
1176  const int ry = y0 >> sps->ctb_log2_size_y;
1177  CTU *ctu = fc->tab.ctus + ry * pps->ctb_width + rx;
1178  CodingUnit *cu = ff_refstruct_pool_get(fc->cu_pool);
1179 
1180  if (!cu)
1181  return NULL;
1182  cu->next = NULL;
1183 
1184  if (lc->cu)
1185  lc->cu->next = cu;
1186  else
1187  ctu->cus = cu;
1188  lc->cu = cu;
1189 
1190  return cu;
1191 }
1192 
1193 static CodingUnit* add_cu(VVCLocalContext *lc, const int x0, const int y0,
1194  const int cb_width, const int cb_height, const int cqt_depth, const VVCTreeType tree_type)
1195 {
1196  VVCFrameContext *fc = lc->fc;
1197  const int ch_type = tree_type == DUAL_TREE_CHROMA ? 1 : 0;
1198  CodingUnit *cu = alloc_cu(lc, x0, y0);
1199 
1200  if (!cu)
1201  return NULL;
1202 
1203  memset(&cu->pu, 0, sizeof(cu->pu));
1204 
1205  lc->parse.prev_tu_cbf_y = 0;
1206 
1207  cu->sbt_flag = 0;
1208  cu->act_enabled_flag = 0;
1209 
1210  cu->tree_type = tree_type;
1211  cu->x0 = x0;
1212  cu->y0 = y0;
1213  cu->cb_width = cb_width;
1214  cu->cb_height = cb_height;
1215  cu->ch_type = ch_type;
1216  cu->cqt_depth = cqt_depth;
1217  cu->tus.head = cu->tus.tail = NULL;
1218  cu->bdpcm_flag[LUMA] = cu->bdpcm_flag[CB] = cu->bdpcm_flag[CR] = 0;
1219  cu->isp_split_type = ISP_NO_SPLIT;
1220  cu->intra_mip_flag = 0;
1221  cu->ciip_flag = 0;
1222  cu->coded_flag = 1;
1223  cu->num_intra_subpartitions = 1;
1224  cu->pu.dmvr_flag = 0;
1225 
1226  set_cb_pos(fc, cu);
1227  return cu;
1228 }
1229 
1230 static void set_cu_tabs(const VVCLocalContext *lc, const CodingUnit *cu)
1231 {
1232  const VVCFrameContext *fc = lc->fc;
1233  const TransformUnit *tu = cu->tus.head;
1234 
1235  if (cu->tree_type != DUAL_TREE_CHROMA) {
1236  set_cb_tab(lc, fc->tab.cpm[LUMA], cu->pred_mode);
1237  set_cb_tab(lc, fc->tab.skip, cu->skip_flag);
1238  }
1239  if (fc->ps.sps->r->sps_chroma_format_idc && cu->tree_type != DUAL_TREE_LUMA)
1240  set_cb_tab(lc, fc->tab.cpm[CHROMA], cu->pred_mode);
1241 
1242  while (tu) {
1243  for (int j = 0; j < tu->nb_tbs; j++) {
1244  const TransformBlock *tb = tu->tbs + j;
1245  if (tb->c_idx != LUMA)
1246  set_qp_c_tab(lc, tu, tb);
1247  if (tb->c_idx != CR && cu->bdpcm_flag[tb->c_idx])
1248  set_tb_tab(fc->tab.pcmf[tb->c_idx], 1, fc, tb);
1249  }
1250  tu = tu->next;
1251  }
1252 }
1253 
1254 //8.5.2.7 Derivation process for merge motion vector difference
1255 static void derive_mmvd(const VVCLocalContext *lc, MvField *mvf, const Mv *mmvd_offset)
1256 {
1257  const SliceContext *sc = lc->sc;
1258  Mv mmvd[2];
1259 
1260  if (mvf->pred_flag == PF_BI) {
1261  const RefPicList *rpl = sc->rpl;
1262  const int poc = lc->fc->ps.ph.poc;
1263  const int diff[] = {
1264  poc - rpl[L0].refs[mvf->ref_idx[L0]].poc,
1265  poc - rpl[L1].refs[mvf->ref_idx[L1]].poc
1266  };
1267  const int sign = FFSIGN(diff[0]) != FFSIGN(diff[1]);
1268 
1269  if (diff[0] == diff[1]) {
1270  mmvd[1] = mmvd[0] = *mmvd_offset;
1271  }
1272  else {
1273  const int i = FFABS(diff[0]) < FFABS(diff[1]);
1274  const int o = !i;
1275  mmvd[i] = *mmvd_offset;
1276  if (!rpl[L0].refs[mvf->ref_idx[L0]].is_lt && !rpl[L1].refs[mvf->ref_idx[L1]].is_lt) {
1277  ff_vvc_mv_scale(&mmvd[o], mmvd_offset, diff[i], diff[o]);
1278  }
1279  else {
1280  mmvd[o].x = sign ? -mmvd[i].x : mmvd[i].x;
1281  mmvd[o].y = sign ? -mmvd[i].y : mmvd[i].y;
1282  }
1283  }
1284  mvf->mv[0].x += mmvd[0].x;
1285  mvf->mv[0].y += mmvd[0].y;
1286  mvf->mv[1].x += mmvd[1].x;
1287  mvf->mv[1].y += mmvd[1].y;
1288  } else {
1289  const int idx = mvf->pred_flag - PF_L0;
1290  mvf->mv[idx].x += mmvd_offset->x;
1291  mvf->mv[idx].y += mmvd_offset->y;
1292  }
1293 
1294 }
1295 
1296 static void mvf_to_mi(const MvField *mvf, MotionInfo *mi)
1297 {
1298  mi->pred_flag = mvf->pred_flag;
1299  mi->bcw_idx = mvf->bcw_idx;
1300  mi->hpel_if_idx = mvf->hpel_if_idx;
1301  for (int i = 0; i < 2; i++) {
1302  const PredFlag mask = i + 1;
1303  if (mvf->pred_flag & mask) {
1304  mi->mv[i][0] = mvf->mv[i];
1305  mi->ref_idx[i] = mvf->ref_idx[i];
1306  }
1307  }
1308 }
1309 
1310 static void mv_merge_refine_pred_flag(MvField *mvf, const int width, const int height)
1311 {
1312  if (mvf->pred_flag == PF_BI && (width + height) == 12) {
1313  mvf->pred_flag = PF_L0;
1314  mvf->bcw_idx = 0;
1315  }
1316 }
1317 
1318 // subblock-based inter prediction data
1319 static void merge_data_subblock(VVCLocalContext *lc)
1320 {
1321  const VVCFrameContext *fc = lc->fc;
1322  const VVCPH *ph = &fc->ps.ph;
1323  CodingUnit* cu = lc->cu;
1324  PredictionUnit *pu = &cu->pu;
1325  int merge_subblock_idx = 0;
1326 
1327  set_cb_tab(lc, fc->tab.msf, pu->merge_subblock_flag);
1328  if (ph->max_num_subblock_merge_cand > 1) {
1329  merge_subblock_idx = ff_vvc_merge_subblock_idx(lc, ph->max_num_subblock_merge_cand);
1330  }
1331  ff_vvc_sb_mv_merge_mode(lc, merge_subblock_idx, pu);
1332 }
1333 
1334 static void merge_data_regular(VVCLocalContext *lc)
1335 {
1336  const VVCFrameContext *fc = lc->fc;
1337  const VVCSPS *sps = fc->ps.sps;
1338  const VVCPH *ph = &fc->ps.ph;
1339  const CodingUnit* cu = lc->cu;
1340  PredictionUnit *pu = &lc->cu->pu;
1341  int merge_idx = 0;
1342  Mv mmvd_offset;
1343  MvField mvf;
1344 
1345  if (sps->r->sps_mmvd_enabled_flag)
1346  pu->mmvd_merge_flag = ff_vvc_mmvd_merge_flag(lc);
1347  if (pu->mmvd_merge_flag) {
1348  int mmvd_cand_flag = 0;
1349  if (sps->max_num_merge_cand > 1)
1350  mmvd_cand_flag = ff_vvc_mmvd_cand_flag(lc);
1351  ff_vvc_mmvd_offset_coding(lc, &mmvd_offset, ph->r->ph_mmvd_fullpel_only_flag);
1352  merge_idx = mmvd_cand_flag;
1353  } else if (sps->max_num_merge_cand > 1) {
1354  merge_idx = ff_vvc_merge_idx(lc);
1355  }
1356  ff_vvc_luma_mv_merge_mode(lc, merge_idx, 0, &mvf);
1357  if (pu->mmvd_merge_flag)
1358  derive_mmvd(lc, &mvf, &mmvd_offset);
1359  mv_merge_refine_pred_flag(&mvf, cu->cb_width, cu->cb_height);
1360  ff_vvc_store_mvf(lc, &mvf);
1361  mvf_to_mi(&mvf, &pu->mi);
1362 }
1363 
1364 static int ciip_flag_decode(VVCLocalContext *lc, const int ciip_avaiable, const int gpm_avaiable, const int is_128)
1365 {
1366  const VVCFrameContext *fc = lc->fc;
1367  const VVCSPS *sps = fc->ps.sps;
1368  const CodingUnit *cu = lc->cu;
1369 
1370  if (ciip_avaiable && gpm_avaiable)
1371  return ff_vvc_ciip_flag(lc);
1372  return sps->r->sps_ciip_enabled_flag && !cu->skip_flag &&
1373  !is_128 && (cu->cb_width * cu->cb_height >= 64);
1374 }
1375 
1376 static void merge_data_gpm(VVCLocalContext *lc)
1377 {
1378  const VVCFrameContext *fc = lc->fc;
1379  const VVCSPS *sps = fc->ps.sps;
1380  PredictionUnit *pu = &lc->cu->pu;
1381  int merge_gpm_idx[2];
1382 
1383  pu->merge_gpm_flag = 1;
1384  pu->gpm_partition_idx = ff_vvc_merge_gpm_partition_idx(lc);
1385  merge_gpm_idx[0] = ff_vvc_merge_gpm_idx(lc, 0);
1386  merge_gpm_idx[1] = 0;
1387  if (sps->max_num_gpm_merge_cand > 2)
1388  merge_gpm_idx[1] = ff_vvc_merge_gpm_idx(lc, 1);
1389 
1390  ff_vvc_luma_mv_merge_gpm(lc, merge_gpm_idx, pu->gpm_mv);
1391  ff_vvc_store_gpm_mvf(lc, pu);
1392 }
1393 
1394 static void merge_data_ciip(VVCLocalContext *lc)
1395 {
1396  const VVCFrameContext* fc = lc->fc;
1397  const VVCSPS* sps = fc->ps.sps;
1398  CodingUnit *cu = lc->cu;
1399  MotionInfo *mi = &cu->pu.mi;
1400  int merge_idx = 0;
1401  MvField mvf;
1402 
1403  if (sps->max_num_merge_cand > 1)
1404  merge_idx = ff_vvc_merge_idx(lc);
1405  ff_vvc_luma_mv_merge_mode(lc, merge_idx, 1, &mvf);
1406  mv_merge_refine_pred_flag(&mvf, cu->cb_width, cu->cb_height);
1407  ff_vvc_store_mvf(lc, &mvf);
1408  mvf_to_mi(&mvf, mi);
1409  cu->intra_pred_mode_y = cu->intra_pred_mode_c = INTRA_PLANAR;
1410  cu->intra_luma_ref_idx = 0;
1411  cu->intra_mip_flag = 0;
1412 }
1413 
1414 // block-based inter prediction data
1415 static void merge_data_block(VVCLocalContext *lc)
1416 {
1417  const VVCFrameContext* fc = lc->fc;
1418  const VVCSPS *sps = fc->ps.sps;
1419  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1420  CodingUnit *cu = lc->cu;
1421  const int cb_width = cu->cb_width;
1422  const int cb_height = cu->cb_height;
1423  const int is_128 = cb_width == 128 || cb_height == 128;
1424  const int ciip_avaiable = sps->r->sps_ciip_enabled_flag &&
1425  !cu->skip_flag && (cb_width * cb_height >= 64);
1426  const int gpm_avaiable = sps->r->sps_gpm_enabled_flag && IS_B(rsh) &&
1427  (cb_width >= 8) && (cb_height >=8) &&
1428  (cb_width < 8 * cb_height) && (cb_height < 8 *cb_width);
1429 
1430  int regular_merge_flag = 1;
1431 
1432  if (!is_128 && (ciip_avaiable || gpm_avaiable))
1433  regular_merge_flag = ff_vvc_regular_merge_flag(lc, cu->skip_flag);
1434  if (regular_merge_flag) {
1435  merge_data_regular(lc);
1436  } else {
1437  cu->ciip_flag = ciip_flag_decode(lc, ciip_avaiable, gpm_avaiable, is_128);
1438  if (cu->ciip_flag)
1439  merge_data_ciip(lc);
1440  else
1441  merge_data_gpm(lc);
1442  }
1443 }
1444 
1445 static int merge_data_ibc(VVCLocalContext *lc)
1446 {
1447  const VVCFrameContext* fc = lc->fc;
1448  const VVCSPS* sps = fc->ps.sps;
1449  MotionInfo *mi = &lc->cu->pu.mi;
1450  int merge_idx = 0;
1451  int ret;
1452 
1453  mi->pred_flag = PF_IBC;
1454 
1455  if (sps->max_num_ibc_merge_cand > 1)
1456  merge_idx = ff_vvc_merge_idx(lc);
1457 
1458  ret = ff_vvc_luma_mv_merge_ibc(lc, merge_idx, &mi->mv[L0][0]);
1459  if (ret)
1460  return ret;
1461  ff_vvc_store_mv(lc, mi);
1462 
1463  return 0;
1464 }
1465 
1466 static int hls_merge_data(VVCLocalContext *lc)
1467 {
1468  const VVCFrameContext *fc = lc->fc;
1469  const VVCPH *ph = &fc->ps.ph;
1470  const CodingUnit *cu = lc->cu;
1471  PredictionUnit *pu = &lc->cu->pu;
1472  int ret;
1473 
1474  pu->merge_gpm_flag = 0;
1475  pu->mi.num_sb_x = pu->mi.num_sb_y = 1;
1476  if (cu->pred_mode == MODE_IBC) {
1477  ret = merge_data_ibc(lc);
1478  if (ret)
1479  return ret;
1480  } else {
1481  if (ph->max_num_subblock_merge_cand > 0 && cu->cb_width >= 8 && cu->cb_height >= 8)
1482  pu->merge_subblock_flag = ff_vvc_merge_subblock_flag(lc);
1483  if (pu->merge_subblock_flag)
1484  merge_data_subblock(lc);
1485  else
1486  merge_data_block(lc);
1487  }
1488  return 0;
1489 }
1490 
1491 static void hls_mvd_coding(VVCLocalContext *lc, Mv* mvd)
1492 {
1493  int16_t mv[2];
1494 
1495  for (int i = 0; i < 2; i++) {
1496  mv[i] = ff_vvc_abs_mvd_greater0_flag(lc);
1497  }
1498 
1499  for (int i = 0; i < 2; i++) {
1500  if (mv[i])
1501  mv[i] += ff_vvc_abs_mvd_greater1_flag(lc);
1502  }
1503 
1504  for (int i = 0; i < 2; i++) {
1505  if (mv[i] > 0) {
1506  if (mv[i] == 2)
1507  mv[i] += ff_vvc_abs_mvd_minus2(lc);
1508  mv[i] = (1 - 2 * ff_vvc_mvd_sign_flag(lc)) * mv[i];
1509  }
1510  }
1511  mvd->x = mv[0];
1512  mvd->y = mv[1];
1513 }
1514 
1515 static int bcw_idx_decode(VVCLocalContext *lc, const MotionInfo *mi, const int cb_width, const int cb_height)
1516 {
1517  const VVCFrameContext *fc = lc->fc;
1518  const VVCSPS *sps = fc->ps.sps;
1519  const VVCPPS *pps = fc->ps.pps;
1520  const VVCPH *ph = &fc->ps.ph;
1521  const VVCSH *sh = &lc->sc->sh;
1522  const PredWeightTable *w = pps->r->pps_wp_info_in_ph_flag ? &ph->pwt : &sh->pwt;
1523  int bcw_idx = 0;
1524 
1525  if (sps->r->sps_bcw_enabled_flag && mi->pred_flag == PF_BI &&
1526  !w->weight_flag[L0][LUMA][mi->ref_idx[0]] &&
1527  !w->weight_flag[L1][LUMA][mi->ref_idx[1]] &&
1528  !w->weight_flag[L0][CHROMA][mi->ref_idx[0]] &&
1529  !w->weight_flag[L1][CHROMA][mi->ref_idx[1]] &&
1530  cb_width * cb_height >= 256) {
1531  bcw_idx = ff_vvc_bcw_idx(lc, ff_vvc_no_backward_pred_flag(lc));
1532  }
1533  return bcw_idx;
1534 }
1535 
1536 static int8_t ref_idx_decode(VVCLocalContext *lc, const VVCSH *sh, const int sym_mvd_flag, const int lx)
1537 {
1538  const H266RawSliceHeader *rsh = sh->r;
1539  int ref_idx = 0;
1540 
1541  if (rsh->num_ref_idx_active[lx] > 1 && !sym_mvd_flag)
1542  ref_idx = ff_vvc_ref_idx_lx(lc, rsh->num_ref_idx_active[lx]);
1543  else if (sym_mvd_flag)
1544  ref_idx = sh->ref_idx_sym[lx];
1545  return ref_idx;
1546 }
1547 
1548 static int mvds_decode(VVCLocalContext *lc, Mv mvds[2][MAX_CONTROL_POINTS],
1549  const int num_cp_mv, const int lx)
1550 {
1551  const VVCFrameContext *fc = lc->fc;
1552  const VVCPH *ph = &fc->ps.ph;
1553  const PredictionUnit *pu = &lc->cu->pu;
1554  const MotionInfo *mi = &pu->mi;
1555  int has_no_zero_mvd = 0;
1556 
1557  if (lx == L1 && ph->r->ph_mvd_l1_zero_flag && mi->pred_flag == PF_BI) {
1558  for (int j = 0; j < num_cp_mv; j++)
1559  AV_ZERO64(&mvds[lx][j]);
1560  } else {
1561  Mv *mvd0 = &mvds[lx][0];
1562  if (lx == L1 && pu->sym_mvd_flag) {
1563  mvd0->x = -mvds[L0][0].x;
1564  mvd0->y = -mvds[L0][0].y;
1565  } else {
1566  hls_mvd_coding(lc, mvd0);
1567  }
1568  has_no_zero_mvd |= (mvd0->x || mvd0->y);
1569  for (int j = 1; j < num_cp_mv; j++) {
1570  Mv *mvd = &mvds[lx][j];
1571  hls_mvd_coding(lc, mvd);
1572  mvd->x += mvd0->x;
1573  mvd->y += mvd0->y;
1574  has_no_zero_mvd |= (mvd->x || mvd->y);
1575  }
1576  }
1577  return has_no_zero_mvd;
1578 }
1579 
1580 static void mvp_add_difference(MotionInfo *mi, const int num_cp_mv,
1581  const Mv mvds[2][MAX_CONTROL_POINTS], const int amvr_shift)
1582 {
1583  for (int i = 0; i < 2; i++) {
1584  const PredFlag mask = i + PF_L0;
1585  if (mi->pred_flag & mask) {
1586  for (int j = 0; j < num_cp_mv; j++) {
1587  const Mv *mvd = &mvds[i][j];
1588  mi->mv[i][j].x += mvd->x * (1 << amvr_shift);
1589  mi->mv[i][j].y += mvd->y * (1 << amvr_shift);
1590  }
1591  }
1592  }
1593 }
1594 
1595 static int mvp_data_ibc(VVCLocalContext *lc)
1596 {
1597  const VVCFrameContext *fc = lc->fc;
1598  const CodingUnit *cu = lc->cu;
1599  const PredictionUnit *pu = &lc->cu->pu;
1600  const VVCSPS *sps = fc->ps.sps;
1601  MotionInfo *mi = &lc->cu->pu.mi;
1602  int mvp_l0_flag = 0;
1603  int amvr_shift = 4;
1604  Mv *mv = &mi->mv[L0][0];
1605  int ret;
1606 
1607  mi->pred_flag = PF_IBC;
1608  mi->num_sb_x = 1;
1609  mi->num_sb_y = 1;
1610 
1611  hls_mvd_coding(lc, mv);
1612  if (sps->max_num_ibc_merge_cand > 1)
1613  mvp_l0_flag = ff_vvc_mvp_lx_flag(lc);
1614  if (sps->r->sps_amvr_enabled_flag && (mv->x || mv->y))
1615  amvr_shift = ff_vvc_amvr_shift(lc, pu->inter_affine_flag, cu->pred_mode, 1);
1616 
1617  ret = ff_vvc_mvp_ibc(lc, mvp_l0_flag, amvr_shift, mv);
1618  if (ret)
1619  return ret;
1620  ff_vvc_store_mv(lc, mi);
1621 
1622  return 0;
1623 }
1624 
1625 static int mvp_data(VVCLocalContext *lc)
1626 {
1627  const VVCFrameContext *fc = lc->fc;
1628  const CodingUnit *cu = lc->cu;
1629  PredictionUnit *pu = &lc->cu->pu;
1630  const VVCSPS *sps = fc->ps.sps;
1631  const VVCPH *ph = &fc->ps.ph;
1632  const VVCSH *sh = &lc->sc->sh;
1633  const H266RawSliceHeader *rsh = sh->r;
1634  MotionInfo *mi = &pu->mi;
1635  const int cb_width = cu->cb_width;
1636  const int cb_height = cu->cb_height;
1637 
1638  int mvp_lx_flag[2] = {0};
1639  int cu_affine_type_flag = 0;
1640  int num_cp_mv;
1641  int amvr_enabled, has_no_zero_mvd = 0, amvr_shift;
1642  Mv mvds[2][MAX_CONTROL_POINTS];
1643 
1644  mi->pred_flag = ff_vvc_pred_flag(lc, IS_B(rsh));
1645  if (sps->r->sps_affine_enabled_flag && cb_width >= 16 && cb_height >= 16) {
1646  pu->inter_affine_flag = ff_vvc_inter_affine_flag(lc);
1647  set_cb_tab(lc, fc->tab.iaf, pu->inter_affine_flag);
1648  if (sps->r->sps_6param_affine_enabled_flag && pu->inter_affine_flag)
1649  cu_affine_type_flag = ff_vvc_cu_affine_type_flag(lc);
1650  }
1651  mi->motion_model_idc = pu->inter_affine_flag + cu_affine_type_flag;
1652  num_cp_mv = mi->motion_model_idc + 1;
1653 
1654  if (sps->r->sps_smvd_enabled_flag && !ph->r->ph_mvd_l1_zero_flag &&
1655  mi->pred_flag == PF_BI && !pu->inter_affine_flag &&
1656  sh->ref_idx_sym[0] > -1 && sh->ref_idx_sym[1] > -1)
1657  pu->sym_mvd_flag = ff_vvc_sym_mvd_flag(lc);
1658 
1659  for (int i = L0; i <= L1; i++) {
1660  const PredFlag pred_flag = PF_L0 + !i;
1661  if (mi->pred_flag != pred_flag) {
1662  mi->ref_idx[i] = ref_idx_decode(lc, sh, pu->sym_mvd_flag, i);
1663  has_no_zero_mvd |= mvds_decode(lc, mvds, num_cp_mv, i);
1664  mvp_lx_flag[i] = ff_vvc_mvp_lx_flag(lc);
1665  }
1666  }
1667 
1668  amvr_enabled = mi->motion_model_idc == MOTION_TRANSLATION ?
1669  sps->r->sps_amvr_enabled_flag : sps->r->sps_affine_amvr_enabled_flag;
1670  amvr_enabled &= has_no_zero_mvd;
1671 
1672  amvr_shift = ff_vvc_amvr_shift(lc, pu->inter_affine_flag, cu->pred_mode, amvr_enabled);
1673 
1674  mi->hpel_if_idx = amvr_shift == 3;
1675  mi->bcw_idx = bcw_idx_decode(lc, mi, cb_width, cb_height);
1676 
1677  if (mi->motion_model_idc)
1678  ff_vvc_affine_mvp(lc, mvp_lx_flag, amvr_shift, mi);
1679  else
1680  ff_vvc_mvp(lc, mvp_lx_flag, amvr_shift, mi);
1681 
1682  mvp_add_difference(mi, num_cp_mv, mvds, amvr_shift);
1683 
1684  if (mi->motion_model_idc)
1685  ff_vvc_store_sb_mvs(lc, pu);
1686  else
1687  ff_vvc_store_mv(lc, &pu->mi);
1688 
1689  return 0;
1690 }
1691 
1692 // derive bdofFlag from 8.5.6 Decoding process for inter blocks
1693 // derive dmvr from 8.5.1 General decoding process for coding units coded in inter prediction mode
1694 static void derive_dmvr_bdof_flag(const VVCLocalContext *lc, PredictionUnit *pu)
1695 {
1696  const VVCFrameContext *fc = lc->fc;
1697  const VVCPPS *pps = fc->ps.pps;
1698  const VVCPH *ph = &fc->ps.ph;
1699  const VVCSH *sh = &lc->sc->sh;
1700  const int poc = ph->poc;
1701  const MotionInfo *mi = &pu->mi;
1702  const int8_t *ref_idx = mi->ref_idx;
1703  const VVCRefPic *rp0 = &lc->sc->rpl[L0].refs[ref_idx[L0]];
1704  const VVCRefPic *rp1 = &lc->sc->rpl[L1].refs[ref_idx[L1]];
1705  const CodingUnit *cu = lc->cu;
1706  const PredWeightTable *w = pps->r->pps_wp_info_in_ph_flag ? &fc->ps.ph.pwt : &sh->pwt;
1707 
1708  pu->bdof_flag = 0;
1709 
1710  if (mi->pred_flag == PF_BI &&
1711  (poc - rp0->poc == rp1->poc - poc) &&
1712  !rp0->is_lt && !rp1->is_lt &&
1713  !cu->ciip_flag &&
1714  !mi->bcw_idx &&
1715  !w->weight_flag[L0][LUMA][ref_idx[L0]] && !w->weight_flag[L1][LUMA][ref_idx[L1]] &&
1716  !w->weight_flag[L0][CHROMA][ref_idx[L0]] && !w->weight_flag[L1][CHROMA][ref_idx[L1]] &&
1717  cu->cb_width >= 8 && cu->cb_height >= 8 &&
1718  (cu->cb_width * cu->cb_height >= 128) &&
1719  !rp0->is_scaled && !rp1->is_scaled) {
1720  if (!ph->r->ph_bdof_disabled_flag &&
1721  mi->motion_model_idc == MOTION_TRANSLATION &&
1722  !pu->merge_subblock_flag &&
1723  !pu->sym_mvd_flag)
1724  pu->bdof_flag = 1;
1725  if (!ph->r->ph_dmvr_disabled_flag &&
1726  pu->general_merge_flag &&
1727  !pu->mmvd_merge_flag)
1728  pu->dmvr_flag = 1;
1729  }
1730 }
1731 
1732 // part of 8.5.1 General decoding process for coding units coded in inter prediction mode
1733 static void refine_regular_subblock(const VVCLocalContext *lc)
1734 {
1735  const CodingUnit *cu = lc->cu;
1736  PredictionUnit *pu = &lc->cu->pu;
1737 
1738  derive_dmvr_bdof_flag(lc, pu);
1739  if (pu->dmvr_flag || pu->bdof_flag) {
1740  pu->mi.num_sb_x = (cu->cb_width > 16) ? (cu->cb_width >> 4) : 1;
1741  pu->mi.num_sb_y = (cu->cb_height > 16) ? (cu->cb_height >> 4) : 1;
1742  }
1743 }
1744 
1745 static void fill_dmvr_info(const VVCLocalContext *lc)
1746 {
1747  const VVCFrameContext *fc = lc->fc;
1748  const CodingUnit *cu = lc->cu;
1749 
1750  if (cu->pred_mode == MODE_IBC) {
1751  ff_vvc_set_intra_mvf(lc, 1);
1752  } else {
1753  const VVCPPS *pps = fc->ps.pps;
1754  const int w = cu->cb_width >> MIN_PU_LOG2;
1755 
1756  for (int y = cu->y0 >> MIN_PU_LOG2; y < (cu->y0 + cu->cb_height) >> MIN_PU_LOG2; y++) {
1757  const int idx = pps->min_pu_width * y + (cu->x0 >> MIN_PU_LOG2);
1758  const MvField *mvf = fc->tab.mvf + idx;
1759  MvField *dmvr_mvf = fc->ref->tab_dmvr_mvf + idx;
1760 
1761  memcpy(dmvr_mvf, mvf, sizeof(MvField) * w);
1762  }
1763  }
1764 }
1765 
1766 static int inter_data(VVCLocalContext *lc)
1767 {
1768  const CodingUnit *cu = lc->cu;
1769  PredictionUnit *pu = &lc->cu->pu;
1770  const MotionInfo *mi = &pu->mi;
1771  int ret = 0;
1772 
1773  pu->general_merge_flag = 1;
1774  if (!cu->skip_flag)
1775  pu->general_merge_flag = ff_vvc_general_merge_flag(lc);
1776 
1777  if (pu->general_merge_flag) {
1778  hls_merge_data(lc);
1779  } else if (cu->pred_mode == MODE_IBC){
1780  ret = mvp_data_ibc(lc);
1781  } else {
1782  ret = mvp_data(lc);
1783  }
1784 
1785  if (cu->pred_mode == MODE_IBC)
1786  {
1787  ff_vvc_update_hmvp(lc, mi);
1788  } else if (!pu->merge_gpm_flag && !pu->inter_affine_flag && !pu->merge_subblock_flag) {
1789  refine_regular_subblock(lc);
1790  ff_vvc_update_hmvp(lc, mi);
1791  }
1792 
1793  if (!pu->dmvr_flag)
1794  fill_dmvr_info(lc);
1795  return ret;
1796 }
1797 
1798 static int hls_coding_unit(VVCLocalContext *lc, int x0, int y0, int cb_width, int cb_height,
1799  int cqt_depth, const VVCTreeType tree_type, VVCModeType mode_type)
1800 {
1801  const VVCFrameContext *fc = lc->fc;
1802  const VVCSPS *sps = fc->ps.sps;
1803  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1804  const int hs = sps->hshift[CHROMA];
1805  const int vs = sps->vshift[CHROMA];
1806  const int is_128 = cb_width > 64 || cb_height > 64;
1807  int pred_mode_plt_flag = 0;
1808  int ret;
1809 
1810  CodingUnit *cu = add_cu(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type);
1811 
1812  if (!cu)
1813  return AVERROR(ENOMEM);
1814 
1815  ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height);
1816 
1817  if (IS_I(rsh) && is_128)
1818  mode_type = MODE_TYPE_INTRA;
1819  cu->pred_mode = pred_mode_decode(lc, tree_type, mode_type);
1820 
1821  if (cu->pred_mode == MODE_INTRA && sps->r->sps_palette_enabled_flag && !is_128 && !cu->skip_flag &&
1822  mode_type != MODE_TYPE_INTER && ((cb_width * cb_height) >
1823  (tree_type != DUAL_TREE_CHROMA ? 16 : (16 << hs << vs))) &&
1824  (mode_type != MODE_TYPE_INTRA || tree_type != DUAL_TREE_CHROMA)) {
1825  pred_mode_plt_flag = ff_vvc_pred_mode_plt_flag(lc);
1826  if (pred_mode_plt_flag) {
1827  avpriv_report_missing_feature(fc->log_ctx, "Palette");
1828  return AVERROR_PATCHWELCOME;
1829  }
1830  }
1831  if (cu->pred_mode == MODE_INTRA && sps->r->sps_act_enabled_flag && tree_type == SINGLE_TREE) {
1832  avpriv_report_missing_feature(fc->log_ctx, "Adaptive Color Transform");
1833  return AVERROR_PATCHWELCOME;
1834  }
1835  if (cu->pred_mode == MODE_INTRA || cu->pred_mode == MODE_PLT) {
1836  if (tree_type == SINGLE_TREE || tree_type == DUAL_TREE_LUMA) {
1837  if (pred_mode_plt_flag) {
1838  avpriv_report_missing_feature(fc->log_ctx, "Palette");
1839  return AVERROR_PATCHWELCOME;
1840  } else {
1841  intra_luma_pred_modes(lc);
1842  }
1843  ff_vvc_set_intra_mvf(lc, 0);
1844  }
1845  if ((tree_type == SINGLE_TREE || tree_type == DUAL_TREE_CHROMA) && sps->r->sps_chroma_format_idc) {
1846  if (pred_mode_plt_flag && tree_type == DUAL_TREE_CHROMA) {
1847  avpriv_report_missing_feature(fc->log_ctx, "Palette");
1848  return AVERROR_PATCHWELCOME;
1849  } else if (!pred_mode_plt_flag) {
1850  if (!cu->act_enabled_flag)
1851  intra_chroma_pred_modes(lc);
1852  }
1853  }
1854  } else if (tree_type != DUAL_TREE_CHROMA) { /* MODE_INTER or MODE_IBC */
1855  if ((ret = inter_data(lc)) < 0)
1856  return ret;
1857  }
1858  if (cu->pred_mode != MODE_INTRA && !pred_mode_plt_flag && !lc->cu->pu.general_merge_flag)
1859  cu->coded_flag = ff_vvc_cu_coded_flag(lc);
1860  else
1861  cu->coded_flag = !(cu->skip_flag || pred_mode_plt_flag);
1862 
1863  if (cu->coded_flag) {
1864  sbt_info(lc, sps);
1865  if (sps->r->sps_act_enabled_flag && cu->pred_mode != MODE_INTRA && tree_type == SINGLE_TREE) {
1866  avpriv_report_missing_feature(fc->log_ctx, "Adaptive Color Transform");
1867  return AVERROR_PATCHWELCOME;
1868  }
1869  lc->parse.lfnst_dc_only = 1;
1870  lc->parse.lfnst_zero_out_sig_coeff_flag = 1;
1871  lc->parse.mts_dc_only = 1;
1872  lc->parse.mts_zero_out_sig_coeff_flag = 1;
1873  ret = hls_transform_tree(lc, x0, y0, cb_width, cb_height, cu->ch_type);
1874  if (ret < 0)
1875  return ret;
1876  cu->lfnst_idx = lfnst_idx_decode(lc);
1877  cu->mts_idx = mts_idx_decode(lc);
1878  set_qp_c(lc);
1879  } else {
1880  ret = skipped_transform_tree_unit(lc);
1881  if (ret < 0)
1882  return ret;
1883  }
1884  set_cu_tabs(lc, cu);
1885 
1886  return 0;
1887 }
1888 
1889 static int derive_mode_type_condition(const VVCLocalContext *lc,
1890  const VVCSplitMode split, const int cb_width, const int cb_height, const VVCModeType mode_type_curr)
1891 {
1892  const H266RawSliceHeader *rsh = lc->sc->sh.r;
1893  const VVCSPS *sps = lc->fc->ps.sps;
1894  const int area = cb_width * cb_height;
1895 
1896  if ((IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag) ||
1897  mode_type_curr != MODE_TYPE_ALL || !sps->r->sps_chroma_format_idc ||
1898  sps->r->sps_chroma_format_idc == CHROMA_FORMAT_444)
1899  return 0;
1900  if ((area == 64 && (split == SPLIT_QT || split == SPLIT_TT_HOR || split == SPLIT_TT_VER)) ||
1901  (area == 32 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER)))
1902  return 1;
1903  if ((area == 64 && (split == SPLIT_BT_HOR || split == SPLIT_BT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
1904  (area == 128 && (split == SPLIT_TT_HOR || split == SPLIT_TT_VER) && sps->r->sps_chroma_format_idc == CHROMA_FORMAT_420) ||
1905  (cb_width == 8 && split == SPLIT_BT_VER) || (cb_width == 16 && split == SPLIT_TT_VER))
1906  return 1 + !IS_I(rsh);
1907 
1908  return 0;
1909 }
1910 
1911 static VVCModeType mode_type_decode(VVCLocalContext *lc, const int x0, const int y0,
1912  const int cb_width, const int cb_height, const VVCSplitMode split, const int ch_type,
1913  const VVCModeType mode_type_curr)
1914 {
1915  VVCModeType mode_type;
1916  const int mode_type_condition = derive_mode_type_condition(lc, split, cb_width, cb_height, mode_type_curr);
1917 
1918  if (mode_type_condition == 1)
1919  mode_type = MODE_TYPE_INTRA;
1920  else if (mode_type_condition == 2) {
1921  mode_type = ff_vvc_non_inter_flag(lc, x0, y0, ch_type) ? MODE_TYPE_INTRA : MODE_TYPE_INTER;
1922  } else {
1923  mode_type = mode_type_curr;
1924  }
1925 
1926  return mode_type;
1927 }
1928 
1929 static int hls_coding_tree(VVCLocalContext *lc,
1930  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
1931  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
1932  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr);
1933 
1934 static int coding_tree_btv(VVCLocalContext *lc,
1935  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
1936  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
1937  VVCTreeType tree_type, VVCModeType mode_type)
1938 {
1939 #define CODING_TREE(x, idx) do { \
1940  ret = hls_coding_tree(lc, x, y0, cb_width / 2, cb_height, \
1941  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
1942  depth_offset, idx, SPLIT_BT_VER, tree_type, mode_type); \
1943  if (ret < 0) \
1944  return ret; \
1945 } while (0);
1946 
1947  const VVCPPS *pps = lc->fc->ps.pps;
1948  const int x1 = x0 + cb_width / 2;
1949  int ret = 0;
1950 
1951  depth_offset += (x0 + cb_width > pps->width) ? 1 : 0;
1952  CODING_TREE(x0, 0);
1953  if (x1 < pps->width)
1954  CODING_TREE(x1, 1);
1955 
1956  return 0;
1957 
1958 #undef CODING_TREE
1959 }
1960 
1961 static int coding_tree_bth(VVCLocalContext *lc,
1962  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
1963  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
1964  VVCTreeType tree_type, VVCModeType mode_type)
1965 {
1966 #define CODING_TREE(y, idx) do { \
1967  ret = hls_coding_tree(lc, x0, y, cb_width , cb_height / 2, \
1968  qg_on_y, qg_on_c, cb_sub_div + 1, cqt_depth, mtt_depth + 1, \
1969  depth_offset, idx, SPLIT_BT_HOR, tree_type, mode_type); \
1970  if (ret < 0) \
1971  return ret; \
1972  } while (0);
1973 
1974  const VVCPPS *pps = lc->fc->ps.pps;
1975  const int y1 = y0 + (cb_height / 2);
1976  int ret = 0;
1977 
1978  depth_offset += (y0 + cb_height > pps->height) ? 1 : 0;
1979  CODING_TREE(y0, 0);
1980  if (y1 < pps->height)
1981  CODING_TREE(y1, 1);
1982 
1983  return 0;
1984 
1985 #undef CODING_TREE
1986 }
1987 
1988 static int coding_tree_ttv(VVCLocalContext *lc,
1989  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
1990  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
1991  VVCTreeType tree_type, VVCModeType mode_type)
1992 {
1993 #define CODING_TREE(x, w, sub_div, idx) do { \
1994  ret = hls_coding_tree(lc, x, y0, w, cb_height, \
1995  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
1996  depth_offset, idx, SPLIT_TT_VER, tree_type, mode_type); \
1997  if (ret < 0) \
1998  return ret; \
1999  } while (0);
2000 
2001  const VVCSH *sh = &lc->sc->sh;
2002  const int x1 = x0 + cb_width / 4;
2003  const int x2 = x0 + cb_width * 3 / 4;
2004  int ret;
2005 
2006  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2007  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2008 
2009  CODING_TREE(x0, cb_width / 4, cb_sub_div + 2, 0);
2010  CODING_TREE(x1, cb_width / 2, cb_sub_div + 1, 1);
2011  CODING_TREE(x2, cb_width / 4, cb_sub_div + 2, 2);
2012 
2013  return 0;
2014 
2015 #undef CODING_TREE
2016 }
2017 
2018 static int coding_tree_tth(VVCLocalContext *lc,
2019  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2020  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2021  VVCTreeType tree_type, VVCModeType mode_type)
2022 {
2023 #define CODING_TREE(y, h, sub_div, idx) do { \
2024  ret = hls_coding_tree(lc, x0, y, cb_width, h, \
2025  qg_on_y, qg_on_c, sub_div, cqt_depth, mtt_depth + 1, \
2026  depth_offset, idx, SPLIT_TT_HOR, tree_type, mode_type); \
2027  if (ret < 0) \
2028  return ret; \
2029  } while (0);
2030 
2031  const VVCSH *sh = &lc->sc->sh;
2032  const int y1 = y0 + (cb_height / 4);
2033  const int y2 = y0 + (3 * cb_height / 4);
2034  int ret;
2035 
2036  qg_on_y = qg_on_y && (cb_sub_div + 2 <= sh->cu_qp_delta_subdiv);
2037  qg_on_c = qg_on_c && (cb_sub_div + 2 <= sh->cu_chroma_qp_offset_subdiv);
2038 
2039  CODING_TREE(y0, cb_height / 4, cb_sub_div + 2, 0);
2040  CODING_TREE(y1, cb_height / 2, cb_sub_div + 1, 1);
2041  CODING_TREE(y2, cb_height / 4, cb_sub_div + 2, 2);
2042 
2043  return 0;
2044 
2045 #undef CODING_TREE
2046 }
2047 
2048 static int coding_tree_qt(VVCLocalContext *lc,
2049  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2050  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2051  VVCTreeType tree_type, VVCModeType mode_type)
2052 {
2053 #define CODING_TREE(x, y, idx) do { \
2054  ret = hls_coding_tree(lc, x, y, cb_width / 2, cb_height / 2, \
2055  qg_on_y, qg_on_c, cb_sub_div + 2, cqt_depth + 1, 0, 0, \
2056  idx, SPLIT_QT, tree_type, mode_type); \
2057  if (ret < 0) \
2058  return ret; \
2059  } while (0);
2060 
2061  const VVCPPS *pps = lc->fc->ps.pps;
2062  const int x1 = x0 + cb_width / 2;
2063  const int y1 = y0 + cb_height / 2;
2064  int ret = 0;
2065 
2066  CODING_TREE(x0, y0, 0);
2067  if (x1 < pps->width)
2068  CODING_TREE(x1, y0, 1);
2069  if (y1 < pps->height)
2070  CODING_TREE(x0, y1, 2);
2071  if (x1 < pps->width &&
2072  y1 < pps->height)
2073  CODING_TREE(x1, y1, 3);
2074 
2075  return 0;
2076 
2077 #undef CODING_TREE
2078 }
2079 
2080 typedef int (*coding_tree_fn)(VVCLocalContext *lc,
2081  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2082  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset,
2083  VVCTreeType tree_type, VVCModeType mode_type);
2084 
2085 const static coding_tree_fn coding_tree[] = {
2086  coding_tree_tth,
2087  coding_tree_bth,
2088  coding_tree_ttv,
2089  coding_tree_btv,
2090  coding_tree_qt,
2091 };
2092 
2093 static int hls_coding_tree(VVCLocalContext *lc,
2094  int x0, int y0, int cb_width, int cb_height, int qg_on_y, int qg_on_c,
2095  int cb_sub_div, int cqt_depth, int mtt_depth, int depth_offset, int part_idx,
2096  VVCSplitMode last_split_mode, VVCTreeType tree_type_curr, VVCModeType mode_type_curr)
2097 {
2098  VVCFrameContext *fc = lc->fc;
2099  const VVCPPS *pps = fc->ps.pps;
2100  const VVCSH *sh = &lc->sc->sh;
2101  const H266RawSliceHeader *rsh = sh->r;
2102  const int ch_type = tree_type_curr == DUAL_TREE_CHROMA;
2103  int ret;
2104  VVCAllowedSplit allowed;
2105 
2106  if (pps->r->pps_cu_qp_delta_enabled_flag && qg_on_y && cb_sub_div <= sh->cu_qp_delta_subdiv) {
2107  lc->parse.is_cu_qp_delta_coded = 0;
2108  lc->parse.cu_qg_top_left_x = x0;
2109  lc->parse.cu_qg_top_left_y = y0;
2110  }
2111  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && qg_on_c &&
2112  cb_sub_div <= sh->cu_chroma_qp_offset_subdiv) {
2113  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2114  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2115  }
2116 
2117  can_split(lc, x0, y0, cb_width, cb_height, mtt_depth, depth_offset, part_idx,
2118  last_split_mode, tree_type_curr, mode_type_curr, &allowed);
2119  if (ff_vvc_split_cu_flag(lc, x0, y0, cb_width, cb_height, ch_type, &allowed)) {
2120  VVCSplitMode split = ff_vvc_split_mode(lc, x0, y0, cb_width, cb_height, cqt_depth, mtt_depth, ch_type, &allowed);
2121  VVCModeType mode_type = mode_type_decode(lc, x0, y0, cb_width, cb_height, split, ch_type, mode_type_curr);
2122 
2123  VVCTreeType tree_type = (mode_type == MODE_TYPE_INTRA) ? DUAL_TREE_LUMA : tree_type_curr;
2124 
2125  if (split != SPLIT_QT) {
2126  if (!(x0 & 31) && !(y0 & 31) && mtt_depth <= 1)
2127  TAB_MSM(fc, mtt_depth, x0, y0) = split;
2128  }
2129  ret = coding_tree[split - 1](lc, x0, y0, cb_width, cb_height, qg_on_y, qg_on_c,
2130  cb_sub_div, cqt_depth, mtt_depth, depth_offset, tree_type, mode_type);
2131  if (ret < 0)
2132  return ret;
2133  if (mode_type_curr == MODE_TYPE_ALL && mode_type == MODE_TYPE_INTRA) {
2134  ret = hls_coding_tree(lc, x0, y0, cb_width, cb_height, 0, qg_on_c, cb_sub_div,
2135  cqt_depth, mtt_depth, 0, 0, split, DUAL_TREE_CHROMA, mode_type);
2136  if (ret < 0)
2137  return ret;
2138  }
2139  } else {
2140  ret = hls_coding_unit(lc, x0, y0, cb_width, cb_height, cqt_depth, tree_type_curr, mode_type_curr);
2141  if (ret < 0)
2142  return ret;
2143  }
2144 
2145  return 0;
2146 }
2147 
2148 static int dual_tree_implicit_qt_split(VVCLocalContext *lc,
2149  const int x0, const int y0, const int cb_size, const int cqt_depth)
2150 {
2151  const VVCSH *sh = &lc->sc->sh;
2152  const H266RawSliceHeader *rsh = sh->r;
2153  const VVCPPS *pps = lc->fc->ps.pps;
2154  const int cb_subdiv = 2 * cqt_depth;
2155  int ret;
2156 
2157  if (cb_size > 64) {
2158  #define DUAL_TREE(x, y) do { \
2159  ret = dual_tree_implicit_qt_split(lc, x, y, cb_size / 2, cqt_depth + 1); \
2160  if (ret < 0) \
2161  return ret; \
2162  } while (0)
2163 
2164  const int x1 = x0 + (cb_size / 2);
2165  const int y1 = y0 + (cb_size / 2);
2166  if (pps->r->pps_cu_qp_delta_enabled_flag && cb_subdiv <= sh->cu_qp_delta_subdiv) {
2167  lc->parse.is_cu_qp_delta_coded = 0;
2168  lc->parse.cu_qg_top_left_x = x0;
2169  lc->parse.cu_qg_top_left_y = y0;
2170  }
2171  if (rsh->sh_cu_chroma_qp_offset_enabled_flag && cb_subdiv <= sh->cu_chroma_qp_offset_subdiv) {
2172  lc->parse.is_cu_chroma_qp_offset_coded = 0;
2173  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2174  }
2175  DUAL_TREE(x0, y0);
2176  if (x1 < pps->width)
2177  DUAL_TREE(x1, y0);
2178  if (y1 < pps->height)
2179  DUAL_TREE(x0, y1);
2180  if (x1 < pps->width && y1 < pps->height)
2181  DUAL_TREE(x1, y1);
2182  #undef DUAL_TREE
2183  } else {
2184  #define CODING_TREE(tree_type) do { \
2185  const int qg_on_y = tree_type == DUAL_TREE_LUMA; \
2186  ret = hls_coding_tree(lc, x0, y0, cb_size, cb_size, qg_on_y, !qg_on_y, \
2187  cb_subdiv, cqt_depth, 0, 0, 0, SPLIT_NONE, tree_type, MODE_TYPE_ALL); \
2188  if (ret < 0) \
2189  return ret; \
2190  } while (0)
2191  CODING_TREE(DUAL_TREE_LUMA);
2192  CODING_TREE(DUAL_TREE_CHROMA);
2193  #undef CODING_TREE
2194  }
2195  return 0;
2196 }
2197 
2198 #define SET_SAO(elem, value) \
2199 do { \
2200  if (!sao_merge_up_flag && !sao_merge_left_flag) \
2201  sao->elem = value; \
2202  else if (sao_merge_left_flag) \
2203  sao->elem = CTB(fc->tab.sao, rx-1, ry).elem; \
2204  else if (sao_merge_up_flag) \
2205  sao->elem = CTB(fc->tab.sao, rx, ry-1).elem; \
2206  else \
2207  sao->elem = 0; \
2208 } while (0)
2209 
2210 static void hls_sao(VVCLocalContext *lc, const int rx, const int ry)
2211 {
2212  VVCFrameContext *fc = lc->fc;
2213  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2214  int sao_merge_left_flag = 0;
2215  int sao_merge_up_flag = 0;
2216  SAOParams *sao = &CTB(fc->tab.sao, rx, ry);
2217  int c_idx, i;
2218 
2219  if (rsh->sh_sao_luma_used_flag || rsh->sh_sao_chroma_used_flag) {
2220  if (rx > 0) {
2221  if (lc->ctb_left_flag)
2222  sao_merge_left_flag = ff_vvc_sao_merge_flag_decode(lc);
2223  }
2224  if (ry > 0 && !sao_merge_left_flag) {
2225  if (lc->ctb_up_flag)
2226  sao_merge_up_flag = ff_vvc_sao_merge_flag_decode(lc);
2227  }
2228  }
2229 
2230  for (c_idx = 0; c_idx < (fc->ps.sps->r->sps_chroma_format_idc ? 3 : 1); c_idx++) {
2231  const int sao_used_flag = !c_idx ? rsh->sh_sao_luma_used_flag : rsh->sh_sao_chroma_used_flag;
2232  if (!sao_used_flag) {
2233  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
2234  continue;
2235  }
2236 
2237  if (c_idx == 2) {
2238  sao->type_idx[2] = sao->type_idx[1];
2239  sao->eo_class[2] = sao->eo_class[1];
2240  } else {
2241  SET_SAO(type_idx[c_idx], ff_vvc_sao_type_idx_decode(lc));
2242  }
2243 
2244  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
2245  continue;
2246 
2247  for (i = 0; i < 4; i++)
2248  SET_SAO(offset_abs[c_idx][i], ff_vvc_sao_offset_abs_decode(lc));
2249 
2250  if (sao->type_idx[c_idx] == SAO_BAND) {
2251  for (i = 0; i < 4; i++) {
2252  if (sao->offset_abs[c_idx][i]) {
2253  SET_SAO(offset_sign[c_idx][i],
2254  ff_vvc_sao_offset_sign_decode(lc));
2255  } else {
2256  sao->offset_sign[c_idx][i] = 0;
2257  }
2258  }
2259  SET_SAO(band_position[c_idx], ff_vvc_sao_band_position_decode(lc));
2260  } else if (c_idx != 2) {
2261  SET_SAO(eo_class[c_idx], ff_vvc_sao_eo_class_decode(lc));
2262  }
2263 
2264  // Inferred parameters
2265  sao->offset_val[c_idx][0] = 0;
2266  for (i = 0; i < 4; i++) {
2267  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
2268  if (sao->type_idx[c_idx] == SAO_EDGE) {
2269  if (i > 1)
2270  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2271  } else if (sao->offset_sign[c_idx][i]) {
2272  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
2273  }
2274  sao->offset_val[c_idx][i + 1] *= 1 << (fc->ps.sps->bit_depth - FFMIN(10, fc->ps.sps->bit_depth));
2275  }
2276  }
2277 }
2278 
2279 static void alf_params(VVCLocalContext *lc, const int rx, const int ry)
2280 {
2281  const VVCFrameContext *fc = lc->fc;
2282  const H266RawSliceHeader *sh = lc->sc->sh.r;
2283  ALFParams *alf = &CTB(fc->tab.alf, rx, ry);
2284 
2285  alf->ctb_flag[LUMA] = alf->ctb_flag[CB] = alf->ctb_flag[CR] = 0;
2286  if (sh->sh_alf_enabled_flag) {
2287  alf->ctb_flag[LUMA] = ff_vvc_alf_ctb_flag(lc, rx, ry, LUMA);
2288  if (alf->ctb_flag[LUMA]) {
2289  uint8_t alf_use_aps_flag = 0;
2290  if (sh->sh_num_alf_aps_ids_luma > 0)
2291  alf_use_aps_flag = ff_vvc_alf_use_aps_flag(lc);
2292  if (alf_use_aps_flag) {
2293  alf->ctb_filt_set_idx_y = 16;
2294  if (sh->sh_num_alf_aps_ids_luma > 1)
2295  alf->ctb_filt_set_idx_y += ff_vvc_alf_luma_prev_filter_idx(lc);
2296  } else {
2297  alf->ctb_filt_set_idx_y = ff_vvc_alf_luma_fixed_filter_idx(lc);
2298  }
2299  }
2300  for (int c_idx = CB; c_idx <= CR; c_idx++) {
2301  const uint8_t alf_enabled_flag =
2302  c_idx == CB ? sh->sh_alf_cb_enabled_flag : sh->sh_alf_cr_enabled_flag;
2303  if (alf_enabled_flag) {
2304  const VVCALF *aps = fc->ps.alf_list[sh->sh_alf_aps_id_chroma];
2305  alf->ctb_flag[c_idx] = ff_vvc_alf_ctb_flag(lc, rx, ry, c_idx);
2306  alf->alf_ctb_filter_alt_idx[c_idx - 1] = 0;
2307  if (alf->ctb_flag[c_idx] && aps->num_chroma_filters > 1)
2308  alf->alf_ctb_filter_alt_idx[c_idx - 1] = ff_vvc_alf_ctb_filter_alt_idx(lc, c_idx, aps->num_chroma_filters);
2309  }
2310  }
2311  }
2312  if (fc->ps.sps->r->sps_ccalf_enabled_flag) {
2313  const uint8_t cc_enabled[] = { sh->sh_alf_cc_cb_enabled_flag, sh->sh_alf_cc_cr_enabled_flag };
2314  const uint8_t cc_aps_id[] = { sh->sh_alf_cc_cb_aps_id, sh->sh_alf_cc_cr_aps_id };
2315  for (int i = 0; i < 2; i++) {
2316  alf->ctb_cc_idc[i] = 0;
2317  if (cc_enabled[i]) {
2318  const VVCALF *aps = fc->ps.alf_list[cc_aps_id[i]];
2319  alf->ctb_cc_idc[i] = ff_vvc_alf_ctb_cc_idc(lc, rx, ry, i, aps->num_cc_filters[i]);
2320  }
2321  }
2322  }
2323 }
2324 
2325 static void deblock_params(VVCLocalContext *lc, const int rx, const int ry)
2326 {
2327  VVCFrameContext *fc = lc->fc;
2328  const VVCSH *sh = &lc->sc->sh;
2329  CTB(fc->tab.deblock, rx, ry) = sh->deblock;
2330 }
2331 
2332 static int hls_coding_tree_unit(VVCLocalContext *lc,
2333  const int x0, const int y0, const int ctu_idx, const int rx, const int ry)
2334 {
2335  const VVCFrameContext *fc = lc->fc;
2336  const VVCSPS *sps = fc->ps.sps;
2337  const VVCPPS *pps = fc->ps.pps;
2338  const VVCSH *sh = &lc->sc->sh;
2339  const H266RawSliceHeader *rsh = sh->r;
2340  const unsigned int ctb_size = sps->ctb_size_y;
2341  int ret = 0;
2342 
2343  memset(lc->parse.chroma_qp_offset, 0, sizeof(lc->parse.chroma_qp_offset));
2344 
2345  hls_sao(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2346  alf_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2347  deblock_params(lc, x0 >> sps->ctb_log2_size_y, y0 >> sps->ctb_log2_size_y);
2348 
2349  if (IS_I(rsh) && sps->r->sps_qtbtt_dual_tree_intra_flag)
2350  ret = dual_tree_implicit_qt_split(lc, x0, y0, ctb_size, 0);
2351  else
2352  ret = hls_coding_tree(lc, x0, y0, ctb_size, ctb_size,
2353  1, 1, 0, 0, 0, 0, 0, SPLIT_NONE, SINGLE_TREE, MODE_TYPE_ALL);
2354  if (ret < 0)
2355  return ret;
2356 
2357  if (rx == pps->ctb_to_col_bd[rx + 1] - 1) {
2358  if (ctu_idx == sh->num_ctus_in_curr_slice - 1) {
2359  const int end_of_slice_one_bit = ff_vvc_end_of_slice_flag_decode(lc);
2360  if (!end_of_slice_one_bit)
2361  return AVERROR_INVALIDDATA;
2362  } else {
2363  if (ry == pps->ctb_to_row_bd[ry + 1] - 1) {
2364  const int end_of_tile_one_bit = ff_vvc_end_of_tile_one_bit(lc);
2365  if (!end_of_tile_one_bit)
2366  return AVERROR_INVALIDDATA;
2367  } else {
2368  if (fc->ps.sps->r->sps_entropy_coding_sync_enabled_flag) {
2369  const int end_of_subset_one_bit = ff_vvc_end_of_subset_one_bit(lc);
2370  if (!end_of_subset_one_bit)
2371  return AVERROR_INVALIDDATA;
2372  }
2373  }
2374  }
2375  }
2376 
2377  return 0;
2378 }
2379 
2380 static int has_inter_luma(const CodingUnit *cu)
2381 {
2382  return cu->pred_mode != MODE_INTRA && cu->pred_mode != MODE_PLT && cu->tree_type != DUAL_TREE_CHROMA;
2383 }
2384 
2385 static int pred_get_y(const int y0, const Mv *mv, const int height)
2386 {
2387  return FFMAX(0, y0 + (mv->y >> 4) + height);
2388 }
2389 
2390 static void cu_get_max_y(const CodingUnit *cu, int max_y[2][VVC_MAX_REF_ENTRIES], const VVCFrameContext *fc)
2391 {
2392  const PredictionUnit *pu = &cu->pu;
2393 
2394  if (pu->merge_gpm_flag) {
2395  for (int i = 0; i < FF_ARRAY_ELEMS(pu->gpm_mv); i++) {
2396  const MvField *mvf = pu->gpm_mv + i;
2397  const int lx = mvf->pred_flag - PF_L0;
2398  const int idx = mvf->ref_idx[lx];
2399  const int y = pred_get_y(cu->y0, mvf->mv + lx, cu->cb_height);
2400 
2401  max_y[lx][idx] = FFMAX(max_y[lx][idx], y);
2402  }
2403  } else {
2404  const MotionInfo *mi = &pu->mi;
2405  const int max_dmvr_off = (!pu->inter_affine_flag && pu->dmvr_flag) ? 2 : 0;
2406  const int sbw = cu->cb_width / mi->num_sb_x;
2407  const int sbh = cu->cb_height / mi->num_sb_y;
2408  for (int sby = 0; sby < mi->num_sb_y; sby++) {
2409  for (int sbx = 0; sbx < mi->num_sb_x; sbx++) {
2410  const int x0 = cu->x0 + sbx * sbw;
2411  const int y0 = cu->y0 + sby * sbh;
2412  const MvField *mvf = ff_vvc_get_mvf(fc, x0, y0);
2413  for (int lx = 0; lx < 2; lx++) {
2414  const PredFlag mask = 1 << lx;
2415  if (mvf->pred_flag & mask) {
2416  const int idx = mvf->ref_idx[lx];
2417  const int y = pred_get_y(y0, mvf->mv + lx, sbh);
2418 
2419  max_y[lx][idx] = FFMAX(max_y[lx][idx], y + max_dmvr_off);
2420  }
2421  }
2422  }
2423  }
2424  }
2425 }
2426 
2427 static void ctu_get_pred(VVCLocalContext *lc, const int rs)
2428 {
2429  const VVCFrameContext *fc = lc->fc;
2430  const H266RawSliceHeader *rsh = lc->sc->sh.r;
2431  CTU *ctu = fc->tab.ctus + rs;
2432  const CodingUnit *cu = ctu->cus;
2433 
2434  if (IS_I(rsh))
2435  return;
2436 
2437  for (int lx = 0; lx < 2; lx++)
2438  memset(ctu->max_y[lx], -1, sizeof(ctu->max_y[0][0]) * rsh->num_ref_idx_active[lx]);
2439 
2440  while (cu) {
2441  if (has_inter_luma(cu)) {
2442  cu_get_max_y(cu, ctu->max_y, fc);
2443  ctu->has_dmvr |= cu->pu.dmvr_flag;
2444  }
2445  cu = cu->next;
2446  }
2447  ctu->max_y_idx[0] = ctu->max_y_idx[1] = 0;
2448 }
2449 
2450 int ff_vvc_coding_tree_unit(VVCLocalContext *lc,
2451  const int ctu_idx, const int rs, const int rx, const int ry)
2452 {
2453  const VVCFrameContext *fc = lc->fc;
2454  const VVCSPS *sps = fc->ps.sps;
2455  const VVCPPS *pps = fc->ps.pps;
2456  const int x_ctb = rx << sps->ctb_log2_size_y;
2457  const int y_ctb = ry << sps->ctb_log2_size_y;
2458  const int ctb_size = 1 << sps->ctb_log2_size_y << sps->ctb_log2_size_y;
2459  EntryPoint* ep = lc->ep;
2460  int ret;
2461 
2462  if (rx == pps->ctb_to_col_bd[rx]) {
2463  ep->num_hmvp = 0;
2464  ep->num_hmvp_ibc = 0;
2465  ep->is_first_qg = ry == pps->ctb_to_row_bd[ry] || !ctu_idx;
2466  }
2467 
2468  lc->coeffs = fc->tab.coeffs + rs * ctb_size * VVC_MAX_SAMPLE_ARRAYS;
2469  lc->cu = NULL;
2470 
2471  ff_vvc_cabac_init(lc, ctu_idx, rx, ry);
2472  ff_vvc_decode_neighbour(lc, x_ctb, y_ctb, rx, ry, rs);
2473  ret = hls_coding_tree_unit(lc, x_ctb, y_ctb, ctu_idx, rx, ry);
2474  if (ret < 0)
2475  return ret;
2476  ctu_get_pred(lc, rs);
2477 
2478  return 0;
2479 }
2480 
2481 void ff_vvc_decode_neighbour(VVCLocalContext *lc, const int x_ctb, const int y_ctb,
2482  const int rx, const int ry, const int rs)
2483 {
2484  VVCFrameContext *fc = lc->fc;
2485  const int ctb_size = fc->ps.sps->ctb_size_y;
2486 
2487  lc->end_of_tiles_x = fc->ps.pps->width;
2488  lc->end_of_tiles_y = fc->ps.pps->height;
2489  if (fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx + 1])
2490  lc->end_of_tiles_x = FFMIN(x_ctb + ctb_size, lc->end_of_tiles_x);
2491  if (fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry + 1])
2492  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, lc->end_of_tiles_y);
2493 
2494  lc->boundary_flags = 0;
2495  if (rx > 0 && fc->ps.pps->ctb_to_col_bd[rx] != fc->ps.pps->ctb_to_col_bd[rx - 1])
2496  lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2497  if (rx > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - 1])
2498  lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2499  if (ry > 0 && fc->ps.pps->ctb_to_row_bd[ry] != fc->ps.pps->ctb_to_row_bd[ry - 1])
2500  lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2501  if (ry > 0 && fc->tab.slice_idx[rs] != fc->tab.slice_idx[rs - fc->ps.pps->ctb_width])
2502  lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2503  if (fc->ps.sps->r->sps_subpic_ctu_top_left_x[lc->sc->sh.r->curr_subpic_idx] == rx)
2504  lc->boundary_flags |= BOUNDARY_LEFT_SUBPIC;
2505  if (fc->ps.sps->r->sps_subpic_ctu_top_left_y[lc->sc->sh.r->curr_subpic_idx] == ry)
2506  lc->boundary_flags |= BOUNDARY_UPPER_SUBPIC;
2507  lc->ctb_left_flag = rx > 0 && !(lc->boundary_flags & BOUNDARY_LEFT_TILE);
2508  lc->ctb_up_flag = ry > 0 && !(lc->boundary_flags & BOUNDARY_UPPER_TILE) && !(lc->boundary_flags & BOUNDARY_UPPER_SLICE);
2509  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]) &&
2510  (fc->ps.pps->ctb_to_row_bd[ry] == fc->ps.pps->ctb_to_row_bd[ry - 1]);
2511  lc->ctb_up_left_flag = lc->ctb_left_flag && lc->ctb_up_flag;
2512 }
2513 
2514 void ff_vvc_set_neighbour_available(VVCLocalContext *lc,
2515  const int x0, const int y0, const int w, const int h)
2516 {
2517  const int log2_ctb_size = lc->fc->ps.sps->ctb_log2_size_y;
2518  const int x0b = av_zero_extend(x0, log2_ctb_size);
2519  const int y0b = av_zero_extend(y0, log2_ctb_size);
2520 
2521  lc->na.cand_up = (lc->ctb_up_flag || y0b);
2522  lc->na.cand_left = (lc->ctb_left_flag || x0b);
2523  lc->na.cand_up_left = (x0b || y0b) ? lc->na.cand_left && lc->na.cand_up : lc->ctb_up_left_flag;
2524  lc->na.cand_up_right_sap =
2525  (x0b + w == 1 << log2_ctb_size) ? lc->ctb_up_right_flag && !y0b : lc->na.cand_up;
2526  lc->na.cand_up_right = lc->na.cand_up_right_sap && (x0 + w) < lc->end_of_tiles_x;
2527 }
2528 
2529 void ff_vvc_ctu_free_cus(CTU *ctu)
2530 {
2531  CodingUnit **cus = &ctu->cus;
2532  while (*cus) {
2533  CodingUnit *cu = *cus;
2534  TransformUnit **head = &cu->tus.head;
2535 
2536  *cus = cu->next;
2537 
2538  while (*head) {
2539  TransformUnit *tu = *head;
2540  *head = tu->next;
2541  ff_refstruct_unref(&tu);
2542  }
2543  cu->tus.tail = NULL;
2544 
2545  ff_refstruct_unref(&cu);
2546  }
2547 }
2548 
2549 int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
2550 {
2551  const int min_cb_log2_size_y = fc->ps.sps->min_cb_log2_size_y;
2552  const int x = xc >> min_cb_log2_size_y;
2553  const int y = yc >> min_cb_log2_size_y;
2554  return fc->tab.qp[LUMA][x + y * fc->ps.pps->min_cb_width];
2555 }
2556 
2557 void ff_vvc_ep_init_stat_coeff(EntryPoint *ep,
2558  const int bit_depth, const int persistent_rice_adaptation_enabled_flag)
2559 {
2560  for (size_t i = 0; i < FF_ARRAY_ELEMS(ep->stat_coeff); ++i) {
2561  ep->stat_coeff[i] =
2562  persistent_rice_adaptation_enabled_flag ? 2 * (av_log2(bit_depth - 10)) : 0;
2563  }
2564 }
VVCSPS
Definition: ps.h:58
ff_vvc_residual_coding
int ff_vvc_residual_coding(VVCLocalContext *lc, TransformBlock *tb)
Definition: cabac.c:2407
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:260
ff_vvc_cu_chroma_qp_offset_idx
int ff_vvc_cu_chroma_qp_offset_idx(VVCLocalContext *lc)
Definition: cabac.c:1663
H266RawSliceHeader::sh_alf_cc_cr_enabled_flag
uint8_t sh_alf_cc_cr_enabled_flag
Definition: cbs_h266.h:789
VVCSH::num_ctus_in_curr_slice
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
Definition: ps.h:242
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:1409
VVCPH
Definition: ps.h:147
ff_vvc_update_hmvp
void ff_vvc_update_hmvp(VVCLocalContext *lc, const MotionInfo *mi)
Definition: mvs.c:1919
VVCPPS
Definition: ps.h:92
ff_vvc_sao_eo_class_decode
int ff_vvc_sao_eo_class_decode(VVCLocalContext *lc)
Definition: cabac.c:1015
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:482
set_tb_pos
static void set_tb_pos(const VVCFrameContext *fc, const TransformBlock *tb)
Definition: ctu.c:41
VVCLocalContext::mts_zero_out_sig_coeff_flag
int mts_zero_out_sig_coeff_flag
MtsZeroOutSigCoeffFlag;.
Definition: ctu.h:406
TransformBlock::tb_width
int tb_width
Definition: ctu.h:146
VVCPPS::r
const H266RawPPS * r
RefStruct reference.
Definition: ps.h:93
MOTION_TRANSLATION
@ MOTION_TRANSLATION
Definition: ctu.h:213
CODING_TREE
#define CODING_TREE(x, idx)
CTU::max_y_idx
int max_y_idx[2]
Definition: ctu.h:334
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:1851
MotionInfo
Definition: ctu.h:239
SAO_BAND
@ SAO_BAND
Definition: hevcdec.h:160
set_cb_pos
static void set_cb_pos(const VVCFrameContext *fc, const CodingUnit *cu)
Definition: ctu.c:1144
TransformUnit::height
int height
Definition: ctu.h:174
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:1378
intra_chroma_pred_modes
static void intra_chroma_pred_modes(VVCLocalContext *lc)
Definition: ctu.c:1004
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:231
PF_IBC
@ PF_IBC
Definition: ctu.h:223
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:261
CodingUnit
Definition: hevcdec.h:285
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
CodingUnit::act_enabled_flag
uint8_t act_enabled_flag
Definition: ctu.h:295
PredictionUnit::gpm_partition_idx
uint8_t gpm_partition_idx
Definition: ctu.h:261
ff_vvc_ref_idx_lx
int ff_vvc_ref_idx_lx(VVCLocalContext *lc, const uint8_t nb_refs)
Definition: cabac.c:1511
CodingUnit::head
TransformUnit * head
RefStruct reference.
Definition: ctu.h:320
TransformUnit::nb_tbs
uint8_t nb_tbs
Definition: ctu.h:179
CodingUnit::bdpcm_flag
int bdpcm_flag[VVC_MAX_SAMPLE_ARRAYS]
BdpcmFlag.
Definition: ctu.h:315
ff_vvc_end_of_slice_flag_decode
int ff_vvc_end_of_slice_flag_decode(VVCLocalContext *lc)
Definition: cabac.c:2465
MODE_IBC
@ MODE_IBC
Definition: ctu.h:190
TransformBlock::min_scan_y
int min_scan_y
Definition: ctu.h:154
ff_vvc_intra_luma_ref_idx
int ff_vvc_intra_luma_ref_idx(VVCLocalContext *lc)
Definition: cabac.c:1282
ff_vvc_inter_affine_flag
int ff_vvc_inter_affine_flag(VVCLocalContext *lc)
Definition: cabac.c:1495
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3005
VVCRefPic
Definition: dec.h:45
w
uint8_t w
Definition: llviddspenc.c:38
VVCLocalContext::mts_dc_only
int mts_dc_only
MtsDcOnly.
Definition: ctu.h:405
NeighbourAvailable::cand_left
int cand_left
Definition: hevcdec.h:311
CodingUnit::intra_mip_flag
uint8_t intra_mip_flag
intra_mip_flag
Definition: ctu.h:298
NeighbourAvailable::cand_up
int cand_up
Definition: hevcdec.h:312
ff_vvc_intra_mip_flag
int ff_vvc_intra_mip_flag(VVCLocalContext *lc, const uint8_t *intra_mip_flag)
Definition: cabac.c:1260
VVCLocalContext::sc
SliceContext * sc
Definition: ctu.h:432
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:1193
INTRA_DC
@ INTRA_DC
Definition: hevcdec.h:122
ff_vvc_lfnst_idx
int ff_vvc_lfnst_idx(VVCLocalContext *lc, const int inc)
Definition: cabac.c:2446
b
#define b
Definition: input.c:41
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:811
VVCModeType
VVCModeType
Definition: ctu.c:35
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:1961
SPLIT_BT_HOR
@ SPLIT_BT_HOR
Definition: ctu.h:125
NeighbourAvailable::cand_up_right
int cand_up_right
Definition: hevcdec.h:314
Mv::y
int16_t y
vertical component of motion vector
Definition: hevcdec.h:300
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:1889
ff_vvc_cu_affine_type_flag
int ff_vvc_cu_affine_type_flag(VVCLocalContext *lc)
Definition: cabac.c:1501
SAO_EDGE
@ SAO_EDGE
Definition: hevcdec.h:161
TransformUnit::x0
int x0
Definition: ctu.h:171
INTRA_VDIAG
@ INTRA_VDIAG
Definition: ctu.h:233
VVCSH::r
const H266RawSliceHeader * r
RefStruct reference.
Definition: ps.h:238
ff_vvc_mmvd_merge_flag
int ff_vvc_mmvd_merge_flag(VVCLocalContext *lc)
Definition: cabac.c:1384
TransformBlock::min_scan_x
int min_scan_x
Definition: ctu.h:153
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:472
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:122
ff_vvc_ciip_flag
int ff_vvc_ciip_flag(VVCLocalContext *lc)
Definition: cabac.c:1475
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
DUAL_TREE
#define DUAL_TREE(x, y)
ff_vvc_intra_luma_mpm_idx
int ff_vvc_intra_luma_mpm_idx(VVCLocalContext *lc)
Definition: cabac.c:1314
mv_merge_refine_pred_flag
static void mv_merge_refine_pred_flag(MvField *mvf, const int width, const int height)
Definition: ctu.c:1310
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
TransformBlock::max_scan_y
int max_scan_y
Definition: ctu.h:152
CHROMA_FORMAT_420
@ CHROMA_FORMAT_420
Definition: ps.h:53
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:2148
ff_vvc_abs_mvd_greater0_flag
int ff_vvc_abs_mvd_greater0_flag(VVCLocalContext *lc)
Definition: cabac.c:1526
RefPicList
Definition: hevcdec.h:190
alf_params
static void alf_params(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2279
ff_vvc_isp_split_type
enum IspType ff_vvc_isp_split_type(VVCLocalContext *lc, const int intra_subpartitions_mode_flag)
Definition: cabac.c:1297
VVCLocalContext::ctb_up_right_flag
uint8_t ctb_up_right_flag
Definition: ctu.h:374
VVCFrameContext::tab
struct VVCFrameContext::@269 tab
ff_vvc_sbt_quad_flag
int ff_vvc_sbt_quad_flag(VVCLocalContext *lc)
Definition: cabac.c:2428
alloc_tu
static TransformUnit * alloc_tu(VVCFrameContext *fc, CodingUnit *cu)
Definition: ctu.c:214
VVCLocalContext::coeffs
int * coeffs
Definition: ctu.h:435
VVCLocalContext::lfnst_zero_out_sig_coeff_flag
int lfnst_zero_out_sig_coeff_flag
LfnstZeroOutSigCoeffFlag.
Definition: ctu.h:403
deblock_params
static void deblock_params(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2325
TransformBlock::max_scan_x
int max_scan_x
Definition: ctu.h:151
SPLIT_QT
@ SPLIT_QT
Definition: ctu.h:128
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:1536
VVCLocalContext::lfnst_dc_only
int lfnst_dc_only
LfnstDcOnly.
Definition: ctu.h:402
ff_vvc_intra_mip_transposed_flag
int ff_vvc_intra_mip_transposed_flag(VVCLocalContext *lc)
Definition: cabac.c:1268
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
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:1402
BOUNDARY_LEFT_TILE
#define BOUNDARY_LEFT_TILE
Definition: hevcdec.h:438
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:1036
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:1010
SPLIT_BT_VER
@ SPLIT_BT_VER
Definition: ctu.h:127
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:2048
MIN_PU_LOG2
#define MIN_PU_LOG2
Definition: dec.h:40
CodingUnit::ch_type
int ch_type
Definition: ctu.h:283
H266RawSliceHeader::sh_alf_cc_cr_aps_id
uint8_t sh_alf_cc_cr_aps_id
Definition: cbs_h266.h:790
H266RawSliceHeader::sh_cb_qp_offset
int8_t sh_cb_qp_offset
Definition: cbs_h266.h:806
ff_vvc_intra_mip_mode
int ff_vvc_intra_mip_mode(VVCLocalContext *lc)
Definition: cabac.c:1273
VVCFrameParamSets::sps
const VVCSPS * sps
RefStruct reference.
Definition: ps.h:229
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:2450
PredictionUnit::gpm_mv
MvField gpm_mv[2]
Definition: ctu.h:262
merge_data_regular
static void merge_data_regular(VVCLocalContext *lc)
Definition: ctu.c:1334
VVCLocalContext::fc
VVCFrameContext * fc
Definition: ctu.h:433
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:1798
VVCSH::pwt
PredWeightTable pwt
Definition: ps.h:246
PredictionUnit
Definition: hevcdec.h:318
EntryPoint::stat_coeff
int stat_coeff[VVC_MAX_SAMPLE_ARRAYS]
StatCoeff.
Definition: ctu.h:355
MODE_INTER
@ MODE_INTER
Definition: hevcdec.h:102
FFSIGN
#define FFSIGN(a)
Definition: common.h:75
CodingUnit::apply_lfnst_flag
int apply_lfnst_flag[VVC_MAX_SAMPLE_ARRAYS]
ApplyLfnstFlag[].
Definition: ctu.h:317
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:1694
ff_vvc_cu_coded_flag
int ff_vvc_cu_coded_flag(VVCLocalContext *lc)
Definition: cabac.c:2415
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
TransformBlock::c_idx
uint8_t c_idx
Definition: ctu.h:141
SPLIT_TT_VER
@ SPLIT_TT_VER
Definition: ctu.h:126
CodingUnit::sbt_pos_flag
uint8_t sbt_pos_flag
Definition: ctu.h:290
VVCLocalContext::ctb_up_left_flag
uint8_t ctb_up_left_flag
Definition: ctu.h:375
alloc_cu
static CodingUnit * alloc_cu(VVCLocalContext *lc, const int x0, const int y0)
Definition: ctu.c:1170
ctu_get_pred
static void ctu_get_pred(VVCLocalContext *lc, const int rs)
Definition: ctu.c:2427
TransformBlock::x0
int x0
Definition: ctu.h:143
SliceContext::rpl
RefPicList * rpl
Definition: dec.h:111
VVCALF
Definition: ps.h:171
MODE_TYPE_ALL
@ MODE_TYPE_ALL
Definition: ctu.c:36
ff_vvc_mvp_lx_flag
int ff_vvc_mvp_lx_flag(VVCLocalContext *lc)
Definition: cabac.c:1546
H266RawSliceHeader::sh_alf_enabled_flag
uint8_t sh_alf_enabled_flag
Definition: cbs_h266.h:781
refstruct.h
ISP_VER_SPLIT
@ ISP_VER_SPLIT
Definition: ctu.h:119
CodingUnit::cb_width
int cb_width
Definition: ctu.h:281
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:1988
merge_data_subblock
static void merge_data_subblock(VVCLocalContext *lc)
Definition: ctu.c:1319
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:1084
H266RawSliceHeader::num_ref_idx_active
uint8_t num_ref_idx_active[2]
NumRefIdxActive[].
Definition: cbs_h266.h:837
merge_data_ciip
static void merge_data_ciip(VVCLocalContext *lc)
Definition: ctu.c:1394
CodingUnit::pu
PredictionUnit pu
Definition: ctu.h:326
ff_vvc_merge_gpm_idx
int ff_vvc_merge_gpm_idx(VVCLocalContext *lc, const int idx)
Definition: cabac.c:1461
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:2093
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
VVCLocalContext::parse
struct VVCLocalContext::@267 parse
ff_vvc_store_gpm_mvf
void ff_vvc_store_gpm_mvf(const VVCLocalContext *lc, const PredictionUnit *pu)
Definition: mvs.c:453
MTS_DCT2_DCT2
@ MTS_DCT2_DCT2
Definition: ctu.h:132
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:249
RefPicList::refs
VVCRefPic refs[VVC_MAX_REF_ENTRIES]
Definition: dec.h:56
mask
static const uint16_t mask[17]
Definition: lzw.c:38
CodingUnit::tus
struct CodingUnit::@266 tus
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:1911
ff_vvc_tu_y_coded_flag
int ff_vvc_tu_y_coded_flag(VVCLocalContext *lc)
Definition: cabac.c:1611
width
#define width
ff_vvc_store_mv
void ff_vvc_store_mv(const VVCLocalContext *lc, const MotionInfo *mi)
Definition: mvs.c:504
SAO_NOT_APPLIED
@ SAO_NOT_APPLIED
Definition: hevcdec.h:159
ISP_HOR_SPLIT
@ ISP_HOR_SPLIT
Definition: ctu.h:118
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:2018
bcw_idx_decode
static int bcw_idx_decode(VVCLocalContext *lc, const MotionInfo *mi, const int cb_width, const int cb_height)
Definition: ctu.c:1515
AV_ZERO64
#define AV_ZERO64(d)
Definition: intreadwrite.h:625
mi
#define mi
Definition: vf_colormatrix.c:106
TransformBlock::y0
int y0
Definition: ctu.h:144
TransformUnit::next
struct TransformUnit * next
RefStruct reference.
Definition: ctu.h:182
set_cu_tabs
static void set_cu_tabs(const VVCLocalContext *lc, const CodingUnit *cu)
Definition: ctu.c:1230
CHROMA_FORMAT_444
@ CHROMA_FORMAT_444
Definition: ps.h:55
merge_data_ibc
static int merge_data_ibc(VVCLocalContext *lc)
Definition: ctu.c:1445
CodingUnit::cqt_depth
int cqt_depth
Definition: ctu.h:284
VVCSH
Definition: ps.h:237
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:1580
ff_vvc_bcw_idx
int ff_vvc_bcw_idx(VVCLocalContext *lc, const int no_backward_pred_flag)
Definition: cabac.c:1590
PredWeightTable
Definition: ps.h:137
CodingUnit::tree_type
VVCTreeType tree_type
Definition: ctu.h:278
VVCFrameParamSets::ph
VVCPH ph
Definition: ps.h:231
PredictionUnit::bdof_flag
uint8_t bdof_flag
Definition: ctu.h:270
ff_vvc_sbt_pos_flag
int ff_vvc_sbt_pos_flag(VVCLocalContext *lc)
Definition: cabac.c:2441
CodingUnit::mts_idx
MtsIdx mts_idx
Definition: ctu.h:293
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:1309
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:178
NeighbourAvailable::cand_up_right_sap
int cand_up_right_sap
Definition: hevcdec.h:315
ff_vvc_cu_skip_flag
int ff_vvc_cu_skip_flag(VVCLocalContext *lc, const uint8_t *cu_skip_flag)
Definition: cabac.c:1242
hls_merge_data
static int hls_merge_data(VVCLocalContext *lc)
Definition: ctu.c:1466
set_qp_y
static int set_qp_y(VVCLocalContext *lc, const int x0, const int y0, const int has_qp_delta)
Definition: ctu.c:144
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:1364
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:809
H266RawSPS
Definition: cbs_h266.h:308
CTU
Definition: ctu.h:331
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:314
aps
static int FUNC() aps(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current, int prefix)
Definition: cbs_h266_syntax_template.c:2463
EntryPoint::is_first_qg
uint8_t is_first_qg
Definition: ctu.h:363
VVCSPS::ctb_log2_size_y
uint8_t ctb_log2_size_y
CtbLog2SizeY.
Definition: ps.h:71
CodingUnit::sbt_flag
uint8_t sbt_flag
Definition: ctu.h:288
inter.h
VVCTreeType
VVCTreeType
Definition: ctu.h:164
IspType
IspType
Definition: ctu.h:116
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
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:1592
ff_vvc_pred_mode_plt_flag
int ff_vvc_pred_mode_plt_flag(VVCLocalContext *lc)
Definition: cabac.c:1217
VVCLocalContext
Definition: ctu.h:371
VVCSH::ref_idx_sym
int8_t ref_idx_sym[2]
RefIdxSymL0, RefIdxSymL1.
Definition: ps.h:247
H266RawSliceHeader::curr_subpic_idx
uint16_t curr_subpic_idx
CurrSubpicIdx.
Definition: cbs_h266.h:835
INTRA_HORZ
@ INTRA_HORZ
Definition: ctu.h:230
VVCSH::max_tt_size
uint8_t max_tt_size[2]
MaxTtSizeY, MaxTtSizeC.
Definition: ps.h:258
EntryPoint::qp_y
int8_t qp_y
QpY.
Definition: ctu.h:353
ff_vvc_cu_chroma_qp_offset_flag
int ff_vvc_cu_chroma_qp_offset_flag(VVCLocalContext *lc)
Definition: cabac.c:1658
TransformBlock::log2_tb_width
int log2_tb_width
Definition: ctu.h:148
CodingUnit::intra_luma_ref_idx
uint8_t intra_luma_ref_idx
IntraLumaRefLineIdx[][].
Definition: ctu.h:297
mvp_data_ibc
static int mvp_data_ibc(VVCLocalContext *lc)
Definition: ctu.c:1595
L0
#define L0
Definition: hevcdec.h:58
ff_vvc_sbt_horizontal_flag
int ff_vvc_sbt_horizontal_flag(VVCLocalContext *lc)
Definition: cabac.c:2433
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:1052
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:2332
BOUNDARY_UPPER_TILE
#define BOUNDARY_UPPER_TILE
Definition: hevcdec.h:440
MODE_TYPE_INTRA
@ MODE_TYPE_INTRA
Definition: ctu.c:38
H266RawSliceHeader::sh_joint_cbcr_qp_offset
int8_t sh_joint_cbcr_qp_offset
Definition: cbs_h266.h:808
skipped_transform_tree_unit
static int skipped_transform_tree_unit(VVCLocalContext *lc)
Definition: ctu.c:1128
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:124
Mv::x
int16_t x
horizontal component of motion vector
Definition: hevcdec.h:299
CTB
#define CTB(tab, x, y)
Definition: filter.c:265
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:1037
PF_BI
@ PF_BI
Definition: hevcdec.h:117
MotionInfo::num_sb_y
int num_sb_y
Definition: ctu.h:248
ff_vvc_abs_mvd_minus2
int ff_vvc_abs_mvd_minus2(VVCLocalContext *lc)
Definition: cabac.c:1536
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:1717
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:1042
cabac.h
TransformUnit
Definition: hevcdec.h:328
ff_vvc_pred_mode_ibc_flag
int ff_vvc_pred_mode_ibc_flag(VVCLocalContext *lc, const int is_chroma)
Definition: cabac.c:1248
DUAL_TREE_LUMA
@ DUAL_TREE_LUMA
Definition: ctu.h:166
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:230
PredictionUnit::mmvd_merge_flag
uint8_t mmvd_merge_flag
Definition: ctu.h:253
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:807
VVCSH::max_mtt_depth
uint8_t max_mtt_depth[2]
MaxMttDepthY, MaxMttDepthC.
Definition: ps.h:259
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:2481
TransformBlock::tb_height
int tb_height
Definition: ctu.h:147
ff_vvc_intra_luma_mpm_remainder
int ff_vvc_intra_luma_mpm_remainder(VVCLocalContext *lc)
Definition: cabac.c:1322
EntryPoint::num_hmvp_ibc
int num_hmvp_ibc
NumHmvpIbcCand.
Definition: ctu.h:368
TransformBlock::ts
uint8_t ts
transform_skip_flag
Definition: ctu.h:142
ff_vvc_intra_bdpcm_chroma_dir_flag
int ff_vvc_intra_bdpcm_chroma_dir_flag(VVCLocalContext *lc)
Definition: cabac.c:1237
mvs.h
BOUNDARY_UPPER_SLICE
#define BOUNDARY_UPPER_SLICE
Definition: hevcdec.h:439
mvf_to_mi
static void mvf_to_mi(const MvField *mvf, MotionInfo *mi)
Definition: ctu.c:1296
CodingUnit::intra_pred_mode_y
IntraPredMode intra_pred_mode_y
IntraPredModeY.
Definition: ctu.h:311
ff_vvc_pred_flag
PredFlag ff_vvc_pred_flag(VVCLocalContext *lc, const int is_b)
Definition: cabac.c:1480
INTRA_PLANAR
@ INTRA_PLANAR
Definition: hevcdec.h:121
coding_tree
const static coding_tree_fn coding_tree[]
Definition: ctu.c:2085
refine_regular_subblock
static void refine_regular_subblock(const VVCLocalContext *lc)
Definition: ctu.c:1733
ff_vvc_merge_subblock_idx
int ff_vvc_merge_subblock_idx(VVCLocalContext *lc, const int max_num_subblock_merge_cand)
Definition: cabac.c:1368
PredictionUnit::merge_gpm_flag
uint8_t merge_gpm_flag
Definition: ctu.h:260
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
VVCRefPic::poc
int poc
Definition: dec.h:47
CodingUnit::sbt_horizontal_flag
uint8_t sbt_horizontal_flag
Definition: ctu.h:289
ff_vvc_merge_gpm_partition_idx
int ff_vvc_merge_gpm_partition_idx(VVCLocalContext *lc)
Definition: cabac.c:1451
H266RawSliceHeader::sh_alf_aps_id_chroma
uint8_t sh_alf_aps_id_chroma
Definition: cbs_h266.h:786
VVCLocalContext::infer_tu_cbf_luma
int infer_tu_cbf_luma
InferTuCbfLuma.
Definition: ctu.h:399
MvField
Definition: hevcdec.h:303
VVCLocalContext::end_of_tiles_x
int end_of_tiles_x
Definition: ctu.h:376
INTRA_INVALID
@ INTRA_INVALID
Definition: ctu.h:227
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:820
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
ff_vvc_sym_mvd_flag
int ff_vvc_sym_mvd_flag(VVCLocalContext *lc)
Definition: cabac.c:1506
CodingUnit::coded_flag
uint8_t coded_flag
Definition: ctu.h:286
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
VVCLocalContext::ctb_up_flag
uint8_t ctb_up_flag
Definition: ctu.h:373
ff_vvc_end_of_tile_one_bit
int ff_vvc_end_of_tile_one_bit(VVCLocalContext *lc)
Definition: cabac.c:2470
height
#define height
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
ff_vvc_intra_subpartitions_mode_flag
int ff_vvc_intra_subpartitions_mode_flag(VVCLocalContext *lc)
Definition: cabac.c:1292
CTU::has_dmvr
int has_dmvr
Definition: ctu.h:335
CodingUnit::lfnst_idx
int lfnst_idx
Definition: ctu.h:292
VVCSH::deblock
DBParams deblock
Definition: ps.h:253
MAX_CONTROL_POINTS
#define MAX_CONTROL_POINTS
Definition: ctu.h:64
H266RawSliceHeader::sh_cr_qp_offset
int8_t sh_cr_qp_offset
Definition: cbs_h266.h:807
H266RawSliceHeader::sh_alf_cb_enabled_flag
uint8_t sh_alf_cb_enabled_flag
Definition: cbs_h266.h:784
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:1934
av_zero_extend
#define av_zero_extend
Definition: common.h:151
VVCLocalContext::na
NeighbourAvailable na
Definition: ctu.h:420
CodingUnit::intra_pred_mode_c
IntraPredMode intra_pred_mode_c
IntraPredModeC.
Definition: ctu.h:312
ff_vvc_sao_band_position_decode
int ff_vvc_sao_band_position_decode(VVCLocalContext *lc)
Definition: cabac.c:991
MODE_TYPE_INTER
@ MODE_TYPE_INTER
Definition: ctu.c:37
MvField::pred_flag
int8_t pred_flag
Definition: hevcdec.h:306
MvField::hpel_if_idx
uint8_t hpel_if_idx
hpelIfIdx
Definition: ctu.h:201
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:1436
ff_vvc_merge_subblock_flag
int ff_vvc_merge_subblock_flag(VVCLocalContext *lc)
Definition: cabac.c:1362
ALFParams::ctb_cc_idc
uint8_t ctb_cc_idc[2]
alf_ctb_cc_cb_idc, alf_ctb_cc_cr_idc
Definition: ctu.h:463
CHROMA_FORMAT_422
@ CHROMA_FORMAT_422
Definition: ps.h:54
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:1162
CTU::max_y
int max_y[2][VVC_MAX_REF_ENTRIES]
Definition: ctu.h:333
H266RawSliceHeader
Definition: cbs_h266.h:769
get_cclm_enabled
static int get_cclm_enabled(const VVCLocalContext *lc, const int x0, const int y0)
Definition: ctu.c:633
set_cb_tab
static void set_cb_tab(const VVCLocalContext *lc, uint8_t *tab, const uint8_t v)
Definition: ctu.c:124
VVCLocalContext::boundary_flags
int boundary_flags
Definition: ctu.h:430
PredictionUnit::mi
MotionInfo mi
Definition: ctu.h:266
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:67
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:273
VVCAllowedSplit
Definition: ctu.h:438
BOUNDARY_LEFT_SUBPIC
#define BOUNDARY_LEFT_SUBPIC
Definition: ctu.h:424
MODE_PLT
@ MODE_PLT
Definition: ctu.h:189
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ISP_NO_SPLIT
@ ISP_NO_SPLIT
Definition: ctu.h:117
luma_intra_pred_mode
static enum IntraPredMode luma_intra_pred_mode(VVCLocalContext *lc, const int intra_subpartitions_mode_flag)
Definition: ctu.c:684
NeighbourAvailable::cand_up_left
int cand_up_left
Definition: hevcdec.h:313
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:1022
ff_vvc_abs_mvd_greater1_flag
int ff_vvc_abs_mvd_greater1_flag(VVCLocalContext *lc)
Definition: cabac.c:1531
ff_vvc_transform_skip_flag
int ff_vvc_transform_skip_flag(VVCLocalContext *lc, const int inc)
Definition: cabac.c:1722
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:1255
pred_get_y
static int pred_get_y(const int y0, const Mv *mv, const int height)
Definition: ctu.c:2385
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:1601
PF_L0
@ PF_L0
Definition: hevcdec.h:115
VVCLocalContext::prev_tu_cbf_y
int prev_tu_cbf_y
prevTuCbfY;
Definition: ctu.h:400
VVCLocalContext::cu_qg_top_left_x
int cu_qg_top_left_x
CuQgTopLeftX.
Definition: ctu.h:394
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:279
TransformUnit::tbs
TransformBlock tbs[VVC_MAX_SAMPLE_ARRAYS]
Definition: ctu.h:180
H266RawSliceHeader::sh_sao_chroma_used_flag
uint8_t sh_sao_chroma_used_flag
Definition: cbs_h266.h:812
VVCPH::poc
int32_t poc
PicOrderCntVal.
Definition: ps.h:153
EntryPoint
Definition: ctu.h:352
TransformBlock::coeffs
int * coeffs
Definition: ctu.h:161
ff_vvc_store_sb_mvs
void ff_vvc_store_sb_mvs(const VVCLocalContext *lc, PredictionUnit *pu)
Definition: mvs.c:408
ff_vvc_end_of_subset_one_bit
int ff_vvc_end_of_subset_one_bit(VVCLocalContext *lc)
Definition: cabac.c:2475
set_qp_c
static void set_qp_c(VVCLocalContext *lc)
Definition: ctu.c:187
H266RawSliceHeader::sh_alf_cc_cb_aps_id
uint8_t sh_alf_cc_cb_aps_id
Definition: cbs_h266.h:788
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:173
hls_sao
static void hls_sao(VVCLocalContext *lc, const int rx, const int ry)
Definition: ctu.c:2210
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:293
VVCLocalContext::cu
CodingUnit * cu
Definition: ctu.h:416
ff_vvc_sbt_flag
int ff_vvc_sbt_flag(VVCLocalContext *lc)
Definition: cabac.c:2420
ff_vvc_get_qPy
int ff_vvc_get_qPy(const VVCFrameContext *fc, const int xc, const int yc)
Definition: ctu.c:2549
ff_vvc_cu_qp_delta_abs
int ff_vvc_cu_qp_delta_abs(VVCLocalContext *lc)
Definition: cabac.c:1625
INTRA_VERT
@ INTRA_VERT
Definition: ctu.h:232
BOUNDARY_UPPER_SUBPIC
#define BOUNDARY_UPPER_SUBPIC
Definition: ctu.h:427
PredictionUnit::dmvr_flag
uint8_t dmvr_flag
Definition: ctu.h:269
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:406
ret
ret
Definition: filter_design.txt:187
VVCLocalContext::chroma_qp_offset
int chroma_qp_offset[3]
CuQpOffsetCb, CuQpOffsetCr, CuQpOffsetCbCr.
Definition: ctu.h:397
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:1206
IntraPredMode
IntraPredMode
Definition: hevcdec.h:120
ff_vvc_alf_luma_fixed_filter_idx
int ff_vvc_alf_luma_fixed_filter_idx(VVCLocalContext *lc)
Definition: cabac.c:1047
hls_mvd_coding
static void hls_mvd_coding(VVCLocalContext *lc, Mv *mvd)
Definition: ctu.c:1491
VVCLocalContext::sbt_num_fourths_tb0
int sbt_num_fourths_tb0
SbtNumFourthsTb0.
Definition: ctu.h:391
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:1541
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:1713
H266RawSliceHeader::sh_alf_cc_cb_enabled_flag
uint8_t sh_alf_cc_cb_enabled_flag
Definition: cbs_h266.h:787
ALFParams::alf_ctb_filter_alt_idx
uint8_t alf_ctb_filter_alt_idx[2]
alf_ctb_filter_alt_idx[]
Definition: ctu.h:462
PredictionUnit::inter_affine_flag
uint8_t inter_affine_flag
Definition: ctu.h:255
ff_vvc_get_mvf
MvField * ff_vvc_get_mvf(const VVCFrameContext *fc, const int x0, const int y0)
Definition: mvs.c:1938
SKIPPED_TRANSFORM_TREE
#define SKIPPED_TRANSFORM_TREE(x, y)
CodingUnit::cb_height
int cb_height
Definition: ctu.h:282
ff_vvc_cu_qp_delta_sign_flag
int ff_vvc_cu_qp_delta_sign_flag(VVCLocalContext *lc)
Definition: cabac.c:1653
TransformBlock::log2_tb_height
int log2_tb_height
Definition: ctu.h:149
CodingUnit::tail
TransformUnit * tail
RefStruct reference.
Definition: ctu.h:321
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:2514
inter_data
static int inter_data(VVCLocalContext *lc)
Definition: ctu.c:1766
cu_get_max_y
static void cu_get_max_y(const CodingUnit *cu, int max_y[2][VVC_MAX_REF_ENTRIES], const VVCFrameContext *fc)
Definition: ctu.c:2390
DUAL_TREE_CHROMA
@ DUAL_TREE_CHROMA
Definition: ctu.h:167
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:140
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
PredMode
PredMode
Definition: hevcdec.h:101
MotionInfo::num_sb_x
int num_sb_x
Definition: ctu.h:248
PredictionUnit::sym_mvd_flag
int sym_mvd_flag
Definition: ctu.h:264
ff_vvc_cclm_mode_idx
int ff_vvc_cclm_mode_idx(VVCLocalContext *lc)
Definition: cabac.c:1332
ff_vvc_luma_mv_merge_ibc
int ff_vvc_luma_mv_merge_ibc(VVCLocalContext *lc, const int merge_idx, Mv *mv)
Definition: mvs.c:1722
fill_dmvr_info
static void fill_dmvr_info(const VVCLocalContext *lc)
Definition: ctu.c:1745
TransformBlock
Definition: ctu.h:139
intra_luma_pred_modes
static void intra_luma_pred_modes(VVCLocalContext *lc)
Definition: ctu.c:951
TAB_MSM
#define TAB_MSM(fc, depth, x, y)
Definition: ctu.c:32
VVCSH::slice_qp_y
int8_t slice_qp_y
SliceQpY.
Definition: ps.h:250
CodingUnit::pred_mode
enum PredMode pred_mode
PredMode.
Definition: hevcdec.h:289
ff_vvc_sao_type_idx_decode
int ff_vvc_sao_type_idx_decode(VVCLocalContext *lc)
Definition: cabac.c:981
ALFParams::ctb_filt_set_idx_y
uint8_t ctb_filt_set_idx_y
AlfCtbFiltSetIdxY.
Definition: ctu.h:461
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
MIN_TU_SIZE
#define MIN_TU_SIZE
Definition: ctu.h:43
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
SAOParams::type_idx
uint8_t type_idx[3]
sao_type_idx
Definition: dsp.h:44
mvp_data
static int mvp_data(VVCLocalContext *lc)
Definition: ctu.c:1625
EntryPoint::num_hmvp
int num_hmvp
NumHmvpCand.
Definition: ctu.h:366
get_qp_y_pred
static int get_qp_y_pred(const VVCLocalContext *lc)
Definition: ctu.c:77
PredictionUnit::general_merge_flag
uint8_t general_merge_flag
Definition: ctu.h:252
VVCLocalContext::end_of_tiles_y
int end_of_tiles_y
Definition: ctu.h:377
sbt_info
static void sbt_info(VVCLocalContext *lc, const VVCSPS *sps)
Definition: ctu.c:1089
MAX_QP
#define MAX_QP
Definition: hevcdec.h:50
TransformUnit::y0
int y0
Definition: ctu.h:172
VVCFrameContext::qp
int8_t * qp[VVC_MAX_SAMPLE_ARRAYS]
Definition: dec.h:157
CodingUnit::next
struct CodingUnit * next
RefStruct reference.
Definition: ctu.h:328
MvField::mv
Mv mv[2]
mvL0, vvL1
Definition: hevcdec.h:304
ALFParams
Definition: ctu.h:459
ff_vvc_sao_merge_flag_decode
int ff_vvc_sao_merge_flag_decode(VVCLocalContext *lc)
Definition: cabac.c:976
Mv
Definition: hevcdec.h:298
merge_data_block
static void merge_data_block(VVCLocalContext *lc)
Definition: ctu.c:1415
MvField::ref_idx
int8_t ref_idx[2]
refIdxL0, refIdxL1
Definition: hevcdec.h:305
set_tb_tab
static void set_tb_tab(uint8_t *tab, uint8_t v, const VVCFrameContext *fc, const TransformBlock *tb)
Definition: ctu.c:62
CTU::cus
CodingUnit * cus
Definition: ctu.h:332
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:2455
ff_vvc_general_merge_flag
int ff_vvc_general_merge_flag(VVCLocalContext *lc)
Definition: cabac.c:1346
ff_vvc_ctu_free_cus
void ff_vvc_ctu_free_cus(CTU *ctu)
Definition: ctu.c:2529
VVCFrameContext::ps
VVCFrameParamSets ps
Definition: dec.h:124
VVCSH::max_bt_size
uint8_t max_bt_size[2]
MaxBtSizeY, MaxBtSizeC.
Definition: ps.h:257
TAB_ISPMF
#define TAB_ISPMF(fc, x, y)
Definition: ctu.c:33
SINGLE_TREE
@ SINGLE_TREE
Definition: ctu.h:165
ff_vvc_intra_chroma_pred_mode
int ff_vvc_intra_chroma_pred_mode(VVCLocalContext *lc)
Definition: cabac.c:1339
VVCSPS::r
const H266RawSPS * r
RefStruct reference.
Definition: ps.h:59
PredFlag
PredFlag
Definition: hevcdec.h:113
H266RawSliceHeader::sh_num_alf_aps_ids_luma
uint8_t sh_num_alf_aps_ids_luma
Definition: cbs_h266.h:782
SliceContext::sh
VVCSH sh
Definition: dec.h:108
ff_vvc_tu_cr_coded_flag
int ff_vvc_tu_cr_coded_flag(VVCLocalContext *lc, int tu_cb_coded_flag)
Definition: cabac.c:1606
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:1062
CodingUnit::isp_split_type
enum IspType isp_split_type
IntraSubPartitionsSplitType.
Definition: ctu.h:305
VVCFrameContext
Definition: dec.h:115
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:2080
ff_vvc_intra_luma_mpm_flag
int ff_vvc_intra_luma_mpm_flag(VVCLocalContext *lc)
Definition: cabac.c:1304
CodingUnit::mip_chroma_direct_flag
int mip_chroma_direct_flag
MipChromaDirectFlag.
Definition: ctu.h:313
ALFParams::ctb_flag
uint8_t ctb_flag[3]
alf_ctb_flag[]
Definition: ctu.h:460
MvField::bcw_idx
uint8_t bcw_idx
bcwIdx
Definition: ctu.h:202
ff_vvc_sao_offset_abs_decode
int ff_vvc_sao_offset_abs_decode(VVCLocalContext *lc)
Definition: cabac.c:1000
CodingUnit::skip_flag
uint8_t skip_flag
cu_skip_flag;
Definition: ctu.h:299
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:1389
ff_vvc_store_mvf
void ff_vvc_store_mvf(const VVCLocalContext *lc, const MvField *mvf)
Definition: mvs.c:498
SET_SAO
#define SET_SAO(elem, value)
Definition: ctu.c:2198
VVCSH::min_qt_size
uint8_t min_qt_size[2]
MinQtSizeY, MinQtSizeC.
Definition: ps.h:256
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:1548
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:1567
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:176
ff_vvc_intra_bdpcm_luma_dir_flag
int ff_vvc_intra_bdpcm_luma_dir_flag(VVCLocalContext *lc)
Definition: cabac.c:1227
ff_vvc_intra_bdpcm_luma_flag
int ff_vvc_intra_bdpcm_luma_flag(VVCLocalContext *lc)
Definition: cabac.c:1222
h
h
Definition: vp9dsp_template.c:2038
ctu.h
BOUNDARY_LEFT_SLICE
#define BOUNDARY_LEFT_SLICE
Definition: hevcdec.h:437
VVCLocalContext::ep
EntryPoint * ep
Definition: ctu.h:434
set_qp_c_tab
static void set_qp_c_tab(const VVCLocalContext *lc, const TransformUnit *tu, const TransformBlock *tb)
Definition: ctu.c:179
VVCLocalContext::cu_qg_top_left_y
int cu_qg_top_left_y
CuQgTopLeftY.
Definition: ctu.h:395
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:2557
INTRA_LT_CCLM
@ INTRA_LT_CCLM
Definition: ctu.h:234
H266RawSliceHeader::sh_alf_cr_enabled_flag
uint8_t sh_alf_cr_enabled_flag
Definition: cbs_h266.h:785
int
int
Definition: ffmpeg_filter.c:424
CodingUnit::ciip_flag
uint8_t ciip_flag
Definition: ctu.h:302
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:1196
ff_vvc_cclm_mode_flag
int ff_vvc_cclm_mode_flag(VVCLocalContext *lc)
Definition: cabac.c:1327
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
PredictionUnit::merge_subblock_flag
uint8_t merge_subblock_flag
Definition: ctu.h:258
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
has_inter_luma
static int has_inter_luma(const CodingUnit *cu)
Definition: ctu.c:2380
CodingUnit::num_intra_subpartitions
int num_intra_subpartitions
Definition: ctu.h:309
ff_vvc_set_intra_mvf
void ff_vvc_set_intra_mvf(const VVCLocalContext *lc, const int dmvr)
Definition: mvs.c:269
VVCLocalContext::ctb_left_flag
uint8_t ctb_left_flag
Definition: ctu.h:372
ff_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
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:131
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:396
VVCLocalContext::is_cu_qp_delta_coded
uint8_t is_cu_qp_delta_coded
IsCuQpDeltaCoded.
Definition: ctu.h:393
merge_data_gpm
static void merge_data_gpm(VVCLocalContext *lc)
Definition: ctu.c:1376
CodingUnit::y0
int y0
Definition: ctu.h:280
CodingUnit::qp
int8_t qp[4]
QpY, Qp′Cb, Qp′Cr, Qp′CbCr.
Definition: ctu.h:324
ff_vvc_intra_bdpcm_chroma_flag
int ff_vvc_intra_bdpcm_chroma_flag(VVCLocalContext *lc)
Definition: cabac.c:1232
Generated on Fri Jul 26 2024 19:22:11 for FFmpeg by   doxygen 1.8.17