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  "Resoltuion 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 (current->num_tile_columns > VVC_MAX_TILE_COLUMNS) {
1901  av_log(ctx->log_ctx, AV_LOG_ERROR,
1902  "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1903  current->num_tile_columns, VVC_MAX_TILE_COLUMNS);
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  if (current->num_tile_columns > VVC_MAX_TILE_COLUMNS) {
1913  av_log(ctx->log_ctx, AV_LOG_ERROR,
1914  "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1915  current->num_tile_columns, VVC_MAX_TILE_COLUMNS);
1916  return AVERROR_INVALIDDATA;
1917  }
1918 
1919  remaining_size = pic_height_in_ctbs_y;
1920  for (i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++) {
1921  if (current->pps_tile_row_height_minus1[i] >= remaining_size) {
1922  av_log(ctx->log_ctx, AV_LOG_ERROR,
1923  "Tile row height(%d) exceeds picture height\n",i);
1924  return AVERROR_INVALIDDATA;
1925  }
1926  current->row_height_val[i] = current->pps_tile_row_height_minus1[i] + 1;
1927  remaining_size -= (current->pps_tile_row_height_minus1[i] + 1);
1928  }
1929  unified_size = current->pps_tile_row_height_minus1[i - 1] + 1;
1930 
1931  while (remaining_size > 0) {
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  if (current->num_tile_rows > VVC_MAX_TILE_ROWS) {
1939  av_log(ctx->log_ctx, AV_LOG_ERROR,
1940  "NumTileRows(%d) > than VVC_MAX_TILE_ROWS(%d)\n",
1941  current->num_tile_rows, VVC_MAX_TILE_ROWS);
1942  return AVERROR_INVALIDDATA;
1943  }
1944 
1945  current->num_tiles_in_pic = current->num_tile_columns *
1946  current->num_tile_rows;
1947  if (current->num_tiles_in_pic > VVC_MAX_TILES_PER_AU) {
1948  av_log(ctx->log_ctx, AV_LOG_ERROR,
1949  "NumTilesInPic(%d) > than VVC_MAX_TILES_PER_AU(%d)\n",
1950  current->num_tiles_in_pic, VVC_MAX_TILES_PER_AU);
1951  return AVERROR_INVALIDDATA;
1952  }
1953 
1954  if (current->num_tiles_in_pic > 1) {
1955  flag(pps_loop_filter_across_tiles_enabled_flag);
1956  flag(pps_rect_slice_flag);
1957  } else {
1958  infer(pps_loop_filter_across_tiles_enabled_flag, 0);
1959  infer(pps_rect_slice_flag, 1);
1960  }
1961  if (current->pps_rect_slice_flag)
1962  flag(pps_single_slice_per_subpic_flag);
1963  else
1964  infer(pps_single_slice_per_subpic_flag, 1);
1965  if (current->pps_rect_slice_flag &&
1966  !current->pps_single_slice_per_subpic_flag) {
1967  int j, num_slices = 0;
1968  uint16_t tile_idx = 0, tile_x, tile_y, ctu_x, ctu_y;
1969  uint16_t slice_top_left_ctu_x[VVC_MAX_SLICES];
1970  uint16_t slice_top_left_ctu_y[VVC_MAX_SLICES];
1971  ue(pps_num_slices_in_pic_minus1, 0, VVC_MAX_SLICES - 1);
1972  if (current->pps_num_slices_in_pic_minus1 > 1)
1973  flag(pps_tile_idx_delta_present_flag);
1974  else
1975  infer(pps_tile_idx_delta_present_flag, 0);
1976  for (i = 0; i < current->pps_num_slices_in_pic_minus1; i++) {
1977  current->slice_top_left_tile_idx[i] = tile_idx;
1978  tile_x = tile_idx % current->num_tile_columns;
1979  tile_y = tile_idx / current->num_tile_columns;
1980  if (tile_x != current->num_tile_columns - 1) {
1981  ues(pps_slice_width_in_tiles_minus1[i],
1982  0, current->num_tile_columns - 1, 1, i);
1983  } else {
1984  infer(pps_slice_width_in_tiles_minus1[i], 0);
1985  }
1986  if (tile_y != current->num_tile_rows - 1 &&
1987  (current->pps_tile_idx_delta_present_flag || tile_x == 0)) {
1988  ues(pps_slice_height_in_tiles_minus1[i],
1989  0, current->num_tile_rows - 1, 1, i);
1990  } else {
1991  if (tile_y == current->num_tile_rows - 1)
1992  infer(pps_slice_height_in_tiles_minus1[i], 0);
1993  else
1994  infer(pps_slice_height_in_tiles_minus1[i],
1995  current->pps_slice_height_in_tiles_minus1[i - 1]);
1996  }
1997 
1998  ctu_x = ctu_y = 0;
1999  for (j = 0; j < tile_x; j++) {
2000  ctu_x += current->col_width_val[j];
2001  }
2002  for (j = 0; j < tile_y; j++) {
2003  ctu_y += current->row_height_val[j];
2004  }
2005  if (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
2006  current->pps_slice_height_in_tiles_minus1[i] == 0 &&
2007  current->row_height_val[tile_y] > 1) {
2008  int uniform_slice_height, remaining_height_in_ctbs_y;
2009  remaining_height_in_ctbs_y =
2010  current->row_height_val[tile_y];
2011  ues(pps_num_exp_slices_in_tile[i],
2012  0, current->row_height_val[tile_y] - 1, 1, i);
2013  if (current->pps_num_exp_slices_in_tile[i] == 0) {
2014  current->num_slices_in_tile[i] = 1;
2015  current->slice_height_in_ctus[i] = current->row_height_val[tile_y];
2016  slice_top_left_ctu_x[i] = ctu_x;
2017  slice_top_left_ctu_y[i] = ctu_y;
2018  } else {
2019  uint16_t slice_height_in_ctus;
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  while (remaining_height_in_ctbs_y > uniform_slice_height) {
2041  current->slice_height_in_ctus[i + j] =
2042  uniform_slice_height;
2043  slice_top_left_ctu_x[i + j] = ctu_x;
2044  slice_top_left_ctu_y[i + j] = ctu_y;
2045  ctu_y += uniform_slice_height;
2046 
2047  remaining_height_in_ctbs_y -= uniform_slice_height;
2048  j++;
2049  }
2050  if (remaining_height_in_ctbs_y > 0) {
2051  current->slice_height_in_ctus[i + j] =
2052  remaining_height_in_ctbs_y;
2053  slice_top_left_ctu_x[i + j] = ctu_x;
2054  slice_top_left_ctu_y[i + j] = ctu_y;
2055  j++;
2056  }
2057  current->num_slices_in_tile[i] = j;
2058  }
2059  for (int k = 0; k < current->num_slices_in_tile[i]; k++)
2060  current->slice_top_left_tile_idx[i + k] = tile_idx;
2061  i += current->num_slices_in_tile[i] - 1;
2062  } else {
2063  uint16_t height = 0;
2064  infer(pps_num_exp_slices_in_tile[i], 0);
2065  if (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
2066  current->pps_slice_height_in_tiles_minus1[i] == 0)
2067  current->num_slices_in_tile[i] = 1;
2068 
2069  for (j = 0;
2070  j <= current->pps_slice_height_in_tiles_minus1[i];
2071  j++) {
2072  height +=
2073  current->row_height_val[tile_y + j];
2074  }
2075  current->slice_height_in_ctus[i] = height;
2076 
2077  slice_top_left_ctu_x[i] = ctu_x;
2078  slice_top_left_ctu_y[i] = ctu_y;
2079  }
2080  if (i < current->pps_num_slices_in_pic_minus1) {
2081  if (current->pps_tile_idx_delta_present_flag) {
2082  // Two conditions must be met:
2083  // 1. −NumTilesInPic + 1 <= pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2084  // 2. 0 <= tile_idx + pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2085  // Combining these conditions yields: -tile_idx <= pps_tile_idx_delta_val[i] <= NumTilesInPic - 1 - tile_idx
2086  ses(pps_tile_idx_delta_val[i],
2087  -tile_idx, current->num_tiles_in_pic - 1 - tile_idx, 1, i);
2088  if (current->pps_tile_idx_delta_val[i] == 0) {
2089  av_log(ctx->log_ctx, AV_LOG_ERROR,
2090  "pps_tile_idx_delta_val[i] shall not be equal to 0.\n");
2091  }
2092  tile_idx += current->pps_tile_idx_delta_val[i];
2093  } else {
2094  infer(pps_tile_idx_delta_val[i], 0);
2095  tile_idx +=
2096  current->pps_slice_width_in_tiles_minus1[i] + 1;
2097  if (tile_idx % current->num_tile_columns == 0) {
2098  tile_idx +=
2099  current->pps_slice_height_in_tiles_minus1[i] *
2100  current->num_tile_columns;
2101  }
2102  }
2103  }
2104  }
2105  if (i == current->pps_num_slices_in_pic_minus1) {
2106  uint16_t height = 0;
2107 
2108  current->slice_top_left_tile_idx[i] = tile_idx;
2109  current->num_slices_in_tile[i] = 1;
2110  tile_x = tile_idx % current->num_tile_columns;
2111  tile_y = tile_idx / current->num_tile_columns;
2112  if (tile_y >= current->num_tile_rows)
2113  return AVERROR_INVALIDDATA;
2114 
2115  ctu_x = 0, ctu_y = 0;
2116  for (j = 0; j < tile_x; j++) {
2117  ctu_x += current->col_width_val[j];
2118  }
2119  for (j = 0; j < tile_y; j++) {
2120  ctu_y += current->row_height_val[j];
2121  }
2122  slice_top_left_ctu_x[i] = ctu_x;
2123  slice_top_left_ctu_y[i] = ctu_y;
2124 
2125  current->pps_slice_width_in_tiles_minus1[i] =
2126  current->num_tile_columns - tile_x - 1;
2127  current->pps_slice_height_in_tiles_minus1[i] =
2128  current->num_tile_rows - tile_y - 1;
2129 
2130  for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[i];
2131  j++) {
2132  height +=
2133  current->row_height_val[tile_y + j];
2134  }
2135  current->slice_height_in_ctus[i] = height;
2136 
2137  infer(pps_num_exp_slices_in_tile[i], 0);
2138  }
2139  //now, we got all slice information, let's resolve NumSlicesInSubpic
2140  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
2141  current->num_slices_in_subpic[i] = 0;
2142  for (j = 0; j <= current->pps_num_slices_in_pic_minus1; j++) {
2143  uint16_t pos_x = 0, pos_y = 0;
2144  pos_x = slice_top_left_ctu_x[j];
2145  pos_y = slice_top_left_ctu_y[j];
2146  if ((pos_x >= sps->sps_subpic_ctu_top_left_x[i]) &&
2147  (pos_x <
2148  sps->sps_subpic_ctu_top_left_x[i] +
2149  sps->sps_subpic_width_minus1[i] + 1) &&
2150  (pos_y >= sps->sps_subpic_ctu_top_left_y[i]) &&
2151  (pos_y < sps->sps_subpic_ctu_top_left_y[i] +
2152  sps->sps_subpic_height_minus1[i] + 1)) {
2153  current->num_slices_in_subpic[i]++;
2154  }
2155  }
2156  num_slices += current->num_slices_in_subpic[i];
2157  }
2158  if (current->pps_num_slices_in_pic_minus1 + 1 != num_slices)
2159  return AVERROR_INVALIDDATA;
2160  } else {
2161  if (current->pps_no_pic_partition_flag)
2162  infer(pps_num_slices_in_pic_minus1, 0);
2163  else if (current->pps_single_slice_per_subpic_flag) {
2164  for (i = 0; i <= sps->sps_num_subpics_minus1; i++)
2165  current->num_slices_in_subpic[i] = 1;
2166  infer(pps_num_slices_in_pic_minus1,
2167  sps->sps_num_subpics_minus1);
2168  }
2169  // else?
2170  }
2171  if (!current->pps_rect_slice_flag ||
2172  current->pps_single_slice_per_subpic_flag ||
2173  current->pps_num_slices_in_pic_minus1 > 0)
2174  flag(pps_loop_filter_across_slices_enabled_flag);
2175  else
2176  infer(pps_loop_filter_across_slices_enabled_flag, 0);
2177  } else {
2178  infer(pps_num_exp_tile_columns_minus1, 0);
2179  infer(pps_tile_column_width_minus1[0], pic_width_in_ctbs_y - 1);
2180  infer(pps_num_exp_tile_rows_minus1, 0);
2181  infer(pps_tile_row_height_minus1[0], pic_height_in_ctbs_y - 1);
2182  current->col_width_val[0] = pic_width_in_ctbs_y;
2183  current->row_height_val[0] = pic_height_in_ctbs_y;
2184  current->num_tile_columns = 1;
2185  current->num_tile_rows = 1;
2186  current->num_tiles_in_pic = 1;
2187  }
2188 
2189  flag(pps_cabac_init_present_flag);
2190  for (i = 0; i < 2; i++)
2191  ues(pps_num_ref_idx_default_active_minus1[i], 0, 14, 1, i);
2192  flag(pps_rpl1_idx_present_flag);
2193  flag(pps_weighted_pred_flag);
2194  flag(pps_weighted_bipred_flag);
2195  flag(pps_ref_wraparound_enabled_flag);
2196  if (current->pps_ref_wraparound_enabled_flag) {
2197  ue(pps_pic_width_minus_wraparound_offset,
2198  0, (current->pps_pic_width_in_luma_samples / min_cb_size_y)
2199  - (ctb_size_y / min_cb_size_y) - 2);
2200  }
2201 
2202  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2203  se(pps_init_qp_minus26, -(26 + qp_bd_offset), 37);
2204  flag(pps_cu_qp_delta_enabled_flag);
2205  flag(pps_chroma_tool_offsets_present_flag);
2206  if (current->pps_chroma_tool_offsets_present_flag) {
2207  se(pps_cb_qp_offset, -12, 12);
2208  se(pps_cr_qp_offset, -12, 12);
2209  flag(pps_joint_cbcr_qp_offset_present_flag);
2210  if (current->pps_joint_cbcr_qp_offset_present_flag)
2211  se(pps_joint_cbcr_qp_offset_value, -12, 12);
2212  else
2213  infer(pps_joint_cbcr_qp_offset_value, 0);
2214  flag(pps_slice_chroma_qp_offsets_present_flag);
2215  flag(pps_cu_chroma_qp_offset_list_enabled_flag);
2216  if (current->pps_cu_chroma_qp_offset_list_enabled_flag) {
2217  ue(pps_chroma_qp_offset_list_len_minus1, 0, 5);
2218  for (i = 0; i <= current->pps_chroma_qp_offset_list_len_minus1; i++) {
2219  ses(pps_cb_qp_offset_list[i], -12, 12, 1, i);
2220  ses(pps_cr_qp_offset_list[i], -12, 12, 1, i);
2221  if (current->pps_joint_cbcr_qp_offset_present_flag)
2222  ses(pps_joint_cbcr_qp_offset_list[i], -12, 12, 1, i);
2223  else
2224  infer(pps_joint_cbcr_qp_offset_list[i], 0);
2225  }
2226  }
2227  } else {
2228  infer(pps_cb_qp_offset, 0);
2229  infer(pps_cr_qp_offset, 0);
2230  infer(pps_joint_cbcr_qp_offset_present_flag, 0);
2231  infer(pps_joint_cbcr_qp_offset_value, 0);
2232  infer(pps_slice_chroma_qp_offsets_present_flag, 0);
2233  infer(pps_cu_chroma_qp_offset_list_enabled_flag, 0);
2234  }
2235  flag(pps_deblocking_filter_control_present_flag);
2236  if (current->pps_deblocking_filter_control_present_flag) {
2237  flag(pps_deblocking_filter_override_enabled_flag);
2238  flag(pps_deblocking_filter_disabled_flag);
2239  if (!current->pps_no_pic_partition_flag &&
2240  current->pps_deblocking_filter_override_enabled_flag)
2241  flag(pps_dbf_info_in_ph_flag);
2242  else
2243  infer(pps_dbf_info_in_ph_flag, 0);
2244  if (!current->pps_deblocking_filter_disabled_flag) {
2245  se(pps_luma_beta_offset_div2, -12, 12);
2246  se(pps_luma_tc_offset_div2, -12, 12);
2247  if (current->pps_chroma_tool_offsets_present_flag) {
2248  se(pps_cb_beta_offset_div2, -12, 12);
2249  se(pps_cb_tc_offset_div2, -12, 12);
2250  se(pps_cr_beta_offset_div2, -12, 12);
2251  se(pps_cr_tc_offset_div2, -12, 12);
2252  } else {
2253  infer(pps_cb_beta_offset_div2,
2254  current->pps_luma_beta_offset_div2);
2255  infer(pps_cb_tc_offset_div2, current->pps_luma_tc_offset_div2);
2256  infer(pps_cr_beta_offset_div2,
2257  current->pps_luma_beta_offset_div2);
2258  infer(pps_cr_tc_offset_div2, current->pps_luma_tc_offset_div2);
2259  }
2260  } else {
2261  infer(pps_luma_beta_offset_div2, 0);
2262  infer(pps_luma_tc_offset_div2, 0);
2263  infer(pps_cb_beta_offset_div2, 0);
2264  infer(pps_cb_tc_offset_div2, 0);
2265  infer(pps_cr_beta_offset_div2, 0);
2266  infer(pps_cr_tc_offset_div2, 0);
2267  }
2268  } else {
2269  infer(pps_deblocking_filter_override_enabled_flag, 0);
2270  infer(pps_deblocking_filter_disabled_flag, 0);
2271  infer(pps_dbf_info_in_ph_flag, 0);
2272  infer(pps_luma_beta_offset_div2, 0);
2273  infer(pps_luma_tc_offset_div2, 0);
2274  infer(pps_cb_beta_offset_div2, 0);
2275  infer(pps_cb_tc_offset_div2, 0);
2276  infer(pps_cr_beta_offset_div2, 0);
2277  infer(pps_cr_tc_offset_div2, 0);
2278  }
2279 
2280  if (!current->pps_no_pic_partition_flag) {
2281  flag(pps_rpl_info_in_ph_flag);
2282  flag(pps_sao_info_in_ph_flag);
2283  flag(pps_alf_info_in_ph_flag);
2284  if ((current->pps_weighted_pred_flag ||
2285  current->pps_weighted_bipred_flag) &&
2286  current->pps_rpl_info_in_ph_flag)
2287  flag(pps_wp_info_in_ph_flag);
2288  flag(pps_qp_delta_info_in_ph_flag);
2289  }
2290  flag(pps_picture_header_extension_present_flag);
2291  flag(pps_slice_header_extension_present_flag);
2292 
2293  flag(pps_extension_flag);
2294  if (current->pps_extension_flag)
2295  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2296 
2297  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2298  return 0;
2299 }
2300 
2301 static int FUNC(alf_data)(CodedBitstreamContext *ctx, RWContext *rw,
2302  H266RawAPS *current)
2303 {
2304  int err, j, k;
2305 
2306  flag(alf_luma_filter_signal_flag);
2307 
2308  if (current->aps_chroma_present_flag) {
2309  flag(alf_chroma_filter_signal_flag);
2310  flag(alf_cc_cb_filter_signal_flag);
2311  flag(alf_cc_cr_filter_signal_flag);
2312  } else {
2313  infer(alf_chroma_filter_signal_flag, 0);
2314  infer(alf_cc_cb_filter_signal_flag, 0);
2315  infer(alf_cc_cr_filter_signal_flag, 0);
2316  }
2317 
2318  if (current->alf_luma_filter_signal_flag) {
2319  flag(alf_luma_clip_flag);
2320  ue(alf_luma_num_filters_signalled_minus1, 0, VVC_NUM_ALF_FILTERS - 1);
2321  if (current->alf_luma_num_filters_signalled_minus1 > 0) {
2322  unsigned int bits = av_ceil_log2(current->alf_luma_num_filters_signalled_minus1 + 1);
2323  for (int filt_idx = 0; filt_idx < VVC_NUM_ALF_FILTERS; filt_idx++)
2324  us(bits, alf_luma_coeff_delta_idx[filt_idx],
2325  0, current->alf_luma_num_filters_signalled_minus1,
2326  1, filt_idx);
2327  }
2328  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++)
2329  for (j = 0; j < 12; j++) {
2330  ues(alf_luma_coeff_abs[sf_idx][j], 0, 128, 2, sf_idx, j);
2331  if (current->alf_luma_coeff_abs[sf_idx][j])
2332  ubs(1, alf_luma_coeff_sign[sf_idx][j], 2, sf_idx, j);
2333  else
2334  infer(alf_luma_coeff_sign[sf_idx][j], 0);
2335  }
2336  } else {
2337  infer(alf_luma_clip_flag, 0);
2338  infer(alf_luma_num_filters_signalled_minus1, 0);
2339  }
2340  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++) {
2341  for (j = 0; j < 12; j++) {
2342  if (current->alf_luma_clip_flag)
2343  ubs(2, alf_luma_clip_idx[sf_idx][j], 2, sf_idx, j);
2344  else
2345  infer(alf_luma_clip_idx[sf_idx][j], 0);
2346  }
2347  }
2348 
2349  if (current->alf_chroma_filter_signal_flag) {
2350  flag(alf_chroma_clip_flag);
2351  ue(alf_chroma_num_alt_filters_minus1, 0, 7);
2352  } else {
2353  infer(alf_chroma_clip_flag, 0);
2354  infer(alf_chroma_num_alt_filters_minus1, 0);
2355  }
2356  for (int alt_idx = 0; alt_idx <= current->alf_chroma_num_alt_filters_minus1; alt_idx++) {
2357  for (j = 0; j < 6; j++) {
2358  if (current->alf_chroma_filter_signal_flag)
2359  ues(alf_chroma_coeff_abs[alt_idx][j], 0, 128, 2, alt_idx, j);
2360  else
2361  infer(alf_chroma_coeff_abs[alt_idx][j], 0);
2362  if (current->alf_chroma_coeff_abs[alt_idx][j] > 0)
2363  ubs(1, alf_chroma_coeff_sign[alt_idx][j], 2, alt_idx, j);
2364  else
2365  infer(alf_chroma_coeff_sign[alt_idx][j], 0);
2366  }
2367  for (j = 0; j < 6; j++) {
2368  if (current->alf_chroma_clip_flag)
2369  ubs(2, alf_chroma_clip_idx[alt_idx][j], 2, alt_idx, j);
2370  else
2371  infer(alf_chroma_clip_idx[alt_idx][j], 0);
2372  }
2373  }
2374 
2375  if (current->alf_cc_cb_filter_signal_flag)
2376  ue(alf_cc_cb_filters_signalled_minus1, 0, 3);
2377  else
2378  infer(alf_cc_cb_filters_signalled_minus1, 0);
2379  for (k = 0; k <= current->alf_cc_cb_filters_signalled_minus1; k++) {
2380  for (j = 0; j < 7; j++) {
2381  if (current->alf_cc_cb_filter_signal_flag)
2382  ubs(3, alf_cc_cb_mapped_coeff_abs[k][j], 2, k, j);
2383  else
2384  infer(alf_cc_cb_mapped_coeff_abs[k][j], 0);
2385  if (current->alf_cc_cb_mapped_coeff_abs[k][j])
2386  ubs(1, alf_cc_cb_coeff_sign[k][j], 2, k, j);
2387  else
2388  infer(alf_cc_cb_coeff_sign[k][j], 0);
2389  }
2390  }
2391 
2392  if (current->alf_cc_cr_filter_signal_flag)
2393  ue(alf_cc_cr_filters_signalled_minus1, 0, 3);
2394  else
2395  infer(alf_cc_cr_filters_signalled_minus1, 0);
2396  for (k = 0; k < current->alf_cc_cr_filters_signalled_minus1 + 1; k++) {
2397  for (j = 0; j < 7; j++) {
2398  if (current->alf_cc_cr_filter_signal_flag)
2399  ubs(3, alf_cc_cr_mapped_coeff_abs[k][j], 2, k, j);
2400  else
2401  infer(alf_cc_cr_mapped_coeff_abs[k][j], 0);
2402  if (current->alf_cc_cr_mapped_coeff_abs[k][j])
2403  ubs(1, alf_cc_cr_coeff_sign[k][j], 2, k, j);
2404  else
2405  infer(alf_cc_cr_coeff_sign[k][j], 0);
2406  }
2407  }
2408 
2409  return 0;
2410 }
2411 
2412 static int FUNC(lmcs_data)(CodedBitstreamContext *ctx, RWContext *rw,
2413  H266RawAPS *current)
2414 {
2415  int err, i, lmcs_max_bin_idx;
2416 
2417  ue(lmcs_min_bin_idx, 0, 15);
2418  ue(lmcs_delta_max_bin_idx, 0, 15);
2419  ue(lmcs_delta_cw_prec_minus1, 0, 14);
2420 
2421  lmcs_max_bin_idx = 15 - current->lmcs_delta_max_bin_idx;
2422 
2423  if (lmcs_max_bin_idx < current->lmcs_min_bin_idx)
2424  return AVERROR_INVALIDDATA;
2425 
2426  for (i = current->lmcs_min_bin_idx; i <= lmcs_max_bin_idx; i++) {
2427  ubs(current->lmcs_delta_cw_prec_minus1 + 1, lmcs_delta_abs_cw[i], 1, i);
2428  if (current->lmcs_delta_abs_cw[i] > 0)
2429  flags(lmcs_delta_sign_cw_flag[i], 1, i);
2430  else
2431  infer(lmcs_delta_sign_cw_flag[i], 0);
2432  }
2433 
2434  if (current->aps_chroma_present_flag) {
2435  ub(3, lmcs_delta_abs_crs);
2436  if (current->lmcs_delta_abs_crs > 0)
2437  flag(lmcs_delta_sign_crs_flag);
2438  else
2439  infer(lmcs_delta_sign_crs_flag, 0);
2440  } else {
2441  infer(lmcs_delta_abs_crs, 0);
2442  infer(lmcs_delta_sign_crs_flag, 0);
2443  }
2444 
2445  return 0;
2446 }
2447 
2448 static int FUNC(scaling_list_data)(CodedBitstreamContext *ctx, RWContext *rw,
2449  H266RawAPS *current)
2450 {
2451  // 7.4.3.4, deriving DiagScanOrder
2452  static const uint8_t diag_scan_order[64][2] = {
2453  { 0, 0, }, { 0, 1, }, { 1, 0, }, { 0, 2, }, { 1, 1, }, { 2, 0, }, { 0, 3, }, { 1, 2, },
2454  { 2, 1, }, { 3, 0, }, { 0, 4, }, { 1, 3, }, { 2, 2, }, { 3, 1, }, { 4, 0, }, { 0, 5, },
2455  { 1, 4, }, { 2, 3, }, { 3, 2, }, { 4, 1, }, { 5, 0, }, { 0, 6, }, { 1, 5, }, { 2, 4, },
2456  { 3, 3, }, { 4, 2, }, { 5, 1, }, { 6, 0, }, { 0, 7, }, { 1, 6, }, { 2, 5, }, { 3, 4, },
2457  { 4, 3, }, { 5, 2, }, { 6, 1, }, { 7, 0, }, { 1, 7, }, { 2, 6, }, { 3, 5, }, { 4, 4, },
2458  { 5, 3, }, { 6, 2, }, { 7, 1, }, { 2, 7, }, { 3, 6, }, { 4, 5, }, { 5, 4, }, { 6, 3, },
2459  { 7, 2, }, { 3, 7, }, { 4, 6, }, { 5, 5, }, { 6, 4, }, { 7, 3, }, { 4, 7, }, { 5, 6, },
2460  { 6, 5, }, { 7, 4, }, { 5, 7, }, { 6, 6, }, { 7, 5, }, { 6, 7, }, { 7, 6, }, { 7, 7, }, };
2461  int err;
2462 
2463  for (int id = 0; id < 28; id ++) {
2464  if (current->aps_chroma_present_flag || id % 3 == 2 || id == 27) {
2465  flags(scaling_list_copy_mode_flag[id], 1, id);
2466  if (!current->scaling_list_copy_mode_flag[id])
2467  flags(scaling_list_pred_mode_flag[id], 1, id);
2468  else
2469  infer(scaling_list_pred_mode_flag[id], 0);
2470  if ((current->scaling_list_copy_mode_flag[id] ||
2471  current->scaling_list_pred_mode_flag[id]) &&
2472  id != 0 && id != 2 && id != 8) {
2473  int max_id_delta = (id < 2) ? id : ((id < 8) ? (id - 2) : (id - 8));
2474  ues(scaling_list_pred_id_delta[id], 0, max_id_delta, 1, id);
2475  }
2476  if (!current->scaling_list_copy_mode_flag[id]) {
2477  int matrix_size = id < 2 ? 2 : (id < 8 ? 4 : 8);
2478  if (id > 13) {
2479  int idx = id - 14;
2480  ses(scaling_list_dc_coef[idx], -128, 127, 1, idx);
2481  }
2482  for (int i = 0; i < matrix_size * matrix_size; i++) {
2483  int x = diag_scan_order[i][0];
2484  int y = diag_scan_order[i][1];
2485  if (!(id > 25 && x >= 4 && y >= 4))
2486  ses(scaling_list_delta_coef[id][i], -128, 127, 2, id, i);
2487  }
2488  } else if (id > 13) {
2489  int idx = id - 14;
2490  infer(scaling_list_dc_coef[idx], 0);
2491  }
2492  } else {
2493  infer(scaling_list_copy_mode_flag[id], 1);
2494  infer(scaling_list_pred_mode_flag[id], 0);
2495  }
2496  }
2497 
2498  return 0;
2499 }
2500 
2501 static int FUNC(aps)(CodedBitstreamContext *ctx, RWContext *rw,
2502  H266RawAPS *current, int prefix)
2503 {
2504  int aps_id_max = MAX_UINT_BITS(5);
2505  int err;
2506 
2507  if (prefix)
2508  HEADER("Prefix Adaptation parameter set");
2509  else
2510  HEADER("Suffix Adaptation parameter set");
2511 
2512  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
2513  prefix ? VVC_PREFIX_APS_NUT
2514  : VVC_SUFFIX_APS_NUT));
2515 
2516  ub(3, aps_params_type);
2517  if (current->aps_params_type == VVC_ASP_TYPE_ALF ||
2518  current->aps_params_type == VVC_ASP_TYPE_SCALING)
2519  aps_id_max = 7;
2520  else if (current->aps_params_type == VVC_ASP_TYPE_LMCS)
2521  aps_id_max = 3;
2522  u(5, aps_adaptation_parameter_set_id, 0, aps_id_max);
2523  flag(aps_chroma_present_flag);
2524  if (current->aps_params_type == VVC_ASP_TYPE_ALF)
2525  CHECK(FUNC(alf_data)(ctx, rw, current));
2526  else if(current->aps_params_type == VVC_ASP_TYPE_LMCS)
2527  CHECK(FUNC(lmcs_data)(ctx, rw, current));
2528  else if (current->aps_params_type == VVC_ASP_TYPE_SCALING)
2529  CHECK(FUNC(scaling_list_data)(ctx, rw, current));
2530  flag(aps_extension_flag);
2531  if (current->aps_extension_flag)
2532  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2533  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2534 
2535  return 0;
2536 }
2537 
2538 static int FUNC(aud) (CodedBitstreamContext *ctx, RWContext *rw,
2539  H266RawAUD *current)
2540 {
2541  int err;
2542 
2543  HEADER("Access Unit Delimiter");
2544 
2545  CHECK(FUNC(nal_unit_header) (ctx, rw,
2546  &current->nal_unit_header, VVC_AUD_NUT));
2547 
2548  flag(aud_irap_or_gdr_flag);
2549  u(3, aud_pic_type, 0, 2);
2550 
2551  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2552  return 0;
2553 }
2554 
2555 static int FUNC(pred_weight_table) (CodedBitstreamContext *ctx, RWContext *rw,
2556  const H266RawSPS *sps,
2557  const H266RawPPS *pps,
2558  const H266RefPicLists *ref_lists,
2559  uint8_t num_ref_idx_active[2],
2560  H266RawPredWeightTable *current)
2561 {
2562  int err, i, j;
2563  ue(luma_log2_weight_denom, 0, 7);
2564  if (sps->sps_chroma_format_idc != 0) {
2565  se(delta_chroma_log2_weight_denom,
2566  -current->luma_log2_weight_denom,
2567  7 - current->luma_log2_weight_denom);
2568  } else {
2569  infer(delta_chroma_log2_weight_denom, 0);
2570  }
2571  if (pps->pps_wp_info_in_ph_flag) {
2572  ue(num_l0_weights, 0,
2573  FFMIN(15, ref_lists->rpl_ref_list[0].num_ref_entries));
2574  infer(num_weights_l0, current->num_l0_weights);
2575  } else {
2576  infer(num_weights_l0, num_ref_idx_active[0]);
2577  }
2578  for (i = 0; i < current->num_weights_l0; i++) {
2579  flags(luma_weight_l0_flag[i], 1, i);
2580  }
2581  if (sps->sps_chroma_format_idc != 0) {
2582  for (i = 0; i < current->num_weights_l0; i++)
2583  flags(chroma_weight_l0_flag[i], 1, i);
2584  }
2585  for (i = 0; i < current->num_weights_l0; i++) {
2586  if (current->luma_weight_l0_flag[i]) {
2587  ses(delta_luma_weight_l0[i], -128, 127, 1, i);
2588  ses(luma_offset_l0[i], -128, 127, 1, i);
2589  } else {
2590  infer(delta_luma_weight_l0[i], 0);
2591  infer(luma_offset_l0[i], 0);
2592  }
2593  if (current->chroma_weight_l0_flag[i]) {
2594  for (j = 0; j < 2; j++) {
2595  ses(delta_chroma_weight_l0[i][j], -128, 127, 2, i, j);
2596  ses(delta_chroma_offset_l0[i][j], -4 * 128, 4 * 127, 2, i, j);
2597  }
2598  }
2599  }
2600 
2601  if (pps->pps_weighted_bipred_flag &&
2602  ref_lists->rpl_ref_list[1].num_ref_entries > 0) {
2603  if (pps->pps_wp_info_in_ph_flag) {
2604  ue(num_l1_weights, 0,
2605  FFMIN(15, ref_lists->rpl_ref_list[1].num_ref_entries));
2606  infer(num_weights_l1, current->num_l1_weights);
2607  } else {
2608  infer(num_weights_l1, num_ref_idx_active[1]);
2609  }
2610  } else {
2611  infer(num_weights_l1, 0);
2612  }
2613 
2614  for (i = 0; i < current->num_weights_l1; i++)
2615  flags(luma_weight_l1_flag[i], 1, i);
2616  if (sps->sps_chroma_format_idc != 0) {
2617  for (i = 0; i < current->num_weights_l1; i++)
2618  flags(chroma_weight_l1_flag[i], 1, i);
2619  }
2620  for (i = 0; i < current->num_weights_l1; i++) {
2621  if (current->luma_weight_l1_flag[i]) {
2622  ses(delta_luma_weight_l1[i], -128, 127, 1, i);
2623  ses(luma_offset_l1[i], -128, 127, 1, i);
2624  } else {
2625  infer(delta_luma_weight_l1[i], 0);
2626  infer(luma_offset_l1[i], 0);
2627  }
2628  if (current->chroma_weight_l1_flag[i]) {
2629  for (j = 0; j < 2; j++) {
2630  ses(delta_chroma_weight_l1[i][j], -128, 127, 2, i, j);
2631  ses(delta_chroma_offset_l1[i][j], -4 * 128, 4 * 127, 2, i, j);
2632  }
2633  }
2634  }
2635  return 0;
2636 }
2637 
2638 static int FUNC(picture_header) (CodedBitstreamContext *ctx, RWContext *rw,
2639  H266RawPictureHeader *current) {
2640  CodedBitstreamH266Context *h266 = ctx->priv_data;
2641  const H266RawVPS *vps;
2642  const H266RawSPS *sps;
2643  const H266RawPPS *pps;
2644  int err, i;
2645  unsigned int ctb_log2_size_y, min_cb_log2_size_y,
2646  min_qt_log2_size_intra_y, min_qt_log2_size_inter_y;
2647  uint8_t qp_bd_offset;
2648 
2649  flag(ph_gdr_or_irap_pic_flag);
2650  flag(ph_non_ref_pic_flag);
2651  if (current->ph_gdr_or_irap_pic_flag)
2652  flag(ph_gdr_pic_flag);
2653  else
2654  infer(ph_gdr_pic_flag, 0);
2655  flag(ph_inter_slice_allowed_flag);
2656  if (current->ph_inter_slice_allowed_flag)
2657  flag(ph_intra_slice_allowed_flag);
2658  else
2659  infer(ph_intra_slice_allowed_flag, 1);
2660  ue(ph_pic_parameter_set_id, 0, VVC_MAX_PPS_COUNT - 1);
2661  pps = h266->pps[current->ph_pic_parameter_set_id];
2662  if (!pps) {
2663  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
2664  current->ph_pic_parameter_set_id);
2665  return AVERROR_INVALIDDATA;
2666  }
2667  sps = h266->sps[pps->pps_seq_parameter_set_id];
2668  if (!sps) {
2669  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
2670  pps->pps_seq_parameter_set_id);
2671  return AVERROR_INVALIDDATA;
2672  }
2673  vps = h266->vps[sps->sps_video_parameter_set_id];
2674  if (!vps) {
2675  av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
2676  sps->sps_video_parameter_set_id);
2677  return AVERROR_INVALIDDATA;
2678  }
2679 
2680  ub(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_pic_order_cnt_lsb);
2681  if (current->ph_gdr_pic_flag)
2682  ue(ph_recovery_poc_cnt, 0,
2683  1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4));
2684 
2685  for (i = 0; i < sps->sps_num_extra_ph_bytes * 8; i++) {
2686  if (sps->sps_extra_ph_bit_present_flag[i])
2687  flags(ph_extra_bit[i], 1, i);
2688  }
2689  if (sps->sps_poc_msb_cycle_flag) {
2690  flag(ph_poc_msb_cycle_present_flag);
2691  if (current->ph_poc_msb_cycle_present_flag)
2692  ub(sps->sps_poc_msb_cycle_len_minus1 + 1, ph_poc_msb_cycle_val);
2693  }
2694  if (sps->sps_alf_enabled_flag && pps->pps_alf_info_in_ph_flag) {
2695  flag(ph_alf_enabled_flag);
2696  if (current->ph_alf_enabled_flag) {
2697 
2698  ub(3, ph_num_alf_aps_ids_luma);
2699  for (i = 0; i < current->ph_num_alf_aps_ids_luma; i++)
2700  ubs(3, ph_alf_aps_id_luma[i], 1, i);
2701 
2702  if (sps->sps_chroma_format_idc != 0) {
2703  flag(ph_alf_cb_enabled_flag);
2704  flag(ph_alf_cr_enabled_flag);
2705  } else {
2706  infer(ph_alf_cb_enabled_flag, 0);
2707  infer(ph_alf_cr_enabled_flag, 0);
2708  }
2709 
2710  if (current->ph_alf_cb_enabled_flag
2711  || current->ph_alf_cr_enabled_flag) {
2712  ub(3, ph_alf_aps_id_chroma);
2713  }
2714 
2715  if (sps->sps_ccalf_enabled_flag) {
2716  flag(ph_alf_cc_cb_enabled_flag);
2717  if (current->ph_alf_cc_cb_enabled_flag)
2718  ub(3, ph_alf_cc_cb_aps_id);
2719  flag(ph_alf_cc_cr_enabled_flag);
2720  if (current->ph_alf_cc_cr_enabled_flag)
2721  ub(3, ph_alf_cc_cr_aps_id);
2722  }
2723  }
2724  } else {
2725  infer(ph_alf_enabled_flag, 0);
2726  }
2727  if (sps->sps_lmcs_enabled_flag) {
2728  flag(ph_lmcs_enabled_flag);
2729  if (current->ph_lmcs_enabled_flag) {
2730  ub(2, ph_lmcs_aps_id);
2731  if (sps->sps_chroma_format_idc != 0)
2732  flag(ph_chroma_residual_scale_flag);
2733  else
2734  infer(ph_chroma_residual_scale_flag, 0);
2735  }
2736  } else {
2737  infer(ph_lmcs_enabled_flag, 0);
2738  infer(ph_chroma_residual_scale_flag, 0);
2739  }
2740 
2741  if (sps->sps_explicit_scaling_list_enabled_flag) {
2742  flag(ph_explicit_scaling_list_enabled_flag);
2743  if (current->ph_explicit_scaling_list_enabled_flag) {
2744  //todo: check the ph_scaling_list_aps_id range, when aps ready
2745  ub(3, ph_scaling_list_aps_id);
2746  }
2747  } else {
2748  infer(ph_explicit_scaling_list_enabled_flag, 0);
2749  }
2750  if (sps->sps_virtual_boundaries_enabled_flag &&
2751  !sps->sps_virtual_boundaries_present_flag) {
2752  flag(ph_virtual_boundaries_present_flag);
2753  if (current->ph_virtual_boundaries_present_flag) {
2754  ue(ph_num_ver_virtual_boundaries,
2755  0, pps->pps_pic_width_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
2756  for (i = 0; i < current->ph_num_ver_virtual_boundaries; i++) {
2757  ues(ph_virtual_boundary_pos_x_minus1[i],
2758  0, (pps->pps_pic_width_in_luma_samples + 7) / 8 - 2, 1, i);
2759  }
2760  ue(ph_num_hor_virtual_boundaries,
2761  0, pps->pps_pic_height_in_luma_samples <= 8 ? 0 : VVC_MAX_VBS);
2762  for (i = 0; i < current->ph_num_hor_virtual_boundaries; i++) {
2763  ues(ph_virtual_boundary_pos_y_minus1[i],
2764  0, (pps->pps_pic_height_in_luma_samples + 7) / 8 - 2, 1, i);
2765  }
2766  } else {
2767  infer(ph_num_ver_virtual_boundaries, 0);
2768  infer(ph_num_hor_virtual_boundaries, 0);
2769  }
2770  }
2771  if (pps->pps_output_flag_present_flag && !current->ph_non_ref_pic_flag)
2772  flag(ph_pic_output_flag);
2773  else
2774  infer(ph_pic_output_flag, 1);
2775  if (pps->pps_rpl_info_in_ph_flag) {
2776  CHECK(FUNC(ref_pic_lists)
2777  (ctx, rw, sps, pps, &current->ph_ref_pic_lists));
2778  }
2779  if (sps->sps_partition_constraints_override_enabled_flag)
2780  flag(ph_partition_constraints_override_flag);
2781  else
2782  infer(ph_partition_constraints_override_flag, 0);
2783 
2784  ctb_log2_size_y = sps->sps_log2_ctu_size_minus5 + 5;
2785  min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
2786  if (current->ph_intra_slice_allowed_flag) {
2787  if (current->ph_partition_constraints_override_flag) {
2788  ue(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2789  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2790  ue(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2791  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2792  if (current->ph_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
2793  min_qt_log2_size_intra_y =
2794  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2795  min_cb_log2_size_y;
2796  ue(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2797  0, (sps->sps_qtbtt_dual_tree_intra_flag ?
2798  FFMIN(6, ctb_log2_size_y) :
2799  ctb_log2_size_y) - min_qt_log2_size_intra_y);
2800  ue(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2801  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
2802  } else {
2803  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2804  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2805  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2806  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2807  }
2808  if (sps->sps_qtbtt_dual_tree_intra_flag) {
2809  ue(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2810  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2811  ue(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2812  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2813  if (sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
2814  unsigned int min_qt_log2_size_intra_c =
2815  current->ph_log2_diff_min_qt_min_cb_intra_slice_chroma +
2816  min_cb_log2_size_y;
2817  ue(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2818  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2819  ue(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2820  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2821  } else {
2822  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2823  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2824  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2825  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2826  }
2827  }
2828  } else {
2829  infer(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2830  sps->sps_log2_diff_min_qt_min_cb_intra_slice_luma);
2831  infer(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2832  sps->sps_max_mtt_hierarchy_depth_intra_slice_luma);
2833  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2834  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2835  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2836  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2837  infer(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2838  sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma);
2839  infer(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2840  sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma);
2841  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2842  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2843  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2844  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2845  }
2846 
2847  min_qt_log2_size_intra_y =
2848  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2849  min_cb_log2_size_y;
2850  if (pps->pps_cu_qp_delta_enabled_flag)
2851  ue(ph_cu_qp_delta_subdiv_intra_slice, 0,
2852  2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2853  current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2854  else
2855  infer(ph_cu_qp_delta_subdiv_intra_slice, 0);
2856 
2857  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2858  ue(ph_cu_chroma_qp_offset_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_chroma_qp_offset_subdiv_intra_slice, 0);
2863  }
2864  if (current->ph_inter_slice_allowed_flag) {
2865  if (current->ph_partition_constraints_override_flag) {
2866  ue(ph_log2_diff_min_qt_min_cb_inter_slice,
2867  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2868  min_qt_log2_size_inter_y =
2869  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2870  min_cb_log2_size_y;
2871  ue(ph_max_mtt_hierarchy_depth_inter_slice, 0,
2872  2 * (ctb_log2_size_y - min_cb_log2_size_y));
2873  if (current->ph_max_mtt_hierarchy_depth_inter_slice != 0) {
2874  ue(ph_log2_diff_max_bt_min_qt_inter_slice,
2875  0, ctb_log2_size_y - min_qt_log2_size_inter_y);
2876  ue(ph_log2_diff_max_tt_min_qt_inter_slice,
2877  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
2878  }
2879  } else {
2880  infer(ph_log2_diff_min_qt_min_cb_inter_slice,
2881  sps->sps_log2_diff_min_qt_min_cb_inter_slice);
2882  min_qt_log2_size_inter_y =
2883  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2884  min_cb_log2_size_y;
2885  infer(ph_max_mtt_hierarchy_depth_inter_slice,
2886  sps->sps_max_mtt_hierarchy_depth_inter_slice);
2887  infer(ph_log2_diff_max_bt_min_qt_inter_slice,
2888  sps->sps_log2_diff_max_bt_min_qt_inter_slice);
2889  infer(ph_log2_diff_max_tt_min_qt_inter_slice,
2890  sps->sps_log2_diff_max_tt_min_qt_inter_slice);
2891  }
2892 
2893  if (pps->pps_cu_qp_delta_enabled_flag)
2894  ue(ph_cu_qp_delta_subdiv_inter_slice, 0,
2895  2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2896  current->ph_max_mtt_hierarchy_depth_inter_slice));
2897  else
2898  infer(ph_cu_qp_delta_subdiv_inter_slice, 0);
2899 
2900  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2901  ue(ph_cu_chroma_qp_offset_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_chroma_qp_offset_subdiv_inter_slice, 0);
2906  if (sps->sps_temporal_mvp_enabled_flag) {
2907  flag(ph_temporal_mvp_enabled_flag);
2908  if (current->ph_temporal_mvp_enabled_flag &&
2909  pps->pps_rpl_info_in_ph_flag) {
2910  if (current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0)
2911  flag(ph_collocated_from_l0_flag);
2912  else
2913  infer(ph_collocated_from_l0_flag, 1);
2914  if ((current->ph_collocated_from_l0_flag &&
2915  current->ph_ref_pic_lists.rpl_ref_list[0].num_ref_entries > 1)
2916  || (!current->ph_collocated_from_l0_flag &&
2917  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 1)) {
2918  unsigned int idx =
2919  current->ph_collocated_from_l0_flag ? 0 : 1;
2920  ue(ph_collocated_ref_idx, 0,
2921  current->ph_ref_pic_lists.rpl_ref_list[idx].
2922  num_ref_entries - 1);
2923  } else {
2924  infer(ph_collocated_ref_idx, 0);
2925  }
2926  }
2927  }
2928  if (sps->sps_mmvd_fullpel_only_enabled_flag)
2929  flag(ph_mmvd_fullpel_only_flag);
2930  else
2931  infer(ph_mmvd_fullpel_only_flag, 0);
2932  if (!pps->pps_rpl_info_in_ph_flag ||
2933  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) {
2934  flag(ph_mvd_l1_zero_flag);
2935  if (sps->sps_bdof_control_present_in_ph_flag) {
2936  flag(ph_bdof_disabled_flag);
2937  } else {
2938  if (!sps->sps_bdof_control_present_in_ph_flag)
2939  infer(ph_bdof_disabled_flag,
2940  1 - sps->sps_bdof_enabled_flag);
2941  else
2942  infer(ph_bdof_disabled_flag, 1);
2943  }
2944  if (sps->sps_dmvr_control_present_in_ph_flag) {
2945  flag(ph_dmvr_disabled_flag);
2946  } else {
2947  if (!sps->sps_dmvr_control_present_in_ph_flag)
2948  infer(ph_dmvr_disabled_flag,
2949  1 - sps->sps_dmvr_enabled_flag);
2950  else
2951  infer(ph_dmvr_disabled_flag, 1);
2952  }
2953  } else {
2954  infer(ph_mvd_l1_zero_flag, 1);
2955  }
2956  if (sps->sps_prof_control_present_in_ph_flag)
2957  flag(ph_prof_disabled_flag);
2958  else
2959  infer(ph_prof_disabled_flag, !sps->sps_affine_prof_enabled_flag);
2960  if ((pps->pps_weighted_pred_flag ||
2961  pps->pps_weighted_bipred_flag) && pps->pps_wp_info_in_ph_flag) {
2962 
2963  // if pps->pps_wp_info_in_ph_fla == 1
2964  // pred_weight_table will not use num_ref_idx_active
2965  uint8_t num_ref_idx_active[2] = { 0, 0 };
2966  CHECK(FUNC(pred_weight_table)
2967  (ctx, rw, sps, pps, &current->ph_ref_pic_lists,
2968  num_ref_idx_active, &current->ph_pred_weight_table));
2969  }
2970  }
2971 
2972  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2973  if (pps->pps_qp_delta_info_in_ph_flag)
2974  se(ph_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
2975  63 - (26 + pps->pps_init_qp_minus26));
2976 
2977  if (sps->sps_joint_cbcr_enabled_flag)
2978  flag(ph_joint_cbcr_sign_flag);
2979  else
2980  infer(ph_joint_cbcr_sign_flag, 0);
2981  if (sps->sps_sao_enabled_flag && pps->pps_sao_info_in_ph_flag) {
2982  flag(ph_sao_luma_enabled_flag);
2983  if (sps->sps_chroma_format_idc != 0)
2984  flag(ph_sao_chroma_enabled_flag);
2985  else
2986  infer(ph_sao_chroma_enabled_flag, 0);
2987  } else {
2988  infer(ph_sao_luma_enabled_flag, 0);
2989  infer(ph_sao_chroma_enabled_flag, 0);
2990  }
2991 
2992  if (pps->pps_dbf_info_in_ph_flag)
2993  flag(ph_deblocking_params_present_flag);
2994  else
2995  infer(ph_deblocking_params_present_flag, 0);
2996 
2997  if (current->ph_deblocking_params_present_flag) {
2998  if (!pps->pps_deblocking_filter_disabled_flag) {
2999  flag(ph_deblocking_filter_disabled_flag);
3000  if (!current->ph_deblocking_filter_disabled_flag) {
3001  se(ph_luma_beta_offset_div2, -12, 12);
3002  se(ph_luma_tc_offset_div2, -12, 12);
3003  if (pps->pps_chroma_tool_offsets_present_flag) {
3004  se(ph_cb_beta_offset_div2, -12, 12);
3005  se(ph_cb_tc_offset_div2, -12, 12);
3006  se(ph_cr_beta_offset_div2, -12, 12);
3007  se(ph_cr_tc_offset_div2, -12, 12);
3008  } else {
3009  infer(ph_cb_beta_offset_div2,
3010  current->ph_luma_beta_offset_div2);
3011  infer(ph_cb_tc_offset_div2,
3012  current->ph_luma_tc_offset_div2);
3013  infer(ph_cr_beta_offset_div2,
3014  current->ph_luma_beta_offset_div2);
3015  infer(ph_cr_tc_offset_div2,
3016  current->ph_luma_tc_offset_div2);
3017  }
3018  }
3019  } else {
3020  infer(ph_deblocking_filter_disabled_flag, 0);
3021  }
3022  } else {
3023  infer(ph_deblocking_filter_disabled_flag, pps->pps_deblocking_filter_disabled_flag);
3024  if (!current->ph_deblocking_filter_disabled_flag) {
3025  infer(ph_luma_beta_offset_div2, pps->pps_luma_beta_offset_div2);
3026  infer(ph_luma_tc_offset_div2, pps->pps_luma_tc_offset_div2);
3027  infer(ph_cb_beta_offset_div2, pps->pps_cb_beta_offset_div2);
3028  infer(ph_cb_tc_offset_div2, pps->pps_cb_tc_offset_div2);
3029  infer(ph_cr_beta_offset_div2, pps->pps_cr_beta_offset_div2);
3030  infer(ph_cr_tc_offset_div2, pps->pps_cr_tc_offset_div2);
3031  }
3032  }
3033 
3034  if (pps->pps_picture_header_extension_present_flag) {
3035  ue(ph_extension_length, 0, 256);
3036  for (i = 0; i < current->ph_extension_length; i++)
3037  us(8, ph_extension_data_byte[i], 0x00, 0xff, 1, i);
3038  }
3039 
3040  return 0;
3041 }
3042 
3043 static int FUNC(ph) (CodedBitstreamContext *ctx, RWContext *rw,
3044  H266RawPH *current)
3045 {
3046  int err;
3047 
3048  HEADER("Picture Header");
3049 
3050  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, VVC_PH_NUT));
3051  CHECK(FUNC(picture_header) (ctx, rw, &current->ph_picture_header));
3052  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3053  return 0;
3054 }
3055 
3056 static int FUNC(slice_header) (CodedBitstreamContext *ctx, RWContext *rw,
3057  H266RawSliceHeader *current)
3058 {
3059  CodedBitstreamH266Context *h266 = ctx->priv_data;
3060  const H266RawSPS *sps;
3061  const H266RawPPS *pps;
3062  const H266RawPictureHeader *ph;
3063  const H266RefPicLists *ref_pic_lists;
3064  int err, i;
3065  uint8_t nal_unit_type, qp_bd_offset;
3066  uint16_t num_slices_in_subpic;
3067 
3068  HEADER("Slice Header");
3069 
3070  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, -1));
3071 
3072  flag(sh_picture_header_in_slice_header_flag);
3073  if (current->sh_picture_header_in_slice_header_flag) {
3074  // 7.4.8 if sh_picture_header_in_slice_header_flag is true, we do not have a PH NAL unit
3075  CHECK(FUNC(picture_header) (ctx, rw, &current->sh_picture_header));
3076  ph = &current->sh_picture_header;
3077  } else {
3078  ph = h266->ph;
3079  if (!ph) {
3080  av_log(ctx->log_ctx, AV_LOG_ERROR,
3081  "Picture header not available.\n");
3082  return AVERROR_INVALIDDATA;
3083  }
3084  }
3085 
3086  pps = h266->pps[ph->ph_pic_parameter_set_id];
3087  if (!pps) {
3088  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
3089  ph->ph_pic_parameter_set_id);
3090  return AVERROR_INVALIDDATA;
3091  }
3092  sps = h266->sps[pps->pps_seq_parameter_set_id];
3093  if (!sps) {
3094  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
3095  pps->pps_seq_parameter_set_id);
3096  return AVERROR_INVALIDDATA;
3097  }
3098 
3099  if (sps->sps_subpic_info_present_flag) {
3100  ub(sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id);
3101  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
3102  if (pps->sub_pic_id_val[i] == current->sh_subpic_id) {
3103  current->curr_subpic_idx = i;
3104  break;
3105  }
3106  }
3107  if (i > sps->sps_num_subpics_minus1) {
3108  av_log(ctx->log_ctx, AV_LOG_ERROR, "invalid CurrSubpicIdx %d\n", i);
3109  return AVERROR_INVALIDDATA;
3110  }
3111  } else {
3112  current->curr_subpic_idx = 0;
3113  }
3114 
3115  num_slices_in_subpic = pps->num_slices_in_subpic[current->curr_subpic_idx];
3116 
3117  if ((pps->pps_rect_slice_flag && num_slices_in_subpic > 1) ||
3118  (!pps->pps_rect_slice_flag && pps->num_tiles_in_pic > 1)) {
3119  unsigned int bits, max;
3120  if (!pps->pps_rect_slice_flag) {
3121  bits = av_ceil_log2(pps->num_tiles_in_pic);
3122  max = pps->num_tiles_in_pic - 1;
3123  } else {
3124  bits = av_ceil_log2(num_slices_in_subpic);
3125  max = num_slices_in_subpic - 1;
3126  }
3127  u(bits, sh_slice_address, 0, max);
3128  } else {
3129  infer(sh_slice_address, 0);
3130  }
3131 
3132  for (i = 0; i < sps->sps_num_extra_sh_bytes * 8; i++) {
3133  if (sps->sps_extra_sh_bit_present_flag[i])
3134  flags(sh_extra_bit[i], 1, i);
3135  }
3136 
3137  if (!pps->pps_rect_slice_flag &&
3138  pps->num_tiles_in_pic - current->sh_slice_address > 1)
3139  ue(sh_num_tiles_in_slice_minus1, 0, pps->num_tiles_in_pic - 1);
3140  else
3141  infer(sh_num_tiles_in_slice_minus1, 0);
3142 
3143  if (ph->ph_inter_slice_allowed_flag)
3144  ue(sh_slice_type, 0, 2);
3145  else
3146  infer(sh_slice_type, 2);
3147 
3148  nal_unit_type = current->nal_unit_header.nal_unit_type;
3149  if (nal_unit_type == VVC_IDR_W_RADL || nal_unit_type == VVC_IDR_N_LP ||
3150  nal_unit_type == VVC_CRA_NUT || nal_unit_type == VVC_GDR_NUT)
3151  flag(sh_no_output_of_prior_pics_flag);
3152 
3153  if (sps->sps_alf_enabled_flag) {
3154  if (!pps->pps_alf_info_in_ph_flag) {
3155  flag(sh_alf_enabled_flag);
3156  if (current->sh_alf_enabled_flag) {
3157  ub(3, sh_num_alf_aps_ids_luma);
3158  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3159  ubs(3, sh_alf_aps_id_luma[i], 1, i);
3160 
3161  if (sps->sps_chroma_format_idc != 0) {
3162  flag(sh_alf_cb_enabled_flag);
3163  flag(sh_alf_cr_enabled_flag);
3164  }
3165  if (current->sh_alf_cb_enabled_flag ||
3166  current->sh_alf_cr_enabled_flag) {
3167  ub(3, sh_alf_aps_id_chroma);
3168  }
3169 
3170  if (sps->sps_ccalf_enabled_flag) {
3171  flag(sh_alf_cc_cb_enabled_flag);
3172  if (current->sh_alf_cc_cb_enabled_flag)
3173  ub(3, sh_alf_cc_cb_aps_id);
3174 
3175  flag(sh_alf_cc_cr_enabled_flag);
3176  if (current->sh_alf_cc_cr_enabled_flag)
3177  ub(3, sh_alf_cc_cr_aps_id);
3178  }
3179  }
3180  } else {
3181  infer(sh_alf_enabled_flag, ph->ph_alf_enabled_flag);
3182  if (current->sh_alf_enabled_flag) {
3183  infer(sh_num_alf_aps_ids_luma, ph->ph_num_alf_aps_ids_luma);
3184  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3185  infer(sh_alf_aps_id_luma[i], ph->ph_alf_aps_id_luma[i]);
3186 
3187  infer(sh_alf_cb_enabled_flag, ph->ph_alf_cb_enabled_flag);
3188  infer(sh_alf_cr_enabled_flag, ph->ph_alf_cr_enabled_flag);
3189  if (current->sh_alf_cb_enabled_flag ||current->sh_alf_cr_enabled_flag)
3190  infer(sh_alf_aps_id_chroma, ph->ph_alf_aps_id_chroma);
3191 
3192  if (sps->sps_ccalf_enabled_flag) {
3193  infer(sh_alf_cc_cb_enabled_flag, ph->ph_alf_cc_cb_enabled_flag);
3194  if (current->sh_alf_cc_cb_enabled_flag)
3195  infer(sh_alf_cc_cb_aps_id, ph->ph_alf_cc_cb_aps_id);
3196 
3197  infer(sh_alf_cc_cr_enabled_flag, ph->ph_alf_cc_cr_enabled_flag);
3198  if (current->sh_alf_cc_cr_enabled_flag)
3199  infer(sh_alf_cc_cr_aps_id, ph->ph_alf_cc_cr_aps_id);
3200  }
3201  }
3202  }
3203  }
3204 
3205  if (current->sh_picture_header_in_slice_header_flag) {
3206  infer(sh_lmcs_used_flag, ph->ph_lmcs_enabled_flag);
3207  infer(sh_explicit_scaling_list_used_flag,
3208  ph->ph_explicit_scaling_list_enabled_flag);
3209  } else {
3210  if (ph->ph_lmcs_enabled_flag)
3211  flag(sh_lmcs_used_flag);
3212  else
3213  infer(sh_lmcs_used_flag, 0);
3214 
3215  if (ph->ph_explicit_scaling_list_enabled_flag)
3216  flag(sh_explicit_scaling_list_used_flag);
3217  else
3218  infer(sh_explicit_scaling_list_used_flag, 0);
3219  }
3220 
3221  if (!pps->pps_rpl_info_in_ph_flag &&
3222  ((nal_unit_type != VVC_IDR_W_RADL &&
3223  nal_unit_type != VVC_IDR_N_LP) || sps->sps_idr_rpl_present_flag)) {
3224  CHECK(FUNC(ref_pic_lists)
3225  (ctx, rw, sps, pps, &current->sh_ref_pic_lists));
3226  ref_pic_lists = &current->sh_ref_pic_lists;
3227  } else {
3228  ref_pic_lists = &ph->ph_ref_pic_lists;
3229  }
3230  if ((current->sh_slice_type != VVC_SLICE_TYPE_I &&
3231  ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) ||
3232  (current->sh_slice_type == VVC_SLICE_TYPE_B &&
3233  ref_pic_lists->rpl_ref_list[1].num_ref_entries > 1)) {
3234  flag(sh_num_ref_idx_active_override_flag);
3235  if (current->sh_num_ref_idx_active_override_flag) {
3236  for (i = 0;
3237  i < (current->sh_slice_type == VVC_SLICE_TYPE_B ? 2 : 1); i++)
3238  if (ref_pic_lists->rpl_ref_list[i].num_ref_entries > 1)
3239  ues(sh_num_ref_idx_active_minus1[i], 0, 14, 1, i);
3240  else
3241  infer(sh_num_ref_idx_active_minus1[i], 0);
3242  }
3243  } else {
3244  infer(sh_num_ref_idx_active_override_flag, 1);
3245  }
3246 
3247  for (i = 0; i < 2; i++) {
3248  if (current->sh_slice_type == VVC_SLICE_TYPE_B ||
3249  (current->sh_slice_type == VVC_SLICE_TYPE_P && i == 0)) {
3250  if (current->sh_num_ref_idx_active_override_flag) {
3251  current->num_ref_idx_active[i] = current->sh_num_ref_idx_active_minus1[i] + 1;
3252  } else {
3253  current->num_ref_idx_active[i] =
3254  FFMIN(ref_pic_lists->rpl_ref_list[i].num_ref_entries,
3255  pps->pps_num_ref_idx_default_active_minus1[i] + 1);
3256  }
3257  } else {
3258  current->num_ref_idx_active[i] = 0;
3259  }
3260  }
3261 
3262  if (current->sh_slice_type != VVC_SLICE_TYPE_I) {
3263  if (pps->pps_cabac_init_present_flag)
3264  flag(sh_cabac_init_flag);
3265  else
3266  infer(sh_cabac_init_flag, 0);
3267  if (ph->ph_temporal_mvp_enabled_flag) {
3268  if (!pps->pps_rpl_info_in_ph_flag) {
3269  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3270  flag(sh_collocated_from_l0_flag);
3271  else
3272  infer(sh_collocated_from_l0_flag, 1);
3273  if ((current->sh_collocated_from_l0_flag &&
3274  current->num_ref_idx_active[0] > 1) ||
3275  (!current->sh_collocated_from_l0_flag &&
3276  current->num_ref_idx_active[1] > 1)) {
3277  unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1;
3278  ue(sh_collocated_ref_idx, 0, current->num_ref_idx_active[idx] - 1);
3279  } else {
3280  infer(sh_collocated_ref_idx, 0);
3281  }
3282  } else {
3283  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3284  infer(sh_collocated_from_l0_flag, ph->ph_collocated_from_l0_flag);
3285  else
3286  infer(sh_collocated_from_l0_flag, 1);
3287  infer(sh_collocated_ref_idx, ph->ph_collocated_ref_idx);
3288  }
3289  }
3290  if (!pps->pps_wp_info_in_ph_flag &&
3291  ((pps->pps_weighted_pred_flag &&
3292  current->sh_slice_type == VVC_SLICE_TYPE_P) ||
3293  (pps->pps_weighted_bipred_flag &&
3294  current->sh_slice_type == VVC_SLICE_TYPE_B))) {
3295  CHECK(FUNC(pred_weight_table) (ctx, rw, sps, pps, ref_pic_lists,
3296  current->num_ref_idx_active,
3297  &current->sh_pred_weight_table));
3298  }
3299  }
3300  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
3301  if (!pps->pps_qp_delta_info_in_ph_flag)
3302  se(sh_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
3303  63 - (26 + pps->pps_init_qp_minus26));
3304  if (pps->pps_slice_chroma_qp_offsets_present_flag) {
3305  int8_t off;
3306 
3307  se(sh_cb_qp_offset, -12, 12);
3308  off = pps->pps_cb_qp_offset + current->sh_cb_qp_offset;
3309  if (off < -12 || off > 12) {
3310  av_log(ctx->log_ctx, AV_LOG_ERROR,
3311  "pps_cb_qp_offset + sh_cb_qp_offset (%d) not in range [-12, 12].\n",
3312  off);
3313  return AVERROR_INVALIDDATA;
3314  }
3315 
3316  se(sh_cr_qp_offset, -12, 12);
3317  off = pps->pps_cr_qp_offset + current->sh_cr_qp_offset;
3318  if (off < -12 || off > 12) {
3319  av_log(ctx->log_ctx, AV_LOG_ERROR,
3320  "pps_cr_qp_offset + sh_cr_qp_offset (%d) not in range [-12, 12].\n",
3321  off);
3322  return AVERROR_INVALIDDATA;
3323  }
3324 
3325  if (sps->sps_joint_cbcr_enabled_flag) {
3326  se(sh_joint_cbcr_qp_offset, -12, 12);
3327  off =
3328  pps->pps_joint_cbcr_qp_offset_value +
3329  current->sh_joint_cbcr_qp_offset;
3330  if (off < -12 || off > 12) {
3331  av_log(ctx->log_ctx, AV_LOG_ERROR,
3332  "pps_joint_cbcr_qp_offset_value + sh_joint_cbcr_qp_offset (%d)"
3333  "not in range [-12, 12]. \n", off);
3334  return AVERROR_INVALIDDATA;
3335  }
3336  } else {
3337  infer(sh_joint_cbcr_qp_offset, 0);
3338  }
3339  } else {
3340  infer(sh_cb_qp_offset, 0);
3341  infer(sh_cr_qp_offset, 0);
3342  infer(sh_joint_cbcr_qp_offset, 0);
3343  }
3344  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
3345  flag(sh_cu_chroma_qp_offset_enabled_flag);
3346  else
3347  infer(sh_cu_chroma_qp_offset_enabled_flag, 0);
3348  if (sps->sps_sao_enabled_flag && !pps->pps_sao_info_in_ph_flag) {
3349  flag(sh_sao_luma_used_flag);
3350  if (sps->sps_chroma_format_idc != 0)
3351  flag(sh_sao_chroma_used_flag);
3352  else
3353  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3354  } else {
3355  infer(sh_sao_luma_used_flag, ph->ph_sao_luma_enabled_flag);
3356  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3357  }
3358 
3359  if (pps->pps_deblocking_filter_override_enabled_flag &&
3360  !pps->pps_dbf_info_in_ph_flag)
3361  flag(sh_deblocking_params_present_flag);
3362  else
3363  infer(sh_deblocking_params_present_flag, 0);
3364  if (current->sh_deblocking_params_present_flag) {
3365  if (!pps->pps_deblocking_filter_disabled_flag)
3366  flag(sh_deblocking_filter_disabled_flag);
3367  else
3368  infer(sh_deblocking_filter_disabled_flag, 0);
3369  if (!current->sh_deblocking_filter_disabled_flag) {
3370  se(sh_luma_beta_offset_div2, -12, 12);
3371  se(sh_luma_tc_offset_div2, -12, 12);
3372  if (pps->pps_chroma_tool_offsets_present_flag) {
3373  se(sh_cb_beta_offset_div2, -12, 12);
3374  se(sh_cb_tc_offset_div2, -12, 12);
3375  se(sh_cr_beta_offset_div2, -12, 12);
3376  se(sh_cr_tc_offset_div2, -12, 12);
3377  } else {
3378  infer(sh_cb_beta_offset_div2,
3379  current->sh_luma_beta_offset_div2);
3380  infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
3381  infer(sh_cr_beta_offset_div2,
3382  current->sh_luma_beta_offset_div2);
3383  infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
3384  }
3385  }
3386  } else {
3387  infer(sh_deblocking_filter_disabled_flag, ph->ph_deblocking_filter_disabled_flag);
3388  if (!current->sh_deblocking_filter_disabled_flag) {
3389  infer(sh_luma_beta_offset_div2, ph->ph_luma_beta_offset_div2);
3390  infer(sh_luma_tc_offset_div2, ph->ph_luma_tc_offset_div2);
3391  infer(sh_cb_beta_offset_div2, ph->ph_cb_beta_offset_div2);
3392  infer(sh_cb_tc_offset_div2, ph->ph_cb_tc_offset_div2);
3393  infer(sh_cr_beta_offset_div2, ph->ph_cr_beta_offset_div2);
3394  infer(sh_cr_tc_offset_div2, ph->ph_cr_tc_offset_div2);
3395  }
3396  }
3397 
3398  if (sps->sps_dep_quant_enabled_flag)
3399  flag(sh_dep_quant_used_flag);
3400  else
3401  infer(sh_dep_quant_used_flag, 0);
3402 
3403  if (sps->sps_sign_data_hiding_enabled_flag &&
3404  !current->sh_dep_quant_used_flag)
3405  flag(sh_sign_data_hiding_used_flag);
3406  else
3407  infer(sh_sign_data_hiding_used_flag, 0);
3408 
3409  if (sps->sps_transform_skip_enabled_flag &&
3410  !current->sh_dep_quant_used_flag &&
3411  !current->sh_sign_data_hiding_used_flag)
3412  flag(sh_ts_residual_coding_disabled_flag);
3413  else
3414  infer(sh_ts_residual_coding_disabled_flag, 0);
3415 
3416  if (!current->sh_ts_residual_coding_disabled_flag &&
3417  sps->sps_ts_residual_coding_rice_present_in_sh_flag)
3418  ub(3, sh_ts_residual_coding_rice_idx_minus1);
3419  else
3420  infer(sh_ts_residual_coding_rice_idx_minus1, 0);
3421 
3422  if (sps->sps_reverse_last_sig_coeff_enabled_flag)
3423  flag(sh_reverse_last_sig_coeff_flag);
3424  else
3425  infer(sh_reverse_last_sig_coeff_flag, 0);
3426 
3427  if (pps->pps_slice_header_extension_present_flag) {
3428  ue(sh_slice_header_extension_length, 0, 256);
3429  for (i = 0; i < current->sh_slice_header_extension_length; i++)
3430  us(8, sh_slice_header_extension_data_byte[i], 0x00, 0xff, 1, i);
3431  }
3432 
3433  current->num_entry_points = 0;
3434  if (sps->sps_entry_point_offsets_present_flag) {
3435  uint8_t entropy_sync = sps->sps_entropy_coding_sync_enabled_flag;
3436  int height;
3437  if (pps->pps_rect_slice_flag) {
3438  int width_in_tiles;
3439  int slice_idx = current->sh_slice_address;
3440  for (i = 0; i < current->curr_subpic_idx; i++) {
3441  slice_idx += pps->num_slices_in_subpic[i];
3442  }
3443 
3444  if (pps->pps_single_slice_per_subpic_flag) {
3445  const int width_in_ctus = sps->sps_subpic_width_minus1[slice_idx] + 1;
3446  const int subpic_l = sps->sps_subpic_ctu_top_left_x[slice_idx];
3447  const int subpic_r = subpic_l + width_in_ctus;
3448 
3449  int ctb_x = 0, tile_x = 0;
3450  for (; ctb_x < subpic_l && tile_x < pps->num_tile_columns; tile_x++)
3451  ctb_x += pps->col_width_val[tile_x];
3452 
3453  width_in_tiles = 0;
3454  for (; ctb_x < subpic_r && tile_x < pps->num_tile_columns; tile_x++) {
3455  ctb_x += pps->col_width_val[tile_x];
3456  width_in_tiles++;
3457  }
3458 
3459  if (entropy_sync) {
3460  height = sps->sps_subpic_height_minus1[slice_idx] + 1;
3461  } else {
3462  const int height_in_ctus = sps->sps_subpic_height_minus1[slice_idx] + 1;
3463  const int subpic_t = sps->sps_subpic_ctu_top_left_y[slice_idx];
3464  const int subpic_b = subpic_t + height_in_ctus;
3465 
3466  int ctb_y = 0, tile_y = 0, height_in_tiles;
3467  for (; ctb_y < subpic_t && tile_y < pps->num_tile_rows; tile_y++)
3468  ctb_y += pps->row_height_val[tile_y];
3469 
3470  height_in_tiles = 0;
3471  for (; ctb_y < subpic_b && tile_y < pps->num_tile_rows; tile_y++) {
3472  ctb_y += pps->row_height_val[tile_y];
3473  height_in_tiles++;
3474  }
3475 
3476  height = height_in_tiles;
3477  }
3478  } else {
3479  width_in_tiles =
3480  pps->pps_slice_width_in_tiles_minus1[slice_idx] + 1;
3481 
3482  if (entropy_sync)
3483  height = pps->slice_height_in_ctus[slice_idx];
3484  else
3485  height = pps->pps_slice_height_in_tiles_minus1[slice_idx] + 1;
3486  }
3487 
3488  current->num_entry_points = width_in_tiles * height;
3489  } else {
3490  int tile_idx;
3491  int tile_y;
3492  for (tile_idx = current->sh_slice_address;
3493  tile_idx <=
3494  current->sh_slice_address +
3495  current->sh_num_tiles_in_slice_minus1; tile_idx++) {
3496  tile_y = tile_idx / pps->num_tile_rows;
3497  height = pps->row_height_val[tile_y];
3498  current->num_entry_points += (entropy_sync ? height : 1);
3499  }
3500  }
3501  current->num_entry_points--;
3502  if (current->num_entry_points > VVC_MAX_ENTRY_POINTS) {
3503  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
3504  "%" PRIu32 ".\n", current->num_entry_points);
3505  return AVERROR_PATCHWELCOME;
3506  }
3507  if (current->num_entry_points > 0) {
3508  ue(sh_entry_offset_len_minus1, 0, 31);
3509  for (i = 0; i < current->num_entry_points; i++) {
3510  ubs(current->sh_entry_offset_len_minus1 + 1,
3511  sh_entry_point_offset_minus1[i], 1, i);
3512  }
3513  }
3514  }
3515  CHECK(FUNC(byte_alignment) (ctx, rw));
3516 
3517  return 0;
3518 }
3519 
3520 static int FUNC(sei) (CodedBitstreamContext *ctx, RWContext *rw,
3521  H266RawSEI *current, int prefix)
3522 {
3523  int err;
3524 
3525  if (prefix)
3526  HEADER("Prefix Supplemental Enhancement Information");
3527  else
3528  HEADER("Suffix Supplemental Enhancement Information");
3529 
3530  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header,
3531  prefix ? VVC_PREFIX_SEI_NUT
3532  : VVC_SUFFIX_SEI_NUT));
3533 
3534  CHECK(FUNC_SEI(message_list) (ctx, rw, &current->message_list, prefix));
3535 
3536  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3537 
3538  return 0;
3539 }
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H266RawSEI *current, int prefix)
Definition: cbs_h266_syntax_template.c:3520
bit_position
#define bit_position(rw)
Definition: cbs_h2645.c:443
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:1321
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:261
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
H266RawDCI
Definition: cbs_h266.h:252
ub
#define ub(width, name)
Definition: cbs_apv.c:85
ff_ctz
#define ff_ctz
Definition: intmath.h:107
lmcs_data
static int FUNC() lmcs_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current)
Definition: cbs_h266_syntax_template.c:2412
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
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3043
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
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
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
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_NUM_ALF_FILTERS
@ VVC_NUM_ALF_FILTERS
Definition: vvc.h:106
VVC_AUD_NUT
@ VVC_AUD_NUT
Definition: vvc.h:49
VVC_MAX_WIDTH
@ VVC_MAX_WIDTH
Definition: vvc.h:132
VVC_MAX_PPS_COUNT
@ VVC_MAX_PPS_COUNT
Definition: vvc.h:99
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H266RawAUD *current)
Definition: cbs_h266_syntax_template.c:2538
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:364
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
CodedBitstreamH266Context::pps
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:866
CodedBitstreamH266Context::vps
H266RawVPS * vps[VVC_MAX_VPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:864
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:3056
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:83
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:108
H266RawAPS
Definition: cbs_h266.h:600
VVC_MAX_REF_PIC_LISTS
@ VVC_MAX_REF_PIC_LISTS
Definition: vvc.h:112
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_apv.c:132
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:254
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
VVC_MAX_LAYERS
@ VVC_MAX_LAYERS
Definition: vvc.h:80
message_list
static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)
Definition: cbs_sei_syntax_template.c:315
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
VVC_MAX_VPS_COUNT
@ VVC_MAX_VPS_COUNT
Definition: vvc.h:95
H266RawSEI
Definition: cbs_h266.h:853
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
bits
uint8_t bits
Definition: vp3data.h:128
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h266_syntax_template.c:19
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
RWContext
#define RWContext
Definition: cbs_apv.c:129
VVC_MAX_VBS
@ VVC_MAX_VBS
Definition: vvc.h:156
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:235
H266RawGeneralTimingHrdParameters
Definition: cbs_h266.h:180
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:2448
VVC_MAX_DPB_SIZE
@ VVC_MAX_DPB_SIZE
Definition: vvc.h:109
H266RawPPS
Definition: cbs_h266.h:496
aps
static int FUNC() aps(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current, int prefix)
Definition: cbs_h266_syntax_template.c:2501
H266RawOPI
Definition: cbs_h266.h:241
VVC_MAX_HEIGHT
@ VVC_MAX_HEIGHT
Definition: vvc.h:133
H266RawPictureHeader
Definition: cbs_h266.h:676
bits_left
#define bits_left
Definition: bitstream.h:114
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
fixed
#define fixed(width, name, value)
Definition: cbs_apv.c:92
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
VVC_MAX_TILE_ROWS
@ VVC_MAX_TILE_ROWS
Definition: vvc.h:139
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_MAX_TILE_COLUMNS
@ VVC_MAX_TILE_COLUMNS
Definition: vvc.h:141
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_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
height
#define height
Definition: dsp.h:89
VVC_VPS_NUT
@ VVC_VPS_NUT
Definition: vvc.h:43
ubs
#define ubs(width, name, subs,...)
Definition: cbs_apv.c:89
HEADER
#define HEADER(name)
Definition: cbs_apv.c:70
infer
#define infer(name, value)
Definition: cbs_apv.c:139
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
CodedBitstreamH266Context::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:867
H266RefPicListStruct
Definition: cbs_h266.h:160
H266RawSubLayerHRDParameters
Definition: cbs_h266.h:194
CodedBitstreamH266Context
Definition: cbs_h266.h:858
vui_parameters_default
static int FUNC() vui_parameters_default(CodedBitstreamContext *ctx, RWContext *rw, H266RawVUI *current)
Definition: cbs_h266_syntax_template.c:213
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_apv.c:87
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:2301
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
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:2555
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:865
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_SUBLAYERS
@ VVC_MAX_SUBLAYERS
Definition: vvc.h:83
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:495
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:101
VVC_SUFFIX_APS_NUT
@ VVC_SUFFIX_APS_NUT
Definition: vvc.h:47
VVC_MAX_TOTAL_NUM_OLSS
@ VVC_MAX_TOTAL_NUM_OLSS
Definition: vvc.h:92
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
VVC_MAX_ENTRY_POINTS
@ VVC_MAX_ENTRY_POINTS
Definition: vvc.h:153
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
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
VVC_MAX_SLICES
@ VVC_MAX_SLICES
Definition: vvc.h:144
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:1293
cbs_h2645_read_more_rbsp_data
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:328
picture_header
static int FUNC() picture_header(CodedBitstreamContext *ctx, RWContext *rw, H266RawPictureHeader *current)
Definition: cbs_h266_syntax_template.c:2638
VVC_MAX_TILES_PER_AU
@ VVC_MAX_TILES_PER_AU
Definition: vvc.h:136
Generated on Mon May 19 2025 19:21:46 for FFmpeg by   doxygen 1.8.17