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