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  return 0;
293  else if (ps->sps_id_used & (1 << sps_id))
294  return AVERROR_INVALIDDATA;
295  }
296 
297  sps = sps_alloc(rsps, c);
298  if (!sps)
299  return AVERROR(ENOMEM);
300 
301  av_refstruct_unref(&ps->sps_list[sps_id]);
302  ps->sps_list[sps_id] = sps;
303  ps->sps_id_used |= (1 << sps_id);
304 
305  return 0;
306 }
307 
308 static void pps_chroma_qp_offset(VVCPPS *pps)
309 {
310  pps->chroma_qp_offset[CB - 1] = pps->r->pps_cb_qp_offset;
311  pps->chroma_qp_offset[CR - 1] = pps->r->pps_cr_qp_offset;
312  pps->chroma_qp_offset[JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_value;
313  for (int i = 0; i < 6; i++) {
314  pps->chroma_qp_offset_list[i][CB - 1] = pps->r->pps_cb_qp_offset_list[i];
315  pps->chroma_qp_offset_list[i][CR - 1] = pps->r->pps_cr_qp_offset_list[i];
316  pps->chroma_qp_offset_list[i][JCBCR - 1]= pps->r->pps_joint_cbcr_qp_offset_list[i];
317  }
318 }
319 
320 static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
321 {
322  const H266RawPPS *r = pps->r;
323 
324  pps->width = r->pps_pic_width_in_luma_samples;
325  pps->height = r->pps_pic_height_in_luma_samples;
326 
327  pps->ctb_width = AV_CEIL_RSHIFT(pps->width, sps->ctb_log2_size_y);
328  pps->ctb_height = AV_CEIL_RSHIFT(pps->height, sps->ctb_log2_size_y);
329  pps->ctb_count = pps->ctb_width * pps->ctb_height;
330 
331  pps->min_cb_width = pps->width >> sps->min_cb_log2_size_y;
332  pps->min_cb_height = pps->height >> sps->min_cb_log2_size_y;
333 
334  pps->min_pu_width = pps->width >> MIN_PU_LOG2;
335  pps->min_pu_height = pps->height >> MIN_PU_LOG2;
336  pps->min_tu_width = pps->width >> MIN_TU_LOG2;
337  pps->min_tu_height = pps->height >> MIN_TU_LOG2;
338 
339  pps->width32 = AV_CEIL_RSHIFT(pps->width, 5);
340  pps->height32 = AV_CEIL_RSHIFT(pps->height, 5);
341  pps->width64 = AV_CEIL_RSHIFT(pps->width, 6);
342  pps->height64 = AV_CEIL_RSHIFT(pps->height, 6);
343 }
344 
345 static int pps_bd(VVCPPS *pps)
346 {
347  const H266RawPPS *r = pps->r;
348 
349  pps->col_bd = av_calloc(r->num_tile_columns + 1, sizeof(*pps->col_bd));
350  pps->row_bd = av_calloc(r->num_tile_rows + 1, sizeof(*pps->row_bd));
351  pps->ctb_to_col_bd = av_calloc(pps->ctb_width + 1, sizeof(*pps->ctb_to_col_bd));
352  pps->ctb_to_row_bd = av_calloc(pps->ctb_height + 1, sizeof(*pps->ctb_to_col_bd));
353  if (!pps->col_bd || !pps->row_bd || !pps->ctb_to_col_bd || !pps->ctb_to_row_bd)
354  return AVERROR(ENOMEM);
355 
356  for (int i = 0, j = 0; i < r->num_tile_columns; i++) {
357  pps->col_bd[i] = j;
358  j += r->col_width_val[i];
359  for (int k = pps->col_bd[i]; k < j; k++)
360  pps->ctb_to_col_bd[k] = pps->col_bd[i];
361  }
362  pps->col_bd[r->num_tile_columns] = pps->ctb_to_col_bd[pps->ctb_width] = pps->ctb_width;
363 
364  for (int i = 0, j = 0; i < r->num_tile_rows; i++) {
365  pps->row_bd[i] = j;
366  j += r->row_height_val[i];
367  for (int k = pps->row_bd[i]; k < j; k++)
368  pps->ctb_to_row_bd[k] = pps->row_bd[i];
369  }
370  pps->row_bd[r->num_tile_rows] = pps->ctb_to_row_bd[pps->ctb_height] = pps->ctb_height;
371 
372  return 0;
373 }
374 
375 
376 static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
377 {
378  if (r->pps_tile_idx_delta_present_flag) {
379  tile_idx += r->pps_tile_idx_delta_val[i];
380  } else {
381  tile_idx += r->pps_slice_width_in_tiles_minus1[i] + 1;
382  if (tile_idx % r->num_tile_columns == 0)
383  tile_idx += (r->pps_slice_height_in_tiles_minus1[i]) * r->num_tile_columns;
384  }
385  return tile_idx;
386 }
387 
388 static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
389 {
390  *tile_x = tile_idx % pps->r->num_tile_columns;
391  *tile_y = tile_idx / pps->r->num_tile_columns;
392 }
393 
394 static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
395 {
396  *rx = pps->col_bd[tile_x];
397  *ry = pps->row_bd[tile_y];
398 }
399 
400 static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
401 {
402  return pps->ctb_width * ry + rx;
403 }
404 
405 static int pps_add_ctus(VVCPPS *pps, int *off, const int rx, const int ry,
406  const int w, const int h)
407 {
408  int start = *off;
409  for (int y = 0; y < h; y++) {
410  for (int x = 0; x < w; x++) {
411  pps->ctb_addr_in_slice[*off] = ctu_rs(rx + x, ry + y, pps);
412  (*off)++;
413  }
414  }
415  return *off - start;
416 }
417 
418 static void pps_single_slice_picture(VVCPPS *pps, int *off)
419 {
420  pps->num_ctus_in_slice[0] = 0;
421  for (int j = 0; j < pps->r->num_tile_rows; j++) {
422  for (int i = 0; i < pps->r->num_tile_columns; i++) {
423  pps->num_ctus_in_slice[0] += pps_add_ctus(pps, off,
424  pps->col_bd[i], pps->row_bd[j],
425  pps->r->col_width_val[i], pps->r->row_height_val[j]);
426  }
427  }
428 }
429 
430 static void subpic_tiles(int *tile_x, int *tile_y, int *tile_x_end, int *tile_y_end,
431  const VVCSPS *sps, const VVCPPS *pps, const int i)
432 {
433  const int rx = sps->r->sps_subpic_ctu_top_left_x[i];
434  const int ry = sps->r->sps_subpic_ctu_top_left_y[i];
435 
436  *tile_x = *tile_y = 0;
437 
438  while (pps->col_bd[*tile_x] < rx)
439  (*tile_x)++;
440 
441  while (pps->row_bd[*tile_y] < ry)
442  (*tile_y)++;
443 
444  *tile_x_end = (*tile_x);
445  *tile_y_end = (*tile_y);
446 
447  while (pps->col_bd[*tile_x_end] < rx + sps->r->sps_subpic_width_minus1[i] + 1)
448  (*tile_x_end)++;
449 
450  while (pps->row_bd[*tile_y_end] < ry + sps->r->sps_subpic_height_minus1[i] + 1)
451  (*tile_y_end)++;
452 }
453 
454 static bool mark_tile_as_used(bool *tile_in_subpic, const int tx, const int ty, const int tile_columns)
455 {
456  const size_t tile_idx = ty * tile_columns + tx;
457  if (tile_in_subpic[tile_idx]) {
458  /* the tile is covered by other subpictures */
459  return false;
460  }
461  tile_in_subpic[tile_idx] = true;
462  return true;
463 }
464 
465 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, bool *tile_in_subpic)
466 {
467  const int subpic_bottom = sps->r->sps_subpic_ctu_top_left_y[i] + sps->r->sps_subpic_height_minus1[i];
468  const int tile_bottom = pps->row_bd[ty] + pps->r->row_height_val[ty] - 1;
469  const bool is_final_subpic_in_tile = subpic_bottom == tile_bottom;
470 
471  if (is_final_subpic_in_tile && !mark_tile_as_used(tile_in_subpic, tx, ty, pps->r->num_tile_columns))
472  return AVERROR_INVALIDDATA;
473 
474  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off,
475  sps->r->sps_subpic_ctu_top_left_x[i], sps->r->sps_subpic_ctu_top_left_y[i],
476  sps->r->sps_subpic_width_minus1[i] + 1, sps->r->sps_subpic_height_minus1[i] + 1);
477 
478  return 0;
479 }
480 
481 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,
482  const int i, int *off, bool *tile_in_subpic)
483 {
484  for (int ty = tile_y; ty < y_end; ty++) {
485  for (int tx = tile_x; tx < x_end; tx++) {
486  if (!mark_tile_as_used(tile_in_subpic, tx, ty, pps->r->num_tile_columns))
487  return AVERROR_INVALIDDATA;
488 
489  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off,
490  pps->col_bd[tx], pps->row_bd[ty],
491  pps->r->col_width_val[tx], pps->r->row_height_val[ty]);
492  }
493  }
494  return 0;
495 }
496 
497 static int pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off, bool *tile_in_subpic)
498 {
499  int tx, ty, x_end, y_end;
500 
501  pps->slice_start_offset[i] = *off;
502  pps->num_ctus_in_slice[i] = 0;
503 
504  subpic_tiles(&tx, &ty, &x_end, &y_end, sps, pps, i);
505  if (ty + 1 == y_end && sps->r->sps_subpic_height_minus1[i] + 1 < pps->r->row_height_val[ty])
506  return pps_subpic_less_than_one_tile_slice(pps, sps, i, tx, ty, off, tile_in_subpic);
507  else
508  return pps_subpic_one_or_more_tiles_slice(pps, tx, ty, x_end, y_end, i, off, tile_in_subpic);
509 }
510 
511 static int pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
512 {
513  if (!sps->r->sps_subpic_info_present_flag) {
514  pps_single_slice_picture(pps, off);
515  } else {
516  bool tile_in_subpic[VVC_MAX_TILES_PER_AU] = {0};
517  for (int i = 0; i < pps->r->pps_num_slices_in_pic_minus1 + 1; i++) {
518  const int ret = pps_subpic_slice(pps, sps, i, off, tile_in_subpic);
519  if (ret < 0)
520  return ret;
521  }
522 
523  // We only use tile_in_subpic to check that the subpictures don't overlap
524  // here; we don't use tile_in_subpic to check that the subpictures cover
525  // every tile. It is possible to avoid doing this work here because the
526  // covering property of subpictures is already guaranteed by the mechanisms
527  // which check every CTU belongs to a slice.
528  }
529  return 0;
530 }
531 
532 static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
533 {
534  const H266RawPPS *r = pps->r;
535  int rx, ry, ctu_y_end, tile_x, tile_y;
536 
537  tile_xy(&tile_x, &tile_y, tile_idx, pps);
538  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
539  ctu_y_end = ry + r->row_height_val[tile_y];
540  while (ry < ctu_y_end) {
541  pps->slice_start_offset[i] = *off;
542  pps->num_ctus_in_slice[i] = pps_add_ctus(pps, off, rx, ry,
543  r->col_width_val[tile_x], r->slice_height_in_ctus[i]);
544  ry += r->slice_height_in_ctus[i++];
545  }
546  i--;
547  return i;
548 }
549 
550 static int pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off, bool *tile_in_slice)
551 {
552  const H266RawPPS *r = pps->r;
553  int rx, ry, tile_x, tile_y;
554 
555  tile_xy(&tile_x, &tile_y, tile_idx, pps);
556  pps->slice_start_offset[i] = *off;
557  pps->num_ctus_in_slice[i] = 0;
558  for (int ty = tile_y; ty <= tile_y + r->pps_slice_height_in_tiles_minus1[i]; ty++) {
559  for (int tx = tile_x; tx <= tile_x + r->pps_slice_width_in_tiles_minus1[i]; tx++) {
560  const int idx = ty * r->num_tile_columns + tx;
561  if (tile_in_slice[idx])
562  return AVERROR_INVALIDDATA;
563  tile_in_slice[idx] = true;
564  ctu_xy(&rx, &ry, tx, ty, pps);
565  pps->num_ctus_in_slice[i] += pps_add_ctus(pps, off, rx, ry,
566  r->col_width_val[tx], r->row_height_val[ty]);
567  }
568  }
569 
570  return 0;
571 }
572 
573 static int pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
574 {
575  const H266RawPPS *r = pps->r;
576  bool tile_in_slice[VVC_MAX_TILES_PER_AU] = {false};
577  int tile_idx = 0, off = 0;
578 
579  if (r->pps_single_slice_per_subpic_flag) {
580  return pps_single_slice_per_subpic(pps, sps, &off);
581  }
582 
583  for (int i = 0; i < r->pps_num_slices_in_pic_minus1 + 1; i++) {
584  if (!r->pps_slice_width_in_tiles_minus1[i] &&
585  !r->pps_slice_height_in_tiles_minus1[i]) {
586  if (tile_in_slice[tile_idx])
587  return AVERROR_INVALIDDATA;
588  tile_in_slice[tile_idx] = true;
589  i = pps_one_tile_slices(pps, tile_idx, i, &off);
590  } else {
591  const int ret = pps_multi_tiles_slice(pps, tile_idx, i, &off, tile_in_slice);
592  if (ret < 0)
593  return ret;
594  }
595  tile_idx = next_tile_idx(tile_idx, i, r);
596  }
597 
598  for (int i = 0; i < r->num_tiles_in_pic; i++) {
599  if (!tile_in_slice[i])
600  return AVERROR_INVALIDDATA;
601  }
602 
603  return 0;
604 }
605 
606 static void pps_no_rect_slice(VVCPPS* pps)
607 {
608  const H266RawPPS* r = pps->r;
609  int rx, ry, off = 0;
610 
611  for (int tile_y = 0; tile_y < r->num_tile_rows; tile_y++) {
612  for (int tile_x = 0; tile_x < r->num_tile_columns; tile_x++) {
613  ctu_xy(&rx, &ry, tile_x, tile_y, pps);
614  pps_add_ctus(pps, &off, rx, ry, r->col_width_val[tile_x], r->row_height_val[tile_y]);
615  }
616  }
617 }
618 
619 static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
620 {
621  pps->ctb_addr_in_slice = av_calloc(pps->ctb_count, sizeof(*pps->ctb_addr_in_slice));
622  if (!pps->ctb_addr_in_slice)
623  return AVERROR(ENOMEM);
624 
625  if (pps->r->pps_rect_slice_flag)
626  return pps_rect_slice(pps, sps);
627 
628  pps_no_rect_slice(pps);
629 
630  return 0;
631 }
632 
633 static void pps_ref_wraparound_offset(VVCPPS *pps, const VVCSPS *sps)
634 {
635  const H266RawPPS *r = pps->r;
636 
637  if (r->pps_ref_wraparound_enabled_flag)
638  pps->ref_wraparound_offset = (pps->width / sps->min_cb_size_y) - r->pps_pic_width_minus_wraparound_offset;
639 }
640 
641 static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
642 {
643  const H266RawSPS *rsps = sps->r;
644  for (int i = 0; i < rsps->sps_num_subpics_minus1 + 1; i++) {
645  if (rsps->sps_subpic_treated_as_pic_flag[i]) {
646  pps->subpic_x[i] = rsps->sps_subpic_ctu_top_left_x[i] << sps->ctb_log2_size_y;
647  pps->subpic_y[i] = rsps->sps_subpic_ctu_top_left_y[i] << sps->ctb_log2_size_y;
648  pps->subpic_width[i] = FFMIN(pps->width - pps->subpic_x[i], (rsps->sps_subpic_width_minus1[i] + 1) << sps->ctb_log2_size_y);
649  pps->subpic_height[i] = FFMIN(pps->height - pps->subpic_y[i], (rsps->sps_subpic_height_minus1[i] + 1) << sps->ctb_log2_size_y);
650  } else {
651  pps->subpic_x[i] = 0;
652  pps->subpic_y[i] = 0;
653  pps->subpic_width[i] = pps->width;
654  pps->subpic_height[i] = pps->height;
655  }
656  }
657 }
658 
659 static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
660 {
661  int ret;
662 
663  pps_chroma_qp_offset(pps);
664  pps_width_height(pps, sps);
665 
666  ret = pps_bd(pps);
667  if (ret < 0)
668  return ret;
669 
670  ret = pps_slice_map(pps, sps);
671  if (ret < 0)
672  return ret;
673 
674  pps_ref_wraparound_offset(pps, sps);
675  pps_subpic(pps, sps);
676 
677  return 0;
678 }
679 
680 static void pps_free(AVRefStructOpaque opaque, void *obj)
681 {
682  VVCPPS *pps = obj;
683 
684  av_refstruct_unref(&pps->r);
685 
686  av_freep(&pps->col_bd);
687  av_freep(&pps->row_bd);
688  av_freep(&pps->ctb_to_col_bd);
689  av_freep(&pps->ctb_to_row_bd);
690  av_freep(&pps->ctb_addr_in_slice);
691 }
692 
693 static const VVCPPS *pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
694 {
695  int ret;
696  VVCPPS *pps = av_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
697 
698  if (!pps)
699  return NULL;
700 
701  av_refstruct_replace(&pps->r, rpps);
702 
703  ret = pps_derive(pps, sps);
704  if (ret < 0)
705  goto fail;
706 
707  return pps;
708 
709 fail:
710  av_refstruct_unref(&pps);
711  return NULL;
712 }
713 
714 static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
715 {
716  int ret = 0;
717  const int pps_id = rpps->pps_pic_parameter_set_id;
718  const int sps_id = rpps->pps_seq_parameter_set_id;
719  const VVCPPS *old_pps = ps->pps_list[pps_id];
720  const VVCPPS *pps;
721 
722  if (old_pps && old_pps->r == rpps)
723  return 0;
724 
725  pps = pps_alloc(rpps, ps->sps_list[sps_id]);
726  if (!pps)
727  return AVERROR(ENOMEM);
728 
729  av_refstruct_unref(&ps->pps_list[pps_id]);
730  ps->pps_list[pps_id] = pps;
731 
732  return ret;
733 }
734 
735 static int decode_ps(VVCParamSets *ps, AVCodecContext *c, const CodedBitstreamH266Context *h266, int is_clvss)
736 {
737  const H266RawPictureHeader *ph = h266->ph;
738  const H266RawPPS *rpps;
739  const H266RawSPS *rsps;
740  int ret;
741 
742  if (!ph)
743  return AVERROR_INVALIDDATA;
744 
745  rpps = h266->pps[ph->ph_pic_parameter_set_id];
746  if (!rpps)
747  return AVERROR_INVALIDDATA;
748 
749  rsps = h266->sps[rpps->pps_seq_parameter_set_id];
750  if (!rsps)
751  return AVERROR_INVALIDDATA;
752 
753  ret = decode_sps(ps, c, rsps, is_clvss);
754  if (ret < 0)
755  return ret;
756 
757  if (rsps->sps_log2_ctu_size_minus5 > 2) {
758  // CTU > 128 are reserved in vvc spec v3
759  av_log(c, AV_LOG_ERROR, "CTU size > 128. \n");
760  return AVERROR_PATCHWELCOME;
761  }
762 
763  ret = decode_pps(ps, rpps);
764  if (ret < 0)
765  return ret;
766 
767  return 0;
768 }
769 
770 #define WEIGHT_TABLE(x) \
771  w->nb_weights[L##x] = r->num_weights_l##x; \
772  for (int i = 0; i < w->nb_weights[L##x]; i++) { \
773  w->weight_flag[L##x][LUMA][i] = r->luma_weight_l##x##_flag[i]; \
774  w->weight_flag[L##x][CHROMA][i] = r->chroma_weight_l##x##_flag[i]; \
775  w->weight[L##x][LUMA][i] = denom[LUMA] + r->delta_luma_weight_l##x[i]; \
776  w->offset[L##x][LUMA][i] = r->luma_offset_l##x[i]; \
777  for (int j = CB; j <= CR; j++) { \
778  w->weight[L##x][j][i] = denom[CHROMA] + r->delta_chroma_weight_l##x[i][j - 1]; \
779  w->offset[L##x][j][i] = 128 + r->delta_chroma_offset_l##x[i][j - 1]; \
780  w->offset[L##x][j][i] -= (128 * w->weight[L##x][j][i]) >> w->log2_denom[CHROMA]; \
781  w->offset[L##x][j][i] = av_clip_intp2(w->offset[L##x][j][i], 7); \
782  } \
783  } \
784 
785 static void pred_weight_table(PredWeightTable *w, const H266RawPredWeightTable *r)
786 {
787  int denom[2];
788 
789  w->log2_denom[LUMA] = r->luma_log2_weight_denom;
790  w->log2_denom[CHROMA] = w->log2_denom[LUMA] + r->delta_chroma_log2_weight_denom;
791  denom[LUMA] = 1 << w->log2_denom[LUMA];
792  denom[CHROMA] = 1 << w->log2_denom[CHROMA];
793  WEIGHT_TABLE(0)
794  WEIGHT_TABLE(1)
795 }
796 
797 // 8.3.1 Decoding process for picture order count
798 static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
799 {
800  const int max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
801  const int prev_poc_lsb = poc_tid0 % max_poc_lsb;
802  const int prev_poc_msb = poc_tid0 - prev_poc_lsb;
803  const int poc_lsb = ph->ph_pic_order_cnt_lsb;
804  int poc_msb;
805 
806  if (ph->ph_poc_msb_cycle_present_flag) {
807  poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
808  } else if (is_clvss) {
809  poc_msb = 0;
810  } else {
811  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
812  poc_msb = prev_poc_msb + max_poc_lsb;
813  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
814  poc_msb = prev_poc_msb - max_poc_lsb;
815  else
816  poc_msb = prev_poc_msb;
817  }
818 
819  return poc_msb + poc_lsb;
820 }
821 
822 static av_always_inline uint16_t lmcs_derive_lut_sample(uint16_t sample,
823  uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
824 {
825  const int lut_sample =
826  pivot1[idx] + ((scale_coeff[idx] * (sample - pivot2[idx]) + (1<< 10)) >> 11);
827  return av_clip(lut_sample, 0, max - 1);
828 }
829 
830 //8.8.2.2 Inverse mapping process for a luma sample
831 static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
832 {
833  const int bit_depth = (sps->sps_bitdepth_minus8 + 8);
834  const int max = (1 << bit_depth);
835  const int org_cw = max / LMCS_MAX_BIN_SIZE;
836  const int shift = av_log2(org_cw);
837  const int off = 1 << (shift - 1);
838  int cw[LMCS_MAX_BIN_SIZE];
839  uint16_t input_pivot[LMCS_MAX_BIN_SIZE];
840  uint16_t scale_coeff[LMCS_MAX_BIN_SIZE];
841  uint16_t inv_scale_coeff[LMCS_MAX_BIN_SIZE];
842  int i, delta_crs;
843  if (bit_depth > LMCS_MAX_BIT_DEPTH)
844  return AVERROR_PATCHWELCOME;
845 
846  if (!rlmcs)
847  return AVERROR_INVALIDDATA;
848 
849  lmcs->min_bin_idx = rlmcs->lmcs_min_bin_idx;
850  lmcs->max_bin_idx = LMCS_MAX_BIN_SIZE - 1 - rlmcs->lmcs_delta_max_bin_idx;
851 
852  memset(cw, 0, sizeof(cw));
853  for (int i = lmcs->min_bin_idx; i <= lmcs->max_bin_idx; i++)
854  cw[i] = org_cw + (1 - 2 * rlmcs->lmcs_delta_sign_cw_flag[i]) * rlmcs->lmcs_delta_abs_cw[i];
855 
856  delta_crs = (1 - 2 * rlmcs->lmcs_delta_sign_crs_flag) * rlmcs->lmcs_delta_abs_crs;
857 
858  lmcs->pivot[0] = 0;
859  for (i = 0; i < LMCS_MAX_BIN_SIZE; i++) {
860  input_pivot[i] = i * org_cw;
861  lmcs->pivot[i + 1] = lmcs->pivot[i] + cw[i];
862  scale_coeff[i] = (cw[i] * (1 << 11) + off) >> shift;
863  if (cw[i] == 0) {
864  inv_scale_coeff[i] = 0;
865  lmcs->chroma_scale_coeff[i] = (1 << 11);
866  } else {
867  inv_scale_coeff[i] = org_cw * (1 << 11) / cw[i];
868  lmcs->chroma_scale_coeff[i] = org_cw * (1 << 11) / (cw[i] + delta_crs);
869  }
870  }
871 
872  //derive lmcs_fwd_lut
873  for (uint16_t sample = 0; sample < max; sample++) {
874  const int idx_y = sample >> shift;
875  const uint16_t fwd_sample = lmcs_derive_lut_sample(sample, lmcs->pivot,
876  input_pivot, scale_coeff, idx_y, max);
877  if (bit_depth > 8)
878  lmcs->fwd_lut.u16[sample] = fwd_sample;
879  else
880  lmcs->fwd_lut.u8 [sample] = fwd_sample;
881 
882  }
883 
884  //derive lmcs_inv_lut
885  i = lmcs->min_bin_idx;
886  for (uint16_t sample = 0; sample < max; sample++) {
887  uint16_t inv_sample;
888  while (i <= lmcs->max_bin_idx && sample >= lmcs->pivot[i + 1])
889  i++;
890  i = FFMIN(i, LMCS_MAX_BIN_SIZE - 1);
891 
892  inv_sample = lmcs_derive_lut_sample(sample, input_pivot, lmcs->pivot,
893  inv_scale_coeff, i, max);
894 
895  if (bit_depth > 8)
896  lmcs->inv_lut.u16[sample] = inv_sample;
897  else
898  lmcs->inv_lut.u8 [sample] = inv_sample;
899  }
900 
901  return 0;
902 }
903 
904 static int ph_max_num_subblock_merge_cand(const H266RawSPS *sps, const H266RawPictureHeader *ph)
905 {
906  if (sps->sps_affine_enabled_flag)
907  return 5 - sps->sps_five_minus_max_num_subblock_merge_cand;
908  return sps->sps_sbtmvp_enabled_flag && ph->ph_temporal_mvp_enabled_flag;
909 }
910 
911 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)
912 {
913  max = FF_CEIL_RSHIFT(max, 3) - 2;
914  for (int i = 0; i < num_pos; i++) {
915  if (pos_minus_1[i] > max)
916  return AVERROR_INVALIDDATA;
917 
918  vbs[i] = (pos_minus_1[i] + 1) << 3;
919 
920  // The distance between any two vertical virtual boundaries shall be greater than or equal to CtbSizeY luma samples
921  if (i && vbs[i] < vbs[i - 1] + ctb_size_y)
922  return AVERROR_INVALIDDATA;
923  }
924  *num_vbs = num_pos;
925 
926  return 0;
927 }
928 
929 #define VBF(f) (sps->sps_virtual_boundaries_present_flag ? sps->sps_##f : ph->r->ph_##f)
930 #define VBFS(c, d) VBF(virtual_boundary_pos_##c##_minus1), VBF(num_##d##_virtual_boundaries)
931 
932 static int ph_vb(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps)
933 {
934  const int ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
935  int ret;
936 
937  if (!sps->sps_virtual_boundaries_enabled_flag)
938  return 0;
939 
940  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);
941  if (ret < 0)
942  return ret;
943 
944  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);
945  if (ret < 0)
946  return ret;
947 
948  return 0;
949 }
950 
951 static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
952 {
953  int ret;
954  ph->max_num_subblock_merge_cand = ph_max_num_subblock_merge_cand(sps, ph->r);
955 
956  ph->poc = ph_compute_poc(ph->r, sps, poc_tid0, is_clvss);
957 
958  if (pps->pps_wp_info_in_ph_flag)
959  pred_weight_table(&ph->pwt, &ph->r->ph_pred_weight_table);
960 
961  ret = ph_vb(ph, sps, pps);
962  if (ret < 0)
963  return ret;
964 
965  return 0;
966 }
967 
968 static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref,
969  const int poc_tid0, const int is_clvss)
970 {
971  int ret;
972  VVCPH *ph = &fps->ph;
973  const H266RawSPS *sps = fps->sps->r;
974  const H266RawPPS *pps = fps->pps->r;
975 
976  ph->r = rph;
977  av_refstruct_replace(&ph->rref, rph_ref);
978  ret = ph_derive(ph, sps, pps, poc_tid0, is_clvss);
979  if (ret < 0)
980  return ret;
981 
982  return 0;
983 }
984 
985 static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
986  const CodedBitstreamH266Context *h266, const int poc_tid0, const int is_clvss)
987 {
988  const H266RawPictureHeader *ph = h266->ph;
989  const H266RawPPS *rpps;
990  int ret;
991 
992  if (!ph)
993  return AVERROR_INVALIDDATA;
994 
995  rpps = h266->pps[ph->ph_pic_parameter_set_id];
996  if (!rpps)
997  return AVERROR_INVALIDDATA;
998 
999  av_refstruct_replace(&fps->sps, ps->sps_list[rpps->pps_seq_parameter_set_id]);
1000  av_refstruct_replace(&fps->pps, ps->pps_list[rpps->pps_pic_parameter_set_id]);
1001 
1002  ret = decode_ph(fps, ph, h266->ph_ref, poc_tid0, is_clvss);
1003  if (ret < 0)
1004  return ret;
1005 
1006  if (ph->ph_explicit_scaling_list_enabled_flag)
1007  av_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
1008 
1009  if (ph->ph_lmcs_enabled_flag) {
1010  ret = lmcs_derive_lut(&fps->lmcs, ps->lmcs_list[ph->ph_lmcs_aps_id], fps->sps->r);
1011  if (ret < 0)
1012  return ret;
1013  }
1014 
1015  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
1016  av_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
1017 
1018  return 0;
1019 }
1020 
1021 static void decode_recovery_flag(VVCContext *s)
1022 {
1023  if (IS_IDR(s))
1024  s->no_output_before_recovery_flag = 1;
1025  else if (IS_CRA(s) || IS_GDR(s))
1026  s->no_output_before_recovery_flag = s->last_eos;
1027 }
1028 
1029 static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
1030 {
1031  if (s->no_output_before_recovery_flag) {
1032  if (IS_GDR(s))
1033  s->gdr_recovery_point_poc = ph->poc + ph->r->ph_recovery_poc_cnt;
1034  if (!GDR_IS_RECOVERED(s) && s->gdr_recovery_point_poc <= ph->poc)
1035  GDR_SET_RECOVERED(s);
1036  }
1037 }
1038 
1039 int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
1040 {
1041  int ret = 0;
1042  VVCParamSets *ps = &s->ps;
1043  const CodedBitstreamH266Context *h266 = s->cbc->priv_data;
1044  int is_clvss;
1045 
1046  decode_recovery_flag(s);
1047  is_clvss = IS_CLVSS(s);
1048 
1049  ret = decode_ps(ps, s->avctx, h266, is_clvss);
1050  if (ret < 0)
1051  return ret;
1052 
1053  ret = decode_frame_ps(fps, ps, h266, s->poc_tid0, is_clvss);
1054  decode_recovery_poc(s, &fps->ph);
1055  return ret;
1056 }
1057 
1058 void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
1059 {
1060  av_refstruct_unref(&fps->sps);
1061  av_refstruct_unref(&fps->pps);
1062  av_refstruct_unref(&fps->ph.rref);
1063  av_refstruct_unref(&fps->sl);
1064  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
1065  av_refstruct_unref(&fps->alf_list[i]);
1066 }
1067 
1068 void ff_vvc_ps_uninit(VVCParamSets *ps)
1069 {
1070  for (int i = 0; i < FF_ARRAY_ELEMS(ps->scaling_list); i++)
1071  av_refstruct_unref(&ps->scaling_list[i]);
1072  for (int i = 0; i < FF_ARRAY_ELEMS(ps->lmcs_list); i++)
1073  av_refstruct_unref(&ps->lmcs_list[i]);
1074  for (int i = 0; i < FF_ARRAY_ELEMS(ps->alf_list); i++)
1075  av_refstruct_unref(&ps->alf_list[i]);
1076  for (int i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
1077  av_refstruct_unref(&ps->sps_list[i]);
1078  for (int i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
1079  av_refstruct_unref(&ps->pps_list[i]);
1080 }
1081 
1082 static void alf_coeff(int16_t *coeff,
1083  const uint8_t *abs, const uint8_t *sign, const int size)
1084 {
1085  for (int i = 0; i < size; i++)
1086  coeff[i] = (1 - 2 * sign[i]) * abs[i];
1087 }
1088 
1089 static void alf_coeff_cc(int16_t *coeff,
1090  const uint8_t *mapped_abs, const uint8_t *sign)
1091 {
1092  for (int i = 0; i < ALF_NUM_COEFF_CC; i++) {
1093  int c = mapped_abs[i];
1094  if (c)
1095  c = (1 - 2 * sign[i]) * (1 << (c - 1));
1096  coeff[i] = c;
1097  }
1098 }
1099 
1100 static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
1101 {
1102  if (!aps->alf_luma_filter_signal_flag)
1103  return;
1104 
1105  for (int i = 0; i < ALF_NUM_FILTERS_LUMA; i++) {
1106  const int ref = aps->alf_luma_coeff_delta_idx[i];
1107  const uint8_t *abs = aps->alf_luma_coeff_abs[ref];
1108  const uint8_t *sign = aps->alf_luma_coeff_sign[ref];
1109 
1110  alf_coeff(alf->luma_coeff[i], abs, sign, ALF_NUM_COEFF_LUMA);
1111  memcpy(alf->luma_clip_idx[i], aps->alf_luma_clip_idx[ref],
1112  sizeof(alf->luma_clip_idx[i]));
1113  }
1114 }
1115 
1116 static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
1117 {
1118  if (!aps->alf_chroma_filter_signal_flag)
1119  return;
1120 
1121  alf->num_chroma_filters = aps->alf_chroma_num_alt_filters_minus1 + 1;
1122  for (int i = 0; i < alf->num_chroma_filters; i++) {
1123  const uint8_t *abs = aps->alf_chroma_coeff_abs[i];
1124  const uint8_t *sign = aps->alf_chroma_coeff_sign[i];
1125 
1126  alf_coeff(alf->chroma_coeff[i], abs, sign, ALF_NUM_COEFF_CHROMA);
1127  memcpy(alf->chroma_clip_idx[i], aps->alf_chroma_clip_idx[i],
1128  sizeof(alf->chroma_clip_idx[i]));
1129  }
1130 }
1131 
1132 static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
1133 {
1134  const uint8_t (*abs[])[ALF_NUM_COEFF_CC] =
1135  { aps->alf_cc_cb_mapped_coeff_abs, aps->alf_cc_cr_mapped_coeff_abs };
1136  const uint8_t (*sign[])[ALF_NUM_COEFF_CC] =
1137  {aps->alf_cc_cb_coeff_sign, aps->alf_cc_cr_coeff_sign };
1138  const int signaled[] = { aps->alf_cc_cb_filter_signal_flag, aps->alf_cc_cr_filter_signal_flag};
1139 
1140  alf->num_cc_filters[0] = aps->alf_cc_cb_filters_signalled_minus1 + 1;
1141  alf->num_cc_filters[1] = aps->alf_cc_cr_filters_signalled_minus1 + 1;
1142 
1143  for (int idx = 0; idx < 2; idx++) {
1144  if (signaled[idx]) {
1145  for (int i = 0; i < alf->num_cc_filters[idx]; i++)
1146  alf_coeff_cc(alf->cc_coeff[idx][i], abs[idx][i], sign[idx][i]);
1147  }
1148  }
1149 }
1150 
1151 static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
1152 {
1153  alf_luma(alf, aps);
1154  alf_chroma(alf, aps);
1155  alf_cc(alf, aps);
1156 }
1157 
1158 static void alf_free(AVRefStructOpaque unused, void *obj)
1159 {
1160  VVCALF *alf = obj;
1161 
1162  av_refstruct_unref(&alf->r);
1163 }
1164 
1165 static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
1166 {
1167  VVCALF *a = av_refstruct_alloc_ext(sizeof(*a), 0, NULL, alf_free);
1168  if (!a)
1169  return AVERROR(ENOMEM);
1170 
1171  alf_derive(a, aps);
1172  av_refstruct_replace(&a->r, aps);
1173  av_refstruct_replace(alf, a);
1174  av_refstruct_unref(&a);
1175 
1176  return 0;
1177 }
1178 
1179 static int is_luma_list(const int id)
1180 {
1181  return id % VVC_MAX_SAMPLE_ARRAYS == SL_START_4x4 || id == SL_START_64x64 + 1;
1182 }
1183 
1184 static int derive_matrix_size(const int id)
1185 {
1186  return id < SL_START_4x4 ? 2 : (id < SL_START_8x8 ? 4 : 8);
1187 }
1188 
1189 // 7.4.3.20 Scaling list data semantics
1190 static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
1191 {
1192  for (int id = 0; id < SL_MAX_ID; id++) {
1193  const int matrix_size = derive_matrix_size(id);
1194  const int log2_size = av_log2(matrix_size);
1195  const int list_size = matrix_size * matrix_size;
1196  int coeff[SL_MAX_MATRIX_SIZE * SL_MAX_MATRIX_SIZE];
1197  const uint8_t *pred;
1198  const int *scaling_list;
1199  int dc = 0;
1200 
1201  if (aps->aps_chroma_present_flag || is_luma_list(id)) {
1202  if (!aps->scaling_list_copy_mode_flag[id]) {
1203  int next_coef = 0;
1204 
1205  if (id >= SL_START_16x16)
1206  dc = next_coef = aps->scaling_list_dc_coef[id - SL_START_16x16];
1207 
1208  for (int i = 0; i < list_size; i++) {
1209  const int x = ff_vvc_diag_scan_x[3][3][i];
1210  const int y = ff_vvc_diag_scan_y[3][3][i];
1211 
1212  if (!(id >= SL_START_64x64 && x >= 4 && y >= 4))
1213  next_coef += aps->scaling_list_delta_coef[id][i];
1214  coeff[i] = next_coef;
1215  }
1216  }
1217  }
1218 
1219  //dc
1220  if (id >= SL_START_16x16) {
1221  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id]) {
1222  dc += 8;
1223  } else if (!aps->scaling_list_pred_id_delta[id]) {
1224  dc += 16;
1225  } else {
1226  const int ref_id = id - aps->scaling_list_pred_id_delta[id];
1227  if (ref_id >= SL_START_16x16)
1228  dc += sl->scaling_matrix_dc_rec[ref_id - SL_START_16x16];
1229  else
1230  dc += sl->scaling_matrix_rec[ref_id][0];
1231  }
1232  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = dc & 255;
1233  }
1234 
1235  //ac
1236  scaling_list = aps->scaling_list_copy_mode_flag[id] ? ff_vvc_scaling_list0 : coeff;
1237  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id])
1238  pred = ff_vvc_scaling_pred_8;
1239  else if (!aps->scaling_list_pred_id_delta[id])
1240  pred = ff_vvc_scaling_pred_16;
1241  else
1242  pred = sl->scaling_matrix_rec[id - aps->scaling_list_pred_id_delta[id]];
1243  for (int i = 0; i < list_size; i++) {
1244  const int x = ff_vvc_diag_scan_x[log2_size][log2_size][i];
1245  const int y = ff_vvc_diag_scan_y[log2_size][log2_size][i];
1246  const int off = y * matrix_size + x;
1247  sl->scaling_matrix_rec[id][off] = (pred[off] + scaling_list[i]) & 255;
1248  }
1249  }
1250 }
1251 
1252 static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
1253 {
1254  VVCScalingList *sl = av_refstruct_allocz(sizeof(*sl));
1255  if (!sl)
1256  return AVERROR(ENOMEM);
1257 
1258  scaling_derive(sl, aps);
1259  av_refstruct_replace(scaling, sl);
1260  av_refstruct_unref(&sl);
1261 
1262  return 0;
1263 }
1264 
1265 int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
1266 {
1267  const H266RawAPS *aps = unit->content_ref;
1268  int ret = 0;
1269 
1270  if (!aps)
1271  return AVERROR_INVALIDDATA;
1272 
1273  switch (aps->aps_params_type) {
1274  case VVC_ASP_TYPE_ALF:
1275  ret = aps_decode_alf(&ps->alf_list[aps->aps_adaptation_parameter_set_id], aps);
1276  break;
1277  case VVC_ASP_TYPE_LMCS:
1278  av_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
1279  break;
1280  case VVC_ASP_TYPE_SCALING:
1281  ret = aps_decode_scaling(&ps->scaling_list[aps->aps_adaptation_parameter_set_id], aps);
1282  break;
1283  }
1284 
1285  return ret;
1286 }
1287 
1288 static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
1289 {
1290  if (!sh->r->sh_alf_enabled_flag)
1291  return 0;
1292 
1293  for (int i = 0; i < sh->r->sh_num_alf_aps_ids_luma; i++) {
1294  const VVCALF *alf_aps_luma = fps->alf_list[sh->r->sh_alf_aps_id_luma[i]];
1295  if (!alf_aps_luma)
1296  return AVERROR_INVALIDDATA;
1297  }
1298 
1299  if (sh->r->sh_alf_cb_enabled_flag || sh->r->sh_alf_cr_enabled_flag) {
1300  const VVCALF *alf_aps_chroma = fps->alf_list[sh->r->sh_alf_aps_id_chroma];
1301  if (!alf_aps_chroma)
1302  return AVERROR_INVALIDDATA;
1303  }
1304 
1305  if (fps->sps->r->sps_ccalf_enabled_flag) {
1306  if (sh->r->sh_alf_cc_cb_enabled_flag) {
1307  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cb_aps_id];
1308  if (!alf_aps_cc_cr)
1309  return AVERROR_INVALIDDATA;
1310  }
1311  if (sh->r->sh_alf_cc_cr_enabled_flag) {
1312  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cr_aps_id];
1313  if (!alf_aps_cc_cr)
1314  return AVERROR_INVALIDDATA;
1315  }
1316  }
1317 
1318  return 0;
1319 }
1320 
1321 static int sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1322 {
1323  const int slice_address = sh->r->sh_slice_address;
1324 
1325  if (pps->r->pps_rect_slice_flag) {
1326  int pic_level_slice_idx = slice_address;
1327  for (int j = 0; j < sh->r->curr_subpic_idx; j++)
1328  pic_level_slice_idx += pps->r->num_slices_in_subpic[j];
1329  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + pps->slice_start_offset[pic_level_slice_idx];
1330  sh->num_ctus_in_curr_slice = pps->num_ctus_in_slice[pic_level_slice_idx];
1331  } else {
1332  int tile_x = slice_address % pps->r->num_tile_columns;
1333  int tile_y = slice_address / pps->r->num_tile_columns;
1334  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];
1335 
1336  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + slice_start_ctb;
1337 
1338  sh->num_ctus_in_curr_slice = 0;
1339  for (int tile_idx = slice_address; tile_idx <= slice_address + sh->r->sh_num_tiles_in_slice_minus1; tile_idx++) {
1340  tile_x = tile_idx % pps->r->num_tile_columns;
1341  tile_y = tile_idx / pps->r->num_tile_columns;
1342  sh->num_ctus_in_curr_slice += pps->r->row_height_val[tile_y] * pps->r->col_width_val[tile_x];
1343  }
1344  }
1345 
1346  if (!sh->num_ctus_in_curr_slice)
1347  return AVERROR_INVALIDDATA;
1348 
1349  return 0;
1350 }
1351 
1352 static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
1353 {
1354  const int init_qp = pps->pps_init_qp_minus26 + 26;
1355 
1356  if (!pps->pps_qp_delta_info_in_ph_flag)
1357  sh->slice_qp_y = init_qp + sh->r->sh_qp_delta;
1358  else
1359  sh->slice_qp_y = init_qp + ph->ph_qp_delta;
1360 }
1361 
1362 static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
1363 {
1364  const H266RawSliceHeader *rsh = sh->r;
1365 
1366  if (!pps->pps_wp_info_in_ph_flag &&
1367  ((pps->pps_weighted_pred_flag && IS_P(rsh)) ||
1368  (pps->pps_weighted_bipred_flag && IS_B(rsh))))
1369  pred_weight_table(&sh->pwt, &rsh->sh_pred_weight_table);
1370 }
1371 
1372 static void sh_deblock_offsets(VVCSH *sh)
1373 {
1374  const H266RawSliceHeader *r = sh->r;
1375 
1376  if (!r->sh_deblocking_filter_disabled_flag) {
1377  sh->deblock.beta_offset[LUMA] = r->sh_luma_beta_offset_div2 * 2;
1378  sh->deblock.tc_offset[LUMA] = r->sh_luma_tc_offset_div2 * 2;
1379  sh->deblock.beta_offset[CB] = r->sh_cb_beta_offset_div2 * 2;
1380  sh->deblock.tc_offset[CB] = r->sh_cb_tc_offset_div2 * 2;
1381  sh->deblock.beta_offset[CR] = r->sh_cr_beta_offset_div2 * 2;
1382  sh->deblock.tc_offset[CR] = r->sh_cr_tc_offset_div2 * 2;
1383  }
1384 }
1385 
1386 static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
1387 {
1388  const int min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
1389  int min_qt_log2_size_y[2];
1390 
1391  if (IS_I(sh->r)) {
1392  min_qt_log2_size_y[LUMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma);
1393  min_qt_log2_size_y[CHROMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma);
1394 
1395  sh->max_bt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma);
1396  sh->max_bt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_bt_min_qt_intra_slice_chroma);
1397 
1398  sh->max_tt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma);
1399  sh->max_tt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_tt_min_qt_intra_slice_chroma);
1400 
1401  sh->max_mtt_depth[LUMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_luma;
1402  sh->max_mtt_depth[CHROMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_chroma;
1403 
1404  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_intra_slice;
1405  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_intra_slice;
1406  } else {
1407  for (int i = LUMA; i <= CHROMA; i++) {
1408  min_qt_log2_size_y[i] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_inter_slice);
1409  sh->max_bt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_bt_min_qt_inter_slice);
1410  sh->max_tt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_tt_min_qt_inter_slice);
1411  sh->max_mtt_depth[i] = ph->ph_max_mtt_hierarchy_depth_inter_slice;
1412  }
1413 
1414  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_inter_slice;
1415  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_inter_slice;
1416  }
1417 
1418  sh->min_qt_size[LUMA] = 1 << min_qt_log2_size_y[LUMA];
1419  sh->min_qt_size[CHROMA] = 1 << min_qt_log2_size_y[CHROMA];
1420 }
1421 
1422 static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1423 {
1424  if (sps->sps_entry_point_offsets_present_flag) {
1425  for (int i = 1, j = 0; i < sh->num_ctus_in_curr_slice; i++) {
1426  const int pre_ctb_addr_x = sh->ctb_addr_in_curr_slice[i - 1] % pps->ctb_width;
1427  const int pre_ctb_addr_y = sh->ctb_addr_in_curr_slice[i - 1] / pps->ctb_width;
1428  const int ctb_addr_x = sh->ctb_addr_in_curr_slice[i] % pps->ctb_width;
1429  const int ctb_addr_y = sh->ctb_addr_in_curr_slice[i] / pps->ctb_width;
1430  if (pps->ctb_to_row_bd[ctb_addr_y] != pps->ctb_to_row_bd[pre_ctb_addr_y] ||
1431  pps->ctb_to_col_bd[ctb_addr_x] != pps->ctb_to_col_bd[pre_ctb_addr_x] ||
1432  (ctb_addr_y != pre_ctb_addr_y && sps->sps_entropy_coding_sync_enabled_flag)) {
1433  sh->entry_point_start_ctu[j++] = i;
1434  }
1435  }
1436  }
1437 }
1438 
1439 static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
1440 {
1441  const H266RawSPS *sps = fps->sps->r;
1442  const H266RawPPS *pps = fps->pps->r;
1443  const H266RawPictureHeader *ph = fps->ph.r;
1444  int ret;
1445 
1446  ret = sh_slice_address(sh, sps, fps->pps);
1447  if (ret < 0)
1448  return ret;
1449  ret = sh_alf_aps(sh, fps);
1450  if (ret < 0)
1451  return ret;
1452  sh_inter(sh, sps, pps);
1453  sh_qp_y(sh, pps, ph);
1454  sh_deblock_offsets(sh);
1455  sh_partition_constraints(sh, sps, ph);
1456  sh_entry_points(sh, sps, fps->pps);
1457 
1458  return 0;
1459 }
1460 
1461 int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
1462 {
1463  int ret;
1464 
1465  if (!fps->sps || !fps->pps)
1466  return AVERROR_INVALIDDATA;
1467 
1468  av_refstruct_replace(&sh->r, unit->content_ref);
1469 
1470  ret = sh_derive(sh, fps);
1471  if (ret < 0)
1472  return ret;
1473 
1474  return 0;
1475 }
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:1321
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:215
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:112
VVCSH::num_ctus_in_curr_slice
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
Definition: ps.h:243
SL_MAX_ID
@ SL_MAX_ID
Definition: ps.h:191
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:1039
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:3313
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
SL_START_64x64
@ SL_START_64x64
Definition: ps.h:190
alf_derive
static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:1151
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:3043
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:746
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:418
aps_decode_scaling
static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
Definition: ps.c:1252
VVCLMCS::max_bin_idx
uint8_t max_bin_idx
Definition: ps.h:203
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:643
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
sh_qp_y
static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
Definition: ps.c:1352
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:525
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:511
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:641
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:968
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:405
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
VVCLMCS::fwd_lut
union VVCLMCS::@294 fwd_lut
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
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
pps_alloc
static const VVCPPS * pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
Definition: ps.c:693
VVCALF::num_chroma_filters
uint8_t num_chroma_filters
Definition: ps.h:176
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
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:1362
decode_pps
static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
Definition: ps.c:714
VVCLMCS::chroma_scale_coeff
uint16_t chroma_scale_coeff[LMCS_MAX_BIN_SIZE]
Definition: ps.h:211
JCBCR
#define JCBCR
Definition: dec.h:37
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:40
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:3689
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:619
fail
#define fail()
Definition: checkasm.h:193
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:1461
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:1184
VVCALF::cc_coeff
int16_t cc_coeff[2][ALF_NUM_FILTERS_CC][ALF_NUM_COEFF_CC]
Definition: ps.h:181
VVC_MAX_TILES_PER_AU
@ VVC_MAX_TILES_PER_AU
Definition: vvc.h:136
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:735
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:1058
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:528
sps_ladf
static void sps_ladf(VVCSPS *sps)
Definition: ps.c:171
pps_no_rect_slice
static void pps_no_rect_slice(VVCPPS *pps)
Definition: ps.c:606
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
pps_subpic_slice
static int pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off, bool *tile_in_subpic)
Definition: ps.c:497
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
H266RawVUI
Definition: cbs_h266.h:211
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, bool *tile_in_subpic)
Definition: ps.c:465
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:985
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
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:932
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:770
h2645data.h
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:618
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:505
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:785
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:680
alf_coeff_cc
static void alf_coeff_cc(int16_t *coeff, const uint8_t *mapped_abs, const uint8_t *sign)
Definition: ps.c:1089
NULL
#define NULL
Definition: coverity.c:32
H266RawPictureHeader
Definition: cbs_h266.h:676
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
SL_START_4x4
@ SL_START_4x4
Definition: ps.h:186
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:822
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: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:904
is_luma_list
static int is_luma_list(const int id)
Definition: ps.c:1179
sh_partition_constraints
static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:1386
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:3647
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
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:526
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:911
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:1158
decode_recovery_poc
static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
Definition: ps.c:1029
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:633
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
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
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:430
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:530
VVC_MAX_POINTS_IN_QP_TABLE
@ VVC_MAX_POINTS_IN_QP_TABLE
Definition: vvc.h:121
sample
#define sample
Definition: flacdsp_template.c:44
SL_START_8x8
@ SL_START_8x8
Definition: ps.h:187
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:1165
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:532
ctu_rs
static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
Definition: ps.c:400
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:1439
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:376
alf_coeff
static void alf_coeff(int16_t *coeff, const uint8_t *abs, const uint8_t *sign, const int size)
Definition: ps.c:1082
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
SL_START_16x16
@ SL_START_16x16
Definition: ps.h:188
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
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, bool *tile_in_subpic)
Definition: ps.c:481
lmcs_derive_lut
static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
Definition: ps.c:831
pps_chroma_qp_offset
static void pps_chroma_qp_offset(VVCPPS *pps)
Definition: ps.c:308
CR
#define CR
Definition: filter.c:33
pps_derive
static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:659
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
VVCLMCS::inv_lut
union VVCLMCS::@294 inv_lut
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:1288
scaling_derive
static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
Definition: ps.c:1190
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:1265
mark_tile_as_used
static bool mark_tile_as_used(bool *tile_in_subpic, const int tx, const int ty, const int tile_columns)
Definition: ps.c:454
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:798
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:672
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:573
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:729
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:1021
pps_width_height
static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:320
ff_vvc_ps_uninit
void ff_vvc_ps_uninit(VVCParamSets *ps)
Definition: ps.c:1068
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:532
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:529
id
enum AVCodecID id
Definition: dts2pts.c:367
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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:394
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: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:1100
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:951
H266RawVUI::vui_aspect_ratio_idc
uint8_t vui_aspect_ratio_idc
Definition: cbs_h266.h:219
alf_cc
static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
Definition: ps.c:1132
pps_bd
static int pps_bd(VVCPPS *pps)
Definition: ps.c:345
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:550
tile_xy
static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
Definition: ps.c:388
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:34
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:1372
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:506
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:1116
VBFS
#define VBFS(c, d)
Definition: ps.c:930
sh_entry_points
static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1422
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:3668
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:39
VVCContext
Definition: dec.h:212
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 Sat Mar 15 2025 19:21:43 for FFmpeg by   doxygen 1.8.17