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