FFmpeg
cbs_h266_syntax_template.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 static int FUNC(rbsp_trailing_bits) (CodedBitstreamContext *ctx,
20  RWContext *rw)
21 {
22  int err;
23 
24  fixed(1, rbsp_stop_one_bit, 1);
25  while (byte_alignment(rw) != 0)
26  fixed(1, rbsp_alignment_zero_bit, 0);
27  return 0;
28 }
29 
30 static int FUNC(nal_unit_header) (CodedBitstreamContext *ctx, RWContext *rw,
31  H266RawNALUnitHeader *current,
32  int expected_nal_unit_type)
33 {
34  int err;
35 
36  fixed(1, forbidden_zero_bit, 0);
37  flag(nuh_reserved_zero_bit);
38 
39  u(6, nuh_layer_id, 0, 55);
40 
41  if (expected_nal_unit_type >= 0)
42  u(5, nal_unit_type, expected_nal_unit_type, expected_nal_unit_type);
43  else
44  ub(5, nal_unit_type);
45 
46  u(3, nuh_temporal_id_plus1, 1, 7);
47  return 0;
48 }
49 
50 static int FUNC(byte_alignment) (CodedBitstreamContext *ctx, RWContext *rw)
51 {
52  int err;
53 
54  fixed(1, byte_alignment_bit_equal_to_one, 1);
55  while (byte_alignment(rw) != 0)
56  fixed(1, byte_alignment_bit_equal_to_zero, 0);
57  return 0;
58 }
59 
60 static int FUNC(general_constraints_info) (CodedBitstreamContext *ctx,
61  RWContext *rw,
62  H266GeneralConstraintsInfo *current)
63 {
64  int err, i, num_additional_bits_used;
65 
66  flag(gci_present_flag);
67  if (current->gci_present_flag) {
68  /* general */
69  flag(gci_intra_only_constraint_flag);
70  flag(gci_all_layers_independent_constraint_flag);
71  flag(gci_one_au_only_constraint_flag);
72 
73  /* picture format */
74  u(4, gci_sixteen_minus_max_bitdepth_constraint_idc, 0, 8);
75  ub(2, gci_three_minus_max_chroma_format_constraint_idc);
76 
77  /* NAL unit type related */
78  flag(gci_no_mixed_nalu_types_in_pic_constraint_flag);
79  flag(gci_no_trail_constraint_flag);
80  flag(gci_no_stsa_constraint_flag);
81  flag(gci_no_rasl_constraint_flag);
82  flag(gci_no_radl_constraint_flag);
83  flag(gci_no_idr_constraint_flag);
84  flag(gci_no_cra_constraint_flag);
85  flag(gci_no_gdr_constraint_flag);
86  flag(gci_no_aps_constraint_flag);
87  flag(gci_no_idr_rpl_constraint_flag);
88 
89  /* tile, slice, subpicture partitioning */
90  flag(gci_one_tile_per_pic_constraint_flag);
91  flag(gci_pic_header_in_slice_header_constraint_flag);
92  flag(gci_one_slice_per_pic_constraint_flag);
93  flag(gci_no_rectangular_slice_constraint_flag);
94  flag(gci_one_slice_per_subpic_constraint_flag);
95  flag(gci_no_subpic_info_constraint_flag);
96 
97  /* CTU and block partitioning */
98  ub(2, gci_three_minus_max_log2_ctu_size_constraint_idc);
99  flag(gci_no_partition_constraints_override_constraint_flag);
100  flag(gci_no_mtt_constraint_flag);
101  flag(gci_no_qtbtt_dual_tree_intra_constraint_flag);
102 
103  /* intra */
104  flag(gci_no_palette_constraint_flag);
105  flag(gci_no_ibc_constraint_flag);
106  flag(gci_no_isp_constraint_flag);
107  flag(gci_no_mrl_constraint_flag);
108  flag(gci_no_mip_constraint_flag);
109  flag(gci_no_cclm_constraint_flag);
110 
111  /* inter */
112  flag(gci_no_ref_pic_resampling_constraint_flag);
113  flag(gci_no_res_change_in_clvs_constraint_flag);
114  flag(gci_no_weighted_prediction_constraint_flag);
115  flag(gci_no_ref_wraparound_constraint_flag);
116  flag(gci_no_temporal_mvp_constraint_flag);
117  flag(gci_no_sbtmvp_constraint_flag);
118  flag(gci_no_amvr_constraint_flag);
119  flag(gci_no_bdof_constraint_flag);
120  flag(gci_no_smvd_constraint_flag);
121  flag(gci_no_dmvr_constraint_flag);
122  flag(gci_no_mmvd_constraint_flag);
123  flag(gci_no_affine_motion_constraint_flag);
124  flag(gci_no_prof_constraint_flag);
125  flag(gci_no_bcw_constraint_flag);
126  flag(gci_no_ciip_constraint_flag);
127  flag(gci_no_gpm_constraint_flag);
128 
129  /* transform, quantization, residual */
130  flag(gci_no_luma_transform_size_64_constraint_flag);
131  flag(gci_no_transform_skip_constraint_flag);
132  flag(gci_no_bdpcm_constraint_flag);
133  flag(gci_no_mts_constraint_flag);
134  flag(gci_no_lfnst_constraint_flag);
135  flag(gci_no_joint_cbcr_constraint_flag);
136  flag(gci_no_sbt_constraint_flag);
137  flag(gci_no_act_constraint_flag);
138  flag(gci_no_explicit_scaling_list_constraint_flag);
139  flag(gci_no_dep_quant_constraint_flag);
140  flag(gci_no_sign_data_hiding_constraint_flag);
141  flag(gci_no_cu_qp_delta_constraint_flag);
142  flag(gci_no_chroma_qp_offset_constraint_flag);
143 
144  /* loop filter */
145  flag(gci_no_sao_constraint_flag);
146  flag(gci_no_alf_constraint_flag);
147  flag(gci_no_ccalf_constraint_flag);
148  flag(gci_no_lmcs_constraint_flag);
149  flag(gci_no_ladf_constraint_flag);
150  flag(gci_no_virtual_boundaries_constraint_flag);
151  ub(8, gci_num_additional_bits);
152  if (current->gci_num_additional_bits > 5) {
153  flag(gci_all_rap_pictures_constraint_flag);
154  flag(gci_no_extended_precision_processing_constraint_flag);
155  flag(gci_no_ts_residual_coding_rice_constraint_flag);
156  flag(gci_no_rrc_rice_extension_constraint_flag);
157  flag(gci_no_persistent_rice_adaptation_constraint_flag);
158  flag(gci_no_reverse_last_sig_coeff_constraint_flag);
159  num_additional_bits_used = 6;
160  } else {
161  infer(gci_all_rap_pictures_constraint_flag, 0);
162  infer(gci_no_extended_precision_processing_constraint_flag, 0);
163  infer(gci_no_ts_residual_coding_rice_constraint_flag, 0);
164  infer(gci_no_rrc_rice_extension_constraint_flag, 0);
165  infer(gci_no_persistent_rice_adaptation_constraint_flag, 0);
166  infer(gci_no_reverse_last_sig_coeff_constraint_flag, 0);
167  num_additional_bits_used = 0;
168  }
169 
170  for (i = 0; i < current->gci_num_additional_bits - num_additional_bits_used; i++)
171  flags(gci_reserved_bit[i], 1, i);
172  }
173  while (byte_alignment(rw) != 0)
174  fixed(1, gci_alignment_zero_bit, 0);
175  return 0;
176 }
177 
178 static int FUNC(profile_tier_level) (CodedBitstreamContext *ctx,
179  RWContext *rw,
180  H266RawProfileTierLevel *current,
181  int profile_tier_present_flag,
182  int max_num_sub_layers_minus1)
183 {
184  int err, i;
185 
186  if (profile_tier_present_flag) {
187  ub(7, general_profile_idc);
188  flag(general_tier_flag);
189  }
190  ub(8, general_level_idc);
191  flag(ptl_frame_only_constraint_flag);
192  flag(ptl_multilayer_enabled_flag);
193  if (profile_tier_present_flag) {
194  CHECK(FUNC(general_constraints_info) (ctx, rw,
195  &current->
196  general_constraints_info));
197  }
198  for (i = max_num_sub_layers_minus1 - 1; i >= 0; i--)
199  flags(ptl_sublayer_level_present_flag[i], 1, i);
200  while (byte_alignment(rw) != 0)
201  flag(ptl_reserved_zero_bit);
202  for (i = max_num_sub_layers_minus1 - 1; i >= 0; i--)
203  if (current->ptl_sublayer_level_present_flag[i])
204  ubs(8, sublayer_level_idc[i], 1, i);
205  if (profile_tier_present_flag) {
206  ub(8, ptl_num_sub_profiles);
207  for (i = 0; i < current->ptl_num_sub_profiles; i++)
208  ubs(32, general_sub_profile_idc[i], 1, i);
209  }
210  return 0;
211 }
212 
213 static int FUNC(vui_parameters_default) (CodedBitstreamContext *ctx,
214  RWContext *rw, H266RawVUI *current)
215 {
216  //defined in D.8
217  infer(vui_progressive_source_flag, 0);
218  infer(vui_interlaced_source_flag, 0);
219 
220  infer(vui_non_packed_constraint_flag, 0);
221  infer(vui_non_projected_constraint_flag, 0);
222 
223  infer(vui_aspect_ratio_constant_flag, 0);
224  infer(vui_aspect_ratio_idc, 0);
225 
226  infer(vui_overscan_info_present_flag, 0);
227 
228  infer(vui_colour_primaries, 2);
229  infer(vui_transfer_characteristics, 2);
230  infer(vui_matrix_coeffs, 2);
231  infer(vui_full_range_flag, 0);
232 
233  infer(vui_chroma_sample_loc_type_frame, 6);
234  infer(vui_chroma_sample_loc_type_top_field, 6);
235  infer(vui_chroma_sample_loc_type_bottom_field, 6);
236  return 0;
237 }
238 
239 static int FUNC(vui_parameters) (CodedBitstreamContext *ctx, RWContext *rw,
240  H266RawVUI *current,
241  uint8_t chroma_format_idc)
242 {
243  int err;
244 
245  flag(vui_progressive_source_flag);
246  flag(vui_interlaced_source_flag);
247  flag(vui_non_packed_constraint_flag);
248  flag(vui_non_projected_constraint_flag);
249  flag(vui_aspect_ratio_info_present_flag);
250  if (current->vui_aspect_ratio_info_present_flag) {
251  flag(vui_aspect_ratio_constant_flag);
252  ub(8, vui_aspect_ratio_idc);
253  if (current->vui_aspect_ratio_idc == 255) {
254  ub(16, vui_sar_width);
255  ub(16, vui_sar_height);
256  }
257  } else {
258  infer(vui_aspect_ratio_constant_flag, 0);
259  infer(vui_aspect_ratio_idc, 0);
260  }
261  flag(vui_overscan_info_present_flag);
262  if (current->vui_overscan_info_present_flag)
263  flag(vui_overscan_appropriate_flag);
264  flag(vui_colour_description_present_flag);
265  if (current->vui_colour_description_present_flag) {
266  ub(8, vui_colour_primaries);
267  av_log(ctx->log_ctx, AV_LOG_DEBUG, "vui_colour_primaries == %d \n",
268  current->vui_colour_primaries);
269  ub(8, vui_transfer_characteristics);
270  av_log(ctx->log_ctx, AV_LOG_DEBUG,
271  "vui_transfer_characteristics == %d \n",
272  current->vui_transfer_characteristics);
273  ub(8, vui_matrix_coeffs);
274  av_log(ctx->log_ctx, AV_LOG_DEBUG, "vui_matrix_coeffs == %d \n",
275  current->vui_matrix_coeffs);
276  flag(vui_full_range_flag);
277  } else {
278  infer(vui_colour_primaries, 2);
279  infer(vui_transfer_characteristics, 2);
280  infer(vui_matrix_coeffs, 2);
281  infer(vui_full_range_flag, 0);
282  }
283  flag(vui_chroma_loc_info_present_flag);
284  if (chroma_format_idc != 1 && current->vui_chroma_loc_info_present_flag) {
285  av_log(ctx->log_ctx, AV_LOG_ERROR, "chroma_format_idc == %d,"
286  "vui_chroma_loc_info_present_flag can't not be true",
287  chroma_format_idc);
288  return AVERROR_INVALIDDATA;
289  }
290  if (current->vui_chroma_loc_info_present_flag) {
291  if (current->vui_progressive_source_flag &&
292  !current->vui_interlaced_source_flag) {
293  ue(vui_chroma_sample_loc_type_frame, 0, 6);
294  } else {
295  ue(vui_chroma_sample_loc_type_top_field, 0, 6);
296  ue(vui_chroma_sample_loc_type_bottom_field, 0, 6);
297  }
298  } else {
299  if (chroma_format_idc == 1) {
300  infer(vui_chroma_sample_loc_type_frame, 6);
301  infer(vui_chroma_sample_loc_type_top_field,
302  current->vui_chroma_sample_loc_type_frame);
303  infer(vui_chroma_sample_loc_type_bottom_field,
304  current->vui_chroma_sample_loc_type_frame);
305  }
306  }
307  return 0;
308 }
309 
310 static int FUNC(payload_extension) (CodedBitstreamContext *ctx, RWContext *rw,
311  H266RawExtensionData *current,
312  uint32_t payload_size, int cur_pos)
313 {
314  int err;
315  size_t byte_length, k;
316 
317 #ifdef READ
318  GetBitContext tmp;
319  int bits_left, payload_zero_bits;
320 
321  if (!cbs_h265_payload_extension_present(rw, payload_size, cur_pos))
322  return 0;
323 
324  bits_left = 8 * payload_size - cur_pos;
325  tmp = *rw;
326  if (bits_left > 8)
327  skip_bits_long(&tmp, bits_left - 8);
328  payload_zero_bits = get_bits(&tmp, FFMIN(bits_left, 8));
329  if (!payload_zero_bits)
330  return AVERROR_INVALIDDATA;
331  payload_zero_bits = ff_ctz(payload_zero_bits);
332  current->bit_length = bits_left - payload_zero_bits - 1;
333  allocate(current->data, (current->bit_length + 7) / 8);
334 #endif
335 
336  byte_length = (current->bit_length + 7) / 8;
337  for (k = 0; k < byte_length; k++) {
338  int length = FFMIN(current->bit_length - k * 8, 8);
339  xu(length, reserved_payload_extension_data, current->data[k],
340  0, MAX_UINT_BITS(length), 0);
341  }
342 
343  return 0;
344 }
345 
346 static int FUNC(vui_payload) (CodedBitstreamContext *ctx, RWContext *rw,
347  H266RawVUI *current, uint16_t vui_payload_size,
348  uint8_t chroma_format_idc)
349 {
350  int err;
351  int start_position, current_position;
352 
353  start_position = bit_position(rw);
354  CHECK(FUNC(vui_parameters) (ctx, rw, current, chroma_format_idc));
355  current_position = bit_position(rw) - start_position;
356 
357  if (current_position < 8 * vui_payload_size) {
358  CHECK(FUNC(payload_extension) (ctx, rw, &current->extension_data,
359  vui_payload_size, current_position));
360  fixed(1, vui_payload_bit_equal_to_one, 1);
361  while (byte_alignment(rw) != 0)
362  fixed(1, vui_payload_bit_equal_to_zero, 0);
363  }
364  return 0;
365 }
366 
367 static int FUNC(extension_data) (CodedBitstreamContext *ctx, RWContext *rw,
368  H266RawExtensionData *current)
369 {
370  int err;
371  size_t k;
372 #ifdef READ
373  GetBitContext start;
374  uint8_t bit;
375  start = *rw;
376  for (k = 0; cbs_h2645_read_more_rbsp_data(rw); k++)
377  skip_bits(rw, 1);
378  current->bit_length = k;
379  if (k > 0) {
380  *rw = start;
381  allocate(current->data, (current->bit_length + 7) / 8);
382  for (k = 0; k < current->bit_length; k++) {
383  xu(1, extension_data, bit, 0, 1, 0);
384  current->data[k / 8] |= bit << (7 - k % 8);
385  }
386  }
387 #else
388  for (k = 0; k < current->bit_length; k++)
389  xu(1, extension_data, current->data[k / 8] >> (7 - k % 8) & 1, 0, 1, 0);
390 #endif
391  return 0;
392 }
393 
394 static int FUNC(dpb_parameters) (CodedBitstreamContext *ctx, RWContext *rw,
395  H266DpbParameters *current,
396  uint8_t max_sublayers_minus1,
397  uint8_t sublayer_info_flag)
398 {
399  int err, i;
400  for (i = (sublayer_info_flag ? 0 : max_sublayers_minus1);
401  i <= max_sublayers_minus1; i++) {
402  ues(dpb_max_dec_pic_buffering_minus1[i], 0, VVC_MAX_DPB_SIZE - 1, 1, i);
403  ues(dpb_max_num_reorder_pics[i],
404  0, current->dpb_max_dec_pic_buffering_minus1[i], 1, i);
405  ues(dpb_max_latency_increase_plus1[i], 0, UINT32_MAX - 1, 1, i);
406  }
407  return 0;
408 }
409 
410 static int FUNC(ref_pic_list_struct) (CodedBitstreamContext *ctx,
411  RWContext *rw,
412  H266RefPicListStruct *current,
413  uint8_t list_idx, uint8_t rpls_idx,
414  const H266RawSPS *sps)
415 {
416  CodedBitstreamH266Context *h266 = ctx->priv_data;
417  int err, i, j, general_layer_idx = -1, num_direct_ref_layers = 0;
418  const H266RawVPS *vps = h266->vps[sps->sps_video_parameter_set_id];
419 
420  if (!vps) {
421  av_log(ctx->log_ctx, AV_LOG_ERROR,
422  "VPS id %d not available.\n", sps->sps_video_parameter_set_id);
423  return AVERROR_INVALIDDATA;
424  }
425  //7.4.3.3 (29)
426  for (i = 0; i <= vps->vps_max_layers_minus1; i++) {
427  if (sps->nal_unit_header.nuh_layer_id == vps->vps_layer_id[i]) {
428  general_layer_idx = i;
429  break;
430  }
431  }
432  if (general_layer_idx < 0) {
433  av_log(ctx->log_ctx, AV_LOG_ERROR, "vps_layer_id %d not available.\n",
434  sps->nal_unit_header.nuh_layer_id);
435  return AVERROR_INVALIDDATA;
436  }
437  //7.4.3.3 (28)
438  for (j = 0; j <= vps->vps_max_layers_minus1; j++) {
439  if (vps->vps_direct_ref_layer_flag[general_layer_idx][j])
440  num_direct_ref_layers++;
441  }
442 
443  ue(num_ref_entries, 0, VVC_MAX_REF_ENTRIES);
444  if (sps->sps_long_term_ref_pics_flag &&
445  rpls_idx < sps->sps_num_ref_pic_lists[list_idx] &&
446  current->num_ref_entries > 0)
447  flag(ltrp_in_header_flag);
448  if (sps->sps_long_term_ref_pics_flag &&
449  rpls_idx == sps->sps_num_ref_pic_lists[list_idx])
450  infer(ltrp_in_header_flag, 1);
451  for (i = 0, j = 0; i < current->num_ref_entries; i++) {
452  if (sps->sps_inter_layer_prediction_enabled_flag)
453  flags(inter_layer_ref_pic_flag[i], 1, i);
454  else
455  infer(inter_layer_ref_pic_flag[i], 0);
456 
457  if (!current->inter_layer_ref_pic_flag[i]) {
458  if (sps->sps_long_term_ref_pics_flag)
459  flags(st_ref_pic_flag[i], 1, i);
460  else
461  infer(st_ref_pic_flag[i], 1);
462  if (current->st_ref_pic_flag[i]) {
463  int abs_delta_poc_st;
464  ues(abs_delta_poc_st[i], 0, MAX_UINT_BITS(15), 1, i);
465  if ((sps->sps_weighted_pred_flag ||
466  sps->sps_weighted_bipred_flag) && i != 0)
467  abs_delta_poc_st = current->abs_delta_poc_st[i];
468  else
469  abs_delta_poc_st = current->abs_delta_poc_st[i] + 1;
470  if (abs_delta_poc_st > 0)
471  flags(strp_entry_sign_flag[i], 1, i);
472  } else {
473  if (!current->ltrp_in_header_flag) {
474  uint8_t bits = sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4;
475  ubs(bits, rpls_poc_lsb_lt[j], 1, j);
476  j++;
477  }
478  }
479  } else {
480  if (num_direct_ref_layers == 0) {
481  av_log(ctx->log_ctx, AV_LOG_ERROR,
482  "num_direct_ref_layers needs > 0.\n");
483  return AVERROR_INVALIDDATA;
484  }
485  ues(ilrp_idx[i], 0, num_direct_ref_layers - 1, 1, i);
486  }
487  }
488  return 0;
489 }
490 
491 static int FUNC(ref_pic_lists) (CodedBitstreamContext *ctx, RWContext *rw,
492  const H266RawSPS *sps, const H266RawPPS *pps,
493  H266RefPicLists *current) {
494  const H266RefPicListStruct * ref_list;
495  int err, i, j, num_ltrp_entries;
496  for (i = 0; i < 2; i++) {
497  if (sps->sps_num_ref_pic_lists[i] > 0 &&
498  (i == 0 || (i == 1 && pps->pps_rpl1_idx_present_flag))) {
499  flags(rpl_sps_flag[i], 1, i);
500  } else {
501  if (sps->sps_num_ref_pic_lists[i] == 0) {
502  infer(rpl_sps_flag[i], 0);
503  } else {
504  if (!pps->pps_rpl1_idx_present_flag && i == 1)
505  infer(rpl_sps_flag[1], current->rpl_sps_flag[0]);
506  }
507  }
508  if (current->rpl_sps_flag[i]) {
509  if (sps->sps_num_ref_pic_lists[i] > 1 &&
510  (i == 0 || (i == 1 && pps->pps_rpl1_idx_present_flag))) {
511  uint8_t bits = av_ceil_log2(sps->sps_num_ref_pic_lists[i]);
512  us(bits, rpl_idx[i], 0, sps->sps_num_ref_pic_lists[i] - 1, 1, i);
513  } else if (sps->sps_num_ref_pic_lists[i] == 1) {
514  infer(rpl_idx[i], 0);
515  } else if (i == 1 && !pps->pps_rpl1_idx_present_flag) {
516  infer(rpl_idx[1], current->rpl_idx[0]);
517  } else {
518  //how to handle this? or never happpend?
519  av_log(ctx->log_ctx, AV_LOG_ERROR,
520  "can't infer the rpl_idx[i]\n");
521  return AVERROR_PATCHWELCOME;
522  }
523  memcpy(&current->rpl_ref_list[i],
524  &sps->sps_ref_pic_list_struct[i][current->rpl_idx[i]],
525  sizeof(current->rpl_ref_list[i]));
526  } else {
527  CHECK(FUNC(ref_pic_list_struct) (ctx, rw, &current->rpl_ref_list[i],
528  i, sps->sps_num_ref_pic_lists[i],
529  sps));
530  }
531  ref_list = &current->rpl_ref_list[i];
532 
533  num_ltrp_entries = 0;
534  for (int k = 0; k < ref_list->num_ref_entries; k++) {
535  if (!ref_list->inter_layer_ref_pic_flag[k]) {
536  if (!ref_list->st_ref_pic_flag[k]) {
537  num_ltrp_entries++;
538  }
539  }
540  }
541 
542  for (j = 0; j < num_ltrp_entries; j++) {
543  if (ref_list->ltrp_in_header_flag) {
544  ubs(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4,
545  poc_lsb_lt[i][j], 2, i, j);
546  }
547  flags(delta_poc_msb_cycle_present_flag[i][j], 2, i, j);
548  if (current->delta_poc_msb_cycle_present_flag[i][j]) {
549  uint32_t max =
550  1 << (32 - sps->sps_log2_max_pic_order_cnt_lsb_minus4 - 4);
551  ues(delta_poc_msb_cycle_lt[i][j], 0, max, 2, i, j);
552  }
553  }
554  }
555  return 0;
556 }
557 
558 static int FUNC(general_timing_hrd_parameters)(CodedBitstreamContext *ctx,
559  RWContext *rw,
560  H266RawGeneralTimingHrdParameters *current)
561 {
562  int err;
563  ub(32, num_units_in_tick);
564  u(32, time_scale, 1, MAX_UINT_BITS(32));
565  flag(general_nal_hrd_params_present_flag);
566  flag(general_vcl_hrd_params_present_flag);
567 
568  if (current->general_nal_hrd_params_present_flag ||
569  current->general_vcl_hrd_params_present_flag) {
570  flag(general_same_pic_timing_in_all_ols_flag);
571  flag(general_du_hrd_params_present_flag);
572  if (current->general_du_hrd_params_present_flag)
573  ub(8, tick_divisor_minus2);
574  ub(4, bit_rate_scale);
575  ub(4, cpb_size_scale);
576  if (current->general_du_hrd_params_present_flag)
577  ub(4, cpb_size_du_scale);
578  ue(hrd_cpb_cnt_minus1, 0, 31);
579  } else {
580  //infer general_same_pic_timing_in_all_ols_flag?
581  infer(general_du_hrd_params_present_flag, 0);
582  }
583  return 0;
584 }
585 
586 static int FUNC(sublayer_hrd_parameters) (CodedBitstreamContext *ctx,
587  RWContext *rw,
588  H266RawSubLayerHRDParameters *current,
589  int sublayer_id,
590  const H266RawGeneralTimingHrdParameters *general)
591 {
592  int err, i;
593  for (i = 0; i <= general->hrd_cpb_cnt_minus1; i++) {
594  ues(bit_rate_value_minus1[sublayer_id][i], 0, UINT32_MAX - 1, 2,
595  sublayer_id, i);
596  ues(cpb_size_value_minus1[sublayer_id][i], 0, UINT32_MAX - 1, 2,
597  sublayer_id, i);
598  if (general->general_du_hrd_params_present_flag) {
599  ues(cpb_size_du_value_minus1[sublayer_id][i],
600  0, UINT32_MAX - 1, 2, sublayer_id, i);
601  ues(bit_rate_du_value_minus1[sublayer_id][i],
602  0, UINT32_MAX - 1, 2, sublayer_id, i);
603  }
604  flags(cbr_flag[sublayer_id][i], 2, sublayer_id, i);
605  }
606  return 0;
607 }
608 
609 static int FUNC(ols_timing_hrd_parameters) (CodedBitstreamContext *ctx,
610  RWContext *rw, H266RawOlsTimingHrdParameters *current,
611  uint8_t first_sublayer, uint8_t max_sublayers_minus1,
612  const H266RawGeneralTimingHrdParameters *general)
613 {
614  int err, i;
615  for (i = first_sublayer; i <= max_sublayers_minus1; i++) {
616  flags(fixed_pic_rate_general_flag[i], 1, i);
617  if (!current->fixed_pic_rate_general_flag[i])
618  flags(fixed_pic_rate_within_cvs_flag[i], 1, i);
619  else
620  infer(fixed_pic_rate_within_cvs_flag[i], 1);
621  if (current->fixed_pic_rate_within_cvs_flag[i]) {
622  ues(elemental_duration_in_tc_minus1[i], 0, 2047, 1, i);
623  infer(low_delay_hrd_flag[i], 0);
624  } else if ((general->general_nal_hrd_params_present_flag ||
625  general->general_vcl_hrd_params_present_flag) &&
626  general->hrd_cpb_cnt_minus1 == 0) {
627  flags(low_delay_hrd_flag[i], 1, i);
628  } else {
629  infer(low_delay_hrd_flag[i], 0);
630  }
631  if (general->general_nal_hrd_params_present_flag)
632  CHECK(FUNC(sublayer_hrd_parameters) (ctx, rw,
633  &current->nal_sub_layer_hrd_parameters,
634  i, general));
635  if (general->general_vcl_hrd_params_present_flag)
636  CHECK(FUNC(sublayer_hrd_parameters) (ctx, rw,
637  &current->nal_sub_layer_hrd_parameters,
638  i, general));
639  }
640  return 0;
641 }
642 
643 static int FUNC(opi)(CodedBitstreamContext *ctx, RWContext *rw,
644  H266RawOPI *current)
645 {
646  int err;
647 
648  HEADER("Operating point information");
649 
650  CHECK(FUNC(nal_unit_header)(ctx, rw,
651  &current->nal_unit_header, VVC_OPI_NUT));
652 
653  flag(opi_ols_info_present_flag);
654  flag(opi_htid_info_present_flag);
655 
656  if(current->opi_ols_info_present_flag)
657  ue(opi_ols_idx, 0, VVC_MAX_TOTAL_NUM_OLSS - 1);
658 
659  if(current->opi_htid_info_present_flag)
660  ub(3, opi_htid_plus1);
661 
662  flag(opi_extension_flag);
663  if (current->opi_extension_flag)
664  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
665  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
666 
667  return 0;
668 }
669 
670 static int FUNC(dci)(CodedBitstreamContext *ctx, RWContext *rw,
671  H266RawDCI *current)
672 {
673  int err, i;
674 
675  HEADER("Decoding capability information");
676 
677  CHECK(FUNC(nal_unit_header)(ctx, rw,
678  &current->nal_unit_header, VVC_DCI_NUT));
679 
680  ub(4, dci_reserved_zero_4bits);
681  ub(4, dci_num_ptls_minus1);
682  for (i = 0; i <= current->dci_num_ptls_minus1; i++)
683  CHECK(FUNC(profile_tier_level)(ctx, rw,
684  current->dci_profile_tier_level + i, 1, 0));
685 
686  flag(dci_extension_flag);
687  if (current->dci_extension_flag)
688  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
689  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
690 
691  return 0;
692 }
693 
694 static int FUNC(vps) (CodedBitstreamContext *ctx, RWContext *rw,
695  H266RawVPS *current)
696 {
697  int err, i, j, k;
698  uint16_t total_num_olss = 0;
699  uint8_t ols_mode_idc = 0;
700  uint16_t num_multi_layer_olss = 0;
701  uint8_t layer_included_in_ols_flag[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_LAYERS];
702  uint8_t num_ref_layers[VVC_MAX_LAYERS];
703  uint8_t reference_layer_idx[VVC_MAX_LAYERS][VVC_MAX_LAYERS];
704 
705  HEADER("Video Parameter Set");
706 
707  CHECK(FUNC(nal_unit_header) (ctx, rw,
708  &current->nal_unit_header, VVC_VPS_NUT));
709 
710  u(4, vps_video_parameter_set_id, 1, VVC_MAX_VPS_COUNT - 1);
711  ub(6, vps_max_layers_minus1);
712  u(3, vps_max_sublayers_minus1, 0, 6);
713  if (current->vps_max_layers_minus1 > 0
714  && current->vps_max_sublayers_minus1 > 0)
715  flag(vps_default_ptl_dpb_hrd_max_tid_flag);
716  else
717  infer(vps_default_ptl_dpb_hrd_max_tid_flag, 1);
718 
719  if (current->vps_max_layers_minus1 > 0)
720  flag(vps_all_independent_layers_flag);
721  else
722  infer(vps_all_independent_layers_flag, 1);
723 
724  for (i = 0; i <= current->vps_max_layers_minus1; i++) {
725  ubs(6, vps_layer_id[i], 1, i);
726  if (i > 0 && current->vps_layer_id[i] <= current->vps_layer_id[i - 1]) {
727  av_log(ctx->log_ctx, AV_LOG_ERROR,
728  "vps_layer_id[%d](%d) should > vps_layer_id[%d](%d).\n",
729  i, current->vps_layer_id[i], i - 1,
730  current->vps_layer_id[i - 1]);
731  return AVERROR_INVALIDDATA;
732  }
733  if (i > 0 && !current->vps_all_independent_layers_flag) {
734  flags(vps_independent_layer_flag[i], 1, i);
735  if (!current->vps_independent_layer_flag[i]) {
736  flags(vps_max_tid_ref_present_flag[i], 1, i);
737  for (j = 0; j < i; j++) {
738  flags(vps_direct_ref_layer_flag[i][j], 2, i, j);
739  if (current->vps_max_tid_ref_present_flag[i] &&
740  current->vps_direct_ref_layer_flag[i][j]) {
741  ubs(3, vps_max_tid_il_ref_pics_plus1[i][j], 2, i, j);
742  } else {
743  infer(vps_max_tid_il_ref_pics_plus1[i][j],
744  current->vps_max_sublayers_minus1 + 1);
745  }
746  }
747  } else {
748  for (j = 0; j < i; j++) {
749  infer(vps_direct_ref_layer_flag[i][j], 0);
750  }
751  }
752  } else {
753  infer(vps_independent_layer_flag[i], 1);
754  for (j = 0; j < i; j++) {
755  infer(vps_direct_ref_layer_flag[i][j], 0);
756  }
757  }
758  }
759 
760  if (current->vps_max_layers_minus1 > 0) {
761  if (current->vps_all_independent_layers_flag)
762  flag(vps_each_layer_is_an_ols_flag);
763  else
764  infer(vps_each_layer_is_an_ols_flag, 0);
765  if (!current->vps_each_layer_is_an_ols_flag) {
766  if (!current->vps_all_independent_layers_flag)
767  ub(2, vps_ols_mode_idc);
768  else
769  infer(vps_ols_mode_idc, 2);
770  if (current->vps_ols_mode_idc == 2) {
771  ub(8, vps_num_output_layer_sets_minus2);
772  for (i = 1; i <= current->vps_num_output_layer_sets_minus2 + 1;
773  i++)
774  for (j = 0; j <= current->vps_max_layers_minus1; j++)
775  flags(vps_ols_output_layer_flag[i][j], 2, i, j);
776  }
777  ols_mode_idc = current->vps_ols_mode_idc;
778  } else {
779  ols_mode_idc = 4;
780  }
781  if (ols_mode_idc == 4 || ols_mode_idc == 0 || ols_mode_idc == 1)
782  total_num_olss = current->vps_max_layers_minus1 + 1;
783  else if (ols_mode_idc == 2)
784  total_num_olss = current->vps_num_output_layer_sets_minus2 + 2;
785  else
786  av_log(ctx->log_ctx, AV_LOG_ERROR,
787  "ols_mode_idc == 3, patch welcome");
788  u(8, vps_num_ptls_minus1, 0, total_num_olss - 1);
789  } else {
790  infer(vps_each_layer_is_an_ols_flag, 1);
791  infer(vps_num_ptls_minus1, 0);
792  }
793 
794  for (i = 0; i <= current->vps_num_ptls_minus1; i++) {
795  if (i > 0)
796  flags(vps_pt_present_flag[i], 1, i);
797  else
798  infer(vps_pt_present_flag[i], 1);
799 
800  if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
801  us(3, vps_ptl_max_tid[i], 0, current->vps_max_sublayers_minus1, 1, i);
802  else
803  infer(vps_ptl_max_tid[i], current->vps_max_sublayers_minus1);
804  }
805  while (byte_alignment(rw) != 0)
806  fixed(1, vps_ptl_alignment_zero_bit, 0);
807 
808  {
809  //calc NumMultiLayerOlss
810  int m;
811  uint8_t dependency_flag[VVC_MAX_LAYERS][VVC_MAX_LAYERS];
812  uint16_t num_output_layers_in_ols[VVC_MAX_TOTAL_NUM_OLSS];
813  uint8_t num_sub_layers_in_layer_in_ols[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_TOTAL_NUM_OLSS];
814  uint8_t output_layer_idx[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_LAYERS];
815 
816  //7.4.3.3 vps_direct_ref_layer_flag section
817  for (i = 0; i <= current->vps_max_layers_minus1; i++) {
818  for (j = 0; j <= current->vps_max_layers_minus1; j++) {
819  dependency_flag[i][j] = current->vps_direct_ref_layer_flag[i][j];
820  for (k = 0; k < i; k++) {
821  if (current->vps_direct_ref_layer_flag[i][k] &&
822  dependency_flag[k][j])
823  dependency_flag[i][j] = 1;
824  }
825  }
826  }
827  for (i = 0; i <= current->vps_max_layers_minus1; i++) {
828  int r;
829  for (j = 0, r = 0; j <= current->vps_max_layers_minus1; j++) {
830  if (dependency_flag[i][j])
831  reference_layer_idx[i][r++] = j;
832  }
833  num_ref_layers[i] = r;
834  }
835 
836  //7.4.3.3 vps_ols_output_layer_flag section
837  num_output_layers_in_ols[0] = 1;
838  num_sub_layers_in_layer_in_ols[0][0] =
839  current->vps_ptl_max_tid[current->vps_ols_ptl_idx[0]] + 1;
840  for (i = 1; i < total_num_olss; i++) {
841  if (ols_mode_idc == 4 || ols_mode_idc == 0) {
842  num_output_layers_in_ols[i] = 1;
843  if (current->vps_each_layer_is_an_ols_flag) {
844  num_sub_layers_in_layer_in_ols[i][0] =
845  current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
846  } else {
847  num_sub_layers_in_layer_in_ols[i][i] =
848  current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
849  for (k = i - 1; k >= 0; k--) {
850  num_sub_layers_in_layer_in_ols[i][k] = 0;
851  for (m = k + 1; m <= i; m++) {
852  uint8_t max_sublayer_needed =
853  FFMIN(num_sub_layers_in_layer_in_ols[i][m],
854  current->vps_max_tid_il_ref_pics_plus1[m][k]);
855  if (current->vps_direct_ref_layer_flag[m][k] &&
856  num_sub_layers_in_layer_in_ols[i][k] < max_sublayer_needed)
857  num_sub_layers_in_layer_in_ols[i][k] = max_sublayer_needed;
858  }
859  }
860  }
861  } else if (current->vps_ols_mode_idc == 1) {
862  num_output_layers_in_ols[i] = i + 1;
863  for (j = 0; j < num_output_layers_in_ols[i]; j++) {
864  num_sub_layers_in_layer_in_ols[i][j] =
865  current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
866  }
867  } else if (current->vps_ols_mode_idc == 2) {
868  uint8_t highest_included_layer = 0;
869  for (j = 0; j <= current->vps_max_layers_minus1; j++) {
870  layer_included_in_ols_flag[i][j] = 0;
871  num_sub_layers_in_layer_in_ols[i][j] = 0;
872  }
873  for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++) {
874  if (current->vps_ols_output_layer_flag[i][k]) {
875  layer_included_in_ols_flag[i][k] = 1;
876  highest_included_layer = k;
877  output_layer_idx[i][j] = k;
878  num_sub_layers_in_layer_in_ols[i][k] =
879  current->vps_ptl_max_tid[current->
880  vps_ols_ptl_idx[i]] + 1;
881  j++;
882  }
883  }
884  num_output_layers_in_ols[i] = j;
885  for (j = 0; j < num_output_layers_in_ols[i]; j++) {
886  int idx = output_layer_idx[i][j];
887  for (k = 0; k < num_ref_layers[idx]; k++) {
888  if (!layer_included_in_ols_flag[i][reference_layer_idx[idx][k]])
889  layer_included_in_ols_flag[i][reference_layer_idx[idx][k]] = 1;
890  }
891  }
892  for (k = highest_included_layer - 1; k >= 0; k--) {
893  if (layer_included_in_ols_flag[i][k] &&
894  !current->vps_ols_output_layer_flag[i][k]) {
895  for (m = k + 1; m <= highest_included_layer; m++) {
896  uint8_t max_sublayer_needed =
897  FFMIN(num_sub_layers_in_layer_in_ols[i][m],
898  current->vps_max_tid_il_ref_pics_plus1[m][k]);
899  if (current->vps_direct_ref_layer_flag[m][k] &&
900  layer_included_in_ols_flag[i][m] &&
901  num_sub_layers_in_layer_in_ols[i][k] <
902  max_sublayer_needed)
903  num_sub_layers_in_layer_in_ols[i][k] =
904  max_sublayer_needed;
905  }
906  }
907  }
908  }
909  if (!num_output_layers_in_ols[i])
910  return AVERROR_INVALIDDATA;
911  }
912  for (i = 1; i < total_num_olss; i++) {
913  int num_layers_in_ols = 0;
914  if (current->vps_each_layer_is_an_ols_flag) {
915  num_layers_in_ols = 1;
916  } else if (current->vps_ols_mode_idc == 0 ||
917  current->vps_ols_mode_idc == 1) {
918  num_layers_in_ols = i + 1;
919  } else if (current->vps_ols_mode_idc == 2) {
920  for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++)
921  if (layer_included_in_ols_flag[i][k])
922  j++;
923  num_layers_in_ols = j;
924  }
925  if (num_layers_in_ols > 1) {
926  num_multi_layer_olss++;
927  }
928  }
929  if (!current->vps_each_layer_is_an_ols_flag && num_multi_layer_olss == 0)
930  return AVERROR_INVALIDDATA;
931  }
932 
933  for (i = 0; i <= current->vps_num_ptls_minus1; i++) {
934  CHECK(FUNC(profile_tier_level) (ctx, rw,
935  current->vps_profile_tier_level + i,
936  current->vps_pt_present_flag[i],
937  current->vps_ptl_max_tid[i]));
938  }
939  for (i = 0; i < total_num_olss; i++) {
940  if (current->vps_num_ptls_minus1 > 0 &&
941  current->vps_num_ptls_minus1 + 1 != total_num_olss) {
942  us(8, vps_ols_ptl_idx[i], 0, current->vps_num_ptls_minus1, 1, i);
943  } else if (current->vps_num_ptls_minus1 == 0) {
944  infer(vps_ols_ptl_idx[i], 0);
945  } else {
946  infer(vps_ols_ptl_idx[i], i);
947  }
948  }
949 
950  if (!current->vps_each_layer_is_an_ols_flag) {
951  uint16_t vps_num_dpb_params;
952  ue(vps_num_dpb_params_minus1, 0, num_multi_layer_olss - 1);
953  if (current->vps_each_layer_is_an_ols_flag)
954  vps_num_dpb_params = 0;
955  else
956  vps_num_dpb_params = current->vps_num_dpb_params_minus1 + 1;
957 
958  if (current->vps_max_sublayers_minus1 > 0)
959  flag(vps_sublayer_dpb_params_present_flag);
960  else
961  infer(vps_sublayer_dpb_params_present_flag, 0);
962 
963  for (i = 0; i < vps_num_dpb_params; i++) {
964  if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
965  us(3, vps_dpb_max_tid[i], 0, current->vps_max_sublayers_minus1,
966  1, i);
967  else
968  infer(vps_dpb_max_tid[i], current->vps_max_sublayers_minus1);
969  CHECK(FUNC(dpb_parameters) (ctx, rw, current->vps_dpb_params + i,
970  current->vps_dpb_max_tid[i],
971  current->
972  vps_sublayer_dpb_params_present_flag));
973  }
974  for (i = 0; i < num_multi_layer_olss; i++) {
975  ues(vps_ols_dpb_pic_width[i], 0, UINT16_MAX, 1, i);
976  ues(vps_ols_dpb_pic_height[i], 0, UINT16_MAX, 1, i);
977  ubs(2, vps_ols_dpb_chroma_format[i], 1, i);
978  ues(vps_ols_dpb_bitdepth_minus8[i], 0, 8, 1, i);
979  if (vps_num_dpb_params > 1
980  && vps_num_dpb_params != num_multi_layer_olss)
981  ues(vps_ols_dpb_params_idx[i], 0, vps_num_dpb_params - 1, 1, i);
982  else if (vps_num_dpb_params == 1)
983  infer(vps_ols_dpb_params_idx[i], 0);
984  else
985  infer(vps_ols_dpb_params_idx[i], i);
986  }
987  flag(vps_timing_hrd_params_present_flag);
988  if (current->vps_timing_hrd_params_present_flag) {
989  CHECK(FUNC(general_timing_hrd_parameters) (ctx, rw,
990  &current->
991  vps_general_timing_hrd_parameters));
992  if (current->vps_max_sublayers_minus1 > 0)
993  flag(vps_sublayer_cpb_params_present_flag);
994  else
995  infer(vps_sublayer_cpb_params_present_flag, 0);
996  ue(vps_num_ols_timing_hrd_params_minus1, 0,
997  num_multi_layer_olss - 1);
998  for (i = 0; i <= current->vps_num_ols_timing_hrd_params_minus1; i++) {
999  uint8_t first_sublayer;
1000  if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
1001  us(3, vps_hrd_max_tid[i], 0,
1002  current->vps_max_sublayers_minus1, 1, i);
1003  else
1004  infer(vps_hrd_max_tid[i],
1005  current->vps_max_sublayers_minus1);
1006  first_sublayer = current->vps_sublayer_cpb_params_present_flag ?
1007  0 : current->vps_hrd_max_tid[i];
1008  CHECK(FUNC(ols_timing_hrd_parameters)
1009  (ctx, rw, &current->vps_ols_timing_hrd_parameters,
1010  first_sublayer, current->vps_max_sublayers_minus1,
1011  &current->vps_general_timing_hrd_parameters));
1012 
1013  }
1014  if (current->vps_num_ols_timing_hrd_params_minus1 > 0 &&
1015  current->vps_num_ols_timing_hrd_params_minus1 + 1 !=
1016  num_multi_layer_olss) {
1017  for (i = 0; i < num_multi_layer_olss; i++) {
1018  ues(vps_ols_timing_hrd_idx[i], 0,
1019  current->vps_num_ols_timing_hrd_params_minus1, 1, i);
1020  }
1021  } else if (current->vps_num_ols_timing_hrd_params_minus1 == 0) {
1022  for (i = 0; i < num_multi_layer_olss; i++)
1023  infer(vps_ols_timing_hrd_idx[i], 0);
1024  } else {
1025  for (i = 0; i < num_multi_layer_olss; i++)
1026  infer(vps_ols_timing_hrd_idx[i], i);
1027  }
1028  }
1029  }
1030 
1031  flag(vps_extension_flag);
1032  if (current->vps_extension_flag)
1033  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
1034  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
1035 
1036  return 0;
1037 }
1038 
1039 static int FUNC(sps_range_extension)(CodedBitstreamContext *ctx, RWContext *rw,
1040  H266RawSPS *current)
1041 {
1042  int err;
1043 
1044  flag(sps_extended_precision_flag);
1045  if (current->sps_transform_skip_enabled_flag)
1046  flag(sps_ts_residual_coding_rice_present_in_sh_flag);
1047  else
1048  infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1049  flag(sps_rrc_rice_extension_flag);
1050  flag(sps_persistent_rice_adaptation_enabled_flag);
1051  flag(sps_reverse_last_sig_coeff_enabled_flag);
1052 
1053  return 0;
1054 }
1055 
1056 static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
1057  H266RawSPS *current)
1058 {
1059  CodedBitstreamH266Context *h266 = ctx->priv_data;
1060  int err, i, j, max_width_minus1, max_height_minus1;
1061  unsigned int ctb_log2_size_y, min_cb_log2_size_y,
1062  min_qt_log2_size_intra_y, min_qt_log2_size_inter_y,
1063  ctb_size_y, max_num_merge_cand, tmp_width_val, tmp_height_val;
1064  uint8_t qp_bd_offset, sub_width_c, sub_height_c;
1065 
1066  static const uint8_t h266_sub_width_c[] = {
1067  1, 2, 2, 1
1068  };
1069  static const uint8_t h266_sub_height_c[] = {
1070  1, 2, 1, 1
1071  };
1072 
1073  HEADER("Sequence Parameter Set");
1074 
1075  CHECK(FUNC(nal_unit_header) (ctx, rw,
1076  &current->nal_unit_header, VVC_SPS_NUT));
1077 
1078  ub(4, sps_seq_parameter_set_id);
1079  ub(4, sps_video_parameter_set_id);
1080  if (current->sps_video_parameter_set_id == 0 && !h266->vps[0]) {
1081  H266RawVPS *vps = av_refstruct_allocz(sizeof(*vps));
1082  if (!vps)
1083  return AVERROR(ENOMEM);
1084  vps->vps_max_layers_minus1 = 0;
1085  vps->vps_independent_layer_flag[0] = 1;
1086  vps->vps_layer_id[0] = current->nal_unit_header.nuh_layer_id;
1087  h266->vps[0] = vps;
1088  }
1089 
1090  u(3, sps_max_sublayers_minus1, 0, VVC_MAX_SUBLAYERS - 1);
1091  u(2, sps_chroma_format_idc, 0, 3);
1092  sub_width_c = h266_sub_width_c[current->sps_chroma_format_idc];
1093  sub_height_c = h266_sub_height_c[current->sps_chroma_format_idc];
1094 
1095  u(2, sps_log2_ctu_size_minus5, 0, 3);
1096  ctb_log2_size_y = current->sps_log2_ctu_size_minus5 + 5;
1097  ctb_size_y = 1 << ctb_log2_size_y;
1098 
1099  flag(sps_ptl_dpb_hrd_params_present_flag);
1100  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1101  CHECK(FUNC(profile_tier_level) (ctx, rw, &current->profile_tier_level,
1102  1, current->sps_max_sublayers_minus1));
1103  }
1104  flag(sps_gdr_enabled_flag);
1105  flag(sps_ref_pic_resampling_enabled_flag);
1106  if (current->sps_ref_pic_resampling_enabled_flag)
1107  flag(sps_res_change_in_clvs_allowed_flag);
1108  else
1109  infer(sps_res_change_in_clvs_allowed_flag, 0);
1110 
1111  ue(sps_pic_width_max_in_luma_samples, 1, VVC_MAX_WIDTH);
1112  ue(sps_pic_height_max_in_luma_samples, 1, VVC_MAX_HEIGHT);
1113 
1114  flag(sps_conformance_window_flag);
1115  if (current->sps_conformance_window_flag) {
1116  uint16_t width = current->sps_pic_width_max_in_luma_samples / sub_width_c;
1117  uint16_t height = current->sps_pic_height_max_in_luma_samples / sub_height_c;
1118  ue(sps_conf_win_left_offset, 0, width);
1119  ue(sps_conf_win_right_offset, 0, width - current->sps_conf_win_left_offset);
1120  ue(sps_conf_win_top_offset, 0, height);
1121  ue(sps_conf_win_bottom_offset, 0, height - current->sps_conf_win_top_offset);
1122  } else {
1123  infer(sps_conf_win_left_offset, 0);
1124  infer(sps_conf_win_right_offset, 0);
1125  infer(sps_conf_win_top_offset, 0);
1126  infer(sps_conf_win_bottom_offset, 0);
1127  }
1128 
1129  tmp_width_val = AV_CEIL_RSHIFT(current->sps_pic_width_max_in_luma_samples,
1130  ctb_log2_size_y);
1131  tmp_height_val = AV_CEIL_RSHIFT(current->sps_pic_height_max_in_luma_samples,
1132  ctb_log2_size_y);
1133  max_width_minus1 = tmp_width_val - 1;
1134  max_height_minus1 = tmp_height_val - 1;
1135 
1136  flag(sps_subpic_info_present_flag);
1137  if (current->sps_subpic_info_present_flag) {
1138  ue(sps_num_subpics_minus1, 0, VVC_MAX_SLICES - 1);
1139  if (current->sps_num_subpics_minus1 > 0) {
1140  flag(sps_independent_subpics_flag);
1141  flag(sps_subpic_same_size_flag);
1142  }
1143 
1144  if (current->sps_num_subpics_minus1 > 0) {
1145  int wlen = av_ceil_log2(tmp_width_val);
1146  int hlen = av_ceil_log2(tmp_height_val);
1147  infer(sps_subpic_ctu_top_left_x[0], 0);
1148  infer(sps_subpic_ctu_top_left_y[0], 0);
1149  if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1150  us(wlen, sps_subpic_width_minus1[0], 0, max_width_minus1, 1, 0);
1151  else
1152  infer(sps_subpic_width_minus1[0], max_width_minus1);
1153  if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
1154  us(hlen, sps_subpic_height_minus1[0], 0, max_height_minus1, 1, 0);
1155  else
1156  infer(sps_subpic_height_minus1[0], max_height_minus1);
1157  if (!current->sps_independent_subpics_flag) {
1158  flags(sps_subpic_treated_as_pic_flag[0], 1, 0);
1159  flags(sps_loop_filter_across_subpic_enabled_flag[0], 1, 0);
1160  } else {
1161  infer(sps_subpic_treated_as_pic_flag[0], 1);
1162  infer(sps_loop_filter_across_subpic_enabled_flag[0], 1);
1163  }
1164  for (i = 1; i <= current->sps_num_subpics_minus1; i++) {
1165  if (!current->sps_subpic_same_size_flag) {
1166  const int win_right_edge =
1167  current->sps_pic_width_max_in_luma_samples -
1168  current->sps_conf_win_right_offset * sub_width_c;
1169  const int win_bottom_edge =
1170  current->sps_pic_height_max_in_luma_samples -
1171  current->sps_conf_win_bottom_offset * sub_height_c;
1172  const int win_left_edge =
1173  current->sps_conf_win_left_offset * sub_width_c;
1174  const int win_top_edge =
1175  current->sps_conf_win_top_offset * sub_height_c;
1176  const int win_left_edge_ctus =
1177  AV_CEIL_RSHIFT(win_left_edge, ctb_log2_size_y);
1178  const int win_right_edge_ctus =
1179  AV_CEIL_RSHIFT(win_right_edge, ctb_log2_size_y);
1180  const int win_top_edge_ctus =
1181  AV_CEIL_RSHIFT(win_top_edge, ctb_log2_size_y);
1182  const int win_bottom_edge_ctus =
1183  AV_CEIL_RSHIFT(win_bottom_edge, ctb_log2_size_y);
1184  const int min_width =
1185  FFMAX(win_left_edge_ctus - current->sps_subpic_ctu_top_left_x[i], 0);
1186  const int min_height =
1187  FFMAX(win_top_edge_ctus - current->sps_subpic_ctu_top_left_y[i], 0);
1188 
1189  if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1190  us(wlen, sps_subpic_ctu_top_left_x[i], 0, win_right_edge_ctus - 1, 1, i);
1191  else
1192  infer(sps_subpic_ctu_top_left_x[i], 0);
1193 
1194  if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
1195  us(hlen, sps_subpic_ctu_top_left_y[i], 0, win_bottom_edge_ctus - 1, 1, i);
1196  else
1197  infer(sps_subpic_ctu_top_left_y[i], 0);
1198 
1199  max_width_minus1 = tmp_width_val - current->sps_subpic_ctu_top_left_x[i] - 1;
1200  max_height_minus1 = tmp_height_val - current->sps_subpic_ctu_top_left_y[i] - 1;
1201 
1202  if (i < current->sps_num_subpics_minus1 &&
1203  current->sps_pic_width_max_in_luma_samples > ctb_size_y) {
1204  us(wlen, sps_subpic_width_minus1[i], min_width, max_width_minus1, 1, i);
1205  } else {
1206  infer(sps_subpic_width_minus1[i], max_width_minus1);
1207  }
1208 
1209  if (i < current->sps_num_subpics_minus1 &&
1210  current->sps_pic_height_max_in_luma_samples > ctb_size_y) {
1211  us(hlen, sps_subpic_height_minus1[i], min_height, max_height_minus1, 1, i);
1212  } else {
1213  infer(sps_subpic_height_minus1[i], max_height_minus1);
1214  }
1215  } else {
1216  int num_subpic_cols = tmp_width_val /
1217  (current->sps_subpic_width_minus1[0] + 1);
1218  if (tmp_width_val % (current->sps_subpic_width_minus1[0] + 1) ||
1219  tmp_height_val % (current->sps_subpic_width_minus1[0] + 1) ||
1220  current->sps_num_subpics_minus1 !=
1221  (num_subpic_cols * tmp_height_val /
1222  (current->sps_subpic_height_minus1[0] + 1) - 1))
1223  return AVERROR_INVALIDDATA;
1224  infer(sps_subpic_ctu_top_left_x[i],
1225  (i % num_subpic_cols) *
1226  (current->sps_subpic_width_minus1[0] + 1));
1227  infer(sps_subpic_ctu_top_left_y[i],
1228  (i / num_subpic_cols) *
1229  (current->sps_subpic_height_minus1[0] + 1));
1230  infer(sps_subpic_width_minus1[i],
1231  current->sps_subpic_width_minus1[0]);
1232  infer(sps_subpic_height_minus1[i],
1233  current->sps_subpic_height_minus1[0]);
1234  }
1235  if (!current->sps_independent_subpics_flag) {
1236  flags(sps_subpic_treated_as_pic_flag[i], 1, i);
1237  flags(sps_loop_filter_across_subpic_enabled_flag[i], 1, i);
1238  } else {
1239  infer(sps_subpic_treated_as_pic_flag[i], 1);
1240  infer(sps_loop_filter_across_subpic_enabled_flag[i], 0);
1241  }
1242  }
1243  } else {
1244  infer(sps_subpic_ctu_top_left_x[0], 0);
1245  infer(sps_subpic_ctu_top_left_y[0], 0);
1246  infer(sps_subpic_width_minus1[0], max_width_minus1);
1247  infer(sps_subpic_height_minus1[0], max_height_minus1);
1248  }
1249  ue(sps_subpic_id_len_minus1, 0, 15);
1250  if ((1 << (current->sps_subpic_id_len_minus1 + 1)) <
1251  current->sps_num_subpics_minus1 + 1) {
1252  av_log(ctx->log_ctx, AV_LOG_ERROR,
1253  "sps_subpic_id_len_minus1(%d) is too small\n",
1254  current->sps_subpic_id_len_minus1);
1255  return AVERROR_INVALIDDATA;
1256  }
1257  flag(sps_subpic_id_mapping_explicitly_signalled_flag);
1258  if (current->sps_subpic_id_mapping_explicitly_signalled_flag) {
1259  flag(sps_subpic_id_mapping_present_flag);
1260  if (current->sps_subpic_id_mapping_present_flag) {
1261  for (i = 0; i <= current->sps_num_subpics_minus1; i++) {
1262  ubs(current->sps_subpic_id_len_minus1 + 1,
1263  sps_subpic_id[i], 1, i);
1264  }
1265  }
1266  }
1267  } else {
1268  infer(sps_num_subpics_minus1, 0);
1269  infer(sps_independent_subpics_flag, 1);
1270  infer(sps_subpic_same_size_flag, 0);
1271  infer(sps_subpic_id_mapping_explicitly_signalled_flag, 0);
1272  infer(sps_subpic_ctu_top_left_x[0], 0);
1273  infer(sps_subpic_ctu_top_left_y[0], 0);
1274  infer(sps_subpic_width_minus1[0], max_width_minus1);
1275  infer(sps_subpic_height_minus1[0], max_height_minus1);
1276  }
1277 
1278 
1279  ue(sps_bitdepth_minus8, 0, 8);
1280  qp_bd_offset = 6 * current->sps_bitdepth_minus8;
1281 
1282  flag(sps_entropy_coding_sync_enabled_flag);
1283  flag(sps_entry_point_offsets_present_flag);
1284 
1285  u(4, sps_log2_max_pic_order_cnt_lsb_minus4, 0, 12);
1286  flag(sps_poc_msb_cycle_flag);
1287  if (current->sps_poc_msb_cycle_flag)
1288  ue(sps_poc_msb_cycle_len_minus1,
1289  0, 32 - current->sps_log2_max_pic_order_cnt_lsb_minus4 - 5);
1290 
1291  u(2, sps_num_extra_ph_bytes, 0, 2);
1292  for (i = 0; i < (current->sps_num_extra_ph_bytes * 8); i++) {
1293  flags(sps_extra_ph_bit_present_flag[i], 1, i);
1294  }
1295 
1296  u(2, sps_num_extra_sh_bytes, 0, 2);
1297  for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
1298  flags(sps_extra_sh_bit_present_flag[i], 1, i);
1299  }
1300 
1301  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1302  if (current->sps_max_sublayers_minus1 > 0)
1303  flag(sps_sublayer_dpb_params_flag);
1304  else
1305  infer(sps_sublayer_dpb_params_flag, 0);
1306  CHECK(FUNC(dpb_parameters) (ctx, rw, &current->sps_dpb_params,
1307  current->sps_max_sublayers_minus1,
1308  current->sps_sublayer_dpb_params_flag));
1309  }
1310 
1311  ue(sps_log2_min_luma_coding_block_size_minus2,
1312  0, FFMIN(4, current->sps_log2_ctu_size_minus5 + 3));
1313  min_cb_log2_size_y =
1314  current->sps_log2_min_luma_coding_block_size_minus2 + 2;
1315 
1316  flag(sps_partition_constraints_override_enabled_flag);
1317 
1318  ue(sps_log2_diff_min_qt_min_cb_intra_slice_luma,
1319  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1320  min_qt_log2_size_intra_y =
1321  current->sps_log2_diff_min_qt_min_cb_intra_slice_luma +
1322  min_cb_log2_size_y;
1323 
1324  ue(sps_max_mtt_hierarchy_depth_intra_slice_luma,
1325  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1326 
1327  if (current->sps_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
1328  ue(sps_log2_diff_max_bt_min_qt_intra_slice_luma,
1329  0, ctb_log2_size_y - min_qt_log2_size_intra_y);
1330  ue(sps_log2_diff_max_tt_min_qt_intra_slice_luma,
1331  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
1332  } else {
1333  infer(sps_log2_diff_max_bt_min_qt_intra_slice_luma, 0);
1334  infer(sps_log2_diff_max_tt_min_qt_intra_slice_luma, 0);
1335  }
1336 
1337  if (current->sps_chroma_format_idc != 0) {
1338  flag(sps_qtbtt_dual_tree_intra_flag);
1339  } else {
1340  infer(sps_qtbtt_dual_tree_intra_flag, 0);
1341  }
1342 
1343  if (current->sps_qtbtt_dual_tree_intra_flag) {
1344  ue(sps_log2_diff_min_qt_min_cb_intra_slice_chroma,
1345  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1346  ue(sps_max_mtt_hierarchy_depth_intra_slice_chroma,
1347  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1348  if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
1349  unsigned int min_qt_log2_size_intra_c =
1350  current->sps_log2_diff_min_qt_min_cb_intra_slice_chroma +
1351  min_cb_log2_size_y;
1352  ue(sps_log2_diff_max_bt_min_qt_intra_slice_chroma,
1353  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1354  ue(sps_log2_diff_max_tt_min_qt_intra_slice_chroma,
1355  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1356  }
1357  } else {
1358  infer(sps_log2_diff_min_qt_min_cb_intra_slice_chroma, 0);
1359  infer(sps_max_mtt_hierarchy_depth_intra_slice_chroma, 0);
1360  }
1361  if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma == 0) {
1362  infer(sps_log2_diff_max_bt_min_qt_intra_slice_chroma, 0);
1363  infer(sps_log2_diff_max_tt_min_qt_intra_slice_chroma, 0);
1364  }
1365 
1366  ue(sps_log2_diff_min_qt_min_cb_inter_slice,
1367  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1368  min_qt_log2_size_inter_y =
1369  current->sps_log2_diff_min_qt_min_cb_inter_slice + min_cb_log2_size_y;
1370 
1371  ue(sps_max_mtt_hierarchy_depth_inter_slice,
1372  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1373  if (current->sps_max_mtt_hierarchy_depth_inter_slice != 0) {
1374  ue(sps_log2_diff_max_bt_min_qt_inter_slice,
1375  0, ctb_log2_size_y - min_qt_log2_size_inter_y);
1376  ue(sps_log2_diff_max_tt_min_qt_inter_slice,
1377  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
1378  } else {
1379  infer(sps_log2_diff_max_bt_min_qt_inter_slice, 0);
1380  infer(sps_log2_diff_max_tt_min_qt_inter_slice, 0);
1381  }
1382 
1383  if (ctb_size_y > 32)
1384  flag(sps_max_luma_transform_size_64_flag);
1385  else
1386  infer(sps_max_luma_transform_size_64_flag, 0);
1387 
1388  flag(sps_transform_skip_enabled_flag);
1389  if (current->sps_transform_skip_enabled_flag) {
1390  ue(sps_log2_transform_skip_max_size_minus2, 0, 3);
1391  flag(sps_bdpcm_enabled_flag);
1392  }
1393 
1394  flag(sps_mts_enabled_flag);
1395  if (current->sps_mts_enabled_flag) {
1396  flag(sps_explicit_mts_intra_enabled_flag);
1397  flag(sps_explicit_mts_inter_enabled_flag);
1398  } else {
1399  infer(sps_explicit_mts_intra_enabled_flag, 0);
1400  infer(sps_explicit_mts_inter_enabled_flag, 0);
1401  }
1402 
1403  flag(sps_lfnst_enabled_flag);
1404 
1405  if (current->sps_chroma_format_idc != 0) {
1406  uint8_t num_qp_tables;
1407  flag(sps_joint_cbcr_enabled_flag);
1408  flag(sps_same_qp_table_for_chroma_flag);
1409  num_qp_tables = current->sps_same_qp_table_for_chroma_flag ?
1410  1 : (current->sps_joint_cbcr_enabled_flag ? 3 : 2);
1411  for (i = 0; i < num_qp_tables; i++) {
1412  ses(sps_qp_table_start_minus26[i], -26 - qp_bd_offset, 36, 1, i);
1413  ues(sps_num_points_in_qp_table_minus1[i],
1414  0, 36 - current->sps_qp_table_start_minus26[i], 1, i);
1415  for (j = 0; j <= current->sps_num_points_in_qp_table_minus1[i]; j++) {
1416  uint8_t max = MAX_UINT_BITS(8);
1417  ues(sps_delta_qp_in_val_minus1[i][j], 0, max, 2, i, j);
1418  ues(sps_delta_qp_diff_val[i][j], 0, max, 2, i, j);
1419  }
1420  }
1421  } else {
1422  infer(sps_joint_cbcr_enabled_flag, 0);
1423  infer(sps_same_qp_table_for_chroma_flag, 0);
1424  }
1425 
1426  flag(sps_sao_enabled_flag);
1427  flag(sps_alf_enabled_flag);
1428  if (current->sps_alf_enabled_flag && current->sps_chroma_format_idc)
1429  flag(sps_ccalf_enabled_flag);
1430  else
1431  infer(sps_ccalf_enabled_flag, 0);
1432  flag(sps_lmcs_enabled_flag);
1433  flag(sps_weighted_pred_flag);
1434  flag(sps_weighted_bipred_flag);
1435  flag(sps_long_term_ref_pics_flag);
1436  if (current->sps_video_parameter_set_id > 0)
1437  flag(sps_inter_layer_prediction_enabled_flag);
1438  else
1439  infer(sps_inter_layer_prediction_enabled_flag, 0);
1440  flag(sps_idr_rpl_present_flag);
1441  flag(sps_rpl1_same_as_rpl0_flag);
1442 
1443  for (i = 0; i < (current->sps_rpl1_same_as_rpl0_flag ? 1 : 2); i++) {
1444  ues(sps_num_ref_pic_lists[i], 0, VVC_MAX_REF_PIC_LISTS, 1, i);
1445  for (j = 0; j < current->sps_num_ref_pic_lists[i]; j++)
1446  CHECK(FUNC(ref_pic_list_struct) (ctx, rw,
1447  &current->
1448  sps_ref_pic_list_struct[i][j], i,
1449  j, current));
1450  }
1451 
1452  if (current->sps_rpl1_same_as_rpl0_flag) {
1453  current->sps_num_ref_pic_lists[1] = current->sps_num_ref_pic_lists[0];
1454  for (j = 0; j < current->sps_num_ref_pic_lists[0]; j++)
1455  memcpy(&current->sps_ref_pic_list_struct[1][j],
1456  &current->sps_ref_pic_list_struct[0][j],
1457  sizeof(current->sps_ref_pic_list_struct[0][j]));
1458  }
1459 
1460  flag(sps_ref_wraparound_enabled_flag);
1461 
1462  flag(sps_temporal_mvp_enabled_flag);
1463  if (current->sps_temporal_mvp_enabled_flag)
1464  flag(sps_sbtmvp_enabled_flag);
1465  else
1466  infer(sps_sbtmvp_enabled_flag, 0);
1467 
1468  flag(sps_amvr_enabled_flag);
1469  flag(sps_bdof_enabled_flag);
1470  if (current->sps_bdof_enabled_flag)
1471  flag(sps_bdof_control_present_in_ph_flag);
1472  else
1473  infer(sps_bdof_control_present_in_ph_flag, 0);
1474 
1475  flag(sps_smvd_enabled_flag);
1476  flag(sps_dmvr_enabled_flag);
1477  if (current->sps_dmvr_enabled_flag)
1478  flag(sps_dmvr_control_present_in_ph_flag);
1479  else
1480  infer(sps_dmvr_control_present_in_ph_flag, 0);
1481 
1482  flag(sps_mmvd_enabled_flag);
1483  if (current->sps_mmvd_enabled_flag)
1484  flag(sps_mmvd_fullpel_only_enabled_flag);
1485  else
1486  infer(sps_mmvd_fullpel_only_enabled_flag, 0);
1487 
1488  ue(sps_six_minus_max_num_merge_cand, 0, 5);
1489  max_num_merge_cand = 6 - current->sps_six_minus_max_num_merge_cand;
1490 
1491  flag(sps_sbt_enabled_flag);
1492 
1493  flag(sps_affine_enabled_flag);
1494  if (current->sps_affine_enabled_flag) {
1495  ue(sps_five_minus_max_num_subblock_merge_cand,
1496  0, 5 - current->sps_sbtmvp_enabled_flag);
1497  flag(sps_6param_affine_enabled_flag);
1498  if (current->sps_amvr_enabled_flag)
1499  flag(sps_affine_amvr_enabled_flag);
1500  else
1501  infer(sps_affine_amvr_enabled_flag, 0);
1502  flag(sps_affine_prof_enabled_flag);
1503  if (current->sps_affine_prof_enabled_flag)
1504  flag(sps_prof_control_present_in_ph_flag);
1505  else
1506  infer(sps_prof_control_present_in_ph_flag, 0);
1507  } else {
1508  infer(sps_6param_affine_enabled_flag, 0);
1509  infer(sps_affine_amvr_enabled_flag, 0);
1510  infer(sps_affine_prof_enabled_flag, 0);
1511  infer(sps_prof_control_present_in_ph_flag, 0);
1512  }
1513 
1514  flag(sps_bcw_enabled_flag);
1515  flag(sps_ciip_enabled_flag);
1516 
1517  if (max_num_merge_cand >= 2) {
1518  flag(sps_gpm_enabled_flag);
1519  if (current->sps_gpm_enabled_flag && max_num_merge_cand >= 3)
1520  ue(sps_max_num_merge_cand_minus_max_num_gpm_cand,
1521  0, max_num_merge_cand - 2);
1522  } else {
1523  infer(sps_gpm_enabled_flag, 0);
1524  }
1525 
1526  ue(sps_log2_parallel_merge_level_minus2, 0, ctb_log2_size_y - 2);
1527 
1528  flag(sps_isp_enabled_flag);
1529  flag(sps_mrl_enabled_flag);
1530  flag(sps_mip_enabled_flag);
1531 
1532  if (current->sps_chroma_format_idc != 0)
1533  flag(sps_cclm_enabled_flag);
1534  else
1535  infer(sps_cclm_enabled_flag, 0);
1536  if (current->sps_chroma_format_idc == 1) {
1537  flag(sps_chroma_horizontal_collocated_flag);
1538  flag(sps_chroma_vertical_collocated_flag);
1539  } else {
1540  infer(sps_chroma_horizontal_collocated_flag, 1);
1541  infer(sps_chroma_vertical_collocated_flag, 1);
1542  }
1543 
1544  flag(sps_palette_enabled_flag);
1545  if (current->sps_chroma_format_idc == 3 &&
1546  !current->sps_max_luma_transform_size_64_flag)
1547  flag(sps_act_enabled_flag);
1548  else
1549  infer(sps_act_enabled_flag, 0);
1550  if (current->sps_transform_skip_enabled_flag ||
1551  current->sps_palette_enabled_flag)
1552  ue(sps_min_qp_prime_ts, 0, 8);
1553 
1554  flag(sps_ibc_enabled_flag);
1555  if (current->sps_ibc_enabled_flag)
1556  ue(sps_six_minus_max_num_ibc_merge_cand, 0, 5);
1557 
1558  flag(sps_ladf_enabled_flag);
1559  if (current->sps_ladf_enabled_flag) {
1560  ub(2, sps_num_ladf_intervals_minus2);
1561  se(sps_ladf_lowest_interval_qp_offset, -63, 63);
1562  for (i = 0; i < current->sps_num_ladf_intervals_minus2 + 1; i++) {
1563  ses(sps_ladf_qp_offset[i], -63, 63, 1, i);
1564  ues(sps_ladf_delta_threshold_minus1[i],
1565  0, (2 << (8 + current->sps_bitdepth_minus8)) - 3, 1, i);
1566  }
1567  }
1568 
1569  flag(sps_explicit_scaling_list_enabled_flag);
1570  if (current->sps_lfnst_enabled_flag &&
1571  current->sps_explicit_scaling_list_enabled_flag)
1572  flag(sps_scaling_matrix_for_lfnst_disabled_flag);
1573 
1574  if (current->sps_act_enabled_flag &&
1575  current->sps_explicit_scaling_list_enabled_flag)
1576  flag(sps_scaling_matrix_for_alternative_colour_space_disabled_flag);
1577  else
1578  infer(sps_scaling_matrix_for_alternative_colour_space_disabled_flag, 0);
1579  if (current->sps_scaling_matrix_for_alternative_colour_space_disabled_flag)
1580  flag(sps_scaling_matrix_designated_colour_space_flag);
1581 
1582  flag(sps_dep_quant_enabled_flag);
1583  flag(sps_sign_data_hiding_enabled_flag);
1584 
1585  flag(sps_virtual_boundaries_enabled_flag);
1586  if (current->sps_virtual_boundaries_enabled_flag) {
1587  flag(sps_virtual_boundaries_present_flag);
1588  if (current->sps_virtual_boundaries_present_flag) {
1589  ue(sps_num_ver_virtual_boundaries,
1590  0, current->sps_pic_width_max_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
1591  for (i = 0; i < current->sps_num_ver_virtual_boundaries; i++)
1592  ues(sps_virtual_boundary_pos_x_minus1[i],
1593  0, (current->sps_pic_width_max_in_luma_samples + 7) / 8 - 2,
1594  1, i);
1595  ue(sps_num_hor_virtual_boundaries,
1596  0, current->sps_pic_height_max_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
1597  for (i = 0; i < current->sps_num_hor_virtual_boundaries; i++)
1598  ues(sps_virtual_boundary_pos_y_minus1[i],
1599  0, (current->sps_pic_height_max_in_luma_samples + 7) /
1600  8 - 2, 1, i);
1601  }
1602  } else {
1603  infer(sps_virtual_boundaries_present_flag, 0);
1604  infer(sps_num_ver_virtual_boundaries, 0);
1605  infer(sps_num_hor_virtual_boundaries, 0);
1606  }
1607 
1608  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1609  flag(sps_timing_hrd_params_present_flag);
1610  if (current->sps_timing_hrd_params_present_flag) {
1611  uint8_t first_sublayer;
1612  CHECK(FUNC(general_timing_hrd_parameters) (ctx, rw,
1613  &current->sps_general_timing_hrd_parameters));
1614  if (current->sps_max_sublayers_minus1 > 0)
1615  flag(sps_sublayer_cpb_params_present_flag);
1616  else
1617  infer(sps_sublayer_cpb_params_present_flag, 0);
1618  first_sublayer = current->sps_sublayer_cpb_params_present_flag ?
1619  0 : current->sps_max_sublayers_minus1;
1620  CHECK(FUNC(ols_timing_hrd_parameters) (ctx, rw,
1621  &current->sps_ols_timing_hrd_parameters, first_sublayer,
1622  current->sps_max_sublayers_minus1,
1623  &current->sps_general_timing_hrd_parameters));
1624  }
1625  }
1626 
1627  flag(sps_field_seq_flag);
1628  flag(sps_vui_parameters_present_flag);
1629  if (current->sps_vui_parameters_present_flag) {
1630  ue(sps_vui_payload_size_minus1, 0, 1023);
1631  while (byte_alignment(rw) != 0)
1632  fixed(1, sps_vui_alignment_zero_bit, 0);
1633  CHECK(FUNC(vui_payload) (ctx, rw, &current->vui,
1634  current->sps_vui_payload_size_minus1 + 1,
1635  current->sps_chroma_format_idc));
1636  } else {
1637  CHECK(FUNC(vui_parameters_default) (ctx, rw, &current->vui));
1638  }
1639 
1640  flag(sps_extension_flag);
1641  if (current->sps_extension_flag) {
1642  flag(sps_range_extension_flag);
1643  ub(7, sps_extension_7bits);
1644 
1645  if (current->sps_range_extension_flag) {
1646  if (current->sps_bitdepth_minus8 <= 10 - 8)
1647  return AVERROR_INVALIDDATA;
1648  CHECK(FUNC(sps_range_extension)(ctx, rw, current));
1649  } else {
1650  infer(sps_extended_precision_flag, 0);
1651  infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1652  infer(sps_rrc_rice_extension_flag, 0);
1653  infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1654  infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1655  }
1656  } else {
1657  infer(sps_range_extension_flag, 0);
1658  infer(sps_extension_7bits, 0);
1659  infer(sps_extended_precision_flag, 0);
1660  infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1661  infer(sps_rrc_rice_extension_flag, 0);
1662  infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1663  infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1664  }
1665 
1666  if (current->sps_extension_7bits)
1667  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
1668 
1669  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
1670 
1671  return 0;
1672 }
1673 
1674 static int FUNC(pps) (CodedBitstreamContext *ctx, RWContext *rw,
1675  H266RawPPS *current)
1676 {
1677  CodedBitstreamH266Context *h266 = ctx->priv_data;
1678  const H266RawSPS *sps;
1679  int err, i;
1680  unsigned int min_cb_size_y, divisor, ctb_size_y,
1681  pic_width_in_ctbs_y, pic_height_in_ctbs_y;
1682  uint8_t sub_width_c, sub_height_c, qp_bd_offset;
1683 
1684  static const uint8_t h266_sub_width_c[] = {
1685  1, 2, 2, 1
1686  };
1687  static const uint8_t h266_sub_height_c[] = {
1688  1, 2, 1, 1
1689  };
1690 
1691  HEADER("Picture Parameter Set");
1692 
1693  CHECK(FUNC(nal_unit_header) (ctx, rw,
1694  &current->nal_unit_header, VVC_PPS_NUT));
1695 
1696  ub(6, pps_pic_parameter_set_id);
1697  ub(4, pps_seq_parameter_set_id);
1698  sps = h266->sps[current->pps_seq_parameter_set_id];
1699  if (!sps) {
1700  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1701  current->pps_seq_parameter_set_id);
1702  return AVERROR_INVALIDDATA;
1703  }
1704 
1705  flag(pps_mixed_nalu_types_in_pic_flag);
1706  ue(pps_pic_width_in_luma_samples,
1707  1, sps->sps_pic_width_max_in_luma_samples);
1708  ue(pps_pic_height_in_luma_samples,
1709  1, sps->sps_pic_height_max_in_luma_samples);
1710 
1711  min_cb_size_y = 1 << (sps->sps_log2_min_luma_coding_block_size_minus2 + 2);
1712  divisor = FFMAX(min_cb_size_y, 8);
1713  if (current->pps_pic_width_in_luma_samples % divisor ||
1714  current->pps_pic_height_in_luma_samples % divisor) {
1715  av_log(ctx->log_ctx, AV_LOG_ERROR,
1716  "Invalid dimensions: %ux%u not divisible "
1717  "by %u, MinCbSizeY = %u.\n",
1718  current->pps_pic_width_in_luma_samples,
1719  current->pps_pic_height_in_luma_samples, divisor, min_cb_size_y);
1720  return AVERROR_INVALIDDATA;
1721  }
1722  if (!sps->sps_res_change_in_clvs_allowed_flag &&
1723  (current->pps_pic_width_in_luma_samples !=
1724  sps->sps_pic_width_max_in_luma_samples ||
1725  current->pps_pic_height_in_luma_samples !=
1726  sps->sps_pic_height_max_in_luma_samples)) {
1727  av_log(ctx->log_ctx, AV_LOG_ERROR,
1728  "Resolution change is not allowed, "
1729  "in max resolution (%ux%u) mismatched with pps(%ux%u).\n",
1730  sps->sps_pic_width_max_in_luma_samples,
1731  sps->sps_pic_height_max_in_luma_samples,
1732  current->pps_pic_width_in_luma_samples,
1733  current->pps_pic_height_in_luma_samples);
1734  return AVERROR_INVALIDDATA;
1735  }
1736 
1737  ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
1738  if (sps->sps_ref_wraparound_enabled_flag) {
1739  if ((ctb_size_y / min_cb_size_y + 1) >
1740  (current->pps_pic_width_in_luma_samples / min_cb_size_y - 1)) {
1741  av_log(ctx->log_ctx, AV_LOG_ERROR,
1742  "Invalid width(%u), ctb_size_y = %u, min_cb_size_y = %u.\n",
1743  current->pps_pic_width_in_luma_samples,
1744  ctb_size_y, min_cb_size_y);
1745  return AVERROR_INVALIDDATA;
1746  }
1747  }
1748 
1749  flag(pps_conformance_window_flag);
1750  if (current->pps_pic_width_in_luma_samples ==
1751  sps->sps_pic_width_max_in_luma_samples &&
1752  current->pps_pic_height_in_luma_samples ==
1753  sps->sps_pic_height_max_in_luma_samples &&
1754  current->pps_conformance_window_flag) {
1755  av_log(ctx->log_ctx, AV_LOG_ERROR,
1756  "Conformance window flag should not true.\n");
1757  return AVERROR_INVALIDDATA;
1758  }
1759 
1760  sub_width_c = h266_sub_width_c[sps->sps_chroma_format_idc];
1761  sub_height_c = h266_sub_height_c[sps->sps_chroma_format_idc];
1762  if (current->pps_conformance_window_flag) {
1763  ue(pps_conf_win_left_offset, 0, current->pps_pic_width_in_luma_samples);
1764  ue(pps_conf_win_right_offset,
1765  0, current->pps_pic_width_in_luma_samples);
1766  ue(pps_conf_win_top_offset, 0, current->pps_pic_height_in_luma_samples);
1767  ue(pps_conf_win_bottom_offset,
1768  0, current->pps_pic_height_in_luma_samples);
1769  if (sub_width_c *
1770  (current->pps_conf_win_left_offset +
1771  current->pps_conf_win_right_offset) >=
1772  current->pps_pic_width_in_luma_samples ||
1773  sub_height_c *
1774  (current->pps_conf_win_top_offset +
1775  current->pps_conf_win_bottom_offset) >=
1776  current->pps_pic_height_in_luma_samples) {
1777  av_log(ctx->log_ctx, AV_LOG_ERROR,
1778  "Invalid pps conformance window: (%u, %u, %u, %u), "
1779  "resolution is %ux%u, sub wxh is %ux%u.\n",
1780  current->pps_conf_win_left_offset,
1781  current->pps_conf_win_right_offset,
1782  current->pps_conf_win_top_offset,
1783  current->pps_conf_win_bottom_offset,
1784  current->pps_pic_width_in_luma_samples,
1785  current->pps_pic_height_in_luma_samples,
1786  sub_width_c, sub_height_c);
1787  return AVERROR_INVALIDDATA;
1788  }
1789  } else {
1790  if (current->pps_pic_width_in_luma_samples ==
1791  sps->sps_pic_width_max_in_luma_samples &&
1792  current->pps_pic_height_in_luma_samples ==
1793  sps->sps_pic_height_max_in_luma_samples) {
1794  infer(pps_conf_win_left_offset, sps->sps_conf_win_left_offset);
1795  infer(pps_conf_win_right_offset, sps->sps_conf_win_right_offset);
1796  infer(pps_conf_win_top_offset, sps->sps_conf_win_top_offset);
1797  infer(pps_conf_win_bottom_offset, sps->sps_conf_win_bottom_offset);
1798  } else {
1799  infer(pps_conf_win_left_offset, 0);
1800  infer(pps_conf_win_right_offset, 0);
1801  infer(pps_conf_win_top_offset, 0);
1802  infer(pps_conf_win_bottom_offset, 0);
1803  }
1804 
1805  }
1806 
1807  flag(pps_scaling_window_explicit_signalling_flag);
1808  if (!sps->sps_ref_pic_resampling_enabled_flag &&
1809  current->pps_scaling_window_explicit_signalling_flag) {
1810  av_log(ctx->log_ctx, AV_LOG_ERROR,
1811  "Invalid data: sps_ref_pic_resampling_enabled_flag is false, "
1812  "but pps_scaling_window_explicit_signalling_flag is true.\n");
1813  return AVERROR_INVALIDDATA;
1814  }
1815  if (current->pps_scaling_window_explicit_signalling_flag) {
1816  se(pps_scaling_win_left_offset,
1817  -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1818  current->pps_pic_width_in_luma_samples / sub_width_c);
1819  se(pps_scaling_win_right_offset,
1820  -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1821  current->pps_pic_width_in_luma_samples / sub_width_c);
1822  se(pps_scaling_win_top_offset,
1823  -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1824  current->pps_pic_height_in_luma_samples / sub_height_c);
1825  se(pps_scaling_win_bottom_offset,
1826  -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1827  current->pps_pic_height_in_luma_samples / sub_height_c);
1828  } else {
1829  infer(pps_scaling_win_left_offset, current->pps_conf_win_left_offset);
1830  infer(pps_scaling_win_right_offset, current->pps_conf_win_right_offset);
1831  infer(pps_scaling_win_top_offset, current->pps_conf_win_top_offset);
1832  infer(pps_scaling_win_bottom_offset, current->pps_conf_win_bottom_offset);
1833  }
1834 
1835  flag(pps_output_flag_present_flag);
1836  flag(pps_no_pic_partition_flag);
1837  flag(pps_subpic_id_mapping_present_flag);
1838 
1839  if (current->pps_subpic_id_mapping_present_flag) {
1840  if (!current->pps_no_pic_partition_flag) {
1841  ue(pps_num_subpics_minus1,
1842  sps->sps_num_subpics_minus1, sps->sps_num_subpics_minus1);
1843  } else {
1844  infer(pps_num_subpics_minus1, 0);
1845  }
1846  ue(pps_subpic_id_len_minus1, sps->sps_subpic_id_len_minus1,
1847  sps->sps_subpic_id_len_minus1);
1848  for (i = 0; i <= current->pps_num_subpics_minus1; i++) {
1849  ubs(sps->sps_subpic_id_len_minus1 + 1, pps_subpic_id[i], 1, i);
1850  }
1851  }
1852 
1853  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
1854  if (sps->sps_subpic_id_mapping_explicitly_signalled_flag)
1855  current->sub_pic_id_val[i] = current->pps_subpic_id_mapping_present_flag
1856  ? current->pps_subpic_id[i]
1857  : sps->sps_subpic_id[i];
1858  else
1859  current->sub_pic_id_val[i] = i;
1860  }
1861 
1862  pic_width_in_ctbs_y = AV_CEIL_RSHIFT
1863  (current->pps_pic_width_in_luma_samples, (sps->sps_log2_ctu_size_minus5 + 5));
1864  pic_height_in_ctbs_y = AV_CEIL_RSHIFT(
1865  current->pps_pic_height_in_luma_samples,(sps->sps_log2_ctu_size_minus5 + 5));
1866  if (!current->pps_no_pic_partition_flag) {
1867  unsigned int exp_tile_width = 0, exp_tile_height = 0;
1868  unsigned int unified_size, remaining_size;
1869 
1870  u(2, pps_log2_ctu_size_minus5,
1871  sps->sps_log2_ctu_size_minus5, sps->sps_log2_ctu_size_minus5);
1872  ue(pps_num_exp_tile_columns_minus1,
1873  0, FFMIN(pic_width_in_ctbs_y - 1, VVC_MAX_TILE_COLUMNS - 1));
1874  ue(pps_num_exp_tile_rows_minus1,
1875  0, FFMIN(pic_height_in_ctbs_y - 1, VVC_MAX_TILE_ROWS - 1));
1876 
1877  for (i = 0; i <= current->pps_num_exp_tile_columns_minus1; i++) {
1878  ues(pps_tile_column_width_minus1[i],
1879  0, pic_width_in_ctbs_y - exp_tile_width - 1, 1, i);
1880  exp_tile_width += current->pps_tile_column_width_minus1[i] + 1;
1881  }
1882  for (i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++) {
1883  ues(pps_tile_row_height_minus1[i],
1884  0, pic_height_in_ctbs_y - exp_tile_height - 1, 1, i);
1885  exp_tile_height += current->pps_tile_row_height_minus1[i] + 1;
1886  }
1887 
1888  remaining_size = pic_width_in_ctbs_y;
1889  for (i = 0; i <= current->pps_num_exp_tile_columns_minus1; i++) {
1890  if (current->pps_tile_column_width_minus1[i] >= remaining_size) {
1891  av_log(ctx->log_ctx, AV_LOG_ERROR,
1892  "Tile column width(%d) exceeds picture width\n",i);
1893  return AVERROR_INVALIDDATA;
1894  }
1895  current->col_width_val[i] = current->pps_tile_column_width_minus1[i] + 1;
1896  remaining_size -= (current->pps_tile_column_width_minus1[i] + 1);
1897  }
1898  unified_size = current->pps_tile_column_width_minus1[i - 1] + 1;
1899  while (remaining_size > 0) {
1900  if (i == VVC_MAX_TILE_COLUMNS) {
1901  av_log(ctx->log_ctx, AV_LOG_ERROR,
1902  "Exceeded maximum tile columns (%d) (remaining size: %u)\n",
1903  VVC_MAX_TILE_COLUMNS, remaining_size);
1904  return AVERROR_INVALIDDATA;
1905  }
1906  unified_size = FFMIN(remaining_size, unified_size);
1907  current->col_width_val[i] = unified_size;
1908  remaining_size -= unified_size;
1909  i++;
1910  }
1911  current->num_tile_columns = i;
1912 
1913  remaining_size = pic_height_in_ctbs_y;
1914  for (i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++) {
1915  if (current->pps_tile_row_height_minus1[i] >= remaining_size) {
1916  av_log(ctx->log_ctx, AV_LOG_ERROR,
1917  "Tile row height(%d) exceeds picture height\n",i);
1918  return AVERROR_INVALIDDATA;
1919  }
1920  current->row_height_val[i] = current->pps_tile_row_height_minus1[i] + 1;
1921  remaining_size -= (current->pps_tile_row_height_minus1[i] + 1);
1922  }
1923  unified_size = current->pps_tile_row_height_minus1[i - 1] + 1;
1924 
1925  while (remaining_size > 0) {
1926  if (i == VVC_MAX_TILE_ROWS) {
1927  av_log(ctx->log_ctx, AV_LOG_ERROR,
1928  "Exceeded maximum tile rows (%d) (remaining size: %u)\n",
1929  VVC_MAX_TILE_ROWS, remaining_size);
1930  return AVERROR_INVALIDDATA;
1931  }
1932  unified_size = FFMIN(remaining_size, unified_size);
1933  current->row_height_val[i] = unified_size;
1934  remaining_size -= unified_size;
1935  i++;
1936  }
1937  current->num_tile_rows=i;
1938 
1939  current->num_tiles_in_pic = current->num_tile_columns *
1940  current->num_tile_rows;
1941  if (current->num_tiles_in_pic > VVC_MAX_TILES_PER_AU) {
1942  av_log(ctx->log_ctx, AV_LOG_ERROR,
1943  "NumTilesInPic(%d) > than VVC_MAX_TILES_PER_AU(%d)\n",
1944  current->num_tiles_in_pic, VVC_MAX_TILES_PER_AU);
1945  return AVERROR_INVALIDDATA;
1946  }
1947 
1948  if (current->num_tiles_in_pic > 1) {
1949  flag(pps_loop_filter_across_tiles_enabled_flag);
1950  flag(pps_rect_slice_flag);
1951  } else {
1952  infer(pps_loop_filter_across_tiles_enabled_flag, 0);
1953  infer(pps_rect_slice_flag, 1);
1954  }
1955  if (current->pps_rect_slice_flag)
1956  flag(pps_single_slice_per_subpic_flag);
1957  else
1958  infer(pps_single_slice_per_subpic_flag, 1);
1959  if (current->pps_rect_slice_flag &&
1960  !current->pps_single_slice_per_subpic_flag) {
1961  int j, num_slices = 0;
1962  uint16_t tile_idx = 0, tile_x, tile_y, ctu_x, ctu_y;
1963  uint16_t slice_top_left_ctu_x[VVC_MAX_SLICES];
1964  uint16_t slice_top_left_ctu_y[VVC_MAX_SLICES];
1965  ue(pps_num_slices_in_pic_minus1, 0, VVC_MAX_SLICES - 1);
1966  if (current->pps_num_slices_in_pic_minus1 > 1)
1967  flag(pps_tile_idx_delta_present_flag);
1968  else
1969  infer(pps_tile_idx_delta_present_flag, 0);
1970  for (i = 0; i < current->pps_num_slices_in_pic_minus1; i++) {
1971  current->slice_top_left_tile_idx[i] = tile_idx;
1972  tile_x = tile_idx % current->num_tile_columns;
1973  tile_y = tile_idx / current->num_tile_columns;
1974  if (tile_x != current->num_tile_columns - 1) {
1975  ues(pps_slice_width_in_tiles_minus1[i],
1976  0, current->num_tile_columns - 1, 1, i);
1977  } else {
1978  infer(pps_slice_width_in_tiles_minus1[i], 0);
1979  }
1980  if (tile_y != current->num_tile_rows - 1 &&
1981  (current->pps_tile_idx_delta_present_flag || tile_x == 0)) {
1982  ues(pps_slice_height_in_tiles_minus1[i],
1983  0, current->num_tile_rows - 1, 1, i);
1984  } else {
1985  if (tile_y == current->num_tile_rows - 1)
1986  infer(pps_slice_height_in_tiles_minus1[i], 0);
1987  else
1988  infer(pps_slice_height_in_tiles_minus1[i],
1989  current->pps_slice_height_in_tiles_minus1[i - 1]);
1990  }
1991 
1992  ctu_x = ctu_y = 0;
1993  for (j = 0; j < tile_x; j++) {
1994  ctu_x += current->col_width_val[j];
1995  }
1996  for (j = 0; j < tile_y; j++) {
1997  ctu_y += current->row_height_val[j];
1998  }
1999  if (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
2000  current->pps_slice_height_in_tiles_minus1[i] == 0 &&
2001  current->row_height_val[tile_y] > 1) {
2002  int uniform_slice_height, remaining_height_in_ctbs_y;
2003  remaining_height_in_ctbs_y =
2004  current->row_height_val[tile_y];
2005  ues(pps_num_exp_slices_in_tile[i],
2006  0, current->row_height_val[tile_y] - 1, 1, i);
2007  if (current->pps_num_exp_slices_in_tile[i] == 0) {
2008  current->num_slices_in_tile[i] = 1;
2009  current->slice_height_in_ctus[i] = current->row_height_val[tile_y];
2010  slice_top_left_ctu_x[i] = ctu_x;
2011  slice_top_left_ctu_y[i] = ctu_y;
2012  } else {
2013  uint16_t slice_height_in_ctus;
2014  int num_uniform_slices;
2015 
2016  if (i + current->pps_num_exp_slices_in_tile[i] >
2017  current->pps_num_slices_in_pic_minus1 + 1)
2018  return AVERROR_INVALIDDATA;
2019 
2020  for (j = 0; j < current->pps_num_exp_slices_in_tile[i];
2021  j++) {
2022  ues(pps_exp_slice_height_in_ctus_minus1[i][j], 0,
2023  remaining_height_in_ctbs_y - 1, 2,
2024  i, j);
2025  slice_height_in_ctus =
2026  current->
2027  pps_exp_slice_height_in_ctus_minus1[i][j] + 1;
2028 
2029  current->slice_height_in_ctus[i + j] =
2030  slice_height_in_ctus;
2031  slice_top_left_ctu_x[i + j] = ctu_x;
2032  slice_top_left_ctu_y[i + j] = ctu_y;
2033  ctu_y += slice_height_in_ctus;
2034 
2035  remaining_height_in_ctbs_y -= slice_height_in_ctus;
2036  }
2037  uniform_slice_height = 1 +
2038  (j == 0 ? current->row_height_val[tile_y] - 1:
2039  current->pps_exp_slice_height_in_ctus_minus1[i][j-1]);
2040 
2041  num_uniform_slices = (remaining_height_in_ctbs_y + uniform_slice_height - 1)
2042  / uniform_slice_height;
2043  if (i + current->pps_num_exp_slices_in_tile[i] + num_uniform_slices >
2044  current->pps_num_slices_in_pic_minus1 + 1)
2045  return AVERROR_INVALIDDATA;
2046 
2047  while (remaining_height_in_ctbs_y > uniform_slice_height) {
2048  current->slice_height_in_ctus[i + j] =
2049  uniform_slice_height;
2050  slice_top_left_ctu_x[i + j] = ctu_x;
2051  slice_top_left_ctu_y[i + j] = ctu_y;
2052  ctu_y += uniform_slice_height;
2053 
2054  remaining_height_in_ctbs_y -= uniform_slice_height;
2055  j++;
2056  }
2057  if (remaining_height_in_ctbs_y > 0) {
2058  current->slice_height_in_ctus[i + j] =
2059  remaining_height_in_ctbs_y;
2060  slice_top_left_ctu_x[i + j] = ctu_x;
2061  slice_top_left_ctu_y[i + j] = ctu_y;
2062  j++;
2063  }
2064  current->num_slices_in_tile[i] = j;
2065  }
2066  for (int k = 0; k < current->num_slices_in_tile[i]; k++)
2067  current->slice_top_left_tile_idx[i + k] = tile_idx;
2068  i += current->num_slices_in_tile[i] - 1;
2069  } else {
2070  uint16_t height = 0;
2071  infer(pps_num_exp_slices_in_tile[i], 0);
2072  if (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
2073  current->pps_slice_height_in_tiles_minus1[i] == 0)
2074  current->num_slices_in_tile[i] = 1;
2075 
2076  for (j = 0;
2077  j <= current->pps_slice_height_in_tiles_minus1[i];
2078  j++) {
2079  height +=
2080  current->row_height_val[tile_y + j];
2081  }
2082  current->slice_height_in_ctus[i] = height;
2083 
2084  slice_top_left_ctu_x[i] = ctu_x;
2085  slice_top_left_ctu_y[i] = ctu_y;
2086  }
2087  if (i < current->pps_num_slices_in_pic_minus1) {
2088  if (current->pps_tile_idx_delta_present_flag) {
2089  // Two conditions must be met:
2090  // 1. −NumTilesInPic + 1 <= pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2091  // 2. 0 <= tile_idx + pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2092  // Combining these conditions yields: -tile_idx <= pps_tile_idx_delta_val[i] <= NumTilesInPic - 1 - tile_idx
2093  ses(pps_tile_idx_delta_val[i],
2094  -tile_idx, current->num_tiles_in_pic - 1 - tile_idx, 1, i);
2095  if (current->pps_tile_idx_delta_val[i] == 0) {
2096  av_log(ctx->log_ctx, AV_LOG_ERROR,
2097  "pps_tile_idx_delta_val[i] shall not be equal to 0.\n");
2098  }
2099  tile_idx += current->pps_tile_idx_delta_val[i];
2100  } else {
2101  infer(pps_tile_idx_delta_val[i], 0);
2102  tile_idx +=
2103  current->pps_slice_width_in_tiles_minus1[i] + 1;
2104  if (tile_idx % current->num_tile_columns == 0) {
2105  tile_idx +=
2106  current->pps_slice_height_in_tiles_minus1[i] *
2107  current->num_tile_columns;
2108  }
2109  }
2110  }
2111  }
2112  if (i == current->pps_num_slices_in_pic_minus1) {
2113  uint16_t height = 0;
2114 
2115  current->slice_top_left_tile_idx[i] = tile_idx;
2116  current->num_slices_in_tile[i] = 1;
2117  tile_x = tile_idx % current->num_tile_columns;
2118  tile_y = tile_idx / current->num_tile_columns;
2119  if (tile_y >= current->num_tile_rows)
2120  return AVERROR_INVALIDDATA;
2121 
2122  ctu_x = 0, ctu_y = 0;
2123  for (j = 0; j < tile_x; j++) {
2124  ctu_x += current->col_width_val[j];
2125  }
2126  for (j = 0; j < tile_y; j++) {
2127  ctu_y += current->row_height_val[j];
2128  }
2129  slice_top_left_ctu_x[i] = ctu_x;
2130  slice_top_left_ctu_y[i] = ctu_y;
2131 
2132  current->pps_slice_width_in_tiles_minus1[i] =
2133  current->num_tile_columns - tile_x - 1;
2134  current->pps_slice_height_in_tiles_minus1[i] =
2135  current->num_tile_rows - tile_y - 1;
2136 
2137  for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[i];
2138  j++) {
2139  height +=
2140  current->row_height_val[tile_y + j];
2141  }
2142  current->slice_height_in_ctus[i] = height;
2143 
2144  infer(pps_num_exp_slices_in_tile[i], 0);
2145  }
2146  //now, we got all slice information, let's resolve NumSlicesInSubpic
2147  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
2148  current->num_slices_in_subpic[i] = 0;
2149  for (j = 0; j <= current->pps_num_slices_in_pic_minus1; j++) {
2150  uint16_t pos_x = 0, pos_y = 0;
2151  pos_x = slice_top_left_ctu_x[j];
2152  pos_y = slice_top_left_ctu_y[j];
2153  if ((pos_x >= sps->sps_subpic_ctu_top_left_x[i]) &&
2154  (pos_x <
2155  sps->sps_subpic_ctu_top_left_x[i] +
2156  sps->sps_subpic_width_minus1[i] + 1) &&
2157  (pos_y >= sps->sps_subpic_ctu_top_left_y[i]) &&
2158  (pos_y < sps->sps_subpic_ctu_top_left_y[i] +
2159  sps->sps_subpic_height_minus1[i] + 1)) {
2160  current->num_slices_in_subpic[i]++;
2161  }
2162  }
2163  num_slices += current->num_slices_in_subpic[i];
2164  }
2165  if (current->pps_num_slices_in_pic_minus1 + 1 != num_slices)
2166  return AVERROR_INVALIDDATA;
2167  } else {
2168  if (current->pps_no_pic_partition_flag)
2169  infer(pps_num_slices_in_pic_minus1, 0);
2170  else if (current->pps_single_slice_per_subpic_flag) {
2171  for (i = 0; i <= sps->sps_num_subpics_minus1; i++)
2172  current->num_slices_in_subpic[i] = 1;
2173  infer(pps_num_slices_in_pic_minus1,
2174  sps->sps_num_subpics_minus1);
2175  }
2176  // else?
2177  }
2178  if (!current->pps_rect_slice_flag ||
2179  current->pps_single_slice_per_subpic_flag ||
2180  current->pps_num_slices_in_pic_minus1 > 0)
2181  flag(pps_loop_filter_across_slices_enabled_flag);
2182  else
2183  infer(pps_loop_filter_across_slices_enabled_flag, 0);
2184  } else {
2185  infer(pps_num_exp_tile_columns_minus1, 0);
2186  infer(pps_tile_column_width_minus1[0], pic_width_in_ctbs_y - 1);
2187  infer(pps_num_exp_tile_rows_minus1, 0);
2188  infer(pps_tile_row_height_minus1[0], pic_height_in_ctbs_y - 1);
2189  current->col_width_val[0] = pic_width_in_ctbs_y;
2190  current->row_height_val[0] = pic_height_in_ctbs_y;
2191  current->num_tile_columns = 1;
2192  current->num_tile_rows = 1;
2193  current->num_tiles_in_pic = 1;
2194  }
2195 
2196  flag(pps_cabac_init_present_flag);
2197  for (i = 0; i < 2; i++)
2198  ues(pps_num_ref_idx_default_active_minus1[i], 0, 14, 1, i);
2199  flag(pps_rpl1_idx_present_flag);
2200  flag(pps_weighted_pred_flag);
2201  flag(pps_weighted_bipred_flag);
2202  flag(pps_ref_wraparound_enabled_flag);
2203  if (current->pps_ref_wraparound_enabled_flag) {
2204  ue(pps_pic_width_minus_wraparound_offset,
2205  0, (current->pps_pic_width_in_luma_samples / min_cb_size_y)
2206  - (ctb_size_y / min_cb_size_y) - 2);
2207  }
2208 
2209  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2210  se(pps_init_qp_minus26, -(26 + qp_bd_offset), 37);
2211  flag(pps_cu_qp_delta_enabled_flag);
2212  flag(pps_chroma_tool_offsets_present_flag);
2213  if (current->pps_chroma_tool_offsets_present_flag) {
2214  se(pps_cb_qp_offset, -12, 12);
2215  se(pps_cr_qp_offset, -12, 12);
2216  flag(pps_joint_cbcr_qp_offset_present_flag);
2217  if (current->pps_joint_cbcr_qp_offset_present_flag)
2218  se(pps_joint_cbcr_qp_offset_value, -12, 12);
2219  else
2220  infer(pps_joint_cbcr_qp_offset_value, 0);
2221  flag(pps_slice_chroma_qp_offsets_present_flag);
2222  flag(pps_cu_chroma_qp_offset_list_enabled_flag);
2223  if (current->pps_cu_chroma_qp_offset_list_enabled_flag) {
2224  ue(pps_chroma_qp_offset_list_len_minus1, 0, 5);
2225  for (i = 0; i <= current->pps_chroma_qp_offset_list_len_minus1; i++) {
2226  ses(pps_cb_qp_offset_list[i], -12, 12, 1, i);
2227  ses(pps_cr_qp_offset_list[i], -12, 12, 1, i);
2228  if (current->pps_joint_cbcr_qp_offset_present_flag)
2229  ses(pps_joint_cbcr_qp_offset_list[i], -12, 12, 1, i);
2230  else
2231  infer(pps_joint_cbcr_qp_offset_list[i], 0);
2232  }
2233  }
2234  } else {
2235  infer(pps_cb_qp_offset, 0);
2236  infer(pps_cr_qp_offset, 0);
2237  infer(pps_joint_cbcr_qp_offset_present_flag, 0);
2238  infer(pps_joint_cbcr_qp_offset_value, 0);
2239  infer(pps_slice_chroma_qp_offsets_present_flag, 0);
2240  infer(pps_cu_chroma_qp_offset_list_enabled_flag, 0);
2241  }
2242  flag(pps_deblocking_filter_control_present_flag);
2243  if (current->pps_deblocking_filter_control_present_flag) {
2244  flag(pps_deblocking_filter_override_enabled_flag);
2245  flag(pps_deblocking_filter_disabled_flag);
2246  if (!current->pps_no_pic_partition_flag &&
2247  current->pps_deblocking_filter_override_enabled_flag)
2248  flag(pps_dbf_info_in_ph_flag);
2249  else
2250  infer(pps_dbf_info_in_ph_flag, 0);
2251  if (!current->pps_deblocking_filter_disabled_flag) {
2252  se(pps_luma_beta_offset_div2, -12, 12);
2253  se(pps_luma_tc_offset_div2, -12, 12);
2254  if (current->pps_chroma_tool_offsets_present_flag) {
2255  se(pps_cb_beta_offset_div2, -12, 12);
2256  se(pps_cb_tc_offset_div2, -12, 12);
2257  se(pps_cr_beta_offset_div2, -12, 12);
2258  se(pps_cr_tc_offset_div2, -12, 12);
2259  } else {
2260  infer(pps_cb_beta_offset_div2,
2261  current->pps_luma_beta_offset_div2);
2262  infer(pps_cb_tc_offset_div2, current->pps_luma_tc_offset_div2);
2263  infer(pps_cr_beta_offset_div2,
2264  current->pps_luma_beta_offset_div2);
2265  infer(pps_cr_tc_offset_div2, current->pps_luma_tc_offset_div2);
2266  }
2267  } else {
2268  infer(pps_luma_beta_offset_div2, 0);
2269  infer(pps_luma_tc_offset_div2, 0);
2270  infer(pps_cb_beta_offset_div2, 0);
2271  infer(pps_cb_tc_offset_div2, 0);
2272  infer(pps_cr_beta_offset_div2, 0);
2273  infer(pps_cr_tc_offset_div2, 0);
2274  }
2275  } else {
2276  infer(pps_deblocking_filter_override_enabled_flag, 0);
2277  infer(pps_deblocking_filter_disabled_flag, 0);
2278  infer(pps_dbf_info_in_ph_flag, 0);
2279  infer(pps_luma_beta_offset_div2, 0);
2280  infer(pps_luma_tc_offset_div2, 0);
2281  infer(pps_cb_beta_offset_div2, 0);
2282  infer(pps_cb_tc_offset_div2, 0);
2283  infer(pps_cr_beta_offset_div2, 0);
2284  infer(pps_cr_tc_offset_div2, 0);
2285  }
2286 
2287  if (!current->pps_no_pic_partition_flag) {
2288  flag(pps_rpl_info_in_ph_flag);
2289  flag(pps_sao_info_in_ph_flag);
2290  flag(pps_alf_info_in_ph_flag);
2291  if ((current->pps_weighted_pred_flag ||
2292  current->pps_weighted_bipred_flag) &&
2293  current->pps_rpl_info_in_ph_flag)
2294  flag(pps_wp_info_in_ph_flag);
2295  flag(pps_qp_delta_info_in_ph_flag);
2296  }
2297  flag(pps_picture_header_extension_present_flag);
2298  flag(pps_slice_header_extension_present_flag);
2299 
2300  flag(pps_extension_flag);
2301  if (current->pps_extension_flag)
2302  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2303 
2304  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2305  return 0;
2306 }
2307 
2308 static int FUNC(alf_data)(CodedBitstreamContext *ctx, RWContext *rw,
2309  H266RawAPS *current)
2310 {
2311  int err, j, k;
2312 
2313  flag(alf_luma_filter_signal_flag);
2314 
2315  if (current->aps_chroma_present_flag) {
2316  flag(alf_chroma_filter_signal_flag);
2317  flag(alf_cc_cb_filter_signal_flag);
2318  flag(alf_cc_cr_filter_signal_flag);
2319  } else {
2320  infer(alf_chroma_filter_signal_flag, 0);
2321  infer(alf_cc_cb_filter_signal_flag, 0);
2322  infer(alf_cc_cr_filter_signal_flag, 0);
2323  }
2324 
2325  if (current->alf_luma_filter_signal_flag) {
2326  flag(alf_luma_clip_flag);
2327  ue(alf_luma_num_filters_signalled_minus1, 0, VVC_NUM_ALF_FILTERS - 1);
2328  if (current->alf_luma_num_filters_signalled_minus1 > 0) {
2329  unsigned int bits = av_ceil_log2(current->alf_luma_num_filters_signalled_minus1 + 1);
2330  for (int filt_idx = 0; filt_idx < VVC_NUM_ALF_FILTERS; filt_idx++)
2331  us(bits, alf_luma_coeff_delta_idx[filt_idx],
2332  0, current->alf_luma_num_filters_signalled_minus1,
2333  1, filt_idx);
2334  }
2335  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++)
2336  for (j = 0; j < 12; j++) {
2337  ues(alf_luma_coeff_abs[sf_idx][j], 0, 128, 2, sf_idx, j);
2338  if (current->alf_luma_coeff_abs[sf_idx][j])
2339  ubs(1, alf_luma_coeff_sign[sf_idx][j], 2, sf_idx, j);
2340  else
2341  infer(alf_luma_coeff_sign[sf_idx][j], 0);
2342  }
2343  } else {
2344  infer(alf_luma_clip_flag, 0);
2345  infer(alf_luma_num_filters_signalled_minus1, 0);
2346  }
2347  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++) {
2348  for (j = 0; j < 12; j++) {
2349  if (current->alf_luma_clip_flag)
2350  ubs(2, alf_luma_clip_idx[sf_idx][j], 2, sf_idx, j);
2351  else
2352  infer(alf_luma_clip_idx[sf_idx][j], 0);
2353  }
2354  }
2355 
2356  if (current->alf_chroma_filter_signal_flag) {
2357  flag(alf_chroma_clip_flag);
2358  ue(alf_chroma_num_alt_filters_minus1, 0, 7);
2359  } else {
2360  infer(alf_chroma_clip_flag, 0);
2361  infer(alf_chroma_num_alt_filters_minus1, 0);
2362  }
2363  for (int alt_idx = 0; alt_idx <= current->alf_chroma_num_alt_filters_minus1; alt_idx++) {
2364  for (j = 0; j < 6; j++) {
2365  if (current->alf_chroma_filter_signal_flag)
2366  ues(alf_chroma_coeff_abs[alt_idx][j], 0, 128, 2, alt_idx, j);
2367  else
2368  infer(alf_chroma_coeff_abs[alt_idx][j], 0);
2369  if (current->alf_chroma_coeff_abs[alt_idx][j] > 0)
2370  ubs(1, alf_chroma_coeff_sign[alt_idx][j], 2, alt_idx, j);
2371  else
2372  infer(alf_chroma_coeff_sign[alt_idx][j], 0);
2373  }
2374  for (j = 0; j < 6; j++) {
2375  if (current->alf_chroma_clip_flag)
2376  ubs(2, alf_chroma_clip_idx[alt_idx][j], 2, alt_idx, j);
2377  else
2378  infer(alf_chroma_clip_idx[alt_idx][j], 0);
2379  }
2380  }
2381 
2382  if (current->alf_cc_cb_filter_signal_flag)
2383  ue(alf_cc_cb_filters_signalled_minus1, 0, 3);
2384  else
2385  infer(alf_cc_cb_filters_signalled_minus1, 0);
2386  for (k = 0; k <= current->alf_cc_cb_filters_signalled_minus1; k++) {
2387  for (j = 0; j < 7; j++) {
2388  if (current->alf_cc_cb_filter_signal_flag)
2389  ubs(3, alf_cc_cb_mapped_coeff_abs[k][j], 2, k, j);
2390  else
2391  infer(alf_cc_cb_mapped_coeff_abs[k][j], 0);
2392  if (current->alf_cc_cb_mapped_coeff_abs[k][j])
2393  ubs(1, alf_cc_cb_coeff_sign[k][j], 2, k, j);
2394  else
2395  infer(alf_cc_cb_coeff_sign[k][j], 0);
2396  }
2397  }
2398 
2399  if (current->alf_cc_cr_filter_signal_flag)
2400  ue(alf_cc_cr_filters_signalled_minus1, 0, 3);
2401  else
2402  infer(alf_cc_cr_filters_signalled_minus1, 0);
2403  for (k = 0; k < current->alf_cc_cr_filters_signalled_minus1 + 1; k++) {
2404  for (j = 0; j < 7; j++) {
2405  if (current->alf_cc_cr_filter_signal_flag)
2406  ubs(3, alf_cc_cr_mapped_coeff_abs[k][j], 2, k, j);
2407  else
2408  infer(alf_cc_cr_mapped_coeff_abs[k][j], 0);
2409  if (current->alf_cc_cr_mapped_coeff_abs[k][j])
2410  ubs(1, alf_cc_cr_coeff_sign[k][j], 2, k, j);
2411  else
2412  infer(alf_cc_cr_coeff_sign[k][j], 0);
2413  }
2414  }
2415 
2416  return 0;
2417 }
2418 
2419 static int FUNC(lmcs_data)(CodedBitstreamContext *ctx, RWContext *rw,
2420  H266RawAPS *current)
2421 {
2422  int err, i, lmcs_max_bin_idx;
2423 
2424  ue(lmcs_min_bin_idx, 0, 15);
2425  ue(lmcs_delta_max_bin_idx, 0, 15);
2426  ue(lmcs_delta_cw_prec_minus1, 0, 14);
2427 
2428  lmcs_max_bin_idx = 15 - current->lmcs_delta_max_bin_idx;
2429 
2430  if (lmcs_max_bin_idx < current->lmcs_min_bin_idx)
2431  return AVERROR_INVALIDDATA;
2432 
2433  for (i = current->lmcs_min_bin_idx; i <= lmcs_max_bin_idx; i++) {
2434  ubs(current->lmcs_delta_cw_prec_minus1 + 1, lmcs_delta_abs_cw[i], 1, i);
2435  if (current->lmcs_delta_abs_cw[i] > 0)
2436  flags(lmcs_delta_sign_cw_flag[i], 1, i);
2437  else
2438  infer(lmcs_delta_sign_cw_flag[i], 0);
2439  }
2440 
2441  if (current->aps_chroma_present_flag) {
2442  ub(3, lmcs_delta_abs_crs);
2443  if (current->lmcs_delta_abs_crs > 0)
2444  flag(lmcs_delta_sign_crs_flag);
2445  else
2446  infer(lmcs_delta_sign_crs_flag, 0);
2447  } else {
2448  infer(lmcs_delta_abs_crs, 0);
2449  infer(lmcs_delta_sign_crs_flag, 0);
2450  }
2451 
2452  return 0;
2453 }
2454 
2455 static int FUNC(scaling_list_data)(CodedBitstreamContext *ctx, RWContext *rw,
2456  H266RawAPS *current)
2457 {
2458  // 7.4.3.4, deriving DiagScanOrder
2459  static const uint8_t diag_scan_order[64][2] = {
2460  { 0, 0, }, { 0, 1, }, { 1, 0, }, { 0, 2, }, { 1, 1, }, { 2, 0, }, { 0, 3, }, { 1, 2, },
2461  { 2, 1, }, { 3, 0, }, { 0, 4, }, { 1, 3, }, { 2, 2, }, { 3, 1, }, { 4, 0, }, { 0, 5, },
2462  { 1, 4, }, { 2, 3, }, { 3, 2, }, { 4, 1, }, { 5, 0, }, { 0, 6, }, { 1, 5, }, { 2, 4, },
2463  { 3, 3, }, { 4, 2, }, { 5, 1, }, { 6, 0, }, { 0, 7, }, { 1, 6, }, { 2, 5, }, { 3, 4, },
2464  { 4, 3, }, { 5, 2, }, { 6, 1, }, { 7, 0, }, { 1, 7, }, { 2, 6, }, { 3, 5, }, { 4, 4, },
2465  { 5, 3, }, { 6, 2, }, { 7, 1, }, { 2, 7, }, { 3, 6, }, { 4, 5, }, { 5, 4, }, { 6, 3, },
2466  { 7, 2, }, { 3, 7, }, { 4, 6, }, { 5, 5, }, { 6, 4, }, { 7, 3, }, { 4, 7, }, { 5, 6, },
2467  { 6, 5, }, { 7, 4, }, { 5, 7, }, { 6, 6, }, { 7, 5, }, { 6, 7, }, { 7, 6, }, { 7, 7, }, };
2468  int err;
2469 
2470  for (int id = 0; id < 28; id ++) {
2471  if (current->aps_chroma_present_flag || id % 3 == 2 || id == 27) {
2472  flags(scaling_list_copy_mode_flag[id], 1, id);
2473  if (!current->scaling_list_copy_mode_flag[id])
2474  flags(scaling_list_pred_mode_flag[id], 1, id);
2475  else
2476  infer(scaling_list_pred_mode_flag[id], 0);
2477  if ((current->scaling_list_copy_mode_flag[id] ||
2478  current->scaling_list_pred_mode_flag[id]) &&
2479  id != 0 && id != 2 && id != 8) {
2480  int max_id_delta = (id < 2) ? id : ((id < 8) ? (id - 2) : (id - 8));
2481  ues(scaling_list_pred_id_delta[id], 0, max_id_delta, 1, id);
2482  }
2483  if (!current->scaling_list_copy_mode_flag[id]) {
2484  int matrix_size = id < 2 ? 2 : (id < 8 ? 4 : 8);
2485  if (id > 13) {
2486  int idx = id - 14;
2487  ses(scaling_list_dc_coef[idx], -128, 127, 1, idx);
2488  }
2489  for (int i = 0; i < matrix_size * matrix_size; i++) {
2490  int x = diag_scan_order[i][0];
2491  int y = diag_scan_order[i][1];
2492  if (!(id > 25 && x >= 4 && y >= 4))
2493  ses(scaling_list_delta_coef[id][i], -128, 127, 2, id, i);
2494  }
2495  } else if (id > 13) {
2496  int idx = id - 14;
2497  infer(scaling_list_dc_coef[idx], 0);
2498  }
2499  } else {
2500  infer(scaling_list_copy_mode_flag[id], 1);
2501  infer(scaling_list_pred_mode_flag[id], 0);
2502  }
2503  }
2504 
2505  return 0;
2506 }
2507 
2508 static int FUNC(aps)(CodedBitstreamContext *ctx, RWContext *rw,
2509  H266RawAPS *current, int prefix)
2510 {
2511  int aps_id_max = MAX_UINT_BITS(5);
2512  int err;
2513 
2514  if (prefix)
2515  HEADER("Prefix Adaptation parameter set");
2516  else
2517  HEADER("Suffix Adaptation parameter set");
2518 
2519  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
2520  prefix ? VVC_PREFIX_APS_NUT
2521  : VVC_SUFFIX_APS_NUT));
2522 
2523  ub(3, aps_params_type);
2524  if (current->aps_params_type == VVC_ASP_TYPE_ALF ||
2525  current->aps_params_type == VVC_ASP_TYPE_SCALING)
2526  aps_id_max = 7;
2527  else if (current->aps_params_type == VVC_ASP_TYPE_LMCS)
2528  aps_id_max = 3;
2529  u(5, aps_adaptation_parameter_set_id, 0, aps_id_max);
2530  flag(aps_chroma_present_flag);
2531  if (current->aps_params_type == VVC_ASP_TYPE_ALF)
2532  CHECK(FUNC(alf_data)(ctx, rw, current));
2533  else if(current->aps_params_type == VVC_ASP_TYPE_LMCS)
2534  CHECK(FUNC(lmcs_data)(ctx, rw, current));
2535  else if (current->aps_params_type == VVC_ASP_TYPE_SCALING)
2536  CHECK(FUNC(scaling_list_data)(ctx, rw, current));
2537  flag(aps_extension_flag);
2538  if (current->aps_extension_flag)
2539  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2540  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2541 
2542  return 0;
2543 }
2544 
2545 static int FUNC(aud) (CodedBitstreamContext *ctx, RWContext *rw,
2546  H266RawAUD *current)
2547 {
2548  int err;
2549 
2550  HEADER("Access Unit Delimiter");
2551 
2552  CHECK(FUNC(nal_unit_header) (ctx, rw,
2553  &current->nal_unit_header, VVC_AUD_NUT));
2554 
2555  flag(aud_irap_or_gdr_flag);
2556  u(3, aud_pic_type, 0, 2);
2557 
2558  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2559  return 0;
2560 }
2561 
2562 static int FUNC(pred_weight_table) (CodedBitstreamContext *ctx, RWContext *rw,
2563  const H266RawSPS *sps,
2564  const H266RawPPS *pps,
2565  const H266RefPicLists *ref_lists,
2566  uint8_t num_ref_idx_active[2],
2567  H266RawPredWeightTable *current)
2568 {
2569  int err, i, j;
2570  ue(luma_log2_weight_denom, 0, 7);
2571  if (sps->sps_chroma_format_idc != 0) {
2572  se(delta_chroma_log2_weight_denom,
2573  -current->luma_log2_weight_denom,
2574  7 - current->luma_log2_weight_denom);
2575  } else {
2576  infer(delta_chroma_log2_weight_denom, 0);
2577  }
2578  if (pps->pps_wp_info_in_ph_flag) {
2579  ue(num_l0_weights, 0,
2580  FFMIN(15, ref_lists->rpl_ref_list[0].num_ref_entries));
2581  infer(num_weights_l0, current->num_l0_weights);
2582  } else {
2583  infer(num_weights_l0, num_ref_idx_active[0]);
2584  }
2585  for (i = 0; i < current->num_weights_l0; i++) {
2586  flags(luma_weight_l0_flag[i], 1, i);
2587  }
2588  if (sps->sps_chroma_format_idc != 0) {
2589  for (i = 0; i < current->num_weights_l0; i++)
2590  flags(chroma_weight_l0_flag[i], 1, i);
2591  }
2592  for (i = 0; i < current->num_weights_l0; i++) {
2593  if (current->luma_weight_l0_flag[i]) {
2594  ses(delta_luma_weight_l0[i], -128, 127, 1, i);
2595  ses(luma_offset_l0[i], -128, 127, 1, i);
2596  } else {
2597  infer(delta_luma_weight_l0[i], 0);
2598  infer(luma_offset_l0[i], 0);
2599  }
2600  if (current->chroma_weight_l0_flag[i]) {
2601  for (j = 0; j < 2; j++) {
2602  ses(delta_chroma_weight_l0[i][j], -128, 127, 2, i, j);
2603  ses(delta_chroma_offset_l0[i][j], -4 * 128, 4 * 127, 2, i, j);
2604  }
2605  }
2606  }
2607 
2608  if (pps->pps_weighted_bipred_flag &&
2609  ref_lists->rpl_ref_list[1].num_ref_entries > 0) {
2610  if (pps->pps_wp_info_in_ph_flag) {
2611  ue(num_l1_weights, 0,
2612  FFMIN(15, ref_lists->rpl_ref_list[1].num_ref_entries));
2613  infer(num_weights_l1, current->num_l1_weights);
2614  } else {
2615  infer(num_weights_l1, num_ref_idx_active[1]);
2616  }
2617  } else {
2618  infer(num_weights_l1, 0);
2619  }
2620 
2621  for (i = 0; i < current->num_weights_l1; i++)
2622  flags(luma_weight_l1_flag[i], 1, i);
2623  if (sps->sps_chroma_format_idc != 0) {
2624  for (i = 0; i < current->num_weights_l1; i++)
2625  flags(chroma_weight_l1_flag[i], 1, i);
2626  }
2627  for (i = 0; i < current->num_weights_l1; i++) {
2628  if (current->luma_weight_l1_flag[i]) {
2629  ses(delta_luma_weight_l1[i], -128, 127, 1, i);
2630  ses(luma_offset_l1[i], -128, 127, 1, i);
2631  } else {
2632  infer(delta_luma_weight_l1[i], 0);
2633  infer(luma_offset_l1[i], 0);
2634  }
2635  if (current->chroma_weight_l1_flag[i]) {
2636  for (j = 0; j < 2; j++) {
2637  ses(delta_chroma_weight_l1[i][j], -128, 127, 2, i, j);
2638  ses(delta_chroma_offset_l1[i][j], -4 * 128, 4 * 127, 2, i, j);
2639  }
2640  }
2641  }
2642  return 0;
2643 }
2644 
2645 static int FUNC(picture_header) (CodedBitstreamContext *ctx, RWContext *rw,
2646  H266RawPictureHeader *current) {
2647  CodedBitstreamH266Context *h266 = ctx->priv_data;
2648  const H266RawVPS *vps;
2649  const H266RawSPS *sps;
2650  const H266RawPPS *pps;
2651  int err, i;
2652  unsigned int ctb_log2_size_y, min_cb_log2_size_y,
2653  min_qt_log2_size_intra_y, min_qt_log2_size_inter_y;
2654  uint8_t qp_bd_offset;
2655 
2656  flag(ph_gdr_or_irap_pic_flag);
2657  flag(ph_non_ref_pic_flag);
2658  if (current->ph_gdr_or_irap_pic_flag)
2659  flag(ph_gdr_pic_flag);
2660  else
2661  infer(ph_gdr_pic_flag, 0);
2662  flag(ph_inter_slice_allowed_flag);
2663  if (current->ph_inter_slice_allowed_flag)
2664  flag(ph_intra_slice_allowed_flag);
2665  else
2666  infer(ph_intra_slice_allowed_flag, 1);
2667  ue(ph_pic_parameter_set_id, 0, VVC_MAX_PPS_COUNT - 1);
2668  pps = h266->pps[current->ph_pic_parameter_set_id];
2669  if (!pps) {
2670  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
2671  current->ph_pic_parameter_set_id);
2672  return AVERROR_INVALIDDATA;
2673  }
2674  sps = h266->sps[pps->pps_seq_parameter_set_id];
2675  if (!sps) {
2676  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
2677  pps->pps_seq_parameter_set_id);
2678  return AVERROR_INVALIDDATA;
2679  }
2680  vps = h266->vps[sps->sps_video_parameter_set_id];
2681  if (!vps) {
2682  av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
2683  sps->sps_video_parameter_set_id);
2684  return AVERROR_INVALIDDATA;
2685  }
2686 
2687  ub(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_pic_order_cnt_lsb);
2688  if (current->ph_gdr_pic_flag)
2689  ue(ph_recovery_poc_cnt, 0,
2690  1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4));
2691 
2692  for (i = 0; i < sps->sps_num_extra_ph_bytes * 8; i++) {
2693  if (sps->sps_extra_ph_bit_present_flag[i])
2694  flags(ph_extra_bit[i], 1, i);
2695  }
2696  if (sps->sps_poc_msb_cycle_flag) {
2697  flag(ph_poc_msb_cycle_present_flag);
2698  if (current->ph_poc_msb_cycle_present_flag)
2699  ub(sps->sps_poc_msb_cycle_len_minus1 + 1, ph_poc_msb_cycle_val);
2700  }
2701  if (sps->sps_alf_enabled_flag && pps->pps_alf_info_in_ph_flag) {
2702  flag(ph_alf_enabled_flag);
2703  if (current->ph_alf_enabled_flag) {
2704 
2705  ub(3, ph_num_alf_aps_ids_luma);
2706  for (i = 0; i < current->ph_num_alf_aps_ids_luma; i++)
2707  ubs(3, ph_alf_aps_id_luma[i], 1, i);
2708 
2709  if (sps->sps_chroma_format_idc != 0) {
2710  flag(ph_alf_cb_enabled_flag);
2711  flag(ph_alf_cr_enabled_flag);
2712  } else {
2713  infer(ph_alf_cb_enabled_flag, 0);
2714  infer(ph_alf_cr_enabled_flag, 0);
2715  }
2716 
2717  if (current->ph_alf_cb_enabled_flag
2718  || current->ph_alf_cr_enabled_flag) {
2719  ub(3, ph_alf_aps_id_chroma);
2720  }
2721 
2722  if (sps->sps_ccalf_enabled_flag) {
2723  flag(ph_alf_cc_cb_enabled_flag);
2724  if (current->ph_alf_cc_cb_enabled_flag)
2725  ub(3, ph_alf_cc_cb_aps_id);
2726  flag(ph_alf_cc_cr_enabled_flag);
2727  if (current->ph_alf_cc_cr_enabled_flag)
2728  ub(3, ph_alf_cc_cr_aps_id);
2729  }
2730  }
2731  } else {
2732  infer(ph_alf_enabled_flag, 0);
2733  }
2734  if (sps->sps_lmcs_enabled_flag) {
2735  flag(ph_lmcs_enabled_flag);
2736  if (current->ph_lmcs_enabled_flag) {
2737  ub(2, ph_lmcs_aps_id);
2738  if (sps->sps_chroma_format_idc != 0)
2739  flag(ph_chroma_residual_scale_flag);
2740  else
2741  infer(ph_chroma_residual_scale_flag, 0);
2742  }
2743  } else {
2744  infer(ph_lmcs_enabled_flag, 0);
2745  infer(ph_chroma_residual_scale_flag, 0);
2746  }
2747 
2748  if (sps->sps_explicit_scaling_list_enabled_flag) {
2749  flag(ph_explicit_scaling_list_enabled_flag);
2750  if (current->ph_explicit_scaling_list_enabled_flag) {
2751  //todo: check the ph_scaling_list_aps_id range, when aps ready
2752  ub(3, ph_scaling_list_aps_id);
2753  }
2754  } else {
2755  infer(ph_explicit_scaling_list_enabled_flag, 0);
2756  }
2757  if (sps->sps_virtual_boundaries_enabled_flag &&
2758  !sps->sps_virtual_boundaries_present_flag) {
2759  flag(ph_virtual_boundaries_present_flag);
2760  if (current->ph_virtual_boundaries_present_flag) {
2761  ue(ph_num_ver_virtual_boundaries,
2762  0, pps->pps_pic_width_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
2763  for (i = 0; i < current->ph_num_ver_virtual_boundaries; i++) {
2764  ues(ph_virtual_boundary_pos_x_minus1[i],
2765  0, (pps->pps_pic_width_in_luma_samples + 7) / 8 - 2, 1, i);
2766  }
2767  ue(ph_num_hor_virtual_boundaries,
2768  0, pps->pps_pic_height_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
2769  for (i = 0; i < current->ph_num_hor_virtual_boundaries; i++) {
2770  ues(ph_virtual_boundary_pos_y_minus1[i],
2771  0, (pps->pps_pic_height_in_luma_samples + 7) / 8 - 2, 1, i);
2772  }
2773  } else {
2774  infer(ph_num_ver_virtual_boundaries, 0);
2775  infer(ph_num_hor_virtual_boundaries, 0);
2776  }
2777  }
2778  if (pps->pps_output_flag_present_flag && !current->ph_non_ref_pic_flag)
2779  flag(ph_pic_output_flag);
2780  else
2781  infer(ph_pic_output_flag, 1);
2782  if (pps->pps_rpl_info_in_ph_flag) {
2783  CHECK(FUNC(ref_pic_lists)
2784  (ctx, rw, sps, pps, &current->ph_ref_pic_lists));
2785  }
2786  if (sps->sps_partition_constraints_override_enabled_flag)
2787  flag(ph_partition_constraints_override_flag);
2788  else
2789  infer(ph_partition_constraints_override_flag, 0);
2790 
2791  ctb_log2_size_y = sps->sps_log2_ctu_size_minus5 + 5;
2792  min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
2793  if (current->ph_intra_slice_allowed_flag) {
2794  if (current->ph_partition_constraints_override_flag) {
2795  ue(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2796  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2797  ue(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2798  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2799  if (current->ph_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
2800  min_qt_log2_size_intra_y =
2801  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2802  min_cb_log2_size_y;
2803  ue(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2804  0, (sps->sps_qtbtt_dual_tree_intra_flag ?
2805  FFMIN(6, ctb_log2_size_y) :
2806  ctb_log2_size_y) - min_qt_log2_size_intra_y);
2807  ue(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2808  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
2809  } else {
2810  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2811  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2812  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2813  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2814  }
2815  if (sps->sps_qtbtt_dual_tree_intra_flag) {
2816  ue(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2817  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2818  ue(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2819  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2820  if (sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
2821  unsigned int min_qt_log2_size_intra_c =
2822  current->ph_log2_diff_min_qt_min_cb_intra_slice_chroma +
2823  min_cb_log2_size_y;
2824  ue(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2825  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2826  ue(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2827  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2828  } else {
2829  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2830  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2831  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2832  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2833  }
2834  }
2835  } else {
2836  infer(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2837  sps->sps_log2_diff_min_qt_min_cb_intra_slice_luma);
2838  infer(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2839  sps->sps_max_mtt_hierarchy_depth_intra_slice_luma);
2840  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2841  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2842  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2843  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2844  infer(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2845  sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma);
2846  infer(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2847  sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma);
2848  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2849  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2850  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2851  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2852  }
2853 
2854  min_qt_log2_size_intra_y =
2855  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2856  min_cb_log2_size_y;
2857  if (pps->pps_cu_qp_delta_enabled_flag)
2858  ue(ph_cu_qp_delta_subdiv_intra_slice, 0,
2859  2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2860  current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2861  else
2862  infer(ph_cu_qp_delta_subdiv_intra_slice, 0);
2863 
2864  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2865  ue(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0,
2866  2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2867  current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2868  else
2869  infer(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0);
2870  }
2871  if (current->ph_inter_slice_allowed_flag) {
2872  if (current->ph_partition_constraints_override_flag) {
2873  ue(ph_log2_diff_min_qt_min_cb_inter_slice,
2874  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2875  min_qt_log2_size_inter_y =
2876  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2877  min_cb_log2_size_y;
2878  ue(ph_max_mtt_hierarchy_depth_inter_slice, 0,
2879  2 * (ctb_log2_size_y - min_cb_log2_size_y));
2880  if (current->ph_max_mtt_hierarchy_depth_inter_slice != 0) {
2881  ue(ph_log2_diff_max_bt_min_qt_inter_slice,
2882  0, ctb_log2_size_y - min_qt_log2_size_inter_y);
2883  ue(ph_log2_diff_max_tt_min_qt_inter_slice,
2884  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
2885  }
2886  } else {
2887  infer(ph_log2_diff_min_qt_min_cb_inter_slice,
2888  sps->sps_log2_diff_min_qt_min_cb_inter_slice);
2889  min_qt_log2_size_inter_y =
2890  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2891  min_cb_log2_size_y;
2892  infer(ph_max_mtt_hierarchy_depth_inter_slice,
2893  sps->sps_max_mtt_hierarchy_depth_inter_slice);
2894  infer(ph_log2_diff_max_bt_min_qt_inter_slice,
2895  sps->sps_log2_diff_max_bt_min_qt_inter_slice);
2896  infer(ph_log2_diff_max_tt_min_qt_inter_slice,
2897  sps->sps_log2_diff_max_tt_min_qt_inter_slice);
2898  }
2899 
2900  if (pps->pps_cu_qp_delta_enabled_flag)
2901  ue(ph_cu_qp_delta_subdiv_inter_slice, 0,
2902  2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2903  current->ph_max_mtt_hierarchy_depth_inter_slice));
2904  else
2905  infer(ph_cu_qp_delta_subdiv_inter_slice, 0);
2906 
2907  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2908  ue(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0,
2909  2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2910  current->ph_max_mtt_hierarchy_depth_inter_slice));
2911  else
2912  infer(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0);
2913  if (sps->sps_temporal_mvp_enabled_flag) {
2914  flag(ph_temporal_mvp_enabled_flag);
2915  if (current->ph_temporal_mvp_enabled_flag &&
2916  pps->pps_rpl_info_in_ph_flag) {
2917  if (current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0)
2918  flag(ph_collocated_from_l0_flag);
2919  else
2920  infer(ph_collocated_from_l0_flag, 1);
2921  if ((current->ph_collocated_from_l0_flag &&
2922  current->ph_ref_pic_lists.rpl_ref_list[0].num_ref_entries > 1)
2923  || (!current->ph_collocated_from_l0_flag &&
2924  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 1)) {
2925  unsigned int idx =
2926  current->ph_collocated_from_l0_flag ? 0 : 1;
2927  ue(ph_collocated_ref_idx, 0,
2928  current->ph_ref_pic_lists.rpl_ref_list[idx].
2929  num_ref_entries - 1);
2930  } else {
2931  infer(ph_collocated_ref_idx, 0);
2932  }
2933  }
2934  }
2935  if (sps->sps_mmvd_fullpel_only_enabled_flag)
2936  flag(ph_mmvd_fullpel_only_flag);
2937  else
2938  infer(ph_mmvd_fullpel_only_flag, 0);
2939  if (!pps->pps_rpl_info_in_ph_flag ||
2940  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) {
2941  flag(ph_mvd_l1_zero_flag);
2942  if (sps->sps_bdof_control_present_in_ph_flag) {
2943  flag(ph_bdof_disabled_flag);
2944  } else {
2945  if (!sps->sps_bdof_control_present_in_ph_flag)
2946  infer(ph_bdof_disabled_flag,
2947  1 - sps->sps_bdof_enabled_flag);
2948  else
2949  infer(ph_bdof_disabled_flag, 1);
2950  }
2951  if (sps->sps_dmvr_control_present_in_ph_flag) {
2952  flag(ph_dmvr_disabled_flag);
2953  } else {
2954  if (!sps->sps_dmvr_control_present_in_ph_flag)
2955  infer(ph_dmvr_disabled_flag,
2956  1 - sps->sps_dmvr_enabled_flag);
2957  else
2958  infer(ph_dmvr_disabled_flag, 1);
2959  }
2960  } else {
2961  infer(ph_mvd_l1_zero_flag, 1);
2962  }
2963  if (sps->sps_prof_control_present_in_ph_flag)
2964  flag(ph_prof_disabled_flag);
2965  else
2966  infer(ph_prof_disabled_flag, !sps->sps_affine_prof_enabled_flag);
2967  if ((pps->pps_weighted_pred_flag ||
2968  pps->pps_weighted_bipred_flag) && pps->pps_wp_info_in_ph_flag) {
2969 
2970  // if pps->pps_wp_info_in_ph_fla == 1
2971  // pred_weight_table will not use num_ref_idx_active
2972  uint8_t num_ref_idx_active[2] = { 0, 0 };
2973  CHECK(FUNC(pred_weight_table)
2974  (ctx, rw, sps, pps, &current->ph_ref_pic_lists,
2975  num_ref_idx_active, &current->ph_pred_weight_table));
2976  }
2977  }
2978 
2979  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2980  if (pps->pps_qp_delta_info_in_ph_flag)
2981  se(ph_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
2982  63 - (26 + pps->pps_init_qp_minus26));
2983 
2984  if (sps->sps_joint_cbcr_enabled_flag)
2985  flag(ph_joint_cbcr_sign_flag);
2986  else
2987  infer(ph_joint_cbcr_sign_flag, 0);
2988  if (sps->sps_sao_enabled_flag && pps->pps_sao_info_in_ph_flag) {
2989  flag(ph_sao_luma_enabled_flag);
2990  if (sps->sps_chroma_format_idc != 0)
2991  flag(ph_sao_chroma_enabled_flag);
2992  else
2993  infer(ph_sao_chroma_enabled_flag, 0);
2994  } else {
2995  infer(ph_sao_luma_enabled_flag, 0);
2996  infer(ph_sao_chroma_enabled_flag, 0);
2997  }
2998 
2999  if (pps->pps_dbf_info_in_ph_flag)
3000  flag(ph_deblocking_params_present_flag);
3001  else
3002  infer(ph_deblocking_params_present_flag, 0);
3003 
3004  if (current->ph_deblocking_params_present_flag) {
3005  if (!pps->pps_deblocking_filter_disabled_flag) {
3006  flag(ph_deblocking_filter_disabled_flag);
3007  if (!current->ph_deblocking_filter_disabled_flag) {
3008  se(ph_luma_beta_offset_div2, -12, 12);
3009  se(ph_luma_tc_offset_div2, -12, 12);
3010  if (pps->pps_chroma_tool_offsets_present_flag) {
3011  se(ph_cb_beta_offset_div2, -12, 12);
3012  se(ph_cb_tc_offset_div2, -12, 12);
3013  se(ph_cr_beta_offset_div2, -12, 12);
3014  se(ph_cr_tc_offset_div2, -12, 12);
3015  } else {
3016  infer(ph_cb_beta_offset_div2,
3017  current->ph_luma_beta_offset_div2);
3018  infer(ph_cb_tc_offset_div2,
3019  current->ph_luma_tc_offset_div2);
3020  infer(ph_cr_beta_offset_div2,
3021  current->ph_luma_beta_offset_div2);
3022  infer(ph_cr_tc_offset_div2,
3023  current->ph_luma_tc_offset_div2);
3024  }
3025  }
3026  } else {
3027  infer(ph_deblocking_filter_disabled_flag, 0);
3028  }
3029  } else {
3030  infer(ph_deblocking_filter_disabled_flag, pps->pps_deblocking_filter_disabled_flag);
3031  if (!current->ph_deblocking_filter_disabled_flag) {
3032  infer(ph_luma_beta_offset_div2, pps->pps_luma_beta_offset_div2);
3033  infer(ph_luma_tc_offset_div2, pps->pps_luma_tc_offset_div2);
3034  infer(ph_cb_beta_offset_div2, pps->pps_cb_beta_offset_div2);
3035  infer(ph_cb_tc_offset_div2, pps->pps_cb_tc_offset_div2);
3036  infer(ph_cr_beta_offset_div2, pps->pps_cr_beta_offset_div2);
3037  infer(ph_cr_tc_offset_div2, pps->pps_cr_tc_offset_div2);
3038  }
3039  }
3040 
3041  if (pps->pps_picture_header_extension_present_flag) {
3042  ue(ph_extension_length, 0, 256);
3043  for (i = 0; i < current->ph_extension_length; i++)
3044  us(8, ph_extension_data_byte[i], 0x00, 0xff, 1, i);
3045  }
3046 
3047  return 0;
3048 }
3049 
3050 static int FUNC(ph) (CodedBitstreamContext *ctx, RWContext *rw,
3051  H266RawPH *current)
3052 {
3053  int err;
3054 
3055  HEADER("Picture Header");
3056 
3057  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, VVC_PH_NUT));
3058  CHECK(FUNC(picture_header) (ctx, rw, &current->ph_picture_header));
3059  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3060  return 0;
3061 }
3062 
3063 static int FUNC(slice_header) (CodedBitstreamContext *ctx, RWContext *rw,
3064  H266RawSliceHeader *current)
3065 {
3066  CodedBitstreamH266Context *h266 = ctx->priv_data;
3067  const H266RawSPS *sps;
3068  const H266RawPPS *pps;
3069  const H266RawPictureHeader *ph;
3070  const H266RefPicLists *ref_pic_lists;
3071  int err, i;
3072  uint8_t nal_unit_type, qp_bd_offset;
3073  uint16_t num_slices_in_subpic;
3074 
3075  HEADER("Slice Header");
3076 
3077  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, -1));
3078 
3079  flag(sh_picture_header_in_slice_header_flag);
3080  if (current->sh_picture_header_in_slice_header_flag) {
3081  // 7.4.8 if sh_picture_header_in_slice_header_flag is true, we do not have a PH NAL unit
3082  CHECK(FUNC(picture_header) (ctx, rw, &current->sh_picture_header));
3083  ph = &current->sh_picture_header;
3084  } else {
3085  ph = h266->ph;
3086  if (!ph) {
3087  av_log(ctx->log_ctx, AV_LOG_ERROR,
3088  "Picture header not available.\n");
3089  return AVERROR_INVALIDDATA;
3090  }
3091  }
3092 
3093  pps = h266->pps[ph->ph_pic_parameter_set_id];
3094  if (!pps) {
3095  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
3096  ph->ph_pic_parameter_set_id);
3097  return AVERROR_INVALIDDATA;
3098  }
3099  sps = h266->sps[pps->pps_seq_parameter_set_id];
3100  if (!sps) {
3101  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
3102  pps->pps_seq_parameter_set_id);
3103  return AVERROR_INVALIDDATA;
3104  }
3105 
3106  if (sps->sps_subpic_info_present_flag) {
3107  ub(sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id);
3108  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
3109  if (pps->sub_pic_id_val[i] == current->sh_subpic_id) {
3110  current->curr_subpic_idx = i;
3111  break;
3112  }
3113  }
3114  if (i > sps->sps_num_subpics_minus1) {
3115  av_log(ctx->log_ctx, AV_LOG_ERROR, "invalid CurrSubpicIdx %d\n", i);
3116  return AVERROR_INVALIDDATA;
3117  }
3118  } else {
3119  current->curr_subpic_idx = 0;
3120  }
3121 
3122  num_slices_in_subpic = pps->num_slices_in_subpic[current->curr_subpic_idx];
3123 
3124  if ((pps->pps_rect_slice_flag && num_slices_in_subpic > 1) ||
3125  (!pps->pps_rect_slice_flag && pps->num_tiles_in_pic > 1)) {
3126  unsigned int bits, max;
3127  if (!pps->pps_rect_slice_flag) {
3128  bits = av_ceil_log2(pps->num_tiles_in_pic);
3129  max = pps->num_tiles_in_pic - 1;
3130  } else {
3131  bits = av_ceil_log2(num_slices_in_subpic);
3132  max = num_slices_in_subpic - 1;
3133  }
3134  u(bits, sh_slice_address, 0, max);
3135  } else {
3136  infer(sh_slice_address, 0);
3137  }
3138 
3139  for (i = 0; i < sps->sps_num_extra_sh_bytes * 8; i++) {
3140  if (sps->sps_extra_sh_bit_present_flag[i])
3141  flags(sh_extra_bit[i], 1, i);
3142  }
3143 
3144  if (!pps->pps_rect_slice_flag &&
3145  pps->num_tiles_in_pic - current->sh_slice_address > 1)
3146  ue(sh_num_tiles_in_slice_minus1, 0, pps->num_tiles_in_pic - 1);
3147  else
3148  infer(sh_num_tiles_in_slice_minus1, 0);
3149 
3150  if (ph->ph_inter_slice_allowed_flag)
3151  ue(sh_slice_type, 0, 2);
3152  else
3153  infer(sh_slice_type, 2);
3154 
3155  nal_unit_type = current->nal_unit_header.nal_unit_type;
3156  if (nal_unit_type == VVC_IDR_W_RADL || nal_unit_type == VVC_IDR_N_LP ||
3157  nal_unit_type == VVC_CRA_NUT || nal_unit_type == VVC_GDR_NUT)
3158  flag(sh_no_output_of_prior_pics_flag);
3159 
3160  if (sps->sps_alf_enabled_flag) {
3161  if (!pps->pps_alf_info_in_ph_flag) {
3162  flag(sh_alf_enabled_flag);
3163  if (current->sh_alf_enabled_flag) {
3164  ub(3, sh_num_alf_aps_ids_luma);
3165  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3166  ubs(3, sh_alf_aps_id_luma[i], 1, i);
3167 
3168  if (sps->sps_chroma_format_idc != 0) {
3169  flag(sh_alf_cb_enabled_flag);
3170  flag(sh_alf_cr_enabled_flag);
3171  }
3172  if (current->sh_alf_cb_enabled_flag ||
3173  current->sh_alf_cr_enabled_flag) {
3174  ub(3, sh_alf_aps_id_chroma);
3175  }
3176 
3177  if (sps->sps_ccalf_enabled_flag) {
3178  flag(sh_alf_cc_cb_enabled_flag);
3179  if (current->sh_alf_cc_cb_enabled_flag)
3180  ub(3, sh_alf_cc_cb_aps_id);
3181 
3182  flag(sh_alf_cc_cr_enabled_flag);
3183  if (current->sh_alf_cc_cr_enabled_flag)
3184  ub(3, sh_alf_cc_cr_aps_id);
3185  }
3186  }
3187  } else {
3188  infer(sh_alf_enabled_flag, ph->ph_alf_enabled_flag);
3189  if (current->sh_alf_enabled_flag) {
3190  infer(sh_num_alf_aps_ids_luma, ph->ph_num_alf_aps_ids_luma);
3191  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3192  infer(sh_alf_aps_id_luma[i], ph->ph_alf_aps_id_luma[i]);
3193 
3194  infer(sh_alf_cb_enabled_flag, ph->ph_alf_cb_enabled_flag);
3195  infer(sh_alf_cr_enabled_flag, ph->ph_alf_cr_enabled_flag);
3196  if (current->sh_alf_cb_enabled_flag ||current->sh_alf_cr_enabled_flag)
3197  infer(sh_alf_aps_id_chroma, ph->ph_alf_aps_id_chroma);
3198 
3199  if (sps->sps_ccalf_enabled_flag) {
3200  infer(sh_alf_cc_cb_enabled_flag, ph->ph_alf_cc_cb_enabled_flag);
3201  if (current->sh_alf_cc_cb_enabled_flag)
3202  infer(sh_alf_cc_cb_aps_id, ph->ph_alf_cc_cb_aps_id);
3203 
3204  infer(sh_alf_cc_cr_enabled_flag, ph->ph_alf_cc_cr_enabled_flag);
3205  if (current->sh_alf_cc_cr_enabled_flag)
3206  infer(sh_alf_cc_cr_aps_id, ph->ph_alf_cc_cr_aps_id);
3207  }
3208  }
3209  }
3210  }
3211 
3212  if (current->sh_picture_header_in_slice_header_flag) {
3213  infer(sh_lmcs_used_flag, ph->ph_lmcs_enabled_flag);
3214  infer(sh_explicit_scaling_list_used_flag,
3215  ph->ph_explicit_scaling_list_enabled_flag);
3216  } else {
3217  if (ph->ph_lmcs_enabled_flag)
3218  flag(sh_lmcs_used_flag);
3219  else
3220  infer(sh_lmcs_used_flag, 0);
3221 
3222  if (ph->ph_explicit_scaling_list_enabled_flag)
3223  flag(sh_explicit_scaling_list_used_flag);
3224  else
3225  infer(sh_explicit_scaling_list_used_flag, 0);
3226  }
3227 
3228  if (!pps->pps_rpl_info_in_ph_flag &&
3229  ((nal_unit_type != VVC_IDR_W_RADL &&
3230  nal_unit_type != VVC_IDR_N_LP) || sps->sps_idr_rpl_present_flag)) {
3231  CHECK(FUNC(ref_pic_lists)
3232  (ctx, rw, sps, pps, &current->sh_ref_pic_lists));
3233  ref_pic_lists = &current->sh_ref_pic_lists;
3234  } else {
3235  ref_pic_lists = &ph->ph_ref_pic_lists;
3236  }
3237  if ((current->sh_slice_type != VVC_SLICE_TYPE_I &&
3238  ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) ||
3239  (current->sh_slice_type == VVC_SLICE_TYPE_B &&
3240  ref_pic_lists->rpl_ref_list[1].num_ref_entries > 1)) {
3241  flag(sh_num_ref_idx_active_override_flag);
3242  if (current->sh_num_ref_idx_active_override_flag) {
3243  for (i = 0;
3244  i < (current->sh_slice_type == VVC_SLICE_TYPE_B ? 2 : 1); i++)
3245  if (ref_pic_lists->rpl_ref_list[i].num_ref_entries > 1)
3246  ues(sh_num_ref_idx_active_minus1[i], 0, 14, 1, i);
3247  else
3248  infer(sh_num_ref_idx_active_minus1[i], 0);
3249  }
3250  } else {
3251  infer(sh_num_ref_idx_active_override_flag, 1);
3252  }
3253 
3254  for (i = 0; i < 2; i++) {
3255  if (current->sh_slice_type == VVC_SLICE_TYPE_B ||
3256  (current->sh_slice_type == VVC_SLICE_TYPE_P && i == 0)) {
3257  if (current->sh_num_ref_idx_active_override_flag) {
3258  current->num_ref_idx_active[i] = current->sh_num_ref_idx_active_minus1[i] + 1;
3259  } else {
3260  current->num_ref_idx_active[i] =
3261  FFMIN(ref_pic_lists->rpl_ref_list[i].num_ref_entries,
3262  pps->pps_num_ref_idx_default_active_minus1[i] + 1);
3263  }
3264 
3265  if (current->num_ref_idx_active[i] <= 0) {
3266  av_log(ctx->log_ctx, AV_LOG_ERROR,
3267  "Inter slice but no reference pictures available for RPL%d.\n", i);
3268  return AVERROR_INVALIDDATA;
3269  }
3270  } else {
3271  current->num_ref_idx_active[i] = 0;
3272  }
3273  }
3274 
3275  if (current->sh_slice_type != VVC_SLICE_TYPE_I) {
3276  if (pps->pps_cabac_init_present_flag)
3277  flag(sh_cabac_init_flag);
3278  else
3279  infer(sh_cabac_init_flag, 0);
3280  if (ph->ph_temporal_mvp_enabled_flag) {
3281  if (!pps->pps_rpl_info_in_ph_flag) {
3282  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3283  flag(sh_collocated_from_l0_flag);
3284  else
3285  infer(sh_collocated_from_l0_flag, 1);
3286  if ((current->sh_collocated_from_l0_flag &&
3287  current->num_ref_idx_active[0] > 1) ||
3288  (!current->sh_collocated_from_l0_flag &&
3289  current->num_ref_idx_active[1] > 1)) {
3290  unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1;
3291  ue(sh_collocated_ref_idx, 0, current->num_ref_idx_active[idx] - 1);
3292  } else {
3293  infer(sh_collocated_ref_idx, 0);
3294  }
3295  } else {
3296  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3297  infer(sh_collocated_from_l0_flag, ph->ph_collocated_from_l0_flag);
3298  else
3299  infer(sh_collocated_from_l0_flag, 1);
3300  infer(sh_collocated_ref_idx, ph->ph_collocated_ref_idx);
3301  }
3302  }
3303  if (!pps->pps_wp_info_in_ph_flag &&
3304  ((pps->pps_weighted_pred_flag &&
3305  current->sh_slice_type == VVC_SLICE_TYPE_P) ||
3306  (pps->pps_weighted_bipred_flag &&
3307  current->sh_slice_type == VVC_SLICE_TYPE_B))) {
3308  CHECK(FUNC(pred_weight_table) (ctx, rw, sps, pps, ref_pic_lists,
3309  current->num_ref_idx_active,
3310  &current->sh_pred_weight_table));
3311  }
3312  }
3313  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
3314  if (!pps->pps_qp_delta_info_in_ph_flag)
3315  se(sh_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
3316  63 - (26 + pps->pps_init_qp_minus26));
3317  if (pps->pps_slice_chroma_qp_offsets_present_flag) {
3318  int8_t off;
3319 
3320  se(sh_cb_qp_offset, -12, 12);
3321  off = pps->pps_cb_qp_offset + current->sh_cb_qp_offset;
3322  if (off < -12 || off > 12) {
3323  av_log(ctx->log_ctx, AV_LOG_ERROR,
3324  "pps_cb_qp_offset + sh_cb_qp_offset (%d) not in range [-12, 12].\n",
3325  off);
3326  return AVERROR_INVALIDDATA;
3327  }
3328 
3329  se(sh_cr_qp_offset, -12, 12);
3330  off = pps->pps_cr_qp_offset + current->sh_cr_qp_offset;
3331  if (off < -12 || off > 12) {
3332  av_log(ctx->log_ctx, AV_LOG_ERROR,
3333  "pps_cr_qp_offset + sh_cr_qp_offset (%d) not in range [-12, 12].\n",
3334  off);
3335  return AVERROR_INVALIDDATA;
3336  }
3337 
3338  if (sps->sps_joint_cbcr_enabled_flag) {
3339  se(sh_joint_cbcr_qp_offset, -12, 12);
3340  off =
3341  pps->pps_joint_cbcr_qp_offset_value +
3342  current->sh_joint_cbcr_qp_offset;
3343  if (off < -12 || off > 12) {
3344  av_log(ctx->log_ctx, AV_LOG_ERROR,
3345  "pps_joint_cbcr_qp_offset_value + sh_joint_cbcr_qp_offset (%d)"
3346  "not in range [-12, 12]. \n", off);
3347  return AVERROR_INVALIDDATA;
3348  }
3349  } else {
3350  infer(sh_joint_cbcr_qp_offset, 0);
3351  }
3352  } else {
3353  infer(sh_cb_qp_offset, 0);
3354  infer(sh_cr_qp_offset, 0);
3355  infer(sh_joint_cbcr_qp_offset, 0);
3356  }
3357  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
3358  flag(sh_cu_chroma_qp_offset_enabled_flag);
3359  else
3360  infer(sh_cu_chroma_qp_offset_enabled_flag, 0);
3361  if (sps->sps_sao_enabled_flag && !pps->pps_sao_info_in_ph_flag) {
3362  flag(sh_sao_luma_used_flag);
3363  if (sps->sps_chroma_format_idc != 0)
3364  flag(sh_sao_chroma_used_flag);
3365  else
3366  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3367  } else {
3368  infer(sh_sao_luma_used_flag, ph->ph_sao_luma_enabled_flag);
3369  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3370  }
3371 
3372  if (pps->pps_deblocking_filter_override_enabled_flag &&
3373  !pps->pps_dbf_info_in_ph_flag)
3374  flag(sh_deblocking_params_present_flag);
3375  else
3376  infer(sh_deblocking_params_present_flag, 0);
3377  if (current->sh_deblocking_params_present_flag) {
3378  if (!pps->pps_deblocking_filter_disabled_flag)
3379  flag(sh_deblocking_filter_disabled_flag);
3380  else
3381  infer(sh_deblocking_filter_disabled_flag, 0);
3382  if (!current->sh_deblocking_filter_disabled_flag) {
3383  se(sh_luma_beta_offset_div2, -12, 12);
3384  se(sh_luma_tc_offset_div2, -12, 12);
3385  if (pps->pps_chroma_tool_offsets_present_flag) {
3386  se(sh_cb_beta_offset_div2, -12, 12);
3387  se(sh_cb_tc_offset_div2, -12, 12);
3388  se(sh_cr_beta_offset_div2, -12, 12);
3389  se(sh_cr_tc_offset_div2, -12, 12);
3390  } else {
3391  infer(sh_cb_beta_offset_div2,
3392  current->sh_luma_beta_offset_div2);
3393  infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
3394  infer(sh_cr_beta_offset_div2,
3395  current->sh_luma_beta_offset_div2);
3396  infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
3397  }
3398  }
3399  } else {
3400  infer(sh_deblocking_filter_disabled_flag, ph->ph_deblocking_filter_disabled_flag);
3401  if (!current->sh_deblocking_filter_disabled_flag) {
3402  infer(sh_luma_beta_offset_div2, ph->ph_luma_beta_offset_div2);
3403  infer(sh_luma_tc_offset_div2, ph->ph_luma_tc_offset_div2);
3404  infer(sh_cb_beta_offset_div2, ph->ph_cb_beta_offset_div2);
3405  infer(sh_cb_tc_offset_div2, ph->ph_cb_tc_offset_div2);
3406  infer(sh_cr_beta_offset_div2, ph->ph_cr_beta_offset_div2);
3407  infer(sh_cr_tc_offset_div2, ph->ph_cr_tc_offset_div2);
3408  }
3409  }
3410 
3411  if (sps->sps_dep_quant_enabled_flag)
3412  flag(sh_dep_quant_used_flag);
3413  else
3414  infer(sh_dep_quant_used_flag, 0);
3415 
3416  if (sps->sps_sign_data_hiding_enabled_flag &&
3417  !current->sh_dep_quant_used_flag)
3418  flag(sh_sign_data_hiding_used_flag);
3419  else
3420  infer(sh_sign_data_hiding_used_flag, 0);
3421 
3422  if (sps->sps_transform_skip_enabled_flag &&
3423  !current->sh_dep_quant_used_flag &&
3424  !current->sh_sign_data_hiding_used_flag)
3425  flag(sh_ts_residual_coding_disabled_flag);
3426  else
3427  infer(sh_ts_residual_coding_disabled_flag, 0);
3428 
3429  if (!current->sh_ts_residual_coding_disabled_flag &&
3430  sps->sps_ts_residual_coding_rice_present_in_sh_flag)
3431  ub(3, sh_ts_residual_coding_rice_idx_minus1);
3432  else
3433  infer(sh_ts_residual_coding_rice_idx_minus1, 0);
3434 
3435  if (sps->sps_reverse_last_sig_coeff_enabled_flag)
3436  flag(sh_reverse_last_sig_coeff_flag);
3437  else
3438  infer(sh_reverse_last_sig_coeff_flag, 0);
3439 
3440  if (pps->pps_slice_header_extension_present_flag) {
3441  ue(sh_slice_header_extension_length, 0, 256);
3442  for (i = 0; i < current->sh_slice_header_extension_length; i++)
3443  us(8, sh_slice_header_extension_data_byte[i], 0x00, 0xff, 1, i);
3444  }
3445 
3446  current->num_entry_points = 0;
3447  if (sps->sps_entry_point_offsets_present_flag) {
3448  uint8_t entropy_sync = sps->sps_entropy_coding_sync_enabled_flag;
3449  int height;
3450  if (pps->pps_rect_slice_flag) {
3451  int width_in_tiles;
3452  int slice_idx = current->sh_slice_address;
3453  for (i = 0; i < current->curr_subpic_idx; i++) {
3454  slice_idx += pps->num_slices_in_subpic[i];
3455  }
3456 
3457  if (pps->pps_single_slice_per_subpic_flag) {
3458  const int width_in_ctus = sps->sps_subpic_width_minus1[slice_idx] + 1;
3459  const int subpic_l = sps->sps_subpic_ctu_top_left_x[slice_idx];
3460  const int subpic_r = subpic_l + width_in_ctus;
3461 
3462  int ctb_x = 0, tile_x = 0;
3463  for (; ctb_x < subpic_l && tile_x < pps->num_tile_columns; tile_x++)
3464  ctb_x += pps->col_width_val[tile_x];
3465 
3466  width_in_tiles = 0;
3467  for (; ctb_x < subpic_r && tile_x < pps->num_tile_columns; tile_x++) {
3468  ctb_x += pps->col_width_val[tile_x];
3469  width_in_tiles++;
3470  }
3471 
3472  if (entropy_sync) {
3473  height = sps->sps_subpic_height_minus1[slice_idx] + 1;
3474  } else {
3475  const int height_in_ctus = sps->sps_subpic_height_minus1[slice_idx] + 1;
3476  const int subpic_t = sps->sps_subpic_ctu_top_left_y[slice_idx];
3477  const int subpic_b = subpic_t + height_in_ctus;
3478 
3479  int ctb_y = 0, tile_y = 0, height_in_tiles;
3480  for (; ctb_y < subpic_t && tile_y < pps->num_tile_rows; tile_y++)
3481  ctb_y += pps->row_height_val[tile_y];
3482 
3483  height_in_tiles = 0;
3484  for (; ctb_y < subpic_b && tile_y < pps->num_tile_rows; tile_y++) {
3485  ctb_y += pps->row_height_val[tile_y];
3486  height_in_tiles++;
3487  }
3488 
3489  height = height_in_tiles;
3490  }
3491  } else {
3492  width_in_tiles =
3493  pps->pps_slice_width_in_tiles_minus1[slice_idx] + 1;
3494 
3495  if (entropy_sync)
3496  height = pps->slice_height_in_ctus[slice_idx];
3497  else
3498  height = pps->pps_slice_height_in_tiles_minus1[slice_idx] + 1;
3499  }
3500 
3501  current->num_entry_points = width_in_tiles * height;
3502  } else {
3503  int tile_idx;
3504  int tile_y;
3505  for (tile_idx = current->sh_slice_address;
3506  tile_idx <=
3507  current->sh_slice_address +
3508  current->sh_num_tiles_in_slice_minus1; tile_idx++) {
3509  tile_y = tile_idx / pps->num_tile_rows;
3510  height = pps->row_height_val[tile_y];
3511  current->num_entry_points += (entropy_sync ? height : 1);
3512  }
3513  }
3514  current->num_entry_points--;
3515  if (current->num_entry_points > VVC_MAX_ENTRY_POINTS) {
3516  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
3517  "%" PRIu32 ".\n", current->num_entry_points);
3518  return AVERROR_PATCHWELCOME;
3519  }
3520  if (current->num_entry_points > 0) {
3521  ue(sh_entry_offset_len_minus1, 0, 31);
3522  for (i = 0; i < current->num_entry_points; i++) {
3523  ubs(current->sh_entry_offset_len_minus1 + 1,
3524  sh_entry_point_offset_minus1[i], 1, i);
3525  }
3526  }
3527  }
3528  CHECK(FUNC(byte_alignment) (ctx, rw));
3529 
3530  return 0;
3531 }
3532 
3533 static int FUNC(sei) (CodedBitstreamContext *ctx, RWContext *rw,
3534  H266RawSEI *current, int prefix)
3535 {
3536  int err;
3537 
3538  if (prefix)
3539  HEADER("Prefix Supplemental Enhancement Information");
3540  else
3541  HEADER("Suffix Supplemental Enhancement Information");
3542 
3543  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header,
3544  prefix ? VVC_PREFIX_SEI_NUT
3545  : VVC_SUFFIX_SEI_NUT));
3546 
3547  CHECK(FUNC_SEI(message_list) (ctx, rw, &current->message_list, prefix));
3548 
3549  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3550 
3551  return 0;
3552 }
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H266RawSEI *current, int prefix)
Definition: cbs_h266_syntax_template.c:3533
bit_position
#define bit_position(rw)
Definition: cbs_h2645.c:443
VVC_MAX_REF_PIC_LISTS
@ VVC_MAX_REF_PIC_LISTS
Definition: vvc.h:112
flags
const SwsFlags flags[]
Definition: swscale.c:61
VVC_GDR_NUT
@ VVC_GDR_NUT
Definition: vvc.h:39
sh_slice_address
static int sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1341
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:280
dpb_parameters
static int FUNC() dpb_parameters(CodedBitstreamContext *ctx, RWContext *rw, H266DpbParameters *current, uint8_t max_sublayers_minus1, uint8_t sublayer_info_flag)
Definition: cbs_h266_syntax_template.c:394
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
VVC_MAX_TILES_PER_AU
@ VVC_MAX_TILES_PER_AU
Definition: vvc.h:136
H266RawDCI
Definition: cbs_h266.h:252
VVC_MAX_ENTRY_POINTS
@ VVC_MAX_ENTRY_POINTS
Definition: vvc.h:153
ff_ctz
#define ff_ctz
Definition: intmath.h:105
lmcs_data
static int FUNC() lmcs_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current)
Definition: cbs_h266_syntax_template.c:2419
VVC_DCI_NUT
@ VVC_DCI_NUT
Definition: vvc.h:42
sublayer_hrd_parameters
static int FUNC() sublayer_hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H266RawSubLayerHRDParameters *current, int sublayer_id, const H266RawGeneralTimingHrdParameters *general)
Definition: cbs_h266_syntax_template.c:586
se
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:260
ref_pic_list_struct
static int FUNC() ref_pic_list_struct(CodedBitstreamContext *ctx, RWContext *rw, H266RefPicListStruct *current, uint8_t list_idx, uint8_t rpls_idx, const H266RawSPS *sps)
Definition: cbs_h266_syntax_template.c:410
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3050
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H266RawVUI *current, uint8_t chroma_format_idc)
Definition: cbs_h266_syntax_template.c:239
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:226
H266DpbParameters
Definition: cbs_h266.h:154
profile_tier_level
static int FUNC() profile_tier_level(CodedBitstreamContext *ctx, RWContext *rw, H266RawProfileTierLevel *current, int profile_tier_present_flag, int max_num_sub_layers_minus1)
Definition: cbs_h266_syntax_template.c:178
infer
#define infer(name, value)
Definition: cbs_apv.c:137
H266RefPicListStruct::st_ref_pic_flag
uint8_t st_ref_pic_flag[VVC_MAX_REF_ENTRIES]
Definition: cbs_h266.h:164
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H266RawVPS *current)
Definition: cbs_h266_syntax_template.c:694
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:446
H266RefPicListStruct::ltrp_in_header_flag
uint8_t ltrp_in_header_flag
Definition: cbs_h266.h:162
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
H266RawExtensionData
Definition: cbs_h266.h:148
VVC_MAX_HEIGHT
@ VVC_MAX_HEIGHT
Definition: vvc.h:133
H266RefPicListStruct::num_ref_entries
uint8_t num_ref_entries
Definition: cbs_h266.h:161
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:275
VVC_AUD_NUT
@ VVC_AUD_NUT
Definition: vvc.h:49
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H266RawAUD *current)
Definition: cbs_h266_syntax_template.c:2545
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
ub
#define ub(width, name)
Definition: cbs_apv.c:125
CodedBitstreamH266Context::pps
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:871
CodedBitstreamH266Context::vps
H266RawVPS * vps[VVC_MAX_VPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:869
H266RawAUD
Definition: cbs_h266.h:646
VVC_ASP_TYPE_ALF
@ VVC_ASP_TYPE_ALF
Definition: vvc.h:70
slice_header
static int FUNC() slice_header(CodedBitstreamContext *ctx, RWContext *rw, H266RawSliceHeader *current)
Definition: cbs_h266_syntax_template.c:3063
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
sps_range_extension
static int FUNC() sps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H266RawSPS *current)
Definition: cbs_h266_syntax_template.c:1039
H266RefPicListStruct::inter_layer_ref_pic_flag
uint8_t inter_layer_ref_pic_flag[VVC_MAX_REF_ENTRIES]
Definition: cbs_h266.h:163
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
GetBitContext
Definition: get_bits.h:109
H266RawAPS
Definition: cbs_h266.h:600
ubs
#define ubs(width, name, subs,...)
Definition: cbs_apv.c:72
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:254
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_apv.c:130
H266GeneralConstraintsInfo
Definition: cbs_h266.h:36
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H266RawPPS *current)
Definition: cbs_h266_syntax_template.c:1674
H266RawProfileTierLevel
Definition: cbs_h266.h:133
VVC_IDR_W_RADL
@ VVC_IDR_W_RADL
Definition: vvc.h:36
message_list
static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)
Definition: cbs_sei_syntax_template.c:425
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
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
H266RawVUI
Definition: cbs_h266.h:211
H266RawSEI
Definition: cbs_h266.h:858
VVC_NUM_ALF_FILTERS
@ VVC_NUM_ALF_FILTERS
Definition: vvc.h:106
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
HEADER
#define HEADER(name)
Definition: cbs_apv.c:55
VVC_MAX_TILE_COLUMNS
@ VVC_MAX_TILE_COLUMNS
Definition: vvc.h:141
bits
uint8_t bits
Definition: vp3data.h:128
VVC_MAX_SUBLAYERS
@ VVC_MAX_SUBLAYERS
Definition: vvc.h:83
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h266_syntax_template.c:19
VVC_MAX_TOTAL_NUM_OLSS
@ VVC_MAX_TOTAL_NUM_OLSS
Definition: vvc.h:92
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
H266RefPicLists
Definition: cbs_h266.h:171
FUNC_SEI
#define FUNC_SEI(name)
Definition: cbs_h2645.c:237
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:235
H266RawGeneralTimingHrdParameters
Definition: cbs_h266.h:180
VVC_MAX_VBS
@ VVC_MAX_VBS
Definition: vvc.h:156
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
cbs_h265_payload_extension_present
static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size, int cur_pos)
Definition: cbs_h2645.c:214
H266RawSPS
Definition: cbs_h266.h:308
VVC_SLICE_TYPE_P
@ VVC_SLICE_TYPE_P
Definition: vvc.h:65
H266RawVPS
Definition: cbs_h266.h:262
scaling_list_data
static int FUNC() scaling_list_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current)
Definition: cbs_h266_syntax_template.c:2455
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:2508
H266RawOPI
Definition: cbs_h266.h:241
VVC_MAX_LAYERS
@ VVC_MAX_LAYERS
Definition: vvc.h:80
H266RawPictureHeader
Definition: cbs_h266.h:676
bits_left
#define bits_left
Definition: bitstream.h:116
byte_alignment
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h266_syntax_template.c:50
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
VVC_PREFIX_SEI_NUT
@ VVC_PREFIX_SEI_NUT
Definition: vvc.h:52
general_constraints_info
static int FUNC() general_constraints_info(CodedBitstreamContext *ctx, RWContext *rw, H266GeneralConstraintsInfo *current)
Definition: cbs_h266_syntax_template.c:60
VVC_SLICE_TYPE_B
@ VVC_SLICE_TYPE_B
Definition: vvc.h:64
H266RawPredWeightTable
Definition: cbs_h266.h:652
VVC_ASP_TYPE_LMCS
@ VVC_ASP_TYPE_LMCS
Definition: vvc.h:71
opi
static int FUNC() opi(CodedBitstreamContext *ctx, RWContext *rw, H266RawOPI *current)
Definition: cbs_h266_syntax_template.c:643
VVC_SLICE_TYPE_I
@ VVC_SLICE_TYPE_I
Definition: vvc.h:66
VVC_MAX_VPS_COUNT
@ VVC_MAX_VPS_COUNT
Definition: vvc.h:95
VVC_PH_NUT
@ VVC_PH_NUT
Definition: vvc.h:48
payload_extension
static int FUNC() payload_extension(CodedBitstreamContext *ctx, RWContext *rw, H266RawExtensionData *current, uint32_t payload_size, int cur_pos)
Definition: cbs_h266_syntax_template.c:310
VVC_MAX_DPB_SIZE
@ VVC_MAX_DPB_SIZE
Definition: vvc.h:109
height
#define height
Definition: dsp.h:89
VVC_VPS_NUT
@ VVC_VPS_NUT
Definition: vvc.h:43
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
CodedBitstreamH266Context::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:872
H266RefPicListStruct
Definition: cbs_h266.h:160
H266RawSubLayerHRDParameters
Definition: cbs_h266.h:194
CodedBitstreamH266Context
Definition: cbs_h266.h:863
vui_parameters_default
static int FUNC() vui_parameters_default(CodedBitstreamContext *ctx, RWContext *rw, H266RawVUI *current)
Definition: cbs_h266_syntax_template.c:213
VVC_SPS_NUT
@ VVC_SPS_NUT
Definition: vvc.h:44
alf_data
static int FUNC() alf_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current)
Definition: cbs_h266_syntax_template.c:2308
fixed
#define fixed(width, name, value)
Definition: cbs_apv.c:75
VVC_MAX_WIDTH
@ VVC_MAX_WIDTH
Definition: vvc.h:132
H266RawSliceHeader
Definition: cbs_h266.h:771
ols_timing_hrd_parameters
static int FUNC() ols_timing_hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H266RawOlsTimingHrdParameters *current, uint8_t first_sublayer, uint8_t max_sublayers_minus1, const H266RawGeneralTimingHrdParameters *general)
Definition: cbs_h266_syntax_template.c:609
VVC_MAX_SLICES
@ VVC_MAX_SLICES
Definition: vvc.h:144
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, const H266RawSPS *sps, const H266RawPPS *pps, const H266RefPicLists *ref_lists, uint8_t num_ref_idx_active[2], H266RawPredWeightTable *current)
Definition: cbs_h266_syntax_template.c:2562
nal_unit_header
static int FUNC() nal_unit_header(CodedBitstreamContext *ctx, RWContext *rw, H266RawNALUnitHeader *current, int expected_nal_unit_type)
Definition: cbs_h266_syntax_template.c:30
CodedBitstreamH266Context::sps
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:870
VVC_SUFFIX_SEI_NUT
@ VVC_SUFFIX_SEI_NUT
Definition: vvc.h:53
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
VVC_IDR_N_LP
@ VVC_IDR_N_LP
Definition: vvc.h:37
VVC_MAX_PPS_COUNT
@ VVC_MAX_PPS_COUNT
Definition: vvc.h:99
general_timing_hrd_parameters
static int FUNC() general_timing_hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H266RawGeneralTimingHrdParameters *current)
Definition: cbs_h266_syntax_template.c:558
VVC_PPS_NUT
@ VVC_PPS_NUT
Definition: vvc.h:45
flag
#define flag(name)
Definition: cbs_av1.c:496
RWContext
#define RWContext
Definition: cbs_apv.c:122
VVC_PREFIX_APS_NUT
@ VVC_PREFIX_APS_NUT
Definition: vvc.h:46
H266RawPH
Definition: cbs_h266.h:766
ref_pic_lists
static int FUNC() ref_pic_lists(CodedBitstreamContext *ctx, RWContext *rw, const H266RawSPS *sps, const H266RawPPS *pps, H266RefPicLists *current)
Definition: cbs_h266_syntax_template.c:491
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
VVC_SUFFIX_APS_NUT
@ VVC_SUFFIX_APS_NUT
Definition: vvc.h:47
VVC_ASP_TYPE_SCALING
@ VVC_ASP_TYPE_SCALING
Definition: vvc.h:72
H266RawOlsTimingHrdParameters
Definition: cbs_h266.h:202
VVC_CRA_NUT
@ VVC_CRA_NUT
Definition: vvc.h:38
dci
static int FUNC() dci(CodedBitstreamContext *ctx, RWContext *rw, H266RawDCI *current)
Definition: cbs_h266_syntax_template.c:670
VVC_OPI_NUT
@ VVC_OPI_NUT
Definition: vvc.h:41
extension_data
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawExtensionData *current)
Definition: cbs_h266_syntax_template.c:367
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_apv.c:70
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
H266RawNALUnitHeader
Definition: cbs_h266.h:29
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:269
width
#define width
Definition: dsp.h:89
vui_payload
static int FUNC() vui_payload(CodedBitstreamContext *ctx, RWContext *rw, H266RawVUI *current, uint16_t vui_payload_size, uint8_t chroma_format_idc)
Definition: cbs_h266_syntax_template.c:346
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H266RawSPS *current)
Definition: cbs_h266_syntax_template.c:1056
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1292
VVC_MAX_TILE_ROWS
@ VVC_MAX_TILE_ROWS
Definition: vvc.h:139
cbs_h2645_read_more_rbsp_data
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:328
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
picture_header
static int FUNC() picture_header(CodedBitstreamContext *ctx, RWContext *rw, H266RawPictureHeader *current)
Definition: cbs_h266_syntax_template.c:2645
Generated on Tue Dec 30 2025 19:22:03 for FFmpeg by   doxygen 1.8.17