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