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