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 SliceContext *sc, int is_clvss)
747 {
748  const H266RawSlice *sl = sc->ref;
749  const H266RawPPS *rpps = sl->pps;
750  const H266RawSPS *rsps = sl->sps;
751  int ret;
752 
753  if (!rpps)
754  return AVERROR_INVALIDDATA;
755 
756  if (!rsps)
757  return AVERROR_INVALIDDATA;
758 
759  ret = decode_sps(ps, c, rsps, is_clvss);
760  if (ret < 0)
761  return ret;
762 
763  if (rsps->sps_log2_ctu_size_minus5 > 2) {
764  // CTU > 128 are reserved in vvc spec v3
765  av_log(c, AV_LOG_ERROR, "CTU size > 128. \n");
766  return AVERROR_PATCHWELCOME;
767  }
768 
769  ret = decode_pps(ps, rpps);
770  if (ret < 0)
771  return ret;
772 
773  return 0;
774 }
775 
776 #define WEIGHT_TABLE(x) \
777  w->nb_weights[L##x] = r->num_weights_l##x; \
778  for (int i = 0; i < w->nb_weights[L##x]; i++) { \
779  w->weight_flag[L##x][LUMA][i] = r->luma_weight_l##x##_flag[i]; \
780  w->weight_flag[L##x][CHROMA][i] = r->chroma_weight_l##x##_flag[i]; \
781  w->weight[L##x][LUMA][i] = denom[LUMA] + r->delta_luma_weight_l##x[i]; \
782  w->offset[L##x][LUMA][i] = r->luma_offset_l##x[i]; \
783  for (int j = CB; j <= CR; j++) { \
784  w->weight[L##x][j][i] = denom[CHROMA] + r->delta_chroma_weight_l##x[i][j - 1]; \
785  w->offset[L##x][j][i] = 128 + r->delta_chroma_offset_l##x[i][j - 1]; \
786  w->offset[L##x][j][i] -= (128 * w->weight[L##x][j][i]) >> w->log2_denom[CHROMA]; \
787  w->offset[L##x][j][i] = av_clip_intp2(w->offset[L##x][j][i], 7); \
788  } \
789  } \
790 
791 static void pred_weight_table(PredWeightTable *w, const H266RawPredWeightTable *r)
792 {
793  int denom[2];
794 
795  w->log2_denom[LUMA] = r->luma_log2_weight_denom;
796  w->log2_denom[CHROMA] = w->log2_denom[LUMA] + r->delta_chroma_log2_weight_denom;
797  denom[LUMA] = 1 << w->log2_denom[LUMA];
798  denom[CHROMA] = 1 << w->log2_denom[CHROMA];
799  WEIGHT_TABLE(0)
800  WEIGHT_TABLE(1)
801 }
802 
803 // 8.3.1 Decoding process for picture order count
804 static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
805 {
806  const int max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
807  const int prev_poc_lsb = poc_tid0 % max_poc_lsb;
808  const int prev_poc_msb = poc_tid0 - prev_poc_lsb;
809  const int poc_lsb = ph->ph_pic_order_cnt_lsb;
810  int poc_msb;
811 
812  if (ph->ph_poc_msb_cycle_present_flag) {
813  poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
814  } else if (is_clvss) {
815  poc_msb = 0;
816  } else {
817  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
818  poc_msb = prev_poc_msb + max_poc_lsb;
819  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
820  poc_msb = prev_poc_msb - max_poc_lsb;
821  else
822  poc_msb = prev_poc_msb;
823  }
824 
825  return poc_msb + poc_lsb;
826 }
827 
828 static av_always_inline uint16_t lmcs_derive_lut_sample(uint16_t sample,
829  uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
830 {
831  const int lut_sample =
832  pivot1[idx] + ((scale_coeff[idx] * (sample - pivot2[idx]) + (1<< 10)) >> 11);
833  return av_clip(lut_sample, 0, max - 1);
834 }
835 
836 //8.8.2.2 Inverse mapping process for a luma sample
837 static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
838 {
839  const int bit_depth = (sps->sps_bitdepth_minus8 + 8);
840  const int max = (1 << bit_depth);
841  const int org_cw = max / LMCS_MAX_BIN_SIZE;
842  const int shift = av_log2(org_cw);
843  const int off = 1 << (shift - 1);
844  int cw[LMCS_MAX_BIN_SIZE];
845  uint16_t input_pivot[LMCS_MAX_BIN_SIZE];
846  uint16_t scale_coeff[LMCS_MAX_BIN_SIZE];
847  uint16_t inv_scale_coeff[LMCS_MAX_BIN_SIZE];
848  int i, delta_crs, sum_cw = 0;
849  if (bit_depth > LMCS_MAX_BIT_DEPTH)
850  return AVERROR_PATCHWELCOME;
851 
852  if (!rlmcs)
853  return AVERROR_INVALIDDATA;
854 
855  lmcs->min_bin_idx = rlmcs->lmcs_min_bin_idx;
856  lmcs->max_bin_idx = LMCS_MAX_BIN_SIZE - 1 - rlmcs->lmcs_delta_max_bin_idx;
857 
858  memset(cw, 0, sizeof(cw));
859  for (int i = lmcs->min_bin_idx; i <= lmcs->max_bin_idx; i++) {
860  cw[i] = org_cw + (1 - 2 * rlmcs->lmcs_delta_sign_cw_flag[i]) * rlmcs->lmcs_delta_abs_cw[i];
861  sum_cw += cw[i];
862  }
863  if (sum_cw > (1 << bit_depth) - 1)
864  return AVERROR_INVALIDDATA;
865 
866  delta_crs = (1 - 2 * rlmcs->lmcs_delta_sign_crs_flag) * rlmcs->lmcs_delta_abs_crs;
867 
868  lmcs->pivot[0] = 0;
869  for (i = 0; i < LMCS_MAX_BIN_SIZE; i++) {
870  input_pivot[i] = i * org_cw;
871  lmcs->pivot[i + 1] = lmcs->pivot[i] + cw[i];
872  if (i >= lmcs->min_bin_idx && i <= lmcs->max_bin_idx &&
873  lmcs->pivot[i] % (1 << (bit_depth - 5)) != 0 &&
874  lmcs->pivot[i] >> (bit_depth - 5) == lmcs->pivot[i + 1] >> (bit_depth - 5))
875  return AVERROR_INVALIDDATA;
876  scale_coeff[i] = (cw[i] * (1 << 11) + off) >> shift;
877  if (cw[i] == 0) {
878  inv_scale_coeff[i] = 0;
879  lmcs->chroma_scale_coeff[i] = (1 << 11);
880  } else {
881  const int cw_plus_d = cw[i] + delta_crs;
882  if (cw_plus_d < (org_cw >> 3) || cw_plus_d > ((org_cw << 3) - 1))
883  return AVERROR_INVALIDDATA;
884  inv_scale_coeff[i] = org_cw * (1 << 11) / cw[i];
885  lmcs->chroma_scale_coeff[i] = org_cw * (1 << 11) / cw_plus_d;
886  }
887  }
888 
889  //derive lmcs_fwd_lut
890  for (uint16_t sample = 0; sample < max; sample++) {
891  const int idx_y = sample >> shift;
892  const uint16_t fwd_sample = lmcs_derive_lut_sample(sample, lmcs->pivot,
893  input_pivot, scale_coeff, idx_y, max);
894  if (bit_depth > 8)
895  lmcs->fwd_lut.u16[sample] = fwd_sample;
896  else
897  lmcs->fwd_lut.u8 [sample] = fwd_sample;
898 
899  }
900 
901  //derive lmcs_inv_lut
902  i = lmcs->min_bin_idx;
903  for (uint16_t sample = 0; sample < max; sample++) {
904  uint16_t inv_sample;
905  while (i <= lmcs->max_bin_idx && sample >= lmcs->pivot[i + 1])
906  i++;
907  i = FFMIN(i, LMCS_MAX_BIN_SIZE - 1);
908 
909  inv_sample = lmcs_derive_lut_sample(sample, input_pivot, lmcs->pivot,
910  inv_scale_coeff, i, max);
911 
912  if (bit_depth > 8)
913  lmcs->inv_lut.u16[sample] = inv_sample;
914  else
915  lmcs->inv_lut.u8 [sample] = inv_sample;
916  }
917 
918  return 0;
919 }
920 
921 static int ph_max_num_subblock_merge_cand(const H266RawSPS *sps, const H266RawPictureHeader *ph)
922 {
923  if (sps->sps_affine_enabled_flag)
924  return 5 - sps->sps_five_minus_max_num_subblock_merge_cand;
925  return sps->sps_sbtmvp_enabled_flag && ph->ph_temporal_mvp_enabled_flag;
926 }
927 
928 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)
929 {
930  max = FF_CEIL_RSHIFT(max, 3) - 2;
931  for (int i = 0; i < num_pos; i++) {
932  if (pos_minus_1[i] > max)
933  return AVERROR_INVALIDDATA;
934 
935  vbs[i] = (pos_minus_1[i] + 1) << 3;
936 
937  // The distance between any two vertical virtual boundaries shall be greater than or equal to CtbSizeY luma samples
938  if (i && vbs[i] < vbs[i - 1] + ctb_size_y)
939  return AVERROR_INVALIDDATA;
940  }
941  *num_vbs = num_pos;
942 
943  return 0;
944 }
945 
946 #define VBF(f) (sps->sps_virtual_boundaries_present_flag ? sps->sps_##f : ph->r->ph_##f)
947 #define VBFS(c, d) VBF(virtual_boundary_pos_##c##_minus1), VBF(num_##d##_virtual_boundaries)
948 
949 static int ph_vb(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps)
950 {
951  const int ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
952  int ret;
953 
954  if (!sps->sps_virtual_boundaries_enabled_flag)
955  return 0;
956 
957  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);
958  if (ret < 0)
959  return ret;
960 
961  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);
962  if (ret < 0)
963  return ret;
964 
965  return 0;
966 }
967 
968 static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
969 {
970  int ret;
971  ph->max_num_subblock_merge_cand = ph_max_num_subblock_merge_cand(sps, ph->r);
972 
973  ph->poc = ph_compute_poc(ph->r, sps, poc_tid0, is_clvss);
974 
975  if (pps->pps_wp_info_in_ph_flag)
976  pred_weight_table(&ph->pwt, &ph->r->ph_pred_weight_table);
977 
978  ret = ph_vb(ph, sps, pps);
979  if (ret < 0)
980  return ret;
981 
982  return 0;
983 }
984 
985 static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref,
986  const int poc_tid0, const int is_clvss)
987 {
988  int ret;
989  VVCPH *ph = &fps->ph;
990  const H266RawSPS *sps = fps->sps->r;
991  const H266RawPPS *pps = fps->pps->r;
992 
993  ph->r = rph;
994  av_refstruct_replace(&ph->rref, rph_ref);
995  ret = ph_derive(ph, sps, pps, poc_tid0, is_clvss);
996  if (ret < 0)
997  return ret;
998 
999  return 0;
1000 }
1001 
1002 static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
1003  const SliceContext *sc, const int poc_tid0, const int is_clvss, const VVCContext *s)
1004 {
1005  const H266RawSlice *sl = sc->ref;
1006  const H266RawPictureHeader *ph = sl->ph;
1007  const H266RawPPS *rpps = sl->pps;
1008  int ret;
1009 
1010  if (!ph)
1011  return AVERROR_INVALIDDATA;
1012 
1013  if (!rpps)
1014  return AVERROR_INVALIDDATA;
1015 
1016  av_refstruct_replace(&fps->sps, ps->sps_list[rpps->pps_seq_parameter_set_id]);
1017  av_refstruct_replace(&fps->pps, ps->pps_list[rpps->pps_pic_parameter_set_id]);
1018 
1019  ret = decode_ph(fps, ph, sl->ph_ref, poc_tid0, is_clvss);
1020  if (ret < 0)
1021  return ret;
1022 
1023  if (ph->ph_explicit_scaling_list_enabled_flag)
1024  av_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
1025 
1026  if (ph->ph_lmcs_enabled_flag) {
1027  ret = lmcs_derive_lut(&fps->lmcs, ps->lmcs_list[ph->ph_lmcs_aps_id], fps->sps->r);
1028  if (ret < 0)
1029  return ret;
1030  }
1031 
1032  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
1033  av_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
1034 
1035  return 0;
1036 }
1037 
1038 static void decode_recovery_flag(VVCContext *s)
1039 {
1040  if (IS_IDR(s))
1041  s->no_output_before_recovery_flag = 1;
1042  else if (IS_CRA(s) || IS_GDR(s))
1043  s->no_output_before_recovery_flag = s->last_eos;
1044 }
1045 
1046 static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
1047 {
1048  if (s->no_output_before_recovery_flag) {
1049  if (IS_GDR(s))
1050  s->gdr_recovery_point_poc = ph->poc + ph->r->ph_recovery_poc_cnt;
1051  if (!GDR_IS_RECOVERED(s) && s->gdr_recovery_point_poc <= ph->poc)
1052  GDR_SET_RECOVERED(s);
1053  }
1054 }
1055 
1056 int ff_vvc_decode_frame_ps(struct VVCFrameContext *fc, struct VVCContext *s)
1057 {
1058  int ret = 0;
1059  VVCFrameParamSets *fps = &fc->ps;
1060  VVCParamSets *ps = &s->ps;
1061  const SliceContext *sc = fc->slices[0];
1062  int is_clvss;
1063 
1064  decode_recovery_flag(s);
1065  is_clvss = IS_CLVSS(s);
1066 
1067  ret = decode_ps(ps, s->avctx, sc, is_clvss);
1068  if (ret < 0)
1069  return ret;
1070 
1071  ret = decode_frame_ps(fps, ps, sc, s->poc_tid0, is_clvss, s);
1072  decode_recovery_poc(s, &fps->ph);
1073  return ret;
1074 }
1075 
1076 void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
1077 {
1078  av_refstruct_unref(&fps->sps);
1079  av_refstruct_unref(&fps->pps);
1080  av_refstruct_unref(&fps->ph.rref);
1081  av_refstruct_unref(&fps->sl);
1082  for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
1083  av_refstruct_unref(&fps->alf_list[i]);
1084 }
1085 
1086 void ff_vvc_ps_uninit(VVCParamSets *ps)
1087 {
1088  for (int i = 0; i < FF_ARRAY_ELEMS(ps->scaling_list); i++)
1089  av_refstruct_unref(&ps->scaling_list[i]);
1090  for (int i = 0; i < FF_ARRAY_ELEMS(ps->lmcs_list); i++)
1091  av_refstruct_unref(&ps->lmcs_list[i]);
1092  for (int i = 0; i < FF_ARRAY_ELEMS(ps->alf_list); i++)
1093  av_refstruct_unref(&ps->alf_list[i]);
1094  for (int i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
1095  av_refstruct_unref(&ps->sps_list[i]);
1096  for (int i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
1097  av_refstruct_unref(&ps->pps_list[i]);
1098 }
1099 
1100 static void alf_coeff(int16_t *coeff,
1101  const uint8_t *abs, const uint8_t *sign, const int size)
1102 {
1103  for (int i = 0; i < size; i++)
1104  coeff[i] = (1 - 2 * sign[i]) * abs[i];
1105 }
1106 
1107 static void alf_coeff_cc(int16_t *coeff,
1108  const uint8_t *mapped_abs, const uint8_t *sign)
1109 {
1110  for (int i = 0; i < ALF_NUM_COEFF_CC; i++) {
1111  int c = mapped_abs[i];
1112  if (c)
1113  c = (1 - 2 * sign[i]) * (1 << (c - 1));
1114  coeff[i] = c;
1115  }
1116 }
1117 
1118 static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
1119 {
1120  if (!aps->alf_luma_filter_signal_flag)
1121  return;
1122 
1123  for (int i = 0; i < ALF_NUM_FILTERS_LUMA; i++) {
1124  const int ref = aps->alf_luma_coeff_delta_idx[i];
1125  const uint8_t *abs = aps->alf_luma_coeff_abs[ref];
1126  const uint8_t *sign = aps->alf_luma_coeff_sign[ref];
1127 
1128  alf_coeff(alf->luma_coeff[i], abs, sign, ALF_NUM_COEFF_LUMA);
1129  memcpy(alf->luma_clip_idx[i], aps->alf_luma_clip_idx[ref],
1130  sizeof(alf->luma_clip_idx[i]));
1131  }
1132 }
1133 
1134 static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
1135 {
1136  if (!aps->alf_chroma_filter_signal_flag)
1137  return;
1138 
1139  alf->num_chroma_filters = aps->alf_chroma_num_alt_filters_minus1 + 1;
1140  for (int i = 0; i < alf->num_chroma_filters; i++) {
1141  const uint8_t *abs = aps->alf_chroma_coeff_abs[i];
1142  const uint8_t *sign = aps->alf_chroma_coeff_sign[i];
1143 
1144  alf_coeff(alf->chroma_coeff[i], abs, sign, ALF_NUM_COEFF_CHROMA);
1145  memcpy(alf->chroma_clip_idx[i], aps->alf_chroma_clip_idx[i],
1146  sizeof(alf->chroma_clip_idx[i]));
1147  }
1148 }
1149 
1150 static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
1151 {
1152  const uint8_t (*abs[])[ALF_NUM_COEFF_CC] =
1153  { aps->alf_cc_cb_mapped_coeff_abs, aps->alf_cc_cr_mapped_coeff_abs };
1154  const uint8_t (*sign[])[ALF_NUM_COEFF_CC] =
1155  {aps->alf_cc_cb_coeff_sign, aps->alf_cc_cr_coeff_sign };
1156  const int signaled[] = { aps->alf_cc_cb_filter_signal_flag, aps->alf_cc_cr_filter_signal_flag};
1157 
1158  alf->num_cc_filters[0] = aps->alf_cc_cb_filters_signalled_minus1 + 1;
1159  alf->num_cc_filters[1] = aps->alf_cc_cr_filters_signalled_minus1 + 1;
1160 
1161  for (int idx = 0; idx < 2; idx++) {
1162  if (signaled[idx]) {
1163  for (int i = 0; i < alf->num_cc_filters[idx]; i++)
1164  alf_coeff_cc(alf->cc_coeff[idx][i], abs[idx][i], sign[idx][i]);
1165  }
1166  }
1167 }
1168 
1169 static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
1170 {
1171  alf_luma(alf, aps);
1172  alf_chroma(alf, aps);
1173  alf_cc(alf, aps);
1174 }
1175 
1176 static void alf_free(AVRefStructOpaque unused, void *obj)
1177 {
1178  VVCALF *alf = obj;
1179 
1180  av_refstruct_unref(&alf->r);
1181 }
1182 
1183 static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
1184 {
1185  VVCALF *a = av_refstruct_alloc_ext(sizeof(*a), 0, NULL, alf_free);
1186  if (!a)
1187  return AVERROR(ENOMEM);
1188 
1189  alf_derive(a, aps);
1190  av_refstruct_replace(&a->r, aps);
1191  av_refstruct_replace(alf, a);
1192  av_refstruct_unref(&a);
1193 
1194  return 0;
1195 }
1196 
1197 static int is_luma_list(const int id)
1198 {
1199  return id % VVC_MAX_SAMPLE_ARRAYS == SL_START_4x4 || id == SL_START_64x64 + 1;
1200 }
1201 
1202 static int derive_matrix_size(const int id)
1203 {
1204  return id < SL_START_4x4 ? 2 : (id < SL_START_8x8 ? 4 : 8);
1205 }
1206 
1207 // 7.4.3.20 Scaling list data semantics
1208 static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
1209 {
1210  for (int id = 0; id < SL_MAX_ID; id++) {
1211  const int matrix_size = derive_matrix_size(id);
1212  const int log2_size = av_log2(matrix_size);
1213  const int list_size = matrix_size * matrix_size;
1214  int coeff[SL_MAX_MATRIX_SIZE * SL_MAX_MATRIX_SIZE];
1215  const uint8_t *pred;
1216  const int *scaling_list;
1217  int dc = 0;
1218 
1219  if (aps->aps_chroma_present_flag || is_luma_list(id)) {
1220  if (!aps->scaling_list_copy_mode_flag[id]) {
1221  int next_coef = 0;
1222 
1223  if (id >= SL_START_16x16)
1224  dc = next_coef = aps->scaling_list_dc_coef[id - SL_START_16x16];
1225 
1226  for (int i = 0; i < list_size; i++) {
1227  const int x = ff_vvc_diag_scan_x[3][3][i];
1228  const int y = ff_vvc_diag_scan_y[3][3][i];
1229 
1230  if (!(id >= SL_START_64x64 && x >= 4 && y >= 4))
1231  next_coef += aps->scaling_list_delta_coef[id][i];
1232  coeff[i] = next_coef;
1233  }
1234  }
1235  }
1236 
1237  //dc
1238  if (id >= SL_START_16x16) {
1239  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id]) {
1240  dc += 8;
1241  } else if (!aps->scaling_list_pred_id_delta[id]) {
1242  dc += 16;
1243  } else {
1244  const int ref_id = id - aps->scaling_list_pred_id_delta[id];
1245  if (ref_id >= SL_START_16x16)
1246  dc += sl->scaling_matrix_dc_rec[ref_id - SL_START_16x16];
1247  else
1248  dc += sl->scaling_matrix_rec[ref_id][0];
1249  }
1250  sl->scaling_matrix_dc_rec[id - SL_START_16x16] = dc & 255;
1251  }
1252 
1253  //ac
1254  scaling_list = aps->scaling_list_copy_mode_flag[id] ? ff_vvc_scaling_list0 : coeff;
1255  if (!aps->scaling_list_copy_mode_flag[id] && !aps->scaling_list_pred_mode_flag[id])
1256  pred = ff_vvc_scaling_pred_8;
1257  else if (!aps->scaling_list_pred_id_delta[id])
1258  pred = ff_vvc_scaling_pred_16;
1259  else
1260  pred = sl->scaling_matrix_rec[id - aps->scaling_list_pred_id_delta[id]];
1261  for (int i = 0; i < list_size; i++) {
1262  const int x = ff_vvc_diag_scan_x[log2_size][log2_size][i];
1263  const int y = ff_vvc_diag_scan_y[log2_size][log2_size][i];
1264  const int off = y * matrix_size + x;
1265  sl->scaling_matrix_rec[id][off] = (pred[off] + scaling_list[i]) & 255;
1266  }
1267  }
1268 }
1269 
1270 static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
1271 {
1272  VVCScalingList *sl = av_refstruct_allocz(sizeof(*sl));
1273  if (!sl)
1274  return AVERROR(ENOMEM);
1275 
1276  scaling_derive(sl, aps);
1277  av_refstruct_replace(scaling, sl);
1278  av_refstruct_unref(&sl);
1279 
1280  return 0;
1281 }
1282 
1283 int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
1284 {
1285  const H266RawAPS *aps = unit->content_ref;
1286  int ret = 0;
1287 
1288  if (!aps)
1289  return AVERROR_INVALIDDATA;
1290 
1291  switch (aps->aps_params_type) {
1292  case VVC_ASP_TYPE_ALF:
1293  ret = aps_decode_alf(&ps->alf_list[aps->aps_adaptation_parameter_set_id], aps);
1294  break;
1295  case VVC_ASP_TYPE_LMCS:
1296  av_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
1297  break;
1298  case VVC_ASP_TYPE_SCALING:
1299  ret = aps_decode_scaling(&ps->scaling_list[aps->aps_adaptation_parameter_set_id], aps);
1300  break;
1301  }
1302 
1303  return ret;
1304 }
1305 
1306 static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
1307 {
1308  if (!sh->r->sh_alf_enabled_flag)
1309  return 0;
1310 
1311  for (int i = 0; i < sh->r->sh_num_alf_aps_ids_luma; i++) {
1312  const VVCALF *alf_aps_luma = fps->alf_list[sh->r->sh_alf_aps_id_luma[i]];
1313  if (!alf_aps_luma)
1314  return AVERROR_INVALIDDATA;
1315  }
1316 
1317  if (sh->r->sh_alf_cb_enabled_flag || sh->r->sh_alf_cr_enabled_flag) {
1318  const VVCALF *alf_aps_chroma = fps->alf_list[sh->r->sh_alf_aps_id_chroma];
1319  if (!alf_aps_chroma)
1320  return AVERROR_INVALIDDATA;
1321  }
1322 
1323  if (fps->sps->r->sps_ccalf_enabled_flag) {
1324  if (sh->r->sh_alf_cc_cb_enabled_flag) {
1325  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cb_aps_id];
1326  if (!alf_aps_cc_cr)
1327  return AVERROR_INVALIDDATA;
1328  }
1329  if (sh->r->sh_alf_cc_cr_enabled_flag) {
1330  const VVCALF *alf_aps_cc_cr = fps->alf_list[sh->r->sh_alf_cc_cr_aps_id];
1331  if (!alf_aps_cc_cr)
1332  return AVERROR_INVALIDDATA;
1333  }
1334  }
1335 
1336  return 0;
1337 }
1338 
1339 static int sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1340 {
1341  const int slice_address = sh->r->sh_slice_address;
1342 
1343  if (pps->r->pps_rect_slice_flag) {
1344  int pic_level_slice_idx = slice_address;
1345  for (int j = 0; j < sh->r->curr_subpic_idx; j++)
1346  pic_level_slice_idx += pps->r->num_slices_in_subpic[j];
1347  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + pps->slice_start_offset[pic_level_slice_idx];
1348  sh->num_ctus_in_curr_slice = pps->num_ctus_in_slice[pic_level_slice_idx];
1349  } else {
1350  int tile_x = slice_address % pps->r->num_tile_columns;
1351  int tile_y = slice_address / pps->r->num_tile_columns;
1352  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];
1353 
1354  sh->ctb_addr_in_curr_slice = pps->ctb_addr_in_slice + slice_start_ctb;
1355 
1356  sh->num_ctus_in_curr_slice = 0;
1357  for (int tile_idx = slice_address; tile_idx <= slice_address + sh->r->sh_num_tiles_in_slice_minus1; tile_idx++) {
1358  tile_x = tile_idx % pps->r->num_tile_columns;
1359  tile_y = tile_idx / pps->r->num_tile_columns;
1360  sh->num_ctus_in_curr_slice += pps->r->row_height_val[tile_y] * pps->r->col_width_val[tile_x];
1361  }
1362  }
1363 
1364  if (!sh->num_ctus_in_curr_slice)
1365  return AVERROR_INVALIDDATA;
1366 
1367  return 0;
1368 }
1369 
1370 static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
1371 {
1372  const int init_qp = pps->pps_init_qp_minus26 + 26;
1373 
1374  if (!pps->pps_qp_delta_info_in_ph_flag)
1375  sh->slice_qp_y = init_qp + sh->r->sh_qp_delta;
1376  else
1377  sh->slice_qp_y = init_qp + ph->ph_qp_delta;
1378 }
1379 
1380 static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
1381 {
1382  const H266RawSliceHeader *rsh = sh->r;
1383 
1384  if (!pps->pps_wp_info_in_ph_flag &&
1385  ((pps->pps_weighted_pred_flag && IS_P(rsh)) ||
1386  (pps->pps_weighted_bipred_flag && IS_B(rsh))))
1387  pred_weight_table(&sh->pwt, &rsh->sh_pred_weight_table);
1388 }
1389 
1390 static void sh_deblock_offsets(VVCSH *sh)
1391 {
1392  const H266RawSliceHeader *r = sh->r;
1393 
1394  if (!r->sh_deblocking_filter_disabled_flag) {
1395  sh->deblock.beta_offset[LUMA] = r->sh_luma_beta_offset_div2 * 2;
1396  sh->deblock.tc_offset[LUMA] = r->sh_luma_tc_offset_div2 * 2;
1397  sh->deblock.beta_offset[CB] = r->sh_cb_beta_offset_div2 * 2;
1398  sh->deblock.tc_offset[CB] = r->sh_cb_tc_offset_div2 * 2;
1399  sh->deblock.beta_offset[CR] = r->sh_cr_beta_offset_div2 * 2;
1400  sh->deblock.tc_offset[CR] = r->sh_cr_tc_offset_div2 * 2;
1401  }
1402 }
1403 
1404 static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
1405 {
1406  const int min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
1407  int min_qt_log2_size_y[2];
1408 
1409  if (IS_I(sh->r)) {
1410  min_qt_log2_size_y[LUMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma);
1411  min_qt_log2_size_y[CHROMA] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma);
1412 
1413  sh->max_bt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma);
1414  sh->max_bt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_bt_min_qt_intra_slice_chroma);
1415 
1416  sh->max_tt_size[LUMA] = 1 << (min_qt_log2_size_y[LUMA] + ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma);
1417  sh->max_tt_size[CHROMA] = 1 << (min_qt_log2_size_y[CHROMA]+ ph->ph_log2_diff_max_tt_min_qt_intra_slice_chroma);
1418 
1419  sh->max_mtt_depth[LUMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_luma;
1420  sh->max_mtt_depth[CHROMA] = ph->ph_max_mtt_hierarchy_depth_intra_slice_chroma;
1421 
1422  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_intra_slice;
1423  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_intra_slice;
1424  } else {
1425  for (int i = LUMA; i <= CHROMA; i++) {
1426  min_qt_log2_size_y[i] = (min_cb_log2_size_y + ph->ph_log2_diff_min_qt_min_cb_inter_slice);
1427  sh->max_bt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_bt_min_qt_inter_slice);
1428  sh->max_tt_size[i] = 1 << (min_qt_log2_size_y[i] + ph->ph_log2_diff_max_tt_min_qt_inter_slice);
1429  sh->max_mtt_depth[i] = ph->ph_max_mtt_hierarchy_depth_inter_slice;
1430  }
1431 
1432  sh->cu_qp_delta_subdiv = ph->ph_cu_qp_delta_subdiv_inter_slice;
1433  sh->cu_chroma_qp_offset_subdiv = ph->ph_cu_chroma_qp_offset_subdiv_inter_slice;
1434  }
1435 
1436  sh->min_qt_size[LUMA] = 1 << min_qt_log2_size_y[LUMA];
1437  sh->min_qt_size[CHROMA] = 1 << min_qt_log2_size_y[CHROMA];
1438 }
1439 
1440 static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
1441 {
1442  if (sps->sps_entry_point_offsets_present_flag) {
1443  for (int i = 1, j = 0; i < sh->num_ctus_in_curr_slice; i++) {
1444  const int pre_ctb_addr_x = sh->ctb_addr_in_curr_slice[i - 1] % pps->ctb_width;
1445  const int pre_ctb_addr_y = sh->ctb_addr_in_curr_slice[i - 1] / pps->ctb_width;
1446  const int ctb_addr_x = sh->ctb_addr_in_curr_slice[i] % pps->ctb_width;
1447  const int ctb_addr_y = sh->ctb_addr_in_curr_slice[i] / pps->ctb_width;
1448  if (pps->ctb_to_row_bd[ctb_addr_y] != pps->ctb_to_row_bd[pre_ctb_addr_y] ||
1449  pps->ctb_to_col_bd[ctb_addr_x] != pps->ctb_to_col_bd[pre_ctb_addr_x] ||
1450  (ctb_addr_y != pre_ctb_addr_y && sps->sps_entropy_coding_sync_enabled_flag)) {
1451  sh->entry_point_start_ctu[j++] = i;
1452  }
1453  }
1454  }
1455 }
1456 
1457 static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
1458 {
1459  const H266RawSPS *sps = fps->sps->r;
1460  const H266RawPPS *pps = fps->pps->r;
1461  const H266RawPictureHeader *ph = fps->ph.r;
1462  int ret;
1463 
1464  ret = sh_slice_address(sh, sps, fps->pps);
1465  if (ret < 0)
1466  return ret;
1467  ret = sh_alf_aps(sh, fps);
1468  if (ret < 0)
1469  return ret;
1470  sh_inter(sh, sps, pps);
1471  sh_qp_y(sh, pps, ph);
1472  sh_deblock_offsets(sh);
1473  sh_partition_constraints(sh, sps, ph);
1474  sh_entry_points(sh, sps, fps->pps);
1475 
1476  return 0;
1477 }
1478 
1479 int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
1480 {
1481  int ret;
1482 
1483  if (!fps->sps || !fps->pps)
1484  return AVERROR_INVALIDDATA;
1485 
1486  av_refstruct_replace(&sh->r, unit->content_ref);
1487 
1488  ret = sh_derive(sh, fps);
1489  if (ret < 0)
1490  return ret;
1491 
1492  return 0;
1493 }
VVC_MAX_TILES_PER_AU
@ VVC_MAX_TILES_PER_AU
Definition: vvc.h:136
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:1339
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(struct VVCFrameContext *fc, struct VVCContext *s)
Definition: ps.c:1056
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
SL_START_8x8
@ SL_START_8x8
Definition: ps.h:187
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:3447
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:1169
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:3037
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:1270
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
sh_qp_y
static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
Definition: ps.c:1370
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
VVCLMCS::inv_lut
union VVCLMCS::@332 inv_lut
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:985
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:1380
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
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:3823
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:206
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:1479
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:1202
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
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:1076
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
H266RawSlice::ph_ref
void * ph_ref
RefStruct reference backing referred-to PH above.
Definition: cbs_h266.h:855
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
H266RawVUI
Definition: cbs_h266.h:211
H266RawSlice::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:854
DBParams::beta_offset
int beta_offset
Definition: hevcdec.h:350
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:351
SL_MAX_ID
@ SL_MAX_ID
Definition: ps.h:191
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
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:494
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:74
PredWeightTable
Definition: ps.h:137
VVCFrameParamSets::ph
VVCPH ph
Definition: ps.h:232
decode_ps
static int decode_ps(VVCParamSets *ps, AVCodecContext *c, const SliceContext *sc, int is_clvss)
Definition: ps.c:746
ph_vb
static int ph_vb(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps)
Definition: ps.c:949
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:776
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:791
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:2495
pps_free
static void pps_free(AVRefStructOpaque opaque, void *obj)
Definition: ps.c:691
decode_frame_ps
static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps, const SliceContext *sc, const int poc_tid0, const int is_clvss, const VVCContext *s)
Definition: ps.c:1002
alf_coeff_cc
static void alf_coeff_cc(int16_t *coeff, const uint8_t *mapped_abs, const uint8_t *sign)
Definition: ps.c:1107
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:828
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:921
is_luma_list
static int is_luma_list(const int id)
Definition: ps.c:1197
sh_partition_constraints
static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
Definition: ps.c:1404
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:3781
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: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:928
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:1176
decode_recovery_poc
static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
Definition: ps.c:1046
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
SliceContext
Definition: mss12.h:70
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
VVCLMCS::fwd_lut
union VVCLMCS::@332 fwd_lut
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
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:1183
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
SliceContext::ref
void * ref
RefStruct reference, backing slice data.
Definition: dec.h:119
sh_derive
static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
Definition: ps.c:1457
VVC_MAX_POINTS_IN_QP_TABLE
@ VVC_MAX_POINTS_IN_QP_TABLE
Definition: vvc.h:121
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:1100
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
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:837
pps_chroma_qp_offset
static void pps_chroma_qp_offset(VVCPPS *pps)
Definition: ps.c:309
SL_START_4x4
@ SL_START_4x4
Definition: ps.h:186
CR
#define CR
Definition: filter.c:33
pps_derive
static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
Definition: ps.c:670
H266RawSlice::pps
H266RawPPS * pps
RefStruct reference to referred-to PPS.
Definition: cbs_h266.h:853
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:1306
scaling_derive
static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
Definition: ps.c:1208
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
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:1283
SL_START_64x64
@ SL_START_64x64
Definition: ps.h:190
av_always_inline
#define av_always_inline
Definition: attributes.h:63
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:804
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:1038
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:1086
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
VVC_MAX_SAMPLE_ARRAYS
@ VVC_MAX_SAMPLE_ARRAYS
Definition: vvc.h:77
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:1118
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:968
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:1150
pps_bd
static int pps_bd(VVCPPS *pps)
Definition: ps.c:346
desc
const char * desc
Definition: libsvtav1.c:79
H266RawSlice::sps
H266RawSPS * sps
RefStruct reference to referred-to SPS.
Definition: cbs_h266.h:852
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
sps_free
static void sps_free(AVRefStructOpaque opaque, void *obj)
Definition: ps.c:253
VVCFrameContext
Definition: dec.h:122
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:1390
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
SL_START_16x16
@ SL_START_16x16
Definition: ps.h:188
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:1134
VBFS
#define VBFS(c, d)
Definition: ps.c:947
sh_entry_points
static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1440
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:3802
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
H266RawSlice
Definition: cbs_h266.h:843
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 Tue Oct 14 2025 19:21:57 for FFmpeg by   doxygen 1.8.17