FFmpeg
ps.c
Go to the documentation of this file.
1 /*
2  * VVC parameter set parser
3  *
4  * Copyright (C) 2023 Nuo Mi
5  * Copyright (C) 2022 Xu Mu
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavcodec/cbs_h266.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavcodec/refstruct.h"
28 #include "data.h"
29 #include "ps.h"
30 #include "dec.h"
31 
32 static int sps_map_pixel_format(VVCSPS *sps, void *log_ctx)
33 {
34  const H266RawSPS *r = sps->r;
35  const AVPixFmtDescriptor *desc;
36 
37  switch (sps->bit_depth) {
38  case 8:
39  if (r->sps_chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
40  if (r->sps_chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
41  if (r->sps_chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
42  if (r->sps_chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
43  break;
44  case 10:
45  if (r->sps_chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
46  if (r->sps_chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
47  if (r->sps_chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
48  if (r->sps_chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
49  break;
50  case 12:
51  if (r->sps_chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
52  if (r->sps_chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
53  if (r->sps_chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
54  if (r->sps_chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
55  break;
56  default:
57  av_log(log_ctx, AV_LOG_ERROR,
58  "The following bit-depths are currently specified: 8, 10, 12 bits, "
59  "chroma_format_idc is %d, depth is %d\n",
60  r->sps_chroma_format_idc, sps->bit_depth);
61  return AVERROR_INVALIDDATA;
62  }
63 
64  desc = av_pix_fmt_desc_get(sps->pix_fmt);
65  if (!desc)
66  return AVERROR(EINVAL);
67 
68  sps->hshift[0] = sps->vshift[0] = 0;
69  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
70  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
71 
72  sps->pixel_shift = sps->bit_depth > 8;
73 
74  return 0;
75 }
76 
77 static int sps_bit_depth(VVCSPS *sps, void *log_ctx)
78 {
79  const H266RawSPS *r = sps->r;
80 
81  sps->bit_depth = r->sps_bitdepth_minus8 + 8;
82  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
83  sps->log2_transform_range =
84  r->sps_extended_precision_flag ? FFMAX(15, FFMIN(20, sps->bit_depth + 6)) : 15;
85  return sps_map_pixel_format(sps, log_ctx);
86 }
87 
89 {
90  const H266RawSPS *r = sps->r;
91  const int num_qp_tables = r->sps_same_qp_table_for_chroma_flag ?
92  1 : (r->sps_joint_cbcr_enabled_flag ? 3 : 2);
93 
94  for (int i = 0; i < num_qp_tables; i++) {
95  int num_points_in_qp_table;
97  unsigned int delta_qp_in[VVC_MAX_POINTS_IN_QP_TABLE];
98  int off = sps->qp_bd_offset;
99 
100  num_points_in_qp_table = r->sps_num_points_in_qp_table_minus1[i] + 1;
101 
102  qp_out[0] = qp_in[0] = r->sps_qp_table_start_minus26[i] + 26;
103  for (int j = 0; j < num_points_in_qp_table; j++ ) {
104  delta_qp_in[j] = r->sps_delta_qp_in_val_minus1[i][j] + 1;
105  qp_in[j+1] = qp_in[j] + delta_qp_in[j];
106  qp_out[j+1] = qp_out[j] + (r->sps_delta_qp_in_val_minus1[i][j] ^ r->sps_delta_qp_diff_val[i][j]);
107  }
108  sps->chroma_qp_table[i][qp_in[0] + off] = qp_out[0];
109  for (int k = qp_in[0] - 1 + off; k >= 0; k--)
110  sps->chroma_qp_table[i][k] = av_clip(sps->chroma_qp_table[i][k+1]-1, -off, 63);
111 
112  for (int j = 0; j < num_points_in_qp_table; j++) {
113  int sh = delta_qp_in[j] >> 1;
114  for (int k = qp_in[j] + 1 + off, m = 1; k <= qp_in[j+1] + off; k++, m++) {
115  sps->chroma_qp_table[i][k] = sps->chroma_qp_table[i][qp_in[j] + off] +
116  ((qp_out[j+1] - qp_out[j]) * m + sh) / delta_qp_in[j];
117  }
118  }
119  for (int k = qp_in[num_points_in_qp_table] + 1 + off; k <= 63 + off; k++)
120  sps->chroma_qp_table[i][k] = av_clip(sps->chroma_qp_table[i][k-1] + 1, -sps->qp_bd_offset, 63);
121  }
122  if (r->sps_same_qp_table_for_chroma_flag) {
123  memcpy(&sps->chroma_qp_table[1], &sps->chroma_qp_table[0], sizeof(sps->chroma_qp_table[0]));
124  memcpy(&sps->chroma_qp_table[2], &sps->chroma_qp_table[0], sizeof(sps->chroma_qp_table[0]));
125  }
126 
127  return 0;
128 }
129 
130 static void sps_poc(VVCSPS *sps)
131 {
132  sps->max_pic_order_cnt_lsb = 1 << (sps->r->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
133 }
134 
135 static void sps_inter(VVCSPS *sps)
136 {
137  const H266RawSPS *r = sps->r;
138 
139  sps->max_num_merge_cand = 6 - r->sps_six_minus_max_num_merge_cand;
140  sps->max_num_ibc_merge_cand = 6 - r->sps_six_minus_max_num_ibc_merge_cand;
141 
142  if (sps->r->sps_gpm_enabled_flag) {
143  sps->max_num_gpm_merge_cand = 2;
144  if (sps->max_num_merge_cand >= 3)
145  sps->max_num_gpm_merge_cand = sps->max_num_merge_cand - r->sps_max_num_merge_cand_minus_max_num_gpm_cand;
146  }
147 
148  sps->log2_parallel_merge_level = r->sps_log2_parallel_merge_level_minus2 + 2;
149 }
150 
152 {
153  const H266RawSPS *r = sps->r;
154 
155  sps->ctb_log2_size_y = r->sps_log2_ctu_size_minus5 + 5;
156  sps->ctb_size_y = 1 << sps->ctb_log2_size_y;
157  sps->min_cb_log2_size_y = r->sps_log2_min_luma_coding_block_size_minus2 + 2;
158  sps->min_cb_size_y = 1 << sps->min_cb_log2_size_y;
159  sps->max_tb_size_y = 1 << (r->sps_max_luma_transform_size_64_flag ? 6 : 5);
160  sps->max_ts_size = 1 << (r->sps_log2_transform_skip_max_size_minus2 + 2);
161 }
162 
163 static void sps_ladf(VVCSPS* sps)
164 {
165  const H266RawSPS *r = sps->r;
166 
167  if (r->sps_ladf_enabled_flag) {
168  sps->num_ladf_intervals = r->sps_num_ladf_intervals_minus2 + 2;
169  sps->ladf_interval_lower_bound[0] = 0;
170  for (int i = 0; i < sps->num_ladf_intervals - 1; i++) {
171  sps->ladf_interval_lower_bound[i + 1] =
172  sps->ladf_interval_lower_bound[i] + r->sps_ladf_delta_threshold_minus1[i] + 1;
173  }
174  }
175 }
176 
177 static int sps_derive(VVCSPS *sps, void *log_ctx)
178 {
179  int ret;
180  const H266RawSPS *r = sps->r;
181 
182  ret = sps_bit_depth(sps, log_ctx);
183  if (ret < 0)
184  return ret;
185  sps_poc(sps);
186  sps_inter(sps);
188  sps_ladf(sps);
189  if (r->sps_chroma_format_idc != 0)
191 
192  return 0;
193 }
194 
195 static void sps_free(FFRefStructOpaque opaque, void *obj)
196 {
197  VVCSPS *sps = obj;
198  ff_refstruct_unref(&sps->r);
199 }
200 
201 static const VVCSPS *sps_alloc(const H266RawSPS *rsps, void *log_ctx)
202 {
203  int ret;
204  VVCSPS *sps = ff_refstruct_alloc_ext(sizeof(*sps), 0, NULL, sps_free);
205 
206  if (!sps)
207  return NULL;
208 
209  ff_refstruct_replace(&sps->r, rsps);
210 
211  ret = sps_derive(sps, log_ctx);
212  if (ret < 0)
213  goto fail;
214 
215  return sps;
216 
217 fail:
219  return NULL;
220 }
221 
222 static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx, int is_clvss)
223 {
224  const int sps_id = rsps->sps_seq_parameter_set_id;
225  const VVCSPS *old_sps = ps->sps_list[sps_id];
226  const VVCSPS *sps;
227 
228  if (is_clvss) {
229  ps->sps_id_used = 0;
230  }
231 
232  if (old_sps) {
233  if (old_sps->r == rsps || !memcmp(old_sps->r, rsps, sizeof(*old_sps->r)))
234  return 0;
235  else if (ps->sps_id_used & (1 << sps_id))
236  return AVERROR_INVALIDDATA;
237  }
238 
239  sps = sps_alloc(rsps, log_ctx);
240  if (!sps)
241  return AVERROR(ENOMEM);
242 
243  ff_refstruct_unref(&ps->sps_list[sps_id]);
244  ps->sps_list[sps_id] = sps;
245  ps->sps_id_used |= (1 << sps_id);
246 
247  return 0;
248 }
249 
251 {
252  pps->chroma_qp_offset[CB - 1] = pps->r->pps_cb_qp_offset;
253  pps->chroma_qp_offset[CR - 1] = pps->r->pps_cr_qp_offset;
254  pps->chroma_qp_offset[JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_value;
255  for (int i = 0; i < 6; i++) {
256  pps->chroma_qp_offset_list[i][CB - 1] = pps->r->pps_cb_qp_offset_list[i];
257  pps->chroma_qp_offset_list[i][CR - 1] = pps->r->pps_cr_qp_offset_list[i];
258  pps->chroma_qp_offset_list[i][JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_list[i];
259  }
260 }
261 
262 static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
263 {
264  const H266RawPPS *r = pps->r;
265 
266  pps->width = r->pps_pic_width_in_luma_samples;
267  pps->height = r->pps_pic_height_in_luma_samples;
268 
269  pps->ctb_width = AV_CEIL_RSHIFT(pps->width, sps->ctb_log2_size_y);
270  pps->ctb_height = AV_CEIL_RSHIFT(pps->height, sps->ctb_log2_size_y);
271  pps->ctb_count = pps->ctb_width * pps->ctb_height;
272 
273  pps->min_cb_width = pps->width >> sps->min_cb_log2_size_y;
274  pps->min_cb_height = pps->height >> sps->min_cb_log2_size_y;
275 
276  pps->min_pu_width = pps->width >> MIN_PU_LOG2;
277  pps->min_pu_height = pps->height >> MIN_PU_LOG2;
278  pps->min_tu_width = pps->width >> MIN_TU_LOG2;
279  pps->min_tu_height = pps->height >> MIN_TU_LOG2;
280 
281  pps->width32 = AV_CEIL_RSHIFT(pps->width, 5);
282  pps->height32 = AV_CEIL_RSHIFT(pps->height, 5);
283  pps->width64 = AV_CEIL_RSHIFT(pps->width, 6);
284  pps->height64 = AV_CEIL_RSHIFT(pps->height, 6);
285 }
286 
287 static int pps_bd(VVCPPS *pps)
288 {
289  const H266RawPPS *r = pps->r;
290 
291  pps->col_bd = av_calloc(r->num_tile_columns + 1, sizeof(*pps->col_bd));
292  pps->row_bd = av_calloc(r->num_tile_rows + 1, sizeof(*pps->row_bd));
293  pps->ctb_to_col_bd = av_calloc(pps->ctb_width + 1, sizeof(*pps->ctb_to_col_bd));
294  pps->ctb_to_row_bd = av_calloc(pps->ctb_height + 1, sizeof(*pps->ctb_to_col_bd));
295  if (!pps->col_bd || !pps->row_bd || !pps->ctb_to_col_bd || !pps->ctb_to_row_bd)
296  return AVERROR(ENOMEM);
297 
298  for (int i = 0, j = 0; i < r->num_tile_columns; i++) {
299  pps->col_bd[i] = j;
300  j += r->col_width_val[i];
301  for (int k = pps->col_bd[i]; k < j; k++)
302  pps->ctb_to_col_bd[k] = pps->col_bd[i];
303  }
304  pps->col_bd[r->num_tile_columns] = pps->ctb_to_col_bd[pps->ctb_width] = pps->ctb_width;
305 
306  for (int i = 0, j = 0; i < r->num_tile_rows; i++) {
307  pps->row_bd[i] = j;
308  j += r->row_height_val[i];
309  for (int k = pps->row_bd[i]; k < j; k++)
310  pps->ctb_to_row_bd[k] = pps->row_bd[i];
311  }
312  pps->row_bd[r->num_tile_rows] = pps->ctb_to_row_bd[pps->ctb_height] = pps->ctb_height;
313 
314  return 0;
315 }
316 
317 
318 static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
319 {
320  if (r->pps_tile_idx_delta_present_flag) {
321  tile_idx += r->pps_tile_idx_delta_val[i];
322  } else {
323  tile_idx += r->pps_slice_width_in_tiles_minus1[i] + 1;
324  if (tile_idx % r->num_tile_columns == 0)
325  tile_idx += (r->pps_slice_height_in_tiles_minus1[i]) * r->num_tile_columns;
326  }
327  return tile_idx;
328 }
329 
330 static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
331 {
332  *tile_x = tile_idx % pps->r->num_tile_columns;
333  *tile_y = tile_idx / pps->r->num_tile_columns;
334 }
335 
336 static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
337 {
338  *rx = pps->col_bd[tile_x];
339  *ry = pps->row_bd[tile_y];
340 }
341 
342 static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
343 {
344  return pps->ctb_width * ry + rx;
345 }
346 
347 static int pps_add_ctus(VVCPPS *pps, int *off, const int rx, const int ry,
348  const int w, const int h)
349 {
350  int start = *off;
351  for (int y = 0; y < h; y++) {
352  for (int x = 0; x < w; x++) {
353  pps->ctb_addr_in_slice[*off] = ctu_rs(rx + x, ry + y, pps);
354  (*off)++;
355  }
356  }
357  return *off - start;
358 }
359 
360 static void pps_single_slice_picture(VVCPPS *pps, int *off)
361 {
362  for (int j = 0; j < pps->r->num_tile_rows; j++) {
363  for (int i = 0; i < pps->r->num_tile_columns; i++) {
364  pps->num_ctus_in_slice[0] = pps_add_ctus(pps, off,
365  pps->col_bd[i], pps->row_bd[j],
366  pps->r->col_width_val[i], pps->r->row_height_val[j]);
367  }
368  }
369 }
370 
371 static void subpic_tiles(int *tile_x, int *tile_y, int *tile_x_end, int *tile_y_end,
372  const VVCSPS *sps, const VVCPPS *pps, const int i)
373 {
374  const int rx = sps->r->sps_subpic_ctu_top_left_x[i];
375  const int ry = sps->r->sps_subpic_ctu_top_left_y[i];
376 
377  *tile_x = *tile_y = 0;
378 
379  while (pps->col_bd[*tile_x] != rx)
380  (*tile_x)++;
381 
382  while (pps->row_bd[*tile_y] != ry)
383  (*tile_y)++;
384 
385  *tile_x_end = (*tile_x);
386  *tile_y_end = (*tile_y);
387 
388  while (pps->col_bd[*tile_x_end] < rx + sps->r->sps_subpic_width_minus1[i] + 1)
389  (*tile_x_end)++;
390 
391  while (pps->row_bd[*tile_y_end] < ry + sps->r->sps_subpic_height_minus1[i] + 1)
392  (*tile_y_end)++;
393 }
394 
395 static void pps_subpic_less_than_one_tile_slice(VVCPPS *pps, const VVCSPS *sps, const int i, const int tx, const int ty, int *off)
396 {
397  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off,
398  pps->col_bd[tx], pps->row_bd[ty],
399  pps->r->col_width_val[tx], sps->r->sps_subpic_height_minus1[i] + 1);
400 }
401 
402 static void pps_subpic_one_or_more_tiles_slice(VVCPPS *pps, const int tile_x, const int tile_y, const int x_end, const int y_end, const int i, int *off)
403 {
404  for (int ty = tile_y; ty < y_end; ty++) {
405  for (int tx = tile_x; tx < x_end; tx++) {
406  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off,
407  pps->col_bd[tx], pps->row_bd[ty],
408  pps->r->col_width_val[tx], pps->r->row_height_val[ty]);
409  }
410  }
411 }
412 
413 static void pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off)
414 {
415  int tx, ty, x_end, y_end;
416 
417  pps->slice_start_offset[i] = *off;
418  pps->num_ctus_in_slice[i] = 0;
419 
420  subpic_tiles(&tx, &ty, &x_end, &y_end, sps, pps, i);
421  if (ty + 1 == y_end && sps->r->sps_subpic_height_minus1[i] + 1 < pps->r->row_height_val[ty])
423  else
424  pps_subpic_one_or_more_tiles_slice(pps, tx, ty, x_end, y_end, i, off);
425 }
426 
427 static void pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
428 {
429  if (!sps->r->sps_subpic_info_present_flag) {
431  } else {
432  for (int i = 0; i < pps->r->pps_num_slices_in_pic_minus1 + 1; i++)
433  pps_subpic_slice(pps, sps, i, off);
434  }
435 }
436 
437 static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
438 {
439  const H266RawPPS *r = pps->r;
440  int rx, ry, ctu_y_end, tile_x, tile_y;
441 
442  tile_xy(&tile_x, &tile_y, tile_idx, pps);
443  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
444  ctu_y_end = ry + r->row_height_val[tile_y];
445  while (ry < ctu_y_end) {
446  pps->slice_start_offset[i] = *off;
447  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off, rx, ry,
448  r->col_width_val[tile_x], r->slice_height_in_ctus[i]);
449  ry += r->slice_height_in_ctus[i++];
450  }
451  i--;
452  return i;
453 }
454 
455 static void pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off)
456 {
457  const H266RawPPS *r = pps->r;
458  int rx, ry, tile_x, tile_y;
459 
460  tile_xy(&tile_x, &tile_y, tile_idx, pps);
461  pps->slice_start_offset[i] = *off;
462  pps->num_ctus_in_slice[i] = 0;
463  for (int ty = tile_y; ty <= tile_y + r->pps_slice_height_in_tiles_minus1[i]; ty++) {
464  for (int tx = tile_x; tx <= tile_x + r->pps_slice_width_in_tiles_minus1[i]; tx++) {
465  ctu_xy(&rx, &ry, tx, ty, pps);
466  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off, rx, ry,
467  r->col_width_val[tx], r->row_height_val[ty]);
468  }
469  }
470 }
471 
472 static void pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
473 {
474  const H266RawPPS *r = pps->r;
475  int tile_idx = 0, off = 0;
476 
477  if (r->pps_single_slice_per_subpic_flag) {
479  return;
480  }
481 
482  for (int i = 0; i < r->pps_num_slices_in_pic_minus1 + 1; i++) {
483  if (!r->pps_slice_width_in_tiles_minus1[i] &&
484  !r->pps_slice_height_in_tiles_minus1[i]) {
485  i = pps_one_tile_slices(pps, tile_idx, i, &off);
486  } else {
487  pps_multi_tiles_slice(pps, tile_idx, i, &off);
488  }
489  tile_idx = next_tile_idx(tile_idx, i, r);
490  }
491 }
492 
494 {
495  const H266RawPPS* r = pps->r;
496  int rx, ry, off = 0;
497 
498  for (int tile_y = 0; tile_y < r->num_tile_rows; tile_y++) {
499  for (int tile_x = 0; tile_x < r->num_tile_columns; tile_x++) {
500  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
501  pps_add_ctus(pps, &off, rx, ry, r->col_width_val[tile_x], r->row_height_val[tile_y]);
502  }
503  }
504 }
505 
506 static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
507 {
508  pps->ctb_addr_in_slice = av_calloc(pps->ctb_count, sizeof(*pps->ctb_addr_in_slice));
509  if (!pps->ctb_addr_in_slice)
510  return AVERROR(ENOMEM);
511 
512  if (pps->r->pps_rect_slice_flag)
514  else
516 
517  return 0;
518 }
519 
521 {
522  const H266RawPPS *r = pps->r;
523 
524  if (r->pps_ref_wraparound_enabled_flag)
525  pps->ref_wraparound_offset = (pps->width / sps->min_cb_size_y) - r->pps_pic_width_minus_wraparound_offset;
526 }
527 
528 static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
529 {
530  const H266RawSPS *rsps = sps->r;
531  for (int i = 0; i < rsps->sps_num_subpics_minus1 + 1; i++) {
532  if (rsps->sps_subpic_treated_as_pic_flag[i]) {
533  pps->subpic_x[i] = rsps->sps_subpic_ctu_top_left_x[i] << sps->ctb_log2_size_y;
534  pps->subpic_y[i] = rsps->sps_subpic_ctu_top_left_y[i] << sps->ctb_log2_size_y;
535  pps->subpic_width[i] = FFMIN(pps->width - pps->subpic_x[i], (rsps->sps_subpic_width_minus1[i] + 1) << sps->ctb_log2_size_y);
536  pps->subpic_height[i] = FFMIN(pps->height - pps->subpic_y[i], (rsps->sps_subpic_height_minus1[i] + 1) << sps->ctb_log2_size_y);
537  } else {
538  pps->subpic_x[i] = 0;
539  pps->subpic_y[i] = 0;
540  pps->subpic_width[i] = pps->width;
541  pps->subpic_height[i] = pps->height;
542  }
543  }
544 }
545 
546 static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
547 {
548  int ret;
549 
552 
553  ret = pps_bd(pps);
554  if (ret < 0)
555  return ret;
556 
557  ret = pps_slice_map(pps, sps);
558  if (ret < 0)
559  return ret;
560 
562  pps_subpic(pps, sps);
563 
564  return 0;
565 }
566 
567 static void pps_free(FFRefStructOpaque opaque, void *obj)
568 {
569  VVCPPS *pps = obj;
570 
571  ff_refstruct_unref(&pps->r);
572 
573  av_freep(&pps->col_bd);
574  av_freep(&pps->row_bd);
575  av_freep(&pps->ctb_to_col_bd);
576  av_freep(&pps->ctb_to_row_bd);
577  av_freep(&pps->ctb_addr_in_slice);
578 }
579 
580 static const VVCPPS *pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
581 {
582  int ret;
583  VVCPPS *pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
584 
585  if (!pps)
586  return NULL;
587 
588  ff_refstruct_replace(&pps->r, rpps);
589 
590  ret = pps_derive(pps, sps);
591  if (ret < 0)
592  goto fail;
593 
594  return pps;
595 
596 fail:
598  return NULL;
599 }
600 
601 static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
602 {
603  int ret = 0;
604  const int pps_id = rpps->pps_pic_parameter_set_id;
605  const int sps_id = rpps->pps_seq_parameter_set_id;
606  const VVCPPS *old_pps = ps->pps_list[pps_id];
607  const VVCPPS *pps;
608 
609  if (old_pps && old_pps->r == rpps)
610  return 0;
611 
612  pps = pps_alloc(rpps, ps->sps_list[sps_id]);
613  if (!pps)
614  return AVERROR(ENOMEM);
615 
616  ff_refstruct_unref(&ps->pps_list[pps_id]);
617  ps->pps_list[pps_id] = pps;
618 
619  return ret;
620 }
621 
622 static int decode_ps(VVCParamSets *ps, const CodedBitstreamH266Context *h266, void *log_ctx, int is_clvss)
623 {
624  const H266RawPictureHeader *ph = h266->ph;
625  const H266RawPPS *rpps;
626  const H266RawSPS *rsps;
627  int ret;
628 
629  if (!ph)
630  return AVERROR_INVALIDDATA;
631 
632  rpps = h266->pps[ph->ph_pic_parameter_set_id];
633  if (!rpps)
634  return AVERROR_INVALIDDATA;
635 
636  rsps = h266->sps[rpps->pps_seq_parameter_set_id];
637  if (!rsps)
638  return AVERROR_INVALIDDATA;
639 
640  ret = decode_sps(ps, rsps, log_ctx, is_clvss);
641  if (ret < 0)
642  return ret;
643 
644  ret = decode_pps(ps, rpps);
645  if (ret < 0)
646  return ret;
647 
648  return 0;
649 }
650 
651 #define WEIGHT_TABLE(x) \
652  w->nb_weights[L##x] = r->num_weights_l##x; \
653  for (int i = 0; i < w->nb_weights[L##x]; i++) { \
654  w->weight_flag[L##x][LUMA][i] = r->luma_weight_l##x##_flag[i]; \
655  w->weight_flag[L##x][CHROMA][i] = r->chroma_weight_l##x##_flag[i]; \
656  w->weight[L##x][LUMA][i] = denom[LUMA] + r->delta_luma_weight_l##x[i]; \
657  w->offset[L##x][LUMA][i] = r->luma_offset_l##x[i]; \
658  for (int j = CB; j <= CR; j++) { \
659  w->weight[L##x][j][i] = denom[CHROMA] + r->delta_chroma_weight_l##x[i][j - 1]; \
660  w->offset[L##x][j][i] = 128 + r->delta_chroma_offset_l##x[i][j - 1]; \
661  w->offset[L##x][j][i] -= (128 * w->weight[L##x][j][i]) >> w->log2_denom[CHROMA]; \
662  w->offset[L##x][j][i] = av_clip_intp2(w->offset[L##x][j][i], 7); \
663  } \
664  } \
665 
667 {
668  int denom[2];
669 
670  w->log2_denom[LUMA] = r->luma_log2_weight_denom;
671  w->log2_denom[CHROMA] = w->log2_denom[LUMA] + r->delta_chroma_log2_weight_denom;
672  denom[LUMA] = 1 << w->log2_denom[LUMA];
673  denom[CHROMA] = 1 << w->log2_denom[CHROMA];
674  WEIGHT_TABLE(0)
675  WEIGHT_TABLE(1)
676 }
677 
678 // 8.3.1 Decoding process for picture order count
679 static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
680 {
681  const int max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
682  const int prev_poc_lsb = poc_tid0 % max_poc_lsb;
683  const int prev_poc_msb = poc_tid0 - prev_poc_lsb;
684  const int poc_lsb = ph->ph_pic_order_cnt_lsb;
685  int poc_msb;
686 
687  if (ph->ph_poc_msb_cycle_present_flag) {
688  poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
689  } else if (is_clvss) {
690  poc_msb = 0;
691  } else {
692  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
693  poc_msb = prev_poc_msb + max_poc_lsb;
694  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
695  poc_msb = prev_poc_msb - max_poc_lsb;
696  else
697  poc_msb = prev_poc_msb;
698  }
699 
700  return poc_msb + poc_lsb;
701 }
702 
704  uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
705 {
706  const int lut_sample =
707  pivot1[idx] + ((scale_coeff[idx] * (sample - pivot2[idx]) + (1<< 10)) >> 11);
708  return av_clip(lut_sample, 0, max - 1);
709 }
710 
711 //8.8.2.2 Inverse mapping process for a luma sample
712 static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
713 {
714  const int bit_depth = (sps->sps_bitdepth_minus8 + 8);
715  const int max = (1 << bit_depth);
716  const int org_cw = max / LMCS_MAX_BIN_SIZE;
717  const int shift = av_log2(org_cw);
718  const int off = 1 << (shift - 1);
719  int cw[LMCS_MAX_BIN_SIZE];
720  uint16_t input_pivot[LMCS_MAX_BIN_SIZE];
721  uint16_t scale_coeff[LMCS_MAX_BIN_SIZE];
722  uint16_t inv_scale_coeff[LMCS_MAX_BIN_SIZE];
723  int i, delta_crs;
725  return AVERROR_PATCHWELCOME;
726 
727  if (!rlmcs)
728  return AVERROR_INVALIDDATA;
729 
730  lmcs->min_bin_idx = rlmcs->lmcs_min_bin_idx;
731  lmcs->max_bin_idx = LMCS_MAX_BIN_SIZE - 1 - rlmcs->lmcs_min_bin_idx;
732 
733  memset(cw, 0, sizeof(cw));
734  for (int i = lmcs->min_bin_idx; i <= lmcs->max_bin_idx; i++)
735  cw[i] = org_cw + (1 - 2 * rlmcs->lmcs_delta_sign_cw_flag[i]) * rlmcs->lmcs_delta_abs_cw[i];
736 
737  delta_crs = (1 - 2 * rlmcs->lmcs_delta_sign_crs_flag) * rlmcs->lmcs_delta_abs_crs;
738 
739  lmcs->pivot[0] = 0;
740  for (i = 0; i < LMCS_MAX_BIN_SIZE; i++) {
741  input_pivot[i] = i * org_cw;
742  lmcs->pivot[i + 1] = lmcs->pivot[i] + cw[i];
743  scale_coeff[i] = (cw[i] * (1 << 11) + off) >> shift;
744  if (cw[i] == 0) {
745  inv_scale_coeff[i] = 0;
746  lmcs->chroma_scale_coeff[i] = (1 << 11);
747  } else {
748  inv_scale_coeff[i] = org_cw * (1 << 11) / cw[i];
749  lmcs->chroma_scale_coeff[i] = org_cw * (1 << 11) / (cw[i] + delta_crs);
750  }
751  }
752 
753  //derive lmcs_fwd_lut
754  for (uint16_t sample = 0; sample < max; sample++) {
755  const int idx_y = sample / org_cw;
756  const uint16_t fwd_sample = lmcs_derive_lut_sample(sample, lmcs->pivot,
757  input_pivot, scale_coeff, idx_y, max);
758  if (bit_depth > 8)
759  lmcs->fwd_lut.u16[sample] = fwd_sample;
760  else
761  lmcs->fwd_lut.u8 [sample] = fwd_sample;
762 
763  }
764 
765  //derive lmcs_inv_lut
766  i = lmcs->min_bin_idx;
767  for (uint16_t sample = 0; sample < max; sample++) {
768  uint16_t inv_sample;
769  while (i <= lmcs->max_bin_idx && sample >= lmcs->pivot[i + 1])
770  i++;
771 
772  inv_sample = lmcs_derive_lut_sample(sample, input_pivot, lmcs->pivot,
773  inv_scale_coeff, i, max);
774 
775  if (bit_depth > 8)
776  lmcs->inv_lut.u16[sample] = inv_sample;
777  else
778  lmcs->inv_lut.u8 [sample] = inv_sample;
779  }
780 
781  return 0;
782 }
783 
785 {
786  if (sps->sps_affine_enabled_flag)
787  return 5 - sps->sps_five_minus_max_num_subblock_merge_cand;
788  return sps->sps_sbtmvp_enabled_flag && ph->ph_temporal_mvp_enabled_flag;
789 }
790 
791 static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
792 {
793  ph->max_num_subblock_merge_cand = ph_max_num_subblock_merge_cand(sps, ph->r);
794 
795  ph->poc = ph_compute_poc(ph->r, sps, poc_tid0, is_clvss);
796 
797  if (pps->pps_wp_info_in_ph_flag)
798  pred_weight_table(&ph->pwt, &ph->r->ph_pred_weight_table);
799 
800  return 0;
801 }
802 
803 static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref,
804  const int poc_tid0, const int is_clvss)
805 {
806  int ret;
807  VVCPH *ph = &fps->ph;
808  const H266RawSPS *sps = fps->sps->r;
809  const H266RawPPS *pps = fps->pps->r;
810 
811  ph->r = rph;
812  ff_refstruct_replace(&ph->rref, rph_ref);
813  ret = ph_derive(ph, sps, pps, poc_tid0, is_clvss);
814  if (ret < 0)
815  return ret;
816 
817  return 0;
818 }
819 
820 static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
821  const CodedBitstreamH266Context *h266, const int poc_tid0, const int is_clvss)
822 {
823  const H266RawPictureHeader *ph = h266->ph;
824  const H266RawPPS *rpps;
825  int ret;
826 
827  if (!ph)
828  return AVERROR_INVALIDDATA;
829 
830  rpps = h266->pps[ph->ph_pic_parameter_set_id];
831  if (!rpps)
832  return AVERROR_INVALIDDATA;
833 
836 
837  ret = decode_ph(fps, ph, h266->ph_ref, poc_tid0, is_clvss);
838  if (ret < 0)
839  return ret;
840 
841  if (ph->ph_explicit_scaling_list_enabled_flag)
842  ff_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
843 
844  if (ph->ph_lmcs_enabled_flag) {
845  ret = lmcs_derive_lut(&fps->lmcs, ps->lmcs_list[ph->ph_lmcs_aps_id], fps->sps->r);
846  if (ret < 0)
847  return ret;
848  }
849 
850  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
851  ff_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
852 
853  return 0;
854 }
855 
857 {
858  if (IS_IDR(s))
859  s->no_output_before_recovery_flag = 1;
860  else if (IS_CRA(s) || IS_GDR(s))
861  s->no_output_before_recovery_flag = s->last_eos;
862 }
863 
864 static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
865 {
866  if (s->no_output_before_recovery_flag) {
867  if (IS_GDR(s))
868  s->gdr_recovery_point_poc = ph->poc + ph->r->ph_recovery_poc_cnt;
869  if (!GDR_IS_RECOVERED(s) && s->gdr_recovery_point_poc <= ph->poc)
871  }
872 }
873 
875 {
876  int ret = 0;
877  VVCParamSets *ps = &s->ps;
878  const CodedBitstreamH266Context *h266 = s->cbc->priv_data;
879  int is_clvss;
880 
882  is_clvss = IS_CLVSS(s);
883 
884  ret = decode_ps(ps, h266, s->avctx, is_clvss);
885  if (ret < 0)
886  return ret;
887 
888  ret = decode_frame_ps(fps, ps, h266, s->poc_tid0, is_clvss);
889  decode_recovery_poc(s, &fps->ph);
890  return ret;
891 }
892 
894 {
895  ff_refstruct_unref(&fps->sps);
896  ff_refstruct_unref(&fps->pps);
897  ff_refstruct_unref(&fps->ph.rref);
898  ff_refstruct_unref(&fps->sl);
899  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
900  ff_refstruct_unref(&fps->alf_list[i]);
901 }
902 
904 {
905  for (int i = 0; i < FF_ARRAY_ELEMS(ps->scaling_list); i++)
907  for (int i = 0; i < FF_ARRAY_ELEMS(ps->lmcs_list); i++)
909  for (int i = 0; i < FF_ARRAY_ELEMS(ps->alf_list); i++)
911  for (int i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
913  for (int i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
915 }
916 
917 static void alf_coeff(int16_t *coeff,
918  const uint8_t *abs, const uint8_t *sign, const int size)
919 {
920  for (int i = 0; i < size; i++)
921  coeff[i] = (1 - 2 * sign[i]) * abs[i];
922 }
923 
924 static void alf_coeff_cc(int16_t *coeff,
925  const uint8_t *mapped_abs, const uint8_t *sign)
926 {
927  for (int i = 0; i < ALF_NUM_COEFF_CC; i++) {
928  int c = mapped_abs[i];
929  if (c)
930  c = (1 - 2 * sign[i]) * (1 << (c - 1));
931  coeff[i] = c;
932  }
933 }
934 
935 static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
936 {
937  if (!aps->alf_luma_filter_signal_flag)
938  return;
939 
940  for (int i = 0; i < ALF_NUM_FILTERS_LUMA; i++) {
941  const int ref = aps->alf_luma_coeff_delta_idx[i];
942  const uint8_t *abs = aps->alf_luma_coeff_abs[ref];
943  const uint8_t *sign = aps->alf_luma_coeff_sign[ref];
944 
946  memcpy(alf->luma_clip_idx[i], aps->alf_luma_clip_idx[ref],
947  sizeof(alf->luma_clip_idx[i]));
948  }
949 }
950 
951 static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
952 {
953  if (!aps->alf_chroma_filter_signal_flag)
954  return;
955 
956  alf->num_chroma_filters = aps->alf_chroma_num_alt_filters_minus1 + 1;
957  for (int i = 0; i < alf->num_chroma_filters; i++) {
958  const uint8_t *abs = aps->alf_chroma_coeff_abs[i];
959  const uint8_t *sign = aps->alf_chroma_coeff_sign[i];
960 
962  memcpy(alf->chroma_clip_idx[i], aps->alf_chroma_clip_idx[i],
963  sizeof(alf->chroma_clip_idx[i]));
964  }
965 }
966 
967 static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
968 {
969  const uint8_t (*abs[])[ALF_NUM_COEFF_CC] =
970  { aps->alf_cc_cb_mapped_coeff_abs, aps->alf_cc_cr_mapped_coeff_abs };
971  const uint8_t (*sign[])[ALF_NUM_COEFF_CC] =
972  {aps->alf_cc_cb_coeff_sign, aps->alf_cc_cr_coeff_sign };
973  const int signaled[] = { aps->alf_cc_cb_filter_signal_flag, aps->alf_cc_cr_filter_signal_flag};
974 
975  alf->num_cc_filters[0] = aps->alf_cc_cb_filters_signalled_minus1 + 1;
976  alf->num_cc_filters[1] = aps->alf_cc_cr_filters_signalled_minus1 + 1;
977 
978  for (int idx = 0; idx < 2; idx++) {
979  if (signaled[idx]) {
980  for (int i = 0; i < alf->num_cc_filters[idx]; i++)
981  alf_coeff_cc(alf->cc_coeff[idx][i], abs[idx][i], sign[idx][i]);
982  }
983  }
984 }
985 
986 static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
987 {
988  alf_luma(alf, aps);
989  alf_chroma(alf, aps);
990  alf_cc(alf, aps);
991 }
992 
993 static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
994 {
995  VVCALF *a = ff_refstruct_allocz(sizeof(*a));
996  if (!a)
997  return AVERROR(ENOMEM);
998 
999  alf_derive(a, aps);
1000  ff_refstruct_replace(alf, a);
1002 
1003  return 0;
1004 }
1005 
1006 static int is_luma_list(const int id)
1007 {
1008  return id % VVC_MAX_SAMPLE_ARRAYS == SL_START_4x4 || id == SL_START_64x64 + 1;
1009 }
1010 
1011 static int derive_matrix_size(const int id)
1012 {
1013  return id < SL_START_4x4 ? 2 : (id < SL_START_8x8 ? 4 : 8);
1014 }
1015 
1016 // 7.4.3.20 Scaling list data semantics
1018 {
1019  for (int id = 0; id < SL_MAX_ID; id++) {
1020  const int matrix_size = derive_matrix_size(id);
1021  const int log2_size = av_log2(matrix_size);
1022  const int list_size = matrix_size * matrix_size;
1024  const uint8_t *pred;
1025  const int *scaling_list;
1026  int dc = 0;
1027 
1028  if (aps->aps_chroma_present_flag || is_luma_list(id)) {
1029  if (!aps->scaling_list_copy_mode_flag[id]) {
1030  int next_coef = 0;
1031 
1032  if (id >= SL_START_16x16)
1033  dc = next_coef = aps->scaling_list_dc_coef[id - SL_START_16x16];
1034 
1035  for (int i = 0; i < list_size; i++) {
1036  const int x = ff_vvc_diag_scan_x[3][3][i];
1037  const int y = ff_vvc_diag_scan_y[3][3][i];
1038 
1039  if (!(id >= SL_START_64x64 && x >= 4 && y >= 4))
1040  next_coef += aps->scaling_list_delta_coef[id][i];
1041  coeff[i] = next_coef;
1042  }
1043  }
1044  }
1045 
1046  //dc
1047  if (id >= SL_START_16x16) {
1048  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id]) {
1049  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = 8;
1050  } else if (!aps->scaling_list_pred_id_delta[id]) {
1051  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = 16;
1052  } else {
1053  const int ref_id = id - aps->scaling_list_pred_id_delta[id];
1054  if (ref_id >= SL_START_16x16)
1055  dc += sl->scaling_matrix_dc_rec[ref_id - SL_START_16x16];
1056  else
1057  dc += sl->scaling_matrix_rec[ref_id][0];
1058  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = dc & 255;
1059  }
1060  }
1061 
1062  //ac
1063  scaling_list = aps->scaling_list_copy_mode_flag[id] ? ff_vvc_scaling_list0 : coeff;
1064  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id])
1066  else if (!aps->scaling_list_pred_id_delta[id])
1068  else
1069  pred = sl->scaling_matrix_rec[id - aps->scaling_list_pred_id_delta[id]];
1070  for (int i = 0; i < list_size; i++) {
1071  const int x = ff_vvc_diag_scan_x[log2_size][log2_size][i];
1072  const int y = ff_vvc_diag_scan_y[log2_size][log2_size][i];
1073  const int off = y * matrix_size + x;
1074  sl->scaling_matrix_rec[id][off] = (pred[off] + scaling_list[i]) & 255;
1075  }
1076  }
1077 }
1078 
1079 static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
1080 {
1081  VVCScalingList *sl = ff_refstruct_allocz(sizeof(*sl));
1082  if (!sl)
1083  return AVERROR(ENOMEM);
1084 
1085  scaling_derive(sl, aps);
1086  ff_refstruct_replace(scaling, sl);
1087  ff_refstruct_unref(&sl);
1088 
1089  return 0;
1090 }
1091 
1093 {
1094  const H266RawAPS *aps = unit->content_ref;
1095  int ret = 0;
1096 
1097  if (!aps)
1098  return AVERROR_INVALIDDATA;
1099 
1100  switch (aps->aps_params_type) {
1101  case VVC_ASP_TYPE_ALF:
1102  ret = aps_decode_alf(&ps->alf_list[aps->aps_adaptation_parameter_set_id], aps);
1103  break;
1104  case VVC_ASP_TYPE_LMCS:
1105  ff_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
1106  break;
1107  case VVC_ASP_TYPE_SCALING:
1108  ret = aps_decode_scaling(&ps->scaling_list[aps->aps_adaptation_parameter_set_id], aps);
1109  break;
1110  }
1111 
1112  return ret;
1113 }
1114 
1115 static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
1116 {
1117  if (!sh->r->sh_alf_enabled_flag)
1118  return 0;
1119 
1120  for (int i = 0; i < sh->r->sh_num_alf_aps_ids_luma; i++) {
1121  const VVCALF *alf_aps_luma = fps->alf_list[sh->r->sh_alf_aps_id_luma[i]];
1122  if (!alf_aps_luma)
1123  return AVERROR_INVALIDDATA;
1124  }
1125 
1126  if (sh->r->sh_alf_cb_enabled_flag || sh->r->sh_alf_cr_enabled_flag) {
1127  const VVCALF *alf_aps_chroma = fps->alf_list[sh->r->sh_alf_aps_id_chroma];
1128  if (!alf_aps_chroma)
1129  return AVERROR_INVALIDDATA;
1130  }
1131 
1132  if (fps->sps->r->sps_ccalf_enabled_flag) {
1133  if (sh->r->sh_alf_cc_cb_enabled_flag) {
1134  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cb_aps_id];
1135  if (!alf_aps_cc_cr)
1136  return AVERROR_INVALIDDATA;
1137  }
1138  if (sh->r->sh_alf_cc_cr_enabled_flag) {
1139  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cr_aps_id];
1140  if (!alf_aps_cc_cr)
1141  return AVERROR_INVALIDDATA;
1142  }
1143  }
1144 
1145  return 0;
1146 }
1147 
1148 static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1149 {
1150  const int slice_address = sh->r->sh_slice_address;
1151 
1152  if (pps->r->pps_rect_slice_flag) {
1153  int pic_level_slice_idx = slice_address;
1154  for (int j = 0; j < sh->r->curr_subpic_idx; j++)
1155  pic_level_slice_idx += pps->r->num_slices_in_subpic[j];
1156  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + pps->slice_start_offset[pic_level_slice_idx];
1157  sh->num_ctus_in_curr_slice = pps->num_ctus_in_slice[pic_level_slice_idx];
1158  } else {
1159  int tile_x = slice_address % pps->r->num_tile_columns;
1160  int tile_y = slice_address / pps->r->num_tile_columns;
1161  const int slice_start_ctb = pps->row_bd[tile_y] * pps->ctb_width + pps->col_bd[tile_x] * pps->r->row_height_val[tile_y];
1162 
1163  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + slice_start_ctb;
1164 
1165  sh->num_ctus_in_curr_slice = 0;
1166  for (int tile_idx = slice_address; tile_idx <= slice_address + sh->r->sh_num_tiles_in_slice_minus1; tile_idx++) {
1167  tile_x = tile_idx % pps->r->num_tile_columns;
1168  tile_y = tile_idx / pps->r->num_tile_columns;
1169  sh->num_ctus_in_curr_slice += pps->r->row_height_val[tile_y] * pps->r->col_width_val[tile_x];
1170  }
1171  }
1172 }
1173 
1174 static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
1175 {
1176  const int init_qp = pps->pps_init_qp_minus26 + 26;
1177 
1178  if (!pps->pps_qp_delta_info_in_ph_flag)
1179  sh->slice_qp_y = init_qp + sh->r->sh_qp_delta;
1180  else
1181  sh->slice_qp_y = init_qp + ph->ph_qp_delta;
1182 }
1183 
1184 static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
1185 {
1186  const H266RawSliceHeader *rsh = sh->r;
1187 
1188  if (!pps->pps_wp_info_in_ph_flag &&
1189  ((pps->pps_weighted_pred_flag && IS_P(rsh)) ||
1190  (pps->pps_weighted_bipred_flag && IS_B(rsh))))
1192 }
1193 
1194 static void sh_deblock_offsets(VVCSH *sh)
1195 {
1196  const H266RawSliceHeader *r = sh->r;
1197 
1198  if (!r->sh_deblocking_filter_disabled_flag) {
1199  sh->deblock.beta_offset[LUMA] = r->sh_luma_beta_offset_div2 * 2;
1200  sh->deblock.tc_offset[LUMA] = r->sh_luma_tc_offset_div2 * 2;
1201  sh->deblock.beta_offset[CB] = r->sh_cb_beta_offset_div2 * 2;
1202  sh->deblock.tc_offset[CB] = r->sh_cb_tc_offset_div2 * 2;
1203  sh->deblock.beta_offset[CR] = r->sh_cr_beta_offset_div2 * 2;
1204  sh->deblock.tc_offset[CR] = r->sh_cr_tc_offset_div2 * 2;
1205  }
1206 }
1207 
1209 {
1210  const int min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
1211  int min_qt_log2_size_y[2];
1212 
1213  if (IS_I(sh->r)) {
1214  min_qt_log2_size_y[LUMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma);
1215  min_qt_log2_size_y[CHROMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma);
1216 
1217  sh->max_bt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma);
1218  sh->max_bt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_bt_min_qt_intra_slice_chroma);
1219 
1220  sh->max_tt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma);
1221  sh->max_tt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_tt_min_qt_intra_slice_chroma);
1222 
1223  sh->max_mtt_depth[LUMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_luma;
1224  sh->max_mtt_depth[CHROMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_chroma;
1225 
1226  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_intra_slice;
1227  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_intra_slice;
1228  } else {
1229  for (int i = LUMA; i <= CHROMA; i++) {
1230  min_qt_log2_size_y[i] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_inter_slice);
1231  sh->max_bt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_bt_min_qt_inter_slice);
1232  sh->max_tt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_tt_min_qt_inter_slice);
1233  sh->max_mtt_depth[i] = ph->ph_max_mtt_hierarchy_depth_inter_slice;
1234  }
1235 
1236  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_inter_slice;
1237  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_inter_slice;
1238  }
1239 
1240  sh->min_qt_size[LUMA] = 1 << min_qt_log2_size_y[LUMA];
1241  sh->min_qt_size[CHROMA] = 1 << min_qt_log2_size_y[CHROMA];
1242 }
1243 
1244 static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1245 {
1246  if (sps->sps_entry_point_offsets_present_flag) {
1247  for (int i = 1, j = 0; i < sh->num_ctus_in_curr_slice; i++) {
1248  const int pre_ctb_addr_x = sh->ctb_addr_in_curr_slice[i - 1] % pps->ctb_width;
1249  const int pre_ctb_addr_y = sh->ctb_addr_in_curr_slice[i - 1] / pps->ctb_width;
1250  const int ctb_addr_x = sh->ctb_addr_in_curr_slice[i] % pps->ctb_width;
1251  const int ctb_addr_y = sh->ctb_addr_in_curr_slice[i] / pps->ctb_width;
1252  if (pps->ctb_to_row_bd[ctb_addr_y] != pps->ctb_to_row_bd[pre_ctb_addr_y] ||
1253  pps->ctb_to_col_bd[ctb_addr_x] != pps->ctb_to_col_bd[pre_ctb_addr_x] ||
1254  (ctb_addr_y != pre_ctb_addr_y && sps->sps_entropy_coding_sync_enabled_flag)) {
1255  sh->entry_point_start_ctu[j++] = i;
1256  }
1257  }
1258  }
1259 }
1260 
1261 static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
1262 {
1263  const H266RawSPS *sps = fps->sps->r;
1264  const H266RawPPS *pps = fps->pps->r;
1265  const H266RawPictureHeader *ph = fps->ph.r;
1266  int ret;
1267 
1268  sh_slice_address(sh, sps, fps->pps);
1269  ret = sh_alf_aps(sh, fps);
1270  if (ret < 0)
1271  return ret;
1272  sh_inter(sh, sps, pps);
1273  sh_qp_y(sh, pps, ph);
1274  sh_deblock_offsets(sh);
1276  sh_entry_points(sh, sps, fps->pps);
1277 
1278  return 0;
1279 }
1280 
1282 {
1283  int ret;
1284 
1285  if (!fps->sps || !fps->pps)
1286  return AVERROR_INVALIDDATA;
1287 
1288  ff_refstruct_replace(&sh->r, unit->content_ref);
1289 
1290  ret = sh_derive(sh, fps);
1291  if (ret < 0)
1292  return ret;
1293 
1294  return 0;
1295 }
CB
#define CB
Definition: hevc_filter.c:32
VVCSPS
Definition: ps.h:58
H266RawSPS::sps_subpic_height_minus1
uint16_t sps_subpic_height_minus1[VVC_MAX_SLICES]
Definition: cbs_h266.h:338
sh_qp_y
static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
Definition: ps.c:1174
VVCSH::cu_qp_delta_subdiv
uint8_t cu_qp_delta_subdiv
CuQpDeltaSubdiv.
Definition: ps.h:254
H266RawSliceHeader::sh_alf_cc_cr_enabled_flag
uint8_t sh_alf_cc_cr_enabled_flag
Definition: cbs_h266.h:789
CodedBitstreamUnit::content_ref
void * content_ref
If content is reference counted, a RefStruct reference backing content.
Definition: cbs.h:112
VVCSH::num_ctus_in_curr_slice
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
Definition: ps.h:236
ph_compute_poc
static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
Definition: ps.c:679
VVCPH
Definition: ps.h:147
VVCPPS
Definition: ps.h:92
av_clip
#define av_clip
Definition: common.h:99
VVCLMCS::min_bin_idx
uint8_t min_bin_idx
Definition: ps.h:195
cbs_h266.h
sps_chroma_qp_table
static int sps_chroma_qp_table(VVCSPS *sps)
Definition: ps.c:88
r
const char * r
Definition: vf_curves.c:127
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
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
VVCSH::entry_point_start_ctu
uint32_t entry_point_start_ctu[VVC_MAX_ENTRY_POINTS]
entry point start in ctu_addr
Definition: ps.h:258
VVCPPS::r
const H266RawPPS * r
RefStruct reference.
Definition: ps.h:93
pps_bd
static int pps_bd(VVCPPS *pps)
Definition: ps.c:287
ff_vvc_frame_ps_free
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
Definition: ps.c:893
SL_START_16x16
@ SL_START_16x16
Definition: ps.h:181
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
lmcs_derive_lut
static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
Definition: ps.c:712
decode_sps
static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx, int is_clvss)
Definition: ps.c:222
ff_vvc_ps_uninit
void ff_vvc_ps_uninit(VVCParamSets *ps)
Definition: ps.c:903
VVCSH::cu_chroma_qp_offset_subdiv
uint8_t cu_chroma_qp_offset_subdiv
CuChromaQpOffsetSubdiv.
Definition: ps.h:255
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
pps_slice_map
static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:506
ff_vvc_scaling_list0
const int ff_vvc_scaling_list0[8 *8]
Definition: data.c:299
scale_coeff
static av_always_inline int scale_coeff(const TransformBlock *tb, int coeff, const int scale, const int scale_m, const int log2_transform_range)
Definition: intra.c:418
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3005
ff_vvc_scaling_pred_8
const uint8_t ff_vvc_scaling_pred_8[8 *8]
Definition: data.c:277
pixdesc.h
decode_ph
static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref, const int poc_tid0, const int is_clvss)
Definition: ps.c:803
w
uint8_t w
Definition: llviddspenc.c:38
GDR_IS_RECOVERED
#define GDR_IS_RECOVERED(s)
Definition: ps.h:43
H266RawSPS::sps_subpic_ctu_top_left_y
uint16_t sps_subpic_ctu_top_left_y[VVC_MAX_SLICES]
Definition: cbs_h266.h:336
VVCLMCS::max_bin_idx
uint8_t max_bin_idx
Definition: ps.h:196
H266RawAPS::lmcs_delta_abs_crs
uint8_t lmcs_delta_abs_crs
Definition: cbs_h266.h:637
H266RawSPS::sps_ccalf_enabled_flag
uint8_t sps_ccalf_enabled_flag
Definition: cbs_h266.h:404
H266RawSliceHeader::sh_qp_delta
int8_t sh_qp_delta
Definition: cbs_h266.h:805
sh_inter
static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
Definition: ps.c:1184
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
VVCSH::r
const H266RawSliceHeader * r
RefStruct reference.
Definition: ps.h:232
sps_derive
static int sps_derive(VVCSPS *sps, void *log_ctx)
Definition: ps.c:177
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
H266RawPPS::pps_seq_parameter_set_id
uint8_t pps_seq_parameter_set_id
Definition: cbs_h266.h:500
VVCLMCS
Definition: ps.h:194
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
IS_CLVSS
#define IS_CLVSS(s)
Definition: ps.h:34
VVCALF::num_chroma_filters
uint8_t num_chroma_filters
Definition: ps.h:169
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
LMCS_MAX_BIN_SIZE
#define LMCS_MAX_BIN_SIZE
Definition: ps.h:48
VVCLMCS::chroma_scale_coeff
uint16_t chroma_scale_coeff[LMCS_MAX_BIN_SIZE]
Definition: ps.h:204
pps_alloc
static const VVCPPS * pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
Definition: ps.c:580
sh_deblock_offsets
static void sh_deblock_offsets(VVCSH *sh)
Definition: ps.c:1194
sh_alf_aps
static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
Definition: ps.c:1115
JCBCR
#define JCBCR
Definition: dec.h:37
CodedBitstreamH266Context::pps
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:874
MIN_PU_LOG2
#define MIN_PU_LOG2
Definition: dec.h:40
H266RawSliceHeader::sh_alf_cc_cr_aps_id
uint8_t sh_alf_cc_cr_aps_id
Definition: cbs_h266.h:790
sps_partition_constraints
static void sps_partition_constraints(VVCSPS *sps)
Definition: ps.c:151
VVCFrameParamSets::sps
const VVCSPS * sps
RefStruct reference.
Definition: ps.h:223
VVC_ASP_TYPE_ALF
@ VVC_ASP_TYPE_ALF
Definition: vvc.h:70
IS_P
#define IS_P(rsh)
Definition: ps.h:39
pps_free
static void pps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:567
pps_single_slice_picture
static void pps_single_slice_picture(VVCPPS *pps, int *off)
Definition: ps.c:360
VVCFrameParamSets
Definition: ps.h:222
ff_vvc_decode_frame_ps
int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
Definition: ps.c:874
fail
#define fail()
Definition: checkasm.h:183
VVCSH::pwt
PredWeightTable pwt
Definition: ps.h:240
H266RawSPS::sps_subpic_width_minus1
uint16_t sps_subpic_width_minus1[VVC_MAX_SLICES]
Definition: cbs_h266.h:337
sps_ladf
static void sps_ladf(VVCSPS *sps)
Definition: ps.c:163
H266RawAPS
Definition: cbs_h266.h:598
VVCParamSets::pps_list
const VVCPPS * pps_list[VVC_MAX_PPS_COUNT]
RefStruct reference.
Definition: ps.h:213
VVCALF::cc_coeff
int16_t cc_coeff[2][ALF_NUM_FILTERS_CC][ALF_NUM_COEFF_CC]
Definition: ps.h:174
pps_derive
static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:546
alf_cc
static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:967
VVCFrameParamSets::sl
const VVCScalingList * sl
RefStruct reference.
Definition: ps.h:228
VVCALF
Definition: ps.h:165
H266RawSliceHeader::sh_alf_enabled_flag
uint8_t sh_alf_enabled_flag
Definition: cbs_h266.h:781
refstruct.h
WEIGHT_TABLE
#define WEIGHT_TABLE(x)
Definition: ps.c:651
VVCALF::chroma_clip_idx
uint8_t chroma_clip_idx[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA]
Definition: ps.h:171
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
SL_MAX_MATRIX_SIZE
#define SL_MAX_MATRIX_SIZE
Definition: ps.h:187
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H266RawAPS::lmcs_delta_abs_cw
uint16_t lmcs_delta_abs_cw[16]
Definition: cbs_h266.h:635
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ph_max_num_subblock_merge_cand
static int ph_max_num_subblock_merge_cand(const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:784
LMCS_MAX_BIT_DEPTH
#define LMCS_MAX_BIT_DEPTH
Definition: ps.h:46
DBParams::beta_offset
int beta_offset
Definition: hevcdec.h:342
DBParams::tc_offset
int tc_offset
Definition: hevcdec.h:343
H266RawSPS::sps_seq_parameter_set_id
uint8_t sps_seq_parameter_set_id
Definition: cbs_h266.h:311
s
#define s(width, name)
Definition: cbs_vp9.c:198
pps_single_slice_per_subpic
static void pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
Definition: ps.c:427
H266RawSliceHeader::sh_slice_address
uint16_t sh_slice_address
Definition: cbs_h266.h:775
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
sps_map_pixel_format
static int sps_map_pixel_format(VVCSPS *sps, void *log_ctx)
Definition: ps.c:32
aps_decode_alf
static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
Definition: ps.c:993
ctu_xy
static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
Definition: ps.c:336
alf_derive
static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:986
decode_pps
static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
Definition: ps.c:601
lmcs_derive_lut_sample
static av_always_inline uint16_t lmcs_derive_lut_sample(uint16_t sample, uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
Definition: ps.c:703
VVCFrameParamSets::lmcs
VVCLMCS lmcs
Definition: ps.h:227
VVCSH
Definition: ps.h:231
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:75
PredWeightTable
Definition: ps.h:137
VVCFrameParamSets::ph
VVCPH ph
Definition: ps.h:225
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
decode_frame_ps
static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps, const CodedBitstreamH266Context *h266, const int poc_tid0, const int is_clvss)
Definition: ps.c:820
decode_recovery_flag
static void decode_recovery_flag(VVCContext *s)
Definition: ps.c:856
VVCParamSets::sps_list
const VVCSPS * sps_list[VVC_MAX_SPS_COUNT]
RefStruct reference.
Definition: ps.h:212
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
H266RawSPS
Definition: cbs_h266.h:308
H266RawPPS
Definition: cbs_h266.h:496
aps
static int FUNC() aps(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current, int prefix)
Definition: cbs_h266_syntax_template.c:2463
alf_chroma
static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:951
pps_rect_slice
static void pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:472
ALF_NUM_COEFF_CC
#define ALF_NUM_COEFF_CC
Definition: ps.h:163
NULL
#define NULL
Definition: coverity.c:32
H266RawPictureHeader
Definition: cbs_h266.h:674
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
H266RawPPS::pps_pic_parameter_set_id
uint8_t pps_pic_parameter_set_id
Definition: cbs_h266.h:499
sps_free
static void sps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:195
H266RawSliceHeader::curr_subpic_idx
uint16_t curr_subpic_idx
CurrSubpicIdx.
Definition: cbs_h266.h:835
VVCFrameParamSets::alf_list
const VVCALF * alf_list[VVC_MAX_ALF_COUNT]
RefStruct reference.
Definition: ps.h:226
H266RawAPS::lmcs_delta_sign_cw_flag
uint8_t lmcs_delta_sign_cw_flag[16]
Definition: cbs_h266.h:636
pred_weight_table
static void pred_weight_table(PredWeightTable *w, const H266RawPredWeightTable *r)
Definition: ps.c:666
ff_vvc_diag_scan_y
const uint8_t ff_vvc_diag_scan_y[5][5][16 *16]
Definition: data.c:152
H266RawPredWeightTable
Definition: cbs_h266.h:650
VVCSH::max_tt_size
uint8_t max_tt_size[2]
MaxTtSizeY, MaxTtSizeC.
Definition: ps.h:252
decode_recovery_poc
static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
Definition: ps.c:864
VVC_ASP_TYPE_LMCS
@ VVC_ASP_TYPE_LMCS
Definition: vvc.h:71
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
VVCParamSets::scaling_list
const VVCScalingList * scaling_list[VVC_MAX_SL_COUNT]
RefStruct reference.
Definition: ps.h:216
tile_xy
static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
Definition: ps.c:330
alf_luma
static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:935
ALF_NUM_COEFF_LUMA
#define ALF_NUM_COEFF_LUMA
Definition: ps.h:161
H266RawSliceHeader::sh_num_tiles_in_slice_minus1
uint8_t sh_num_tiles_in_slice_minus1
Definition: cbs_h266.h:777
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
VVCPH::r
const H266RawPictureHeader * r
Definition: ps.h:148
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VVCALF::luma_coeff
int16_t luma_coeff[ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA]
Definition: ps.h:166
IS_B
#define IS_B(rsh)
Definition: ps.h:40
ff_vvc_decode_sh
int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
Definition: ps.c:1281
VVCFrameParamSets::pps
const VVCPPS * pps
RefStruct reference.
Definition: ps.h:224
sh_derive
static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
Definition: ps.c:1261
VVCSH::max_mtt_depth
uint8_t max_mtt_depth[2]
MaxMttDepthY, MaxMttDepthC.
Definition: ps.h:253
pps_subpic
static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:528
VVCScalingList
Definition: ps.h:189
H266RawSPS::sps_subpic_ctu_top_left_x
uint16_t sps_subpic_ctu_top_left_x[VVC_MAX_SLICES]
Definition: cbs_h266.h:335
VVCLMCS::inv_lut
union VVCLMCS::@253 inv_lut
alf_coeff
static void alf_coeff(int16_t *coeff, const uint8_t *abs, const uint8_t *sign, const int size)
Definition: ps.c:917
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
shift
static int shift(int a, int b)
Definition: bonk.c:261
pps_subpic_slice
static void pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off)
Definition: ps.c:413
CodedBitstreamH266Context::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:875
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
sample
#define sample
Definition: flacdsp_template.c:44
ff_vvc_diag_scan_x
const uint8_t ff_vvc_diag_scan_x[5][5][16 *16]
Definition: data.c:27
size
int size
Definition: twinvq_data.h:10344
sh_entry_points
static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1244
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
CR
#define CR
Definition: hevc_filter.c:33
ps.h
H266RawAPS::lmcs_min_bin_idx
uint8_t lmcs_min_bin_idx
Definition: cbs_h266.h:632
H266RawSliceHeader::sh_alf_aps_id_chroma
uint8_t sh_alf_aps_id_chroma
Definition: cbs_h266.h:786
pps_no_rect_slice
static void pps_no_rect_slice(VVCPPS *pps)
Definition: ps.c:493
scaling_derive
static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
Definition: ps.c:1017
aps_decode_scaling
static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
Definition: ps.c:1079
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
VVCLMCS::fwd_lut
union VVCLMCS::@253 fwd_lut
CodedBitstreamH266Context
Definition: cbs_h266.h:866
VVCSH::deblock
DBParams deblock
Definition: ps.h:247
VVCSH::ctb_addr_in_curr_slice
const uint32_t * ctb_addr_in_curr_slice
CtbAddrInCurrSlice.
Definition: ps.h:237
VVCScalingList::scaling_matrix_dc_rec
uint8_t scaling_matrix_dc_rec[SL_MAX_ID - SL_START_16x16]
ScalingMatrixDcRec[refId − 14].
Definition: ps.h:191
pps_width_height
static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:262
H266RawSliceHeader::sh_alf_cb_enabled_flag
uint8_t sh_alf_cb_enabled_flag
Definition: cbs_h266.h:784
sh_slice_address
static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1148
alf_coeff_cc
static void alf_coeff_cc(int16_t *coeff, const uint8_t *mapped_abs, const uint8_t *sign)
Definition: ps.c:924
H266RawSliceHeader::sh_pred_weight_table
H266RawPredWeightTable sh_pred_weight_table
Definition: cbs_h266.h:803
H266RawSliceHeader
Definition: cbs_h266.h:769
IS_GDR
#define IS_GDR(s)
Definition: ps.h:32
VVCLMCS::pivot
uint16_t pivot[LMCS_MAX_BIN_SIZE+1]
Definition: ps.h:203
ALF_NUM_COEFF_CHROMA
#define ALF_NUM_COEFF_CHROMA
Definition: ps.h:162
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
H266RawSliceHeader::sh_alf_aps_id_luma
uint8_t sh_alf_aps_id_luma[8]
Definition: cbs_h266.h:783
SL_MAX_ID
@ SL_MAX_ID
Definition: ps.h:184
CodedBitstreamH266Context::sps
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:873
VVCPH::rref
void * rref
RefStruct reference, backing ph above.
Definition: ps.h:149
sps_bit_depth
static int sps_bit_depth(VVCSPS *sps, void *log_ctx)
Definition: ps.c:77
pps_chroma_qp_offset
static void pps_chroma_qp_offset(VVCPPS *pps)
Definition: ps.c:250
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
VVCLMCS::u16
uint16_t u16[LMCS_MAX_LUT_SIZE]
for high bit-depth
Definition: ps.h:200
derive_matrix_size
static int derive_matrix_size(const int id)
Definition: ps.c:1011
H266RawSliceHeader::sh_alf_cc_cb_aps_id
uint8_t sh_alf_cc_cb_aps_id
Definition: cbs_h266.h:788
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
H266RawAPS::lmcs_delta_sign_crs_flag
uint8_t lmcs_delta_sign_crs_flag
Definition: cbs_h266.h:638
ret
ret
Definition: filter_design.txt:187
data.h
pps_one_tile_slices
static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
Definition: ps.c:437
pred
static const float pred[4]
Definition: siprdata.h:259
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
H266RawSliceHeader::sh_alf_cc_cb_enabled_flag
uint8_t sh_alf_cc_cb_enabled_flag
Definition: cbs_h266.h:787
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
pps_multi_tiles_slice
static void pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off)
Definition: ps.c:455
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
id
enum AVCodecID id
Definition: dts2pts.c:365
decode_ps
static int decode_ps(VVCParamSets *ps, const CodedBitstreamH266Context *h266, void *log_ctx, int is_clvss)
Definition: ps.c:622
SL_START_64x64
@ SL_START_64x64
Definition: ps.h:183
pps_ref_wraparound_offset
static void pps_ref_wraparound_offset(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:520
VVCParamSets::alf_list
const VVCALF * alf_list[VVC_MAX_ALF_COUNT]
RefStruct reference.
Definition: ps.h:214
sps_poc
static void sps_poc(VVCSPS *sps)
Definition: ps.c:130
VVCSH::slice_qp_y
int8_t slice_qp_y
SliceQpY.
Definition: ps.h:244
H266RawSPS::sps_num_subpics_minus1
uint16_t sps_num_subpics_minus1
Definition: cbs_h266.h:332
VVC_MAX_POINTS_IN_QP_TABLE
@ VVC_MAX_POINTS_IN_QP_TABLE
Definition: vvc.h:121
VVC_ASP_TYPE_SCALING
@ VVC_ASP_TYPE_SCALING
Definition: vvc.h:72
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
scaling_list
static int FUNC() scaling_list(CodedBitstreamContext *ctx, RWContext *rw, H264RawScalingList *current, int size_of_scaling_list)
Definition: cbs_h264_syntax_template.c:71
ctu_rs
static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
Definition: ps.c:342
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
VVCLMCS::u8
uint8_t u8[LMCS_MAX_LUT_SIZE]
Definition: ps.h:199
sps_inter
static void sps_inter(VVCSPS *sps)
Definition: ps.c:135
desc
const char * desc
Definition: libsvtav1.c:79
ff_vvc_decode_aps
int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
Definition: ps.c:1092
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
VVCALF::luma_clip_idx
uint8_t luma_clip_idx[ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA]
Definition: ps.h:167
is_luma_list
static int is_luma_list(const int id)
Definition: ps.c:1006
pps_subpic_less_than_one_tile_slice
static void pps_subpic_less_than_one_tile_slice(VVCPPS *pps, const VVCSPS *sps, const int i, const int tx, const int ty, int *off)
Definition: ps.c:395
ALF_NUM_FILTERS_LUMA
#define ALF_NUM_FILTERS_LUMA
Definition: ps.h:157
VVCParamSets
Definition: ps.h:211
VVCSH::max_bt_size
uint8_t max_bt_size[2]
MaxBtSizeY, MaxBtSizeC.
Definition: ps.h:251
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
GDR_SET_RECOVERED
#define GDR_SET_RECOVERED(s)
Definition: ps.h:44
ff_vvc_scaling_pred_16
const uint8_t ff_vvc_scaling_pred_16[8 *8]
Definition: data.c:288
SL_START_8x8
@ SL_START_8x8
Definition: ps.h:180
VVCSPS::r
const H266RawSPS * r
RefStruct reference.
Definition: ps.h:59
VVCALF::num_cc_filters
uint8_t num_cc_filters[2]
alf_cc_cb_filters_signalled_minus1 + 1, alf_cc_cr_filters_signalled_minus1 + 1
Definition: ps.h:173
H266RawSliceHeader::sh_num_alf_aps_ids_luma
uint8_t sh_num_alf_aps_ids_luma
Definition: cbs_h266.h:782
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
CodedBitstreamH266Context::ph_ref
void * ph_ref
RefStruct reference backing ph above.
Definition: cbs_h266.h:876
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VVCSH::min_qt_size
uint8_t min_qt_size[2]
MinQtSizeY, MinQtSizeC.
Definition: ps.h:250
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
next_tile_idx
static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
Definition: ps.c:318
sps_alloc
static const VVCSPS * sps_alloc(const H266RawSPS *rsps, void *log_ctx)
Definition: ps.c:201
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
H266RawSliceHeader::sh_alf_cr_enabled_flag
uint8_t sh_alf_cr_enabled_flag
Definition: cbs_h266.h:785
SL_START_4x4
@ SL_START_4x4
Definition: ps.h:179
subpic_tiles
static void subpic_tiles(int *tile_x, int *tile_y, int *tile_x_end, int *tile_y_end, const VVCSPS *sps, const VVCPPS *pps, const int i)
Definition: ps.c:371
sh_partition_constraints
static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:1208
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
VVCALF::chroma_coeff
int16_t chroma_coeff[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA]
Definition: ps.h:170
H266RawSPS::sps_subpic_treated_as_pic_flag
uint8_t sps_subpic_treated_as_pic_flag[VVC_MAX_SLICES]
Definition: cbs_h266.h:339
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
pps_subpic_one_or_more_tiles_slice
static void pps_subpic_one_or_more_tiles_slice(VVCPPS *pps, const int tile_x, const int tile_y, const int x_end, const int y_end, const int i, int *off)
Definition: ps.c:402
VVCParamSets::sps_id_used
uint16_t sps_id_used
Definition: ps.h:219
LUMA
#define LUMA
Definition: hevc_filter.c:31
VVCParamSets::lmcs_list
const H266RawAPS * lmcs_list[VVC_MAX_LMCS_COUNT]
RefStruct reference.
Definition: ps.h:215
ph_derive
static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
Definition: ps.c:791
MIN_TU_LOG2
#define MIN_TU_LOG2
MinTbLog2SizeY.
Definition: dec.h:39
VVCContext
Definition: dec.h:218
VVCScalingList::scaling_matrix_rec
uint8_t scaling_matrix_rec[SL_MAX_ID][SL_MAX_MATRIX_SIZE *SL_MAX_MATRIX_SIZE]
ScalingMatrixRec.
Definition: ps.h:190
dec.h
pps_add_ctus
static int pps_add_ctus(VVCPPS *pps, int *off, const int rx, const int ry, const int w, const int h)
Definition: ps.c:347
IS_CRA
#define IS_CRA(s)
Definition: ps.h:30