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  const uint8_t delta_qp_out = (r->sps_delta_qp_in_val_minus1[i][j] ^ r->sps_delta_qp_diff_val[i][j]);
105  delta_qp_in[j] = r->sps_delta_qp_in_val_minus1[i][j] + 1;
106  // Note: we cannot check qp_{in,out}[j+1] here as qp_*[j] + delta_qp_*
107  // may not fit in an 8-bit signed integer.
108  if (qp_in[j] + delta_qp_in[j] > 63 || qp_out[j] + delta_qp_out > 63)
109  return AVERROR(EINVAL);
110  qp_in[j+1] = qp_in[j] + delta_qp_in[j];
111  qp_out[j+1] = qp_out[j] + delta_qp_out;
112  }
113  sps->chroma_qp_table[i][qp_in[0] + off] = qp_out[0];
114  for (int k = qp_in[0] - 1 + off; k >= 0; k--)
115  sps->chroma_qp_table[i][k] = av_clip(sps->chroma_qp_table[i][k+1]-1, -off, 63);
116 
117  for (int j = 0; j < num_points_in_qp_table; j++) {
118  int sh = delta_qp_in[j] >> 1;
119  for (int k = qp_in[j] + 1 + off, m = 1; k <= qp_in[j+1] + off; k++, m++) {
120  sps->chroma_qp_table[i][k] = sps->chroma_qp_table[i][qp_in[j] + off] +
121  ((qp_out[j+1] - qp_out[j]) * m + sh) / delta_qp_in[j];
122  }
123  }
124  for (int k = qp_in[num_points_in_qp_table] + 1 + off; k <= 63 + off; k++)
125  sps->chroma_qp_table[i][k] = av_clip(sps->chroma_qp_table[i][k-1] + 1, -sps->qp_bd_offset, 63);
126  }
127  if (r->sps_same_qp_table_for_chroma_flag) {
128  memcpy(&sps->chroma_qp_table[1], &sps->chroma_qp_table[0], sizeof(sps->chroma_qp_table[0]));
129  memcpy(&sps->chroma_qp_table[2], &sps->chroma_qp_table[0], sizeof(sps->chroma_qp_table[0]));
130  }
131 
132  return 0;
133 }
134 
135 static void sps_poc(VVCSPS *sps)
136 {
137  sps->max_pic_order_cnt_lsb = 1 << (sps->r->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
138 }
139 
140 static void sps_inter(VVCSPS *sps)
141 {
142  const H266RawSPS *r = sps->r;
143 
144  sps->max_num_merge_cand = 6 - r->sps_six_minus_max_num_merge_cand;
145  sps->max_num_ibc_merge_cand = 6 - r->sps_six_minus_max_num_ibc_merge_cand;
146 
147  if (sps->r->sps_gpm_enabled_flag) {
148  sps->max_num_gpm_merge_cand = 2;
149  if (sps->max_num_merge_cand >= 3)
150  sps->max_num_gpm_merge_cand = sps->max_num_merge_cand - r->sps_max_num_merge_cand_minus_max_num_gpm_cand;
151  }
152 
153  sps->log2_parallel_merge_level = r->sps_log2_parallel_merge_level_minus2 + 2;
154 }
155 
157 {
158  const H266RawSPS *r = sps->r;
159 
160  sps->ctb_log2_size_y = r->sps_log2_ctu_size_minus5 + 5;
161  sps->ctb_size_y = 1 << sps->ctb_log2_size_y;
162  sps->min_cb_log2_size_y = r->sps_log2_min_luma_coding_block_size_minus2 + 2;
163  sps->min_cb_size_y = 1 << sps->min_cb_log2_size_y;
164  sps->max_tb_size_y = 1 << (r->sps_max_luma_transform_size_64_flag ? 6 : 5);
165  sps->max_ts_size = 1 << (r->sps_log2_transform_skip_max_size_minus2 + 2);
166 }
167 
168 static void sps_ladf(VVCSPS* sps)
169 {
170  const H266RawSPS *r = sps->r;
171 
172  if (r->sps_ladf_enabled_flag) {
173  sps->num_ladf_intervals = r->sps_num_ladf_intervals_minus2 + 2;
174  sps->ladf_interval_lower_bound[0] = 0;
175  for (int i = 0; i < sps->num_ladf_intervals - 1; i++) {
176  sps->ladf_interval_lower_bound[i + 1] =
177  sps->ladf_interval_lower_bound[i] + r->sps_ladf_delta_threshold_minus1[i] + 1;
178  }
179  }
180 }
181 
182 static int sps_derive(VVCSPS *sps, void *log_ctx)
183 {
184  int ret;
185  const H266RawSPS *r = sps->r;
186 
187  ret = sps_bit_depth(sps, log_ctx);
188  if (ret < 0)
189  return ret;
190  sps_poc(sps);
191  sps_inter(sps);
193  sps_ladf(sps);
194  if (r->sps_chroma_format_idc != 0) {
196  if (ret < 0)
197  return ret;
198  }
199 
200  return 0;
201 }
202 
203 static void sps_free(FFRefStructOpaque opaque, void *obj)
204 {
205  VVCSPS *sps = obj;
206  ff_refstruct_unref(&sps->r);
207 }
208 
209 static const VVCSPS *sps_alloc(const H266RawSPS *rsps, void *log_ctx)
210 {
211  int ret;
212  VVCSPS *sps = ff_refstruct_alloc_ext(sizeof(*sps), 0, NULL, sps_free);
213 
214  if (!sps)
215  return NULL;
216 
217  ff_refstruct_replace(&sps->r, rsps);
218 
219  ret = sps_derive(sps, log_ctx);
220  if (ret < 0)
221  goto fail;
222 
223  return sps;
224 
225 fail:
227  return NULL;
228 }
229 
230 static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx, int is_clvss)
231 {
232  const int sps_id = rsps->sps_seq_parameter_set_id;
233  const VVCSPS *old_sps = ps->sps_list[sps_id];
234  const VVCSPS *sps;
235 
236  if (is_clvss) {
237  ps->sps_id_used = 0;
238  }
239 
240  if (old_sps) {
241  if (old_sps->r == rsps || !memcmp(old_sps->r, rsps, sizeof(*old_sps->r)))
242  return 0;
243  else if (ps->sps_id_used & (1 << sps_id))
244  return AVERROR_INVALIDDATA;
245  }
246 
247  sps = sps_alloc(rsps, log_ctx);
248  if (!sps)
249  return AVERROR(ENOMEM);
250 
252  ps->sps_list[sps_id] = sps;
253  ps->sps_id_used |= (1 << sps_id);
254 
255  return 0;
256 }
257 
259 {
260  pps->chroma_qp_offset[CB - 1] = pps->r->pps_cb_qp_offset;
261  pps->chroma_qp_offset[CR - 1] = pps->r->pps_cr_qp_offset;
262  pps->chroma_qp_offset[JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_value;
263  for (int i = 0; i < 6; i++) {
264  pps->chroma_qp_offset_list[i][CB - 1] = pps->r->pps_cb_qp_offset_list[i];
265  pps->chroma_qp_offset_list[i][CR - 1] = pps->r->pps_cr_qp_offset_list[i];
266  pps->chroma_qp_offset_list[i][JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_list[i];
267  }
268 }
269 
270 static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
271 {
272  const H266RawPPS *r = pps->r;
273 
274  pps->width = r->pps_pic_width_in_luma_samples;
275  pps->height = r->pps_pic_height_in_luma_samples;
276 
277  pps->ctb_width = AV_CEIL_RSHIFT(pps->width, sps->ctb_log2_size_y);
278  pps->ctb_height = AV_CEIL_RSHIFT(pps->height, sps->ctb_log2_size_y);
279  pps->ctb_count = pps->ctb_width * pps->ctb_height;
280 
281  pps->min_cb_width = pps->width >> sps->min_cb_log2_size_y;
282  pps->min_cb_height = pps->height >> sps->min_cb_log2_size_y;
283 
284  pps->min_pu_width = pps->width >> MIN_PU_LOG2;
285  pps->min_pu_height = pps->height >> MIN_PU_LOG2;
286  pps->min_tu_width = pps->width >> MIN_TU_LOG2;
287  pps->min_tu_height = pps->height >> MIN_TU_LOG2;
288 
289  pps->width32 = AV_CEIL_RSHIFT(pps->width, 5);
290  pps->height32 = AV_CEIL_RSHIFT(pps->height, 5);
291  pps->width64 = AV_CEIL_RSHIFT(pps->width, 6);
292  pps->height64 = AV_CEIL_RSHIFT(pps->height, 6);
293 }
294 
295 static int pps_bd(VVCPPS *pps)
296 {
297  const H266RawPPS *r = pps->r;
298 
299  pps->col_bd = av_calloc(r->num_tile_columns + 1, sizeof(*pps->col_bd));
300  pps->row_bd = av_calloc(r->num_tile_rows + 1, sizeof(*pps->row_bd));
301  pps->ctb_to_col_bd = av_calloc(pps->ctb_width + 1, sizeof(*pps->ctb_to_col_bd));
302  pps->ctb_to_row_bd = av_calloc(pps->ctb_height + 1, sizeof(*pps->ctb_to_col_bd));
303  if (!pps->col_bd || !pps->row_bd || !pps->ctb_to_col_bd || !pps->ctb_to_row_bd)
304  return AVERROR(ENOMEM);
305 
306  for (int i = 0, j = 0; i < r->num_tile_columns; i++) {
307  pps->col_bd[i] = j;
308  j += r->col_width_val[i];
309  for (int k = pps->col_bd[i]; k < j; k++)
310  pps->ctb_to_col_bd[k] = pps->col_bd[i];
311  }
312  pps->col_bd[r->num_tile_columns] = pps->ctb_to_col_bd[pps->ctb_width] = pps->ctb_width;
313 
314  for (int i = 0, j = 0; i < r->num_tile_rows; i++) {
315  pps->row_bd[i] = j;
316  j += r->row_height_val[i];
317  for (int k = pps->row_bd[i]; k < j; k++)
318  pps->ctb_to_row_bd[k] = pps->row_bd[i];
319  }
320  pps->row_bd[r->num_tile_rows] = pps->ctb_to_row_bd[pps->ctb_height] = pps->ctb_height;
321 
322  return 0;
323 }
324 
325 
326 static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
327 {
328  if (r->pps_tile_idx_delta_present_flag) {
329  tile_idx += r->pps_tile_idx_delta_val[i];
330  } else {
331  tile_idx += r->pps_slice_width_in_tiles_minus1[i] + 1;
332  if (tile_idx % r->num_tile_columns == 0)
333  tile_idx += (r->pps_slice_height_in_tiles_minus1[i]) * r->num_tile_columns;
334  }
335  return tile_idx;
336 }
337 
338 static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
339 {
340  *tile_x = tile_idx % pps->r->num_tile_columns;
341  *tile_y = tile_idx / pps->r->num_tile_columns;
342 }
343 
344 static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
345 {
346  *rx = pps->col_bd[tile_x];
347  *ry = pps->row_bd[tile_y];
348 }
349 
350 static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
351 {
352  return pps->ctb_width * ry + rx;
353 }
354 
355 static int pps_add_ctus(VVCPPS *pps, int *off, const int rx, const int ry,
356  const int w, const int h)
357 {
358  int start = *off;
359  for (int y = 0; y < h; y++) {
360  for (int x = 0; x < w; x++) {
361  pps->ctb_addr_in_slice[*off] = ctu_rs(rx + x, ry + y, pps);
362  (*off)++;
363  }
364  }
365  return *off - start;
366 }
367 
368 static void pps_single_slice_picture(VVCPPS *pps, int *off)
369 {
370  for (int j = 0; j < pps->r->num_tile_rows; j++) {
371  for (int i = 0; i < pps->r->num_tile_columns; i++) {
372  pps->num_ctus_in_slice[0] = pps_add_ctus(pps, off,
373  pps->col_bd[i], pps->row_bd[j],
374  pps->r->col_width_val[i], pps->r->row_height_val[j]);
375  }
376  }
377 }
378 
379 static void subpic_tiles(int *tile_x, int *tile_y, int *tile_x_end, int *tile_y_end,
380  const VVCSPS *sps, const VVCPPS *pps, const int i)
381 {
382  const int rx = sps->r->sps_subpic_ctu_top_left_x[i];
383  const int ry = sps->r->sps_subpic_ctu_top_left_y[i];
384 
385  *tile_x = *tile_y = 0;
386 
387  while (pps->col_bd[*tile_x] != rx)
388  (*tile_x)++;
389 
390  while (pps->row_bd[*tile_y] != ry)
391  (*tile_y)++;
392 
393  *tile_x_end = (*tile_x);
394  *tile_y_end = (*tile_y);
395 
396  while (pps->col_bd[*tile_x_end] < rx + sps->r->sps_subpic_width_minus1[i] + 1)
397  (*tile_x_end)++;
398 
399  while (pps->row_bd[*tile_y_end] < ry + sps->r->sps_subpic_height_minus1[i] + 1)
400  (*tile_y_end)++;
401 }
402 
403 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)
404 {
405  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off,
406  pps->col_bd[tx], pps->row_bd[ty],
407  pps->r->col_width_val[tx], sps->r->sps_subpic_height_minus1[i] + 1);
408 }
409 
410 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)
411 {
412  for (int ty = tile_y; ty < y_end; ty++) {
413  for (int tx = tile_x; tx < x_end; tx++) {
414  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off,
415  pps->col_bd[tx], pps->row_bd[ty],
416  pps->r->col_width_val[tx], pps->r->row_height_val[ty]);
417  }
418  }
419 }
420 
421 static void pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off)
422 {
423  int tx, ty, x_end, y_end;
424 
425  pps->slice_start_offset[i] = *off;
426  pps->num_ctus_in_slice[i] = 0;
427 
428  subpic_tiles(&tx, &ty, &x_end, &y_end, sps, pps, i);
429  if (ty + 1 == y_end && sps->r->sps_subpic_height_minus1[i] + 1 < pps->r->row_height_val[ty])
431  else
432  pps_subpic_one_or_more_tiles_slice(pps, tx, ty, x_end, y_end, i, off);
433 }
434 
435 static void pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
436 {
437  if (!sps->r->sps_subpic_info_present_flag) {
439  } else {
440  for (int i = 0; i < pps->r->pps_num_slices_in_pic_minus1 + 1; i++)
441  pps_subpic_slice(pps, sps, i, off);
442  }
443 }
444 
445 static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
446 {
447  const H266RawPPS *r = pps->r;
448  int rx, ry, ctu_y_end, tile_x, tile_y;
449 
450  tile_xy(&tile_x, &tile_y, tile_idx, pps);
451  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
452  ctu_y_end = ry + r->row_height_val[tile_y];
453  while (ry < ctu_y_end) {
454  pps->slice_start_offset[i] = *off;
455  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off, rx, ry,
456  r->col_width_val[tile_x], r->slice_height_in_ctus[i]);
457  ry += r->slice_height_in_ctus[i++];
458  }
459  i--;
460  return i;
461 }
462 
463 static void pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off)
464 {
465  const H266RawPPS *r = pps->r;
466  int rx, ry, tile_x, tile_y;
467 
468  tile_xy(&tile_x, &tile_y, tile_idx, pps);
469  pps->slice_start_offset[i] = *off;
470  pps->num_ctus_in_slice[i] = 0;
471  for (int ty = tile_y; ty <= tile_y + r->pps_slice_height_in_tiles_minus1[i]; ty++) {
472  for (int tx = tile_x; tx <= tile_x + r->pps_slice_width_in_tiles_minus1[i]; tx++) {
473  ctu_xy(&rx, &ry, tx, ty, pps);
474  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off, rx, ry,
475  r->col_width_val[tx], r->row_height_val[ty]);
476  }
477  }
478 }
479 
480 static void pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
481 {
482  const H266RawPPS *r = pps->r;
483  int tile_idx = 0, off = 0;
484 
485  if (r->pps_single_slice_per_subpic_flag) {
487  return;
488  }
489 
490  for (int i = 0; i < r->pps_num_slices_in_pic_minus1 + 1; i++) {
491  if (!r->pps_slice_width_in_tiles_minus1[i] &&
492  !r->pps_slice_height_in_tiles_minus1[i]) {
493  i = pps_one_tile_slices(pps, tile_idx, i, &off);
494  } else {
495  pps_multi_tiles_slice(pps, tile_idx, i, &off);
496  }
497  tile_idx = next_tile_idx(tile_idx, i, r);
498  }
499 }
500 
502 {
503  const H266RawPPS* r = pps->r;
504  int rx, ry, off = 0;
505 
506  for (int tile_y = 0; tile_y < r->num_tile_rows; tile_y++) {
507  for (int tile_x = 0; tile_x < r->num_tile_columns; tile_x++) {
508  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
509  pps_add_ctus(pps, &off, rx, ry, r->col_width_val[tile_x], r->row_height_val[tile_y]);
510  }
511  }
512 }
513 
514 static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
515 {
516  pps->ctb_addr_in_slice = av_calloc(pps->ctb_count, sizeof(*pps->ctb_addr_in_slice));
517  if (!pps->ctb_addr_in_slice)
518  return AVERROR(ENOMEM);
519 
520  if (pps->r->pps_rect_slice_flag)
522  else
524 
525  return 0;
526 }
527 
529 {
530  const H266RawPPS *r = pps->r;
531 
532  if (r->pps_ref_wraparound_enabled_flag)
533  pps->ref_wraparound_offset = (pps->width / sps->min_cb_size_y) - r->pps_pic_width_minus_wraparound_offset;
534 }
535 
536 static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
537 {
538  const H266RawSPS *rsps = sps->r;
539  for (int i = 0; i < rsps->sps_num_subpics_minus1 + 1; i++) {
540  if (rsps->sps_subpic_treated_as_pic_flag[i]) {
541  pps->subpic_x[i] = rsps->sps_subpic_ctu_top_left_x[i] << sps->ctb_log2_size_y;
542  pps->subpic_y[i] = rsps->sps_subpic_ctu_top_left_y[i] << sps->ctb_log2_size_y;
543  pps->subpic_width[i] = FFMIN(pps->width - pps->subpic_x[i], (rsps->sps_subpic_width_minus1[i] + 1) << sps->ctb_log2_size_y);
544  pps->subpic_height[i] = FFMIN(pps->height - pps->subpic_y[i], (rsps->sps_subpic_height_minus1[i] + 1) << sps->ctb_log2_size_y);
545  } else {
546  pps->subpic_x[i] = 0;
547  pps->subpic_y[i] = 0;
548  pps->subpic_width[i] = pps->width;
549  pps->subpic_height[i] = pps->height;
550  }
551  }
552 }
553 
554 static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
555 {
556  int ret;
557 
560 
561  ret = pps_bd(pps);
562  if (ret < 0)
563  return ret;
564 
565  ret = pps_slice_map(pps, sps);
566  if (ret < 0)
567  return ret;
568 
570  pps_subpic(pps, sps);
571 
572  return 0;
573 }
574 
575 static void pps_free(FFRefStructOpaque opaque, void *obj)
576 {
577  VVCPPS *pps = obj;
578 
579  ff_refstruct_unref(&pps->r);
580 
581  av_freep(&pps->col_bd);
582  av_freep(&pps->row_bd);
583  av_freep(&pps->ctb_to_col_bd);
584  av_freep(&pps->ctb_to_row_bd);
585  av_freep(&pps->ctb_addr_in_slice);
586 }
587 
588 static const VVCPPS *pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
589 {
590  int ret;
591  VVCPPS *pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
592 
593  if (!pps)
594  return NULL;
595 
596  ff_refstruct_replace(&pps->r, rpps);
597 
598  ret = pps_derive(pps, sps);
599  if (ret < 0)
600  goto fail;
601 
602  return pps;
603 
604 fail:
606  return NULL;
607 }
608 
609 static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
610 {
611  int ret = 0;
612  const int pps_id = rpps->pps_pic_parameter_set_id;
613  const int sps_id = rpps->pps_seq_parameter_set_id;
614  const VVCPPS *old_pps = ps->pps_list[pps_id];
615  const VVCPPS *pps;
616 
617  if (old_pps && old_pps->r == rpps)
618  return 0;
619 
620  pps = pps_alloc(rpps, ps->sps_list[sps_id]);
621  if (!pps)
622  return AVERROR(ENOMEM);
623 
625  ps->pps_list[pps_id] = pps;
626 
627  return ret;
628 }
629 
630 static int decode_ps(VVCParamSets *ps, const CodedBitstreamH266Context *h266, void *log_ctx, int is_clvss)
631 {
632  const H266RawPictureHeader *ph = h266->ph;
633  const H266RawPPS *rpps;
634  const H266RawSPS *rsps;
635  int ret;
636 
637  if (!ph)
638  return AVERROR_INVALIDDATA;
639 
640  rpps = h266->pps[ph->ph_pic_parameter_set_id];
641  if (!rpps)
642  return AVERROR_INVALIDDATA;
643 
644  rsps = h266->sps[rpps->pps_seq_parameter_set_id];
645  if (!rsps)
646  return AVERROR_INVALIDDATA;
647 
648  ret = decode_sps(ps, rsps, log_ctx, is_clvss);
649  if (ret < 0)
650  return ret;
651 
652  ret = decode_pps(ps, rpps);
653  if (ret < 0)
654  return ret;
655 
656  return 0;
657 }
658 
659 #define WEIGHT_TABLE(x) \
660  w->nb_weights[L##x] = r->num_weights_l##x; \
661  for (int i = 0; i < w->nb_weights[L##x]; i++) { \
662  w->weight_flag[L##x][LUMA][i] = r->luma_weight_l##x##_flag[i]; \
663  w->weight_flag[L##x][CHROMA][i] = r->chroma_weight_l##x##_flag[i]; \
664  w->weight[L##x][LUMA][i] = denom[LUMA] + r->delta_luma_weight_l##x[i]; \
665  w->offset[L##x][LUMA][i] = r->luma_offset_l##x[i]; \
666  for (int j = CB; j <= CR; j++) { \
667  w->weight[L##x][j][i] = denom[CHROMA] + r->delta_chroma_weight_l##x[i][j - 1]; \
668  w->offset[L##x][j][i] = 128 + r->delta_chroma_offset_l##x[i][j - 1]; \
669  w->offset[L##x][j][i] -= (128 * w->weight[L##x][j][i]) >> w->log2_denom[CHROMA]; \
670  w->offset[L##x][j][i] = av_clip_intp2(w->offset[L##x][j][i], 7); \
671  } \
672  } \
673 
675 {
676  int denom[2];
677 
678  w->log2_denom[LUMA] = r->luma_log2_weight_denom;
679  w->log2_denom[CHROMA] = w->log2_denom[LUMA] + r->delta_chroma_log2_weight_denom;
680  denom[LUMA] = 1 << w->log2_denom[LUMA];
681  denom[CHROMA] = 1 << w->log2_denom[CHROMA];
682  WEIGHT_TABLE(0)
683  WEIGHT_TABLE(1)
684 }
685 
686 // 8.3.1 Decoding process for picture order count
687 static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
688 {
689  const int max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
690  const int prev_poc_lsb = poc_tid0 % max_poc_lsb;
691  const int prev_poc_msb = poc_tid0 - prev_poc_lsb;
692  const int poc_lsb = ph->ph_pic_order_cnt_lsb;
693  int poc_msb;
694 
695  if (ph->ph_poc_msb_cycle_present_flag) {
696  poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
697  } else if (is_clvss) {
698  poc_msb = 0;
699  } else {
700  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
701  poc_msb = prev_poc_msb + max_poc_lsb;
702  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
703  poc_msb = prev_poc_msb - max_poc_lsb;
704  else
705  poc_msb = prev_poc_msb;
706  }
707 
708  return poc_msb + poc_lsb;
709 }
710 
712  uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
713 {
714  const int lut_sample =
715  pivot1[idx] + ((scale_coeff[idx] * (sample - pivot2[idx]) + (1<< 10)) >> 11);
716  return av_clip(lut_sample, 0, max - 1);
717 }
718 
719 //8.8.2.2 Inverse mapping process for a luma sample
720 static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
721 {
722  const int bit_depth = (sps->sps_bitdepth_minus8 + 8);
723  const int max = (1 << bit_depth);
724  const int org_cw = max / LMCS_MAX_BIN_SIZE;
725  const int shift = av_log2(org_cw);
726  const int off = 1 << (shift - 1);
727  int cw[LMCS_MAX_BIN_SIZE];
728  uint16_t input_pivot[LMCS_MAX_BIN_SIZE];
729  uint16_t scale_coeff[LMCS_MAX_BIN_SIZE];
730  uint16_t inv_scale_coeff[LMCS_MAX_BIN_SIZE];
731  int i, delta_crs;
733  return AVERROR_PATCHWELCOME;
734 
735  if (!rlmcs)
736  return AVERROR_INVALIDDATA;
737 
738  lmcs->min_bin_idx = rlmcs->lmcs_min_bin_idx;
739  lmcs->max_bin_idx = LMCS_MAX_BIN_SIZE - 1 - rlmcs->lmcs_min_bin_idx;
740 
741  memset(cw, 0, sizeof(cw));
742  for (int i = lmcs->min_bin_idx; i <= lmcs->max_bin_idx; i++)
743  cw[i] = org_cw + (1 - 2 * rlmcs->lmcs_delta_sign_cw_flag[i]) * rlmcs->lmcs_delta_abs_cw[i];
744 
745  delta_crs = (1 - 2 * rlmcs->lmcs_delta_sign_crs_flag) * rlmcs->lmcs_delta_abs_crs;
746 
747  lmcs->pivot[0] = 0;
748  for (i = 0; i < LMCS_MAX_BIN_SIZE; i++) {
749  input_pivot[i] = i * org_cw;
750  lmcs->pivot[i + 1] = lmcs->pivot[i] + cw[i];
751  scale_coeff[i] = (cw[i] * (1 << 11) + off) >> shift;
752  if (cw[i] == 0) {
753  inv_scale_coeff[i] = 0;
754  lmcs->chroma_scale_coeff[i] = (1 << 11);
755  } else {
756  inv_scale_coeff[i] = org_cw * (1 << 11) / cw[i];
757  lmcs->chroma_scale_coeff[i] = org_cw * (1 << 11) / (cw[i] + delta_crs);
758  }
759  }
760 
761  //derive lmcs_fwd_lut
762  for (uint16_t sample = 0; sample < max; sample++) {
763  const int idx_y = sample / org_cw;
764  const uint16_t fwd_sample = lmcs_derive_lut_sample(sample, lmcs->pivot,
765  input_pivot, scale_coeff, idx_y, max);
766  if (bit_depth > 8)
767  lmcs->fwd_lut.u16[sample] = fwd_sample;
768  else
769  lmcs->fwd_lut.u8 [sample] = fwd_sample;
770 
771  }
772 
773  //derive lmcs_inv_lut
774  i = lmcs->min_bin_idx;
775  for (uint16_t sample = 0; sample < max; sample++) {
776  uint16_t inv_sample;
777  while (i <= lmcs->max_bin_idx && sample >= lmcs->pivot[i + 1])
778  i++;
779 
780  inv_sample = lmcs_derive_lut_sample(sample, input_pivot, lmcs->pivot,
781  inv_scale_coeff, i, max);
782 
783  if (bit_depth > 8)
784  lmcs->inv_lut.u16[sample] = inv_sample;
785  else
786  lmcs->inv_lut.u8 [sample] = inv_sample;
787  }
788 
789  return 0;
790 }
791 
793 {
794  if (sps->sps_affine_enabled_flag)
795  return 5 - sps->sps_five_minus_max_num_subblock_merge_cand;
796  return sps->sps_sbtmvp_enabled_flag && ph->ph_temporal_mvp_enabled_flag;
797 }
798 
799 static int ph_vb_pos(uint16_t *vbs, uint8_t *num_vbs, const uint16_t *pos_minus_1, const uint8_t num_pos, uint16_t max, const int ctb_size_y)
800 {
801  max = FF_CEIL_RSHIFT(max, 3) - 2;
802  for (int i = 0; i < num_pos; i++) {
803  if (pos_minus_1[i] > max)
804  return AVERROR_INVALIDDATA;
805 
806  vbs[i] = (pos_minus_1[i] + 1) << 3;
807 
808  // The distance between any two vertical virtual boundaries shall be greater than or equal to CtbSizeY luma samples
809  if (i && vbs[i] < vbs[i - 1] + ctb_size_y)
810  return AVERROR_INVALIDDATA;
811  }
812  *num_vbs = num_pos;
813 
814  return 0;
815 }
816 
817 #define VBF(f) (sps->sps_virtual_boundaries_present_flag ? sps->sps_##f : ph->r->ph_##f)
818 #define VBFS(c, d) VBF(virtual_boundary_pos_##c##_minus1), VBF(num_##d##_virtual_boundaries)
819 
820 static int ph_vb(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps)
821 {
822  const int ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
823  int ret;
824 
825  if (!sps->sps_virtual_boundaries_enabled_flag)
826  return 0;
827 
828  ret = ph_vb_pos(ph->vb_pos_x, &ph->num_ver_vbs, VBFS(x, ver), pps->pps_pic_width_in_luma_samples, ctb_size_y);
829  if (ret < 0)
830  return ret;
831 
832  ret = ph_vb_pos(ph->vb_pos_y, &ph->num_hor_vbs, VBFS(y, hor), pps->pps_pic_height_in_luma_samples, ctb_size_y);
833  if (ret < 0)
834  return ret;
835 
836  return 0;
837 }
838 
839 static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
840 {
841  int ret;
842  ph->max_num_subblock_merge_cand = ph_max_num_subblock_merge_cand(sps, ph->r);
843 
844  ph->poc = ph_compute_poc(ph->r, sps, poc_tid0, is_clvss);
845 
846  if (pps->pps_wp_info_in_ph_flag)
847  pred_weight_table(&ph->pwt, &ph->r->ph_pred_weight_table);
848 
849  ret = ph_vb(ph, sps, pps);
850  if (ret < 0)
851  return ret;
852 
853  return 0;
854 }
855 
856 static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref,
857  const int poc_tid0, const int is_clvss)
858 {
859  int ret;
860  VVCPH *ph = &fps->ph;
861  const H266RawSPS *sps = fps->sps->r;
862  const H266RawPPS *pps = fps->pps->r;
863 
864  ph->r = rph;
865  ff_refstruct_replace(&ph->rref, rph_ref);
866  ret = ph_derive(ph, sps, pps, poc_tid0, is_clvss);
867  if (ret < 0)
868  return ret;
869 
870  return 0;
871 }
872 
873 static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
874  const CodedBitstreamH266Context *h266, const int poc_tid0, const int is_clvss)
875 {
876  const H266RawPictureHeader *ph = h266->ph;
877  const H266RawPPS *rpps;
878  int ret;
879 
880  if (!ph)
881  return AVERROR_INVALIDDATA;
882 
883  rpps = h266->pps[ph->ph_pic_parameter_set_id];
884  if (!rpps)
885  return AVERROR_INVALIDDATA;
886 
889 
890  ret = decode_ph(fps, ph, h266->ph_ref, poc_tid0, is_clvss);
891  if (ret < 0)
892  return ret;
893 
894  if (ph->ph_explicit_scaling_list_enabled_flag)
895  ff_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
896 
897  if (ph->ph_lmcs_enabled_flag) {
898  ret = lmcs_derive_lut(&fps->lmcs, ps->lmcs_list[ph->ph_lmcs_aps_id], fps->sps->r);
899  if (ret < 0)
900  return ret;
901  }
902 
903  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
904  ff_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
905 
906  return 0;
907 }
908 
910 {
911  if (IS_IDR(s))
912  s->no_output_before_recovery_flag = 1;
913  else if (IS_CRA(s) || IS_GDR(s))
914  s->no_output_before_recovery_flag = s->last_eos;
915 }
916 
917 static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
918 {
919  if (s->no_output_before_recovery_flag) {
920  if (IS_GDR(s))
921  s->gdr_recovery_point_poc = ph->poc + ph->r->ph_recovery_poc_cnt;
922  if (!GDR_IS_RECOVERED(s) && s->gdr_recovery_point_poc <= ph->poc)
924  }
925 }
926 
928 {
929  int ret = 0;
930  VVCParamSets *ps = &s->ps;
931  const CodedBitstreamH266Context *h266 = s->cbc->priv_data;
932  int is_clvss;
933 
935  is_clvss = IS_CLVSS(s);
936 
937  ret = decode_ps(ps, h266, s->avctx, is_clvss);
938  if (ret < 0)
939  return ret;
940 
941  ret = decode_frame_ps(fps, ps, h266, s->poc_tid0, is_clvss);
942  decode_recovery_poc(s, &fps->ph);
943  return ret;
944 }
945 
947 {
948  ff_refstruct_unref(&fps->sps);
949  ff_refstruct_unref(&fps->pps);
950  ff_refstruct_unref(&fps->ph.rref);
951  ff_refstruct_unref(&fps->sl);
952  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
953  ff_refstruct_unref(&fps->alf_list[i]);
954 }
955 
957 {
958  for (int i = 0; i < FF_ARRAY_ELEMS(ps->scaling_list); i++)
960  for (int i = 0; i < FF_ARRAY_ELEMS(ps->lmcs_list); i++)
962  for (int i = 0; i < FF_ARRAY_ELEMS(ps->alf_list); i++)
964  for (int i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
966  for (int i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
968 }
969 
970 static void alf_coeff(int16_t *coeff,
971  const uint8_t *abs, const uint8_t *sign, const int size)
972 {
973  for (int i = 0; i < size; i++)
974  coeff[i] = (1 - 2 * sign[i]) * abs[i];
975 }
976 
977 static void alf_coeff_cc(int16_t *coeff,
978  const uint8_t *mapped_abs, const uint8_t *sign)
979 {
980  for (int i = 0; i < ALF_NUM_COEFF_CC; i++) {
981  int c = mapped_abs[i];
982  if (c)
983  c = (1 - 2 * sign[i]) * (1 << (c - 1));
984  coeff[i] = c;
985  }
986 }
987 
988 static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
989 {
990  if (!aps->alf_luma_filter_signal_flag)
991  return;
992 
993  for (int i = 0; i < ALF_NUM_FILTERS_LUMA; i++) {
994  const int ref = aps->alf_luma_coeff_delta_idx[i];
995  const uint8_t *abs = aps->alf_luma_coeff_abs[ref];
996  const uint8_t *sign = aps->alf_luma_coeff_sign[ref];
997 
999  memcpy(alf->luma_clip_idx[i], aps->alf_luma_clip_idx[ref],
1000  sizeof(alf->luma_clip_idx[i]));
1001  }
1002 }
1003 
1004 static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
1005 {
1006  if (!aps->alf_chroma_filter_signal_flag)
1007  return;
1008 
1009  alf->num_chroma_filters = aps->alf_chroma_num_alt_filters_minus1 + 1;
1010  for (int i = 0; i < alf->num_chroma_filters; i++) {
1011  const uint8_t *abs = aps->alf_chroma_coeff_abs[i];
1012  const uint8_t *sign = aps->alf_chroma_coeff_sign[i];
1013 
1015  memcpy(alf->chroma_clip_idx[i], aps->alf_chroma_clip_idx[i],
1016  sizeof(alf->chroma_clip_idx[i]));
1017  }
1018 }
1019 
1020 static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
1021 {
1022  const uint8_t (*abs[])[ALF_NUM_COEFF_CC] =
1023  { aps->alf_cc_cb_mapped_coeff_abs, aps->alf_cc_cr_mapped_coeff_abs };
1024  const uint8_t (*sign[])[ALF_NUM_COEFF_CC] =
1025  {aps->alf_cc_cb_coeff_sign, aps->alf_cc_cr_coeff_sign };
1026  const int signaled[] = { aps->alf_cc_cb_filter_signal_flag, aps->alf_cc_cr_filter_signal_flag};
1027 
1028  alf->num_cc_filters[0] = aps->alf_cc_cb_filters_signalled_minus1 + 1;
1029  alf->num_cc_filters[1] = aps->alf_cc_cr_filters_signalled_minus1 + 1;
1030 
1031  for (int idx = 0; idx < 2; idx++) {
1032  if (signaled[idx]) {
1033  for (int i = 0; i < alf->num_cc_filters[idx]; i++)
1034  alf_coeff_cc(alf->cc_coeff[idx][i], abs[idx][i], sign[idx][i]);
1035  }
1036  }
1037 }
1038 
1039 static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
1040 {
1041  alf_luma(alf, aps);
1042  alf_chroma(alf, aps);
1043  alf_cc(alf, aps);
1044 }
1045 
1046 static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
1047 {
1048  VVCALF *a = ff_refstruct_allocz(sizeof(*a));
1049  if (!a)
1050  return AVERROR(ENOMEM);
1051 
1052  alf_derive(a, aps);
1053  ff_refstruct_replace(alf, a);
1055 
1056  return 0;
1057 }
1058 
1059 static int is_luma_list(const int id)
1060 {
1061  return id % VVC_MAX_SAMPLE_ARRAYS == SL_START_4x4 || id == SL_START_64x64 + 1;
1062 }
1063 
1064 static int derive_matrix_size(const int id)
1065 {
1066  return id < SL_START_4x4 ? 2 : (id < SL_START_8x8 ? 4 : 8);
1067 }
1068 
1069 // 7.4.3.20 Scaling list data semantics
1071 {
1072  for (int id = 0; id < SL_MAX_ID; id++) {
1073  const int matrix_size = derive_matrix_size(id);
1074  const int log2_size = av_log2(matrix_size);
1075  const int list_size = matrix_size * matrix_size;
1077  const uint8_t *pred;
1078  const int *scaling_list;
1079  int dc = 0;
1080 
1081  if (aps->aps_chroma_present_flag || is_luma_list(id)) {
1082  if (!aps->scaling_list_copy_mode_flag[id]) {
1083  int next_coef = 0;
1084 
1085  if (id >= SL_START_16x16)
1086  dc = next_coef = aps->scaling_list_dc_coef[id - SL_START_16x16];
1087 
1088  for (int i = 0; i < list_size; i++) {
1089  const int x = ff_vvc_diag_scan_x[3][3][i];
1090  const int y = ff_vvc_diag_scan_y[3][3][i];
1091 
1092  if (!(id >= SL_START_64x64 && x >= 4 && y >= 4))
1093  next_coef += aps->scaling_list_delta_coef[id][i];
1094  coeff[i] = next_coef;
1095  }
1096  }
1097  }
1098 
1099  //dc
1100  if (id >= SL_START_16x16) {
1101  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id]) {
1102  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = 8;
1103  } else if (!aps->scaling_list_pred_id_delta[id]) {
1104  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = 16;
1105  } else {
1106  const int ref_id = id - aps->scaling_list_pred_id_delta[id];
1107  if (ref_id >= SL_START_16x16)
1108  dc += sl->scaling_matrix_dc_rec[ref_id - SL_START_16x16];
1109  else
1110  dc += sl->scaling_matrix_rec[ref_id][0];
1111  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = dc & 255;
1112  }
1113  }
1114 
1115  //ac
1116  scaling_list = aps->scaling_list_copy_mode_flag[id] ? ff_vvc_scaling_list0 : coeff;
1117  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id])
1119  else if (!aps->scaling_list_pred_id_delta[id])
1121  else
1122  pred = sl->scaling_matrix_rec[id - aps->scaling_list_pred_id_delta[id]];
1123  for (int i = 0; i < list_size; i++) {
1124  const int x = ff_vvc_diag_scan_x[log2_size][log2_size][i];
1125  const int y = ff_vvc_diag_scan_y[log2_size][log2_size][i];
1126  const int off = y * matrix_size + x;
1127  sl->scaling_matrix_rec[id][off] = (pred[off] + scaling_list[i]) & 255;
1128  }
1129  }
1130 }
1131 
1132 static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
1133 {
1134  VVCScalingList *sl = ff_refstruct_allocz(sizeof(*sl));
1135  if (!sl)
1136  return AVERROR(ENOMEM);
1137 
1138  scaling_derive(sl, aps);
1139  ff_refstruct_replace(scaling, sl);
1140  ff_refstruct_unref(&sl);
1141 
1142  return 0;
1143 }
1144 
1146 {
1147  const H266RawAPS *aps = unit->content_ref;
1148  int ret = 0;
1149 
1150  if (!aps)
1151  return AVERROR_INVALIDDATA;
1152 
1153  switch (aps->aps_params_type) {
1154  case VVC_ASP_TYPE_ALF:
1155  ret = aps_decode_alf(&ps->alf_list[aps->aps_adaptation_parameter_set_id], aps);
1156  break;
1157  case VVC_ASP_TYPE_LMCS:
1158  ff_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
1159  break;
1160  case VVC_ASP_TYPE_SCALING:
1161  ret = aps_decode_scaling(&ps->scaling_list[aps->aps_adaptation_parameter_set_id], aps);
1162  break;
1163  }
1164 
1165  return ret;
1166 }
1167 
1168 static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
1169 {
1170  if (!sh->r->sh_alf_enabled_flag)
1171  return 0;
1172 
1173  for (int i = 0; i < sh->r->sh_num_alf_aps_ids_luma; i++) {
1174  const VVCALF *alf_aps_luma = fps->alf_list[sh->r->sh_alf_aps_id_luma[i]];
1175  if (!alf_aps_luma)
1176  return AVERROR_INVALIDDATA;
1177  }
1178 
1179  if (sh->r->sh_alf_cb_enabled_flag || sh->r->sh_alf_cr_enabled_flag) {
1180  const VVCALF *alf_aps_chroma = fps->alf_list[sh->r->sh_alf_aps_id_chroma];
1181  if (!alf_aps_chroma)
1182  return AVERROR_INVALIDDATA;
1183  }
1184 
1185  if (fps->sps->r->sps_ccalf_enabled_flag) {
1186  if (sh->r->sh_alf_cc_cb_enabled_flag) {
1187  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cb_aps_id];
1188  if (!alf_aps_cc_cr)
1189  return AVERROR_INVALIDDATA;
1190  }
1191  if (sh->r->sh_alf_cc_cr_enabled_flag) {
1192  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cr_aps_id];
1193  if (!alf_aps_cc_cr)
1194  return AVERROR_INVALIDDATA;
1195  }
1196  }
1197 
1198  return 0;
1199 }
1200 
1201 static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1202 {
1203  const int slice_address = sh->r->sh_slice_address;
1204 
1205  if (pps->r->pps_rect_slice_flag) {
1206  int pic_level_slice_idx = slice_address;
1207  for (int j = 0; j < sh->r->curr_subpic_idx; j++)
1208  pic_level_slice_idx += pps->r->num_slices_in_subpic[j];
1209  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + pps->slice_start_offset[pic_level_slice_idx];
1210  sh->num_ctus_in_curr_slice = pps->num_ctus_in_slice[pic_level_slice_idx];
1211  } else {
1212  int tile_x = slice_address % pps->r->num_tile_columns;
1213  int tile_y = slice_address / pps->r->num_tile_columns;
1214  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];
1215 
1216  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + slice_start_ctb;
1217 
1218  sh->num_ctus_in_curr_slice = 0;
1219  for (int tile_idx = slice_address; tile_idx <= slice_address + sh->r->sh_num_tiles_in_slice_minus1; tile_idx++) {
1220  tile_x = tile_idx % pps->r->num_tile_columns;
1221  tile_y = tile_idx / pps->r->num_tile_columns;
1222  sh->num_ctus_in_curr_slice += pps->r->row_height_val[tile_y] * pps->r->col_width_val[tile_x];
1223  }
1224  }
1225 }
1226 
1227 static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
1228 {
1229  const int init_qp = pps->pps_init_qp_minus26 + 26;
1230 
1231  if (!pps->pps_qp_delta_info_in_ph_flag)
1232  sh->slice_qp_y = init_qp + sh->r->sh_qp_delta;
1233  else
1234  sh->slice_qp_y = init_qp + ph->ph_qp_delta;
1235 }
1236 
1237 static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
1238 {
1239  const H266RawSliceHeader *rsh = sh->r;
1240 
1241  if (!pps->pps_wp_info_in_ph_flag &&
1242  ((pps->pps_weighted_pred_flag && IS_P(rsh)) ||
1243  (pps->pps_weighted_bipred_flag && IS_B(rsh))))
1245 }
1246 
1247 static void sh_deblock_offsets(VVCSH *sh)
1248 {
1249  const H266RawSliceHeader *r = sh->r;
1250 
1251  if (!r->sh_deblocking_filter_disabled_flag) {
1252  sh->deblock.beta_offset[LUMA] = r->sh_luma_beta_offset_div2 * 2;
1253  sh->deblock.tc_offset[LUMA] = r->sh_luma_tc_offset_div2 * 2;
1254  sh->deblock.beta_offset[CB] = r->sh_cb_beta_offset_div2 * 2;
1255  sh->deblock.tc_offset[CB] = r->sh_cb_tc_offset_div2 * 2;
1256  sh->deblock.beta_offset[CR] = r->sh_cr_beta_offset_div2 * 2;
1257  sh->deblock.tc_offset[CR] = r->sh_cr_tc_offset_div2 * 2;
1258  }
1259 }
1260 
1262 {
1263  const int min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
1264  int min_qt_log2_size_y[2];
1265 
1266  if (IS_I(sh->r)) {
1267  min_qt_log2_size_y[LUMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma);
1268  min_qt_log2_size_y[CHROMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma);
1269 
1270  sh->max_bt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma);
1271  sh->max_bt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_bt_min_qt_intra_slice_chroma);
1272 
1273  sh->max_tt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma);
1274  sh->max_tt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_tt_min_qt_intra_slice_chroma);
1275 
1276  sh->max_mtt_depth[LUMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_luma;
1277  sh->max_mtt_depth[CHROMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_chroma;
1278 
1279  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_intra_slice;
1280  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_intra_slice;
1281  } else {
1282  for (int i = LUMA; i <= CHROMA; i++) {
1283  min_qt_log2_size_y[i] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_inter_slice);
1284  sh->max_bt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_bt_min_qt_inter_slice);
1285  sh->max_tt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_tt_min_qt_inter_slice);
1286  sh->max_mtt_depth[i] = ph->ph_max_mtt_hierarchy_depth_inter_slice;
1287  }
1288 
1289  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_inter_slice;
1290  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_inter_slice;
1291  }
1292 
1293  sh->min_qt_size[LUMA] = 1 << min_qt_log2_size_y[LUMA];
1294  sh->min_qt_size[CHROMA] = 1 << min_qt_log2_size_y[CHROMA];
1295 }
1296 
1297 static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1298 {
1299  if (sps->sps_entry_point_offsets_present_flag) {
1300  for (int i = 1, j = 0; i < sh->num_ctus_in_curr_slice; i++) {
1301  const int pre_ctb_addr_x = sh->ctb_addr_in_curr_slice[i - 1] % pps->ctb_width;
1302  const int pre_ctb_addr_y = sh->ctb_addr_in_curr_slice[i - 1] / pps->ctb_width;
1303  const int ctb_addr_x = sh->ctb_addr_in_curr_slice[i] % pps->ctb_width;
1304  const int ctb_addr_y = sh->ctb_addr_in_curr_slice[i] / pps->ctb_width;
1305  if (pps->ctb_to_row_bd[ctb_addr_y] != pps->ctb_to_row_bd[pre_ctb_addr_y] ||
1306  pps->ctb_to_col_bd[ctb_addr_x] != pps->ctb_to_col_bd[pre_ctb_addr_x] ||
1307  (ctb_addr_y != pre_ctb_addr_y && sps->sps_entropy_coding_sync_enabled_flag)) {
1308  sh->entry_point_start_ctu[j++] = i;
1309  }
1310  }
1311  }
1312 }
1313 
1314 static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
1315 {
1316  const H266RawSPS *sps = fps->sps->r;
1317  const H266RawPPS *pps = fps->pps->r;
1318  const H266RawPictureHeader *ph = fps->ph.r;
1319  int ret;
1320 
1321  sh_slice_address(sh, sps, fps->pps);
1322  ret = sh_alf_aps(sh, fps);
1323  if (ret < 0)
1324  return ret;
1325  sh_inter(sh, sps, pps);
1326  sh_qp_y(sh, pps, ph);
1327  sh_deblock_offsets(sh);
1329  sh_entry_points(sh, sps, fps->pps);
1330 
1331  return 0;
1332 }
1333 
1335 {
1336  int ret;
1337 
1338  if (!fps->sps || !fps->pps)
1339  return AVERROR_INVALIDDATA;
1340 
1341  ff_refstruct_replace(&sh->r, unit->content_ref);
1342 
1343  ret = sh_derive(sh, fps);
1344  if (ret < 0)
1345  return ret;
1346 
1347  return 0;
1348 }
VVCSPS
Definition: ps.h:58
H266RawSPS::sps_subpic_height_minus1
uint16_t sps_subpic_height_minus1[VVC_MAX_SLICES]
Definition: cbs_h266.h:338
VVCSH::cu_qp_delta_subdiv
uint8_t cu_qp_delta_subdiv
CuQpDeltaSubdiv.
Definition: ps.h:260
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:242
VVCPH
Definition: ps.h:147
VVCPPS
Definition: ps.h:92
av_clip
#define av_clip
Definition: common.h:100
VVCLMCS::min_bin_idx
uint8_t min_bin_idx
Definition: ps.h:201
cbs_h266.h
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
LUMA
#define LUMA
Definition: filter.c:31
ff_vvc_decode_frame_ps
int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
Definition: ps.c:927
VVCSH::entry_point_start_ctu
uint32_t entry_point_start_ctu[VVC_MAX_ENTRY_POINTS]
entry point start in ctu_addr
Definition: ps.h:264
VVCPPS::r
const H266RawPPS * r
RefStruct reference.
Definition: ps.h:93
SL_MAX_MATRIX_SIZE
#define SL_MAX_MATRIX_SIZE
Definition: ps.h:193
CB
#define CB
Definition: filter.c:32
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
VVCSH::cu_chroma_qp_offset_subdiv
uint8_t cu_chroma_qp_offset_subdiv
CuChromaQpOffsetSubdiv.
Definition: ps.h:261
pps_free
static void pps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:575
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
alf_derive
static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:1039
LMCS_MAX_BIN_SIZE
#define LMCS_MAX_BIN_SIZE
Definition: ps.h:48
IS_P
#define IS_P(rsh)
Definition: ps.h:39
data.h
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
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
H266RawSPS::sps_subpic_ctu_top_left_y
uint16_t sps_subpic_ctu_top_left_y[VVC_MAX_SLICES]
Definition: cbs_h266.h:336
pps_single_slice_picture
static void pps_single_slice_picture(VVCPPS *pps, int *off)
Definition: ps.c:368
aps_decode_scaling
static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
Definition: ps.c:1132
VVCLMCS::max_bin_idx
uint8_t max_bin_idx
Definition: ps.h:202
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_qp_y
static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
Definition: ps.c:1227
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
VVCSH::r
const H266RawSliceHeader * r
RefStruct reference.
Definition: ps.h:238
sps_chroma_qp_table
static int sps_chroma_qp_table(VVCSPS *sps)
Definition: ps.c:88
pps_subpic
static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:536
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:856
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:355
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:200
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
pps_alloc
static const VVCPPS * pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
Definition: ps.c:588
VVCALF::num_chroma_filters
uint8_t num_chroma_filters
Definition: ps.h:175
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
sh_inter
static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
Definition: ps.c:1237
decode_pps
static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
Definition: ps.c:609
VVCLMCS::chroma_scale_coeff
uint16_t chroma_scale_coeff[LMCS_MAX_BIN_SIZE]
Definition: ps.h:210
JCBCR
#define JCBCR
Definition: dec.h:37
CodedBitstreamH266Context::pps
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:864
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
ps.h
VVCFrameParamSets::sps
const VVCSPS * sps
RefStruct reference.
Definition: ps.h:229
VVC_ASP_TYPE_ALF
@ VVC_ASP_TYPE_ALF
Definition: vvc.h:70
ALF_NUM_COEFF_CHROMA
#define ALF_NUM_COEFF_CHROMA
Definition: ps.h:168
SL_START_4x4
@ SL_START_4x4
Definition: ps.h:185
VVCFrameParamSets
Definition: ps.h:228
pps_slice_map
static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:514
fail
#define fail()
Definition: checkasm.h:186
VVCSH::pwt
PredWeightTable pwt
Definition: ps.h:246
H266RawSPS::sps_subpic_width_minus1
uint16_t sps_subpic_width_minus1[VVC_MAX_SLICES]
Definition: cbs_h266.h:337
IS_B
#define IS_B(rsh)
Definition: ps.h:40
H266RawAPS
Definition: cbs_h266.h:598
ff_vvc_decode_sh
int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
Definition: ps.c:1334
VVCParamSets::pps_list
const VVCPPS * pps_list[VVC_MAX_PPS_COUNT]
RefStruct reference.
Definition: ps.h:219
derive_matrix_size
static int derive_matrix_size(const int id)
Definition: ps.c:1064
VVCALF::cc_coeff
int16_t cc_coeff[2][ALF_NUM_FILTERS_CC][ALF_NUM_COEFF_CC]
Definition: ps.h:180
VVCFrameParamSets::sl
const VVCScalingList * sl
RefStruct reference.
Definition: ps.h:234
VVCALF
Definition: ps.h:171
H266RawSliceHeader::sh_alf_enabled_flag
uint8_t sh_alf_enabled_flag
Definition: cbs_h266.h:781
refstruct.h
ff_vvc_scaling_pred_16
const uint8_t ff_vvc_scaling_pred_16[8 *8]
Definition: data.c:288
ff_vvc_frame_ps_free
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
Definition: ps.c:946
VVCALF::chroma_clip_idx
uint8_t chroma_clip_idx[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA]
Definition: ps.h:177
GDR_SET_RECOVERED
#define GDR_SET_RECOVERED(s)
Definition: ps.h:44
SL_START_64x64
@ SL_START_64x64
Definition: ps.h:189
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
sps_ladf
static void sps_ladf(VVCSPS *sps)
Definition: ps.c:168
pps_no_rect_slice
static void pps_no_rect_slice(VVCPPS *pps)
Definition: ps.c:501
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
DBParams::beta_offset
int beta_offset
Definition: hevcdec.h:345
DBParams::tc_offset
int tc_offset
Definition: hevcdec.h:346
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
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:60
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:873
VVCFrameParamSets::lmcs
VVCLMCS lmcs
Definition: ps.h:233
VVCSH
Definition: ps.h:237
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:76
PredWeightTable
Definition: ps.h:137
VVCFrameParamSets::ph
VVCPH ph
Definition: ps.h:231
pps_multi_tiles_slice
static void pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off)
Definition: ps.c:463
ph_vb
static int ph_vb(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps)
Definition: ps.c:820
IS_GDR
#define IS_GDR(s)
Definition: ps.h:32
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
WEIGHT_TABLE
#define WEIGHT_TABLE(x)
Definition: ps.c:659
VVCParamSets::sps_list
const VVCSPS * sps_list[VVC_MAX_SPS_COUNT]
RefStruct reference.
Definition: ps.h:218
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
H266RawSPS
Definition: cbs_h266.h:308
FF_CEIL_RSHIFT
#define FF_CEIL_RSHIFT
Definition: common.h:63
pred_weight_table
static void pred_weight_table(PredWeightTable *w, const H266RawPredWeightTable *r)
Definition: ps.c:674
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_coeff_cc
static void alf_coeff_cc(int16_t *coeff, const uint8_t *mapped_abs, const uint8_t *sign)
Definition: ps.c:977
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
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:711
H266RawPPS::pps_pic_parameter_set_id
uint8_t pps_pic_parameter_set_id
Definition: cbs_h266.h:499
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:232
H266RawAPS::lmcs_delta_sign_cw_flag
uint8_t lmcs_delta_sign_cw_flag[16]
Definition: cbs_h266.h:636
ph_max_num_subblock_merge_cand
static int ph_max_num_subblock_merge_cand(const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:792
is_luma_list
static int is_luma_list(const int id)
Definition: ps.c:1059
sh_partition_constraints
static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:1261
H266RawPredWeightTable
Definition: cbs_h266.h:650
VVCSH::max_tt_size
uint8_t max_tt_size[2]
MaxTtSizeY, MaxTtSizeC.
Definition: ps.h:258
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:222
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
ph_vb_pos
static int ph_vb_pos(uint16_t *vbs, uint8_t *num_vbs, const uint16_t *pos_minus_1, const uint8_t num_pos, uint16_t max, const int ctb_size_y)
Definition: ps.c:799
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
ff_vvc_scaling_list0
const int ff_vvc_scaling_list0[8 *8]
Definition: data.c:299
decode_recovery_poc
static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
Definition: ps.c:917
VVCPH::r
const H266RawPictureHeader * r
Definition: ps.h:148
sps_partition_constraints
static void sps_partition_constraints(VVCSPS *sps)
Definition: ps.c:156
ff_vvc_diag_scan_y
const uint8_t ff_vvc_diag_scan_y[5][5][16 *16]
Definition: data.c:152
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
decode_sps
static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx, int is_clvss)
Definition: ps.c:230
VVCALF::luma_coeff
int16_t luma_coeff[ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA]
Definition: ps.h:172
pps_ref_wraparound_offset
static void pps_ref_wraparound_offset(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:528
VVCFrameParamSets::pps
const VVCPPS * pps
RefStruct reference.
Definition: ps.h:230
VVCSH::max_mtt_depth
uint8_t max_mtt_depth[2]
MaxMttDepthY, MaxMttDepthC.
Definition: ps.h:259
HEVCPPS::pps_id
unsigned int pps_id
Definition: ps.h:310
VVCScalingList
Definition: ps.h:195
H266RawSPS::sps_subpic_ctu_top_left_x
uint16_t sps_subpic_ctu_top_left_x[VVC_MAX_SLICES]
Definition: cbs_h266.h:335
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
CodedBitstreamH266Context::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:865
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:379
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
sample
#define sample
Definition: flacdsp_template.c:44
size
int size
Definition: twinvq_data.h:10344
aps_decode_alf
static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
Definition: ps.c:1046
SL_MAX_ID
@ SL_MAX_ID
Definition: ps.h:190
SL_START_8x8
@ SL_START_8x8
Definition: ps.h:186
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
ctu_rs
static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
Definition: ps.c:350
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
sh_derive
static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
Definition: ps.c:1314
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:410
IS_CRA
#define IS_CRA(s)
Definition: ps.h:30
next_tile_idx
static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
Definition: ps.c:326
alf_coeff
static void alf_coeff(int16_t *coeff, const uint8_t *abs, const uint8_t *sign, const int size)
Definition: ps.c:970
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
CodedBitstreamH266Context
Definition: cbs_h266.h:856
VVCSH::deblock
DBParams deblock
Definition: ps.h:253
VVCSH::ctb_addr_in_curr_slice
const uint32_t * ctb_addr_in_curr_slice
CtbAddrInCurrSlice.
Definition: ps.h:243
VVCScalingList::scaling_matrix_dc_rec
uint8_t scaling_matrix_dc_rec[SL_MAX_ID - SL_START_16x16]
ScalingMatrixDcRec[refId − 14].
Definition: ps.h:197
H266RawSliceHeader::sh_alf_cb_enabled_flag
uint8_t sh_alf_cb_enabled_flag
Definition: cbs_h266.h:784
H266RawSliceHeader::sh_pred_weight_table
H266RawPredWeightTable sh_pred_weight_table
Definition: cbs_h266.h:803
H266RawSliceHeader
Definition: cbs_h266.h:769
sps_free
static void sps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:203
VVCLMCS::pivot
uint16_t pivot[LMCS_MAX_BIN_SIZE+1]
Definition: ps.h:209
lmcs_derive_lut
static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
Definition: ps.c:720
pps_chroma_qp_offset
static void pps_chroma_qp_offset(VVCPPS *pps)
Definition: ps.c:258
VVC_MAX_POINTS_IN_QP_TABLE
@ VVC_MAX_POINTS_IN_QP_TABLE
Definition: vvc.h:121
CR
#define CR
Definition: filter.c:33
pps_derive
static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:554
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
sps_bit_depth
static int sps_bit_depth(VVCSPS *sps, void *log_ctx)
Definition: ps.c:77
VVCLMCS::fwd_lut
union VVCLMCS::@273 fwd_lut
H266RawSliceHeader::sh_alf_aps_id_luma
uint8_t sh_alf_aps_id_luma[8]
Definition: cbs_h266.h:783
ff_vvc_diag_scan_x
const uint8_t ff_vvc_diag_scan_x[5][5][16 *16]
Definition: data.c:27
sh_alf_aps
static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
Definition: ps.c:1168
scaling_derive
static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
Definition: ps.c:1070
CodedBitstreamH266Context::sps
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:863
VVCPH::rref
void * rref
RefStruct reference, backing ph above.
Definition: ps.h:149
ff_vvc_decode_aps
int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
Definition: ps.c:1145
av_always_inline
#define av_always_inline
Definition: attributes.h:49
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:403
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:206
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:687
ALF_NUM_COEFF_CC
#define ALF_NUM_COEFF_CC
Definition: ps.h:169
H266RawSliceHeader::sh_alf_cc_cb_aps_id
uint8_t sh_alf_cc_cb_aps_id
Definition: cbs_h266.h:788
SL_START_16x16
@ SL_START_16x16
Definition: ps.h:187
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
GDR_IS_RECOVERED
#define GDR_IS_RECOVERED(s)
Definition: ps.h:43
H266RawAPS::lmcs_delta_sign_crs_flag
uint8_t lmcs_delta_sign_crs_flag
Definition: cbs_h266.h:638
decode_recovery_flag
static void decode_recovery_flag(VVCContext *s)
Definition: ps.c:909
pps_width_height
static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:270
ff_vvc_ps_uninit
void ff_vvc_ps_uninit(VVCParamSets *ps)
Definition: ps.c:956
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
ALF_NUM_COEFF_LUMA
#define ALF_NUM_COEFF_LUMA
Definition: ps.h:167
pps_one_tile_slices
static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
Definition: ps.c:445
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
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
id
enum AVCodecID id
Definition: dts2pts.c:365
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
VVCParamSets::alf_list
const VVCALF * alf_list[VVC_MAX_ALF_COUNT]
RefStruct reference.
Definition: ps.h:220
VVCSH::slice_qp_y
int8_t slice_qp_y
SliceQpY.
Definition: ps.h:250
H266RawSPS::sps_num_subpics_minus1
uint16_t sps_num_subpics_minus1
Definition: cbs_h266.h:332
ctu_xy
static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
Definition: ps.c:344
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
alf_luma
static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:988
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:205
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:839
alf_cc
static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:1020
pps_bd
static int pps_bd(VVCPPS *pps)
Definition: ps.c:295
desc
const char * desc
Definition: libsvtav1.c:79
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:173
VVCLMCS::inv_lut
union VVCLMCS::@273 inv_lut
sps_alloc
static const VVCSPS * sps_alloc(const H266RawSPS *rsps, void *log_ctx)
Definition: ps.c:209
tile_xy
static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
Definition: ps.c:338
VVCParamSets
Definition: ps.h:217
VVCSH::max_bt_size
uint8_t max_bt_size[2]
MaxBtSizeY, MaxBtSizeC.
Definition: ps.h:257
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
HEVCPPS::sps_id
unsigned int sps_id
seq_parameter_set_id
Definition: ps.h:311
IS_CLVSS
#define IS_CLVSS(s)
Definition: ps.h:34
pps_rect_slice
static void pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:480
sps_poc
static void sps_poc(VVCSPS *sps)
Definition: ps.c:135
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:179
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
sh_slice_address
static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1201
pps_single_slice_per_subpic
static void pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
Definition: ps.c:435
CodedBitstreamH266Context::ph_ref
void * ph_ref
RefStruct reference backing ph above.
Definition: cbs_h266.h:866
ALF_NUM_FILTERS_LUMA
#define ALF_NUM_FILTERS_LUMA
Definition: ps.h:163
IS_I
#define IS_I(rsh)
Definition: ps.h:38
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:256
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
sps_inter
static void sps_inter(VVCSPS *sps)
Definition: ps.c:140
sh_deblock_offsets
static void sh_deblock_offsets(VVCSH *sh)
Definition: ps.c:1247
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
LMCS_MAX_BIT_DEPTH
#define LMCS_MAX_BIT_DEPTH
Definition: ps.h:46
H266RawSliceHeader::sh_alf_cr_enabled_flag
uint8_t sh_alf_cr_enabled_flag
Definition: cbs_h266.h:785
alf_chroma
static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:1004
VBFS
#define VBFS(c, d)
Definition: ps.c:818
sh_entry_points
static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1297
pps_subpic_slice
static void pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off)
Definition: ps.c:421
decode_ps
static int decode_ps(VVCParamSets *ps, const CodedBitstreamH266Context *h266, void *log_ctx, int is_clvss)
Definition: ps.c:630
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:176
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
sps_derive
static int sps_derive(VVCSPS *sps, void *log_ctx)
Definition: ps.c:182
VVCParamSets::sps_id_used
uint16_t sps_id_used
Definition: ps.h:225
sps_map_pixel_format
static int sps_map_pixel_format(VVCSPS *sps, void *log_ctx)
Definition: ps.c:32
VVCParamSets::lmcs_list
const H266RawAPS * lmcs_list[VVC_MAX_LMCS_COUNT]
RefStruct reference.
Definition: ps.h:221
ff_vvc_scaling_pred_8
const uint8_t ff_vvc_scaling_pred_8[8 *8]
Definition: data.c:277
MIN_TU_LOG2
#define MIN_TU_LOG2
MinTbLog2SizeY.
Definition: dec.h:39
VVCContext
Definition: dec.h:215
VVCScalingList::scaling_matrix_rec
uint8_t scaling_matrix_rec[SL_MAX_ID][SL_MAX_MATRIX_SIZE *SL_MAX_MATRIX_SIZE]
ScalingMatrixRec.
Definition: ps.h:196
dec.h