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