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;
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;
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 = ff_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  u(2, sps_log2_ctu_size_minus5, 0, 3);
1093  ctb_log2_size_y = current->sps_log2_ctu_size_minus5 + 5;
1094  ctb_size_y = 1 << ctb_log2_size_y;
1095 
1096  flag(sps_ptl_dpb_hrd_params_present_flag);
1097  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1098  CHECK(FUNC(profile_tier_level) (ctx, rw, &current->profile_tier_level,
1099  1, current->sps_max_sublayers_minus1));
1100  }
1101  flag(sps_gdr_enabled_flag);
1102  flag(sps_ref_pic_resampling_enabled_flag);
1103  if (current->sps_ref_pic_resampling_enabled_flag)
1104  flag(sps_res_change_in_clvs_allowed_flag);
1105  else
1106  infer(sps_res_change_in_clvs_allowed_flag, 0);
1107 
1108  ue(sps_pic_width_max_in_luma_samples, 1, VVC_MAX_WIDTH);
1109  ue(sps_pic_height_max_in_luma_samples, 1, VVC_MAX_HEIGHT);
1110 
1111  flag(sps_conformance_window_flag);
1112  if (current->sps_conformance_window_flag) {
1113  uint8_t sub_width_c = h266_sub_width_c[current->sps_chroma_format_idc];
1114  uint8_t sub_height_c = h266_sub_height_c[current->sps_chroma_format_idc];
1115  uint16_t width = current->sps_pic_width_max_in_luma_samples / sub_width_c;
1116  uint16_t height = current->sps_pic_height_max_in_luma_samples / sub_height_c;
1117  ue(sps_conf_win_left_offset, 0, width);
1118  ue(sps_conf_win_right_offset, 0, width - current->sps_conf_win_left_offset);
1119  ue(sps_conf_win_top_offset, 0, height);
1120  ue(sps_conf_win_bottom_offset, 0, height - current->sps_conf_win_top_offset);
1121  } else {
1122  infer(sps_conf_win_left_offset, 0);
1123  infer(sps_conf_win_right_offset, 0);
1124  infer(sps_conf_win_top_offset, 0);
1125  infer(sps_conf_win_bottom_offset, 0);
1126  }
1127 
1128  tmp_width_val = AV_CEIL_RSHIFT(current->sps_pic_width_max_in_luma_samples,
1129  ctb_log2_size_y);
1130  tmp_height_val = AV_CEIL_RSHIFT(current->sps_pic_height_max_in_luma_samples,
1131  ctb_log2_size_y);
1132 
1133  flag(sps_subpic_info_present_flag);
1134  if (current->sps_subpic_info_present_flag) {
1135  ue(sps_num_subpics_minus1, 0, VVC_MAX_SLICES - 1);
1136  if (current->sps_num_subpics_minus1 > 0) {
1137  flag(sps_independent_subpics_flag);
1138  flag(sps_subpic_same_size_flag);
1139  }
1140 
1141  if (current->sps_num_subpics_minus1 > 0) {
1142  int wlen = av_ceil_log2(tmp_width_val);
1143  int hlen = av_ceil_log2(tmp_height_val);
1144  infer(sps_subpic_ctu_top_left_x[0], 0);
1145  infer(sps_subpic_ctu_top_left_y[0], 0);
1146  if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1147  ubs(wlen, sps_subpic_width_minus1[0], 1, 0);
1148  else
1149  infer(sps_subpic_width_minus1[0], tmp_width_val - 1);
1150  if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
1151  ubs(hlen, sps_subpic_height_minus1[0], 1, 0);
1152  else
1153  infer(sps_subpic_height_minus1[0], tmp_height_val - 1);
1154  if (!current->sps_independent_subpics_flag) {
1155  flags(sps_subpic_treated_as_pic_flag[0], 1, 0);
1156  flags(sps_loop_filter_across_subpic_enabled_flag[0], 1, 0);
1157  } else {
1158  infer(sps_subpic_treated_as_pic_flag[0], 1);
1159  infer(sps_loop_filter_across_subpic_enabled_flag[0], 1);
1160  }
1161  for (i = 1; i <= current->sps_num_subpics_minus1; i++) {
1162  if (!current->sps_subpic_same_size_flag) {
1163  if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1164  ubs(wlen, sps_subpic_ctu_top_left_x[i], 1, i);
1165  else
1166  infer(sps_subpic_ctu_top_left_x[i], 0);
1167  if (current->sps_pic_height_max_in_luma_samples >
1168  ctb_size_y)
1169  ubs(hlen, sps_subpic_ctu_top_left_y[i], 1, i);
1170  else
1171  infer(sps_subpic_ctu_top_left_y[i], 0);
1172  if (i < current->sps_num_subpics_minus1 &&
1173  current->sps_pic_width_max_in_luma_samples >
1174  ctb_size_y) {
1175  ubs(wlen, sps_subpic_width_minus1[i], 1, i);
1176  } else {
1177  infer(sps_subpic_width_minus1[i],
1178  tmp_width_val -
1179  current->sps_subpic_ctu_top_left_x[i] - 1);
1180  }
1181  if (i < current->sps_num_subpics_minus1 &&
1182  current->sps_pic_height_max_in_luma_samples >
1183  ctb_size_y) {
1184  ubs(hlen, sps_subpic_height_minus1[i], 1, i);
1185  } else {
1186  infer(sps_subpic_height_minus1[i],
1187  tmp_height_val -
1188  current->sps_subpic_ctu_top_left_y[i] - 1);
1189  }
1190  } else {
1191  int num_subpic_cols = tmp_width_val /
1192  (current->sps_subpic_width_minus1[0] + 1);
1193  if (tmp_width_val % (current->sps_subpic_width_minus1[0] + 1) ||
1194  tmp_height_val % (current->sps_subpic_width_minus1[0] + 1) ||
1195  current->sps_num_subpics_minus1 !=
1196  (num_subpic_cols * tmp_height_val /
1197  (current->sps_subpic_height_minus1[0] + 1) - 1))
1198  return AVERROR_INVALIDDATA;
1199  infer(sps_subpic_ctu_top_left_x[i],
1200  (i % num_subpic_cols) *
1201  (current->sps_subpic_width_minus1[0] + 1));
1202  infer(sps_subpic_ctu_top_left_y[i],
1203  (i / num_subpic_cols) *
1204  (current->sps_subpic_height_minus1[0] + 1));
1205  infer(sps_subpic_width_minus1[i],
1206  current->sps_subpic_width_minus1[0]);
1207  infer(sps_subpic_height_minus1[i],
1208  current->sps_subpic_height_minus1[0]);
1209  }
1210  if (!current->sps_independent_subpics_flag) {
1211  flags(sps_subpic_treated_as_pic_flag[i], 1, i);
1212  flags(sps_loop_filter_across_subpic_enabled_flag[i], 1, i);
1213  } else {
1214  infer(sps_subpic_treated_as_pic_flag[i], 1);
1215  infer(sps_loop_filter_across_subpic_enabled_flag[i], 0);
1216  }
1217  }
1218  } else {
1219  infer(sps_subpic_ctu_top_left_x[0], 0);
1220  infer(sps_subpic_ctu_top_left_y[0], 0);
1221  infer(sps_subpic_width_minus1[0], tmp_width_val - 1);
1222  infer(sps_subpic_height_minus1[0], tmp_height_val - 1);
1223  }
1224  ue(sps_subpic_id_len_minus1, 0, 15);
1225  if ((1 << (current->sps_subpic_id_len_minus1 + 1)) <
1226  current->sps_num_subpics_minus1 + 1) {
1227  av_log(ctx->log_ctx, AV_LOG_ERROR,
1228  "sps_subpic_id_len_minus1(%d) is too small\n",
1229  current->sps_subpic_id_len_minus1);
1230  return AVERROR_INVALIDDATA;
1231  }
1232  flag(sps_subpic_id_mapping_explicitly_signalled_flag);
1233  if (current->sps_subpic_id_mapping_explicitly_signalled_flag) {
1234  flag(sps_subpic_id_mapping_present_flag);
1235  if (current->sps_subpic_id_mapping_present_flag) {
1236  for (i = 0; i <= current->sps_num_subpics_minus1; i++) {
1237  ubs(current->sps_subpic_id_len_minus1 + 1,
1238  sps_subpic_id[i], 1, i);
1239  }
1240  }
1241  }
1242  } else {
1243  infer(sps_num_subpics_minus1, 0);
1244  infer(sps_independent_subpics_flag, 1);
1245  infer(sps_subpic_same_size_flag, 0);
1246  infer(sps_subpic_id_mapping_explicitly_signalled_flag, 0);
1247  infer(sps_subpic_ctu_top_left_x[0], 0);
1248  infer(sps_subpic_ctu_top_left_y[0], 0);
1249  infer(sps_subpic_width_minus1[0], tmp_width_val - 1);
1250  infer(sps_subpic_height_minus1[0], tmp_height_val - 1);
1251  }
1252 
1253 
1254  ue(sps_bitdepth_minus8, 0, 8);
1255  qp_bd_offset = 6 * current->sps_bitdepth_minus8;
1256 
1257  flag(sps_entropy_coding_sync_enabled_flag);
1258  flag(sps_entry_point_offsets_present_flag);
1259 
1260  u(4, sps_log2_max_pic_order_cnt_lsb_minus4, 0, 12);
1261  flag(sps_poc_msb_cycle_flag);
1262  if (current->sps_poc_msb_cycle_flag)
1263  ue(sps_poc_msb_cycle_len_minus1,
1264  0, 32 - current->sps_log2_max_pic_order_cnt_lsb_minus4 - 5);
1265 
1266  u(2, sps_num_extra_ph_bytes, 0, 2);
1267  for (i = 0; i < (current->sps_num_extra_ph_bytes * 8); i++) {
1268  flags(sps_extra_ph_bit_present_flag[i], 1, i);
1269  }
1270 
1271  u(2, sps_num_extra_sh_bytes, 0, 2);
1272  for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
1273  flags(sps_extra_sh_bit_present_flag[i], 1, i);
1274  }
1275 
1276  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1277  if (current->sps_max_sublayers_minus1 > 0)
1278  flag(sps_sublayer_dpb_params_flag);
1279  else
1280  infer(sps_sublayer_dpb_params_flag, 0);
1281  CHECK(FUNC(dpb_parameters) (ctx, rw, &current->sps_dpb_params,
1282  current->sps_max_sublayers_minus1,
1283  current->sps_sublayer_dpb_params_flag));
1284  }
1285 
1286  ue(sps_log2_min_luma_coding_block_size_minus2,
1287  0, FFMIN(4, current->sps_log2_ctu_size_minus5 + 3));
1288  min_cb_log2_size_y =
1289  current->sps_log2_min_luma_coding_block_size_minus2 + 2;
1290 
1291  flag(sps_partition_constraints_override_enabled_flag);
1292 
1293  ue(sps_log2_diff_min_qt_min_cb_intra_slice_luma,
1294  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1295  min_qt_log2_size_intra_y =
1296  current->sps_log2_diff_min_qt_min_cb_intra_slice_luma +
1297  min_cb_log2_size_y;
1298 
1299  ue(sps_max_mtt_hierarchy_depth_intra_slice_luma,
1300  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1301 
1302  if (current->sps_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
1303  ue(sps_log2_diff_max_bt_min_qt_intra_slice_luma,
1304  0, ctb_log2_size_y - min_qt_log2_size_intra_y);
1305  ue(sps_log2_diff_max_tt_min_qt_intra_slice_luma,
1306  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
1307  } else {
1308  infer(sps_log2_diff_max_bt_min_qt_intra_slice_luma, 0);
1309  infer(sps_log2_diff_max_tt_min_qt_intra_slice_luma, 0);
1310  }
1311 
1312  if (current->sps_chroma_format_idc != 0) {
1313  flag(sps_qtbtt_dual_tree_intra_flag);
1314  } else {
1315  infer(sps_qtbtt_dual_tree_intra_flag, 0);
1316  }
1317 
1318  if (current->sps_qtbtt_dual_tree_intra_flag) {
1319  ue(sps_log2_diff_min_qt_min_cb_intra_slice_chroma,
1320  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1321  ue(sps_max_mtt_hierarchy_depth_intra_slice_chroma,
1322  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1323  if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
1324  unsigned int min_qt_log2_size_intra_c =
1325  current->sps_log2_diff_min_qt_min_cb_intra_slice_chroma +
1326  min_cb_log2_size_y;
1327  ue(sps_log2_diff_max_bt_min_qt_intra_slice_chroma,
1328  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1329  ue(sps_log2_diff_max_tt_min_qt_intra_slice_chroma,
1330  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1331  }
1332  } else {
1333  infer(sps_log2_diff_min_qt_min_cb_intra_slice_chroma, 0);
1334  infer(sps_max_mtt_hierarchy_depth_intra_slice_chroma, 0);
1335  }
1336  if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma == 0) {
1337  infer(sps_log2_diff_max_bt_min_qt_intra_slice_chroma, 0);
1338  infer(sps_log2_diff_max_tt_min_qt_intra_slice_chroma, 0);
1339  }
1340 
1341  ue(sps_log2_diff_min_qt_min_cb_inter_slice,
1342  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1343  min_qt_log2_size_inter_y =
1344  current->sps_log2_diff_min_qt_min_cb_inter_slice + min_cb_log2_size_y;
1345 
1346  ue(sps_max_mtt_hierarchy_depth_inter_slice,
1347  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1348  if (current->sps_max_mtt_hierarchy_depth_inter_slice != 0) {
1349  ue(sps_log2_diff_max_bt_min_qt_inter_slice,
1350  0, ctb_log2_size_y - min_qt_log2_size_inter_y);
1351  ue(sps_log2_diff_max_tt_min_qt_inter_slice,
1352  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
1353  } else {
1354  infer(sps_log2_diff_max_bt_min_qt_inter_slice, 0);
1355  infer(sps_log2_diff_max_tt_min_qt_inter_slice, 0);
1356  }
1357 
1358  if (ctb_size_y > 32)
1359  flag(sps_max_luma_transform_size_64_flag);
1360  else
1361  infer(sps_max_luma_transform_size_64_flag, 0);
1362 
1363  flag(sps_transform_skip_enabled_flag);
1364  if (current->sps_transform_skip_enabled_flag) {
1365  ue(sps_log2_transform_skip_max_size_minus2, 0, 3);
1366  flag(sps_bdpcm_enabled_flag);
1367  }
1368 
1369  flag(sps_mts_enabled_flag);
1370  if (current->sps_mts_enabled_flag) {
1371  flag(sps_explicit_mts_intra_enabled_flag);
1372  flag(sps_explicit_mts_inter_enabled_flag);
1373  } else {
1374  infer(sps_explicit_mts_intra_enabled_flag, 0);
1375  infer(sps_explicit_mts_inter_enabled_flag, 0);
1376  }
1377 
1378  flag(sps_lfnst_enabled_flag);
1379 
1380  if (current->sps_chroma_format_idc != 0) {
1381  uint8_t num_qp_tables;
1382  flag(sps_joint_cbcr_enabled_flag);
1383  flag(sps_same_qp_table_for_chroma_flag);
1384  num_qp_tables = current->sps_same_qp_table_for_chroma_flag ?
1385  1 : (current->sps_joint_cbcr_enabled_flag ? 3 : 2);
1386  for (i = 0; i < num_qp_tables; i++) {
1387  ses(sps_qp_table_start_minus26[i], -26 - qp_bd_offset, 36, 1, i);
1388  ues(sps_num_points_in_qp_table_minus1[i],
1389  0, 36 - current->sps_qp_table_start_minus26[i], 1, i);
1390  for (j = 0; j <= current->sps_num_points_in_qp_table_minus1[i]; j++) {
1391  uint8_t max = MAX_UINT_BITS(8);
1392  ues(sps_delta_qp_in_val_minus1[i][j], 0, max, 2, i, j);
1393  ues(sps_delta_qp_diff_val[i][j], 0, max, 2, i, j);
1394  }
1395  }
1396  } else {
1397  infer(sps_joint_cbcr_enabled_flag, 0);
1398  infer(sps_same_qp_table_for_chroma_flag, 0);
1399  }
1400 
1401  flag(sps_sao_enabled_flag);
1402  flag(sps_alf_enabled_flag);
1403  if (current->sps_alf_enabled_flag && current->sps_chroma_format_idc)
1404  flag(sps_ccalf_enabled_flag);
1405  else
1406  infer(sps_ccalf_enabled_flag, 0);
1407  flag(sps_lmcs_enabled_flag);
1408  flag(sps_weighted_pred_flag);
1409  flag(sps_weighted_bipred_flag);
1410  flag(sps_long_term_ref_pics_flag);
1411  if (current->sps_video_parameter_set_id > 0)
1412  flag(sps_inter_layer_prediction_enabled_flag);
1413  else
1414  infer(sps_inter_layer_prediction_enabled_flag, 0);
1415  flag(sps_idr_rpl_present_flag);
1416  flag(sps_rpl1_same_as_rpl0_flag);
1417 
1418  for (i = 0; i < (current->sps_rpl1_same_as_rpl0_flag ? 1 : 2); i++) {
1419  ues(sps_num_ref_pic_lists[i], 0, VVC_MAX_REF_PIC_LISTS, 1, i);
1420  for (j = 0; j < current->sps_num_ref_pic_lists[i]; j++)
1421  CHECK(FUNC(ref_pic_list_struct) (ctx, rw,
1422  &current->
1423  sps_ref_pic_list_struct[i][j], i,
1424  j, current));
1425  }
1426 
1427  if (current->sps_rpl1_same_as_rpl0_flag) {
1428  current->sps_num_ref_pic_lists[1] = current->sps_num_ref_pic_lists[0];
1429  for (j = 0; j < current->sps_num_ref_pic_lists[0]; j++)
1430  memcpy(&current->sps_ref_pic_list_struct[1][j],
1431  &current->sps_ref_pic_list_struct[0][j],
1432  sizeof(current->sps_ref_pic_list_struct[0][j]));
1433  }
1434 
1435  flag(sps_ref_wraparound_enabled_flag);
1436 
1437  flag(sps_temporal_mvp_enabled_flag);
1438  if (current->sps_temporal_mvp_enabled_flag)
1439  flag(sps_sbtmvp_enabled_flag);
1440  else
1441  infer(sps_sbtmvp_enabled_flag, 0);
1442 
1443  flag(sps_amvr_enabled_flag);
1444  flag(sps_bdof_enabled_flag);
1445  if (current->sps_bdof_enabled_flag)
1446  flag(sps_bdof_control_present_in_ph_flag);
1447  else
1448  infer(sps_bdof_control_present_in_ph_flag, 0);
1449 
1450  flag(sps_smvd_enabled_flag);
1451  flag(sps_dmvr_enabled_flag);
1452  if (current->sps_dmvr_enabled_flag)
1453  flag(sps_dmvr_control_present_in_ph_flag);
1454  else
1455  infer(sps_dmvr_control_present_in_ph_flag, 0);
1456 
1457  flag(sps_mmvd_enabled_flag);
1458  if (current->sps_mmvd_enabled_flag)
1459  flag(sps_mmvd_fullpel_only_enabled_flag);
1460  else
1461  infer(sps_mmvd_fullpel_only_enabled_flag, 0);
1462 
1463  ue(sps_six_minus_max_num_merge_cand, 0, 5);
1464  max_num_merge_cand = 6 - current->sps_six_minus_max_num_merge_cand;
1465 
1466  flag(sps_sbt_enabled_flag);
1467 
1468  flag(sps_affine_enabled_flag);
1469  if (current->sps_affine_enabled_flag) {
1470  ue(sps_five_minus_max_num_subblock_merge_cand,
1471  0, 5 - current->sps_sbtmvp_enabled_flag);
1472  flag(sps_6param_affine_enabled_flag);
1473  if (current->sps_amvr_enabled_flag)
1474  flag(sps_affine_amvr_enabled_flag);
1475  else
1476  infer(sps_affine_amvr_enabled_flag, 0);
1477  flag(sps_affine_prof_enabled_flag);
1478  if (current->sps_affine_prof_enabled_flag)
1479  flag(sps_prof_control_present_in_ph_flag);
1480  else
1481  infer(sps_prof_control_present_in_ph_flag, 0);
1482  } else {
1483  infer(sps_6param_affine_enabled_flag, 0);
1484  infer(sps_affine_amvr_enabled_flag, 0);
1485  infer(sps_affine_prof_enabled_flag, 0);
1486  infer(sps_prof_control_present_in_ph_flag, 0);
1487  }
1488 
1489  flag(sps_bcw_enabled_flag);
1490  flag(sps_ciip_enabled_flag);
1491 
1492  if (max_num_merge_cand >= 2) {
1493  flag(sps_gpm_enabled_flag);
1494  if (current->sps_gpm_enabled_flag && max_num_merge_cand >= 3)
1495  ue(sps_max_num_merge_cand_minus_max_num_gpm_cand,
1496  0, max_num_merge_cand - 2);
1497  } else {
1498  infer(sps_gpm_enabled_flag, 0);
1499  }
1500 
1501  ue(sps_log2_parallel_merge_level_minus2, 0, ctb_log2_size_y - 2);
1502 
1503  flag(sps_isp_enabled_flag);
1504  flag(sps_mrl_enabled_flag);
1505  flag(sps_mip_enabled_flag);
1506 
1507  if (current->sps_chroma_format_idc != 0)
1508  flag(sps_cclm_enabled_flag);
1509  else
1510  infer(sps_cclm_enabled_flag, 0);
1511  if (current->sps_chroma_format_idc == 1) {
1512  flag(sps_chroma_horizontal_collocated_flag);
1513  flag(sps_chroma_vertical_collocated_flag);
1514  } else {
1515  infer(sps_chroma_horizontal_collocated_flag, 1);
1516  infer(sps_chroma_vertical_collocated_flag, 1);
1517  }
1518 
1519  flag(sps_palette_enabled_flag);
1520  if (current->sps_chroma_format_idc == 3 &&
1521  !current->sps_max_luma_transform_size_64_flag)
1522  flag(sps_act_enabled_flag);
1523  else
1524  infer(sps_act_enabled_flag, 0);
1525  if (current->sps_transform_skip_enabled_flag ||
1526  current->sps_palette_enabled_flag)
1527  ue(sps_min_qp_prime_ts, 0, 8);
1528 
1529  flag(sps_ibc_enabled_flag);
1530  if (current->sps_ibc_enabled_flag)
1531  ue(sps_six_minus_max_num_ibc_merge_cand, 0, 5);
1532 
1533  flag(sps_ladf_enabled_flag);
1534  if (current->sps_ladf_enabled_flag) {
1535  ub(2, sps_num_ladf_intervals_minus2);
1536  se(sps_ladf_lowest_interval_qp_offset, -63, 63);
1537  for (i = 0; i < current->sps_num_ladf_intervals_minus2 + 1; i++) {
1538  ses(sps_ladf_qp_offset[i], -63, 63, 1, i);
1539  ues(sps_ladf_delta_threshold_minus1[i],
1540  0, (2 << (8 + current->sps_bitdepth_minus8)) - 3, 1, i);
1541  }
1542  }
1543 
1544  flag(sps_explicit_scaling_list_enabled_flag);
1545  if (current->sps_lfnst_enabled_flag &&
1546  current->sps_explicit_scaling_list_enabled_flag)
1547  flag(sps_scaling_matrix_for_lfnst_disabled_flag);
1548 
1549  if (current->sps_act_enabled_flag &&
1550  current->sps_explicit_scaling_list_enabled_flag)
1551  flag(sps_scaling_matrix_for_alternative_colour_space_disabled_flag);
1552  else
1553  infer(sps_scaling_matrix_for_alternative_colour_space_disabled_flag, 0);
1554  if (current->sps_scaling_matrix_for_alternative_colour_space_disabled_flag)
1555  flag(sps_scaling_matrix_designated_colour_space_flag);
1556 
1557  flag(sps_dep_quant_enabled_flag);
1558  flag(sps_sign_data_hiding_enabled_flag);
1559 
1560  flag(sps_virtual_boundaries_enabled_flag);
1561  if (current->sps_virtual_boundaries_enabled_flag) {
1562  flag(sps_virtual_boundaries_present_flag);
1563  if (current->sps_virtual_boundaries_present_flag) {
1564  ue(sps_num_ver_virtual_boundaries,
1565  0, current->sps_pic_width_max_in_luma_samples <= 8 ? 0 : 3);
1566  for (i = 0; i < current->sps_num_ver_virtual_boundaries; i++)
1567  ues(sps_virtual_boundary_pos_x_minus1[i],
1568  0, (current->sps_pic_width_max_in_luma_samples + 7) / 8 - 2,
1569  1, i);
1570  ue(sps_num_hor_virtual_boundaries,
1571  0, current->sps_pic_height_max_in_luma_samples <= 8 ? 0 : 3);
1572  for (i = 0; i < current->sps_num_hor_virtual_boundaries; i++)
1573  ues(sps_virtual_boundary_pos_y_minus1[i],
1574  0, (current->sps_pic_height_max_in_luma_samples + 7) /
1575  8 - 2, 1, i);
1576  }
1577  } else {
1578  infer(sps_virtual_boundaries_present_flag, 0);
1579  infer(sps_num_ver_virtual_boundaries, 0);
1580  infer(sps_num_hor_virtual_boundaries, 0);
1581  }
1582 
1583  if (current->sps_ptl_dpb_hrd_params_present_flag) {
1584  flag(sps_timing_hrd_params_present_flag);
1585  if (current->sps_timing_hrd_params_present_flag) {
1586  uint8_t first_sublayer;
1587  CHECK(FUNC(general_timing_hrd_parameters) (ctx, rw,
1588  &current->sps_general_timing_hrd_parameters));
1589  if (current->sps_max_sublayers_minus1 > 0)
1590  flag(sps_sublayer_cpb_params_present_flag);
1591  else
1592  infer(sps_sublayer_cpb_params_present_flag, 0);
1593  first_sublayer = current->sps_sublayer_cpb_params_present_flag ?
1594  0 : current->sps_max_sublayers_minus1;
1595  CHECK(FUNC(ols_timing_hrd_parameters) (ctx, rw,
1596  &current->sps_ols_timing_hrd_parameters, first_sublayer,
1597  current->sps_max_sublayers_minus1,
1598  &current->sps_general_timing_hrd_parameters));
1599  }
1600  }
1601 
1602  flag(sps_field_seq_flag);
1603  flag(sps_vui_parameters_present_flag);
1604  if (current->sps_vui_parameters_present_flag) {
1605  ue(sps_vui_payload_size_minus1, 0, 1023);
1606  while (byte_alignment(rw) != 0)
1607  fixed(1, sps_vui_alignment_zero_bit, 0);
1608  CHECK(FUNC(vui_payload) (ctx, rw, &current->vui,
1609  current->sps_vui_payload_size_minus1 + 1,
1610  current->sps_chroma_format_idc));
1611  } else {
1612  CHECK(FUNC(vui_parameters_default) (ctx, rw, &current->vui));
1613  }
1614 
1615  flag(sps_extension_flag);
1616  if (current->sps_extension_flag) {
1617  flag(sps_range_extension_flag);
1618  ub(7, sps_extension_7bits);
1619 
1620  if (current->sps_range_extension_flag) {
1621  CHECK(FUNC(sps_range_extension)(ctx, rw, current));
1622  } else {
1623  infer(sps_extended_precision_flag, 0);
1624  infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1625  infer(sps_rrc_rice_extension_flag, 0);
1626  infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1627  infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1628  }
1629  } else {
1630  infer(sps_range_extension_flag, 0);
1631  infer(sps_extension_7bits, 0);
1632  infer(sps_extended_precision_flag, 0);
1633  infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1634  infer(sps_rrc_rice_extension_flag, 0);
1635  infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1636  infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1637  }
1638 
1639  if (current->sps_extension_7bits)
1640  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
1641 
1642  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
1643 
1644  return 0;
1645 }
1646 
1647 static int FUNC(pps) (CodedBitstreamContext *ctx, RWContext *rw,
1648  H266RawPPS *current)
1649 {
1650  CodedBitstreamH266Context *h266 = ctx->priv_data;
1651  const H266RawSPS *sps;
1652  int err, i;
1653  unsigned int min_cb_size_y, divisor, ctb_size_y,
1654  pic_width_in_ctbs_y, pic_height_in_ctbs_y;
1655  uint8_t sub_width_c, sub_height_c, qp_bd_offset;
1656 
1657  static const uint8_t h266_sub_width_c[] = {
1658  1, 2, 2, 1
1659  };
1660  static const uint8_t h266_sub_height_c[] = {
1661  1, 2, 1, 1
1662  };
1663 
1664  HEADER("Picture Parameter Set");
1665 
1666  CHECK(FUNC(nal_unit_header) (ctx, rw,
1667  &current->nal_unit_header, VVC_PPS_NUT));
1668 
1669  ub(6, pps_pic_parameter_set_id);
1670  ub(4, pps_seq_parameter_set_id);
1671  sps = h266->sps[current->pps_seq_parameter_set_id];
1672  if (!sps) {
1673  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1674  current->pps_seq_parameter_set_id);
1675  return AVERROR_INVALIDDATA;
1676  }
1677 
1678  flag(pps_mixed_nalu_types_in_pic_flag);
1679  ue(pps_pic_width_in_luma_samples,
1680  1, sps->sps_pic_width_max_in_luma_samples);
1681  ue(pps_pic_height_in_luma_samples,
1682  1, sps->sps_pic_height_max_in_luma_samples);
1683 
1684  min_cb_size_y = 1 << (sps->sps_log2_min_luma_coding_block_size_minus2 + 2);
1685  divisor = FFMAX(min_cb_size_y, 8);
1686  if (current->pps_pic_width_in_luma_samples % divisor ||
1687  current->pps_pic_height_in_luma_samples % divisor) {
1688  av_log(ctx->log_ctx, AV_LOG_ERROR,
1689  "Invalid dimensions: %ux%u not divisible "
1690  "by %u, MinCbSizeY = %u.\n",
1691  current->pps_pic_width_in_luma_samples,
1692  current->pps_pic_height_in_luma_samples, divisor, min_cb_size_y);
1693  return AVERROR_INVALIDDATA;
1694  }
1695  if (!sps->sps_res_change_in_clvs_allowed_flag &&
1696  (current->pps_pic_width_in_luma_samples !=
1697  sps->sps_pic_width_max_in_luma_samples ||
1698  current->pps_pic_height_in_luma_samples !=
1699  sps->sps_pic_height_max_in_luma_samples)) {
1700  av_log(ctx->log_ctx, AV_LOG_ERROR,
1701  "Resoltuion change is not allowed, "
1702  "in max resolution (%ux%u) mismatched with pps(%ux%u).\n",
1703  sps->sps_pic_width_max_in_luma_samples,
1704  sps->sps_pic_height_max_in_luma_samples,
1705  current->pps_pic_width_in_luma_samples,
1706  current->pps_pic_height_in_luma_samples);
1707  return AVERROR_INVALIDDATA;
1708  }
1709 
1710  ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
1711  if (sps->sps_ref_wraparound_enabled_flag) {
1712  if ((ctb_size_y / min_cb_size_y + 1) >
1713  (current->pps_pic_width_in_luma_samples / min_cb_size_y - 1)) {
1714  av_log(ctx->log_ctx, AV_LOG_ERROR,
1715  "Invalid width(%u), ctb_size_y = %u, min_cb_size_y = %u.\n",
1716  current->pps_pic_width_in_luma_samples,
1717  ctb_size_y, min_cb_size_y);
1718  return AVERROR_INVALIDDATA;
1719  }
1720  }
1721 
1722  flag(pps_conformance_window_flag);
1723  if (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  current->pps_conformance_window_flag) {
1728  av_log(ctx->log_ctx, AV_LOG_ERROR,
1729  "Conformance window flag should not true.\n");
1730  return AVERROR_INVALIDDATA;
1731  }
1732 
1733  sub_width_c = h266_sub_width_c[sps->sps_chroma_format_idc];
1734  sub_height_c = h266_sub_height_c[sps->sps_chroma_format_idc];
1735  if (current->pps_conformance_window_flag) {
1736  ue(pps_conf_win_left_offset, 0, current->pps_pic_width_in_luma_samples);
1737  ue(pps_conf_win_right_offset,
1738  0, current->pps_pic_width_in_luma_samples);
1739  ue(pps_conf_win_top_offset, 0, current->pps_pic_height_in_luma_samples);
1740  ue(pps_conf_win_bottom_offset,
1741  0, current->pps_pic_height_in_luma_samples);
1742  if (sub_width_c *
1743  (current->pps_conf_win_left_offset +
1744  current->pps_conf_win_right_offset) >=
1745  current->pps_pic_width_in_luma_samples ||
1746  sub_height_c *
1747  (current->pps_conf_win_top_offset +
1748  current->pps_conf_win_bottom_offset) >=
1749  current->pps_pic_height_in_luma_samples) {
1750  av_log(ctx->log_ctx, AV_LOG_ERROR,
1751  "Invalid pps conformance window: (%u, %u, %u, %u), "
1752  "resolution is %ux%u, sub wxh is %ux%u.\n",
1753  current->pps_conf_win_left_offset,
1754  current->pps_conf_win_right_offset,
1755  current->pps_conf_win_top_offset,
1756  current->pps_conf_win_bottom_offset,
1757  current->pps_pic_width_in_luma_samples,
1758  current->pps_pic_height_in_luma_samples,
1759  sub_width_c, sub_height_c);
1760  return AVERROR_INVALIDDATA;
1761  }
1762  } else {
1763  if (current->pps_pic_width_in_luma_samples ==
1764  sps->sps_pic_width_max_in_luma_samples &&
1765  current->pps_pic_height_in_luma_samples ==
1766  sps->sps_pic_height_max_in_luma_samples) {
1767  infer(pps_conf_win_left_offset, sps->sps_conf_win_left_offset);
1768  infer(pps_conf_win_right_offset, sps->sps_conf_win_right_offset);
1769  infer(pps_conf_win_top_offset, sps->sps_conf_win_top_offset);
1770  infer(pps_conf_win_bottom_offset, sps->sps_conf_win_bottom_offset);
1771  } else {
1772  infer(pps_conf_win_left_offset, 0);
1773  infer(pps_conf_win_right_offset, 0);
1774  infer(pps_conf_win_top_offset, 0);
1775  infer(pps_conf_win_bottom_offset, 0);
1776  }
1777 
1778  }
1779 
1780  flag(pps_scaling_window_explicit_signalling_flag);
1781  if (!sps->sps_ref_pic_resampling_enabled_flag &&
1782  current->pps_scaling_window_explicit_signalling_flag) {
1783  av_log(ctx->log_ctx, AV_LOG_ERROR,
1784  "Invalid data: sps_ref_pic_resampling_enabled_flag is false, "
1785  "but pps_scaling_window_explicit_signalling_flag is true.\n");
1786  return AVERROR_INVALIDDATA;
1787  }
1788  if (current->pps_scaling_window_explicit_signalling_flag) {
1789  se(pps_scaling_win_left_offset,
1790  -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1791  current->pps_pic_width_in_luma_samples / sub_width_c);
1792  se(pps_scaling_win_right_offset,
1793  -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1794  current->pps_pic_width_in_luma_samples / sub_width_c);
1795  se(pps_scaling_win_top_offset,
1796  -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1797  current->pps_pic_height_in_luma_samples / sub_height_c);
1798  se(pps_scaling_win_bottom_offset,
1799  -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1800  current->pps_pic_height_in_luma_samples / sub_height_c);
1801  } else {
1802  infer(pps_scaling_win_left_offset, current->pps_conf_win_left_offset);
1803  infer(pps_scaling_win_right_offset, current->pps_conf_win_right_offset);
1804  infer(pps_scaling_win_top_offset, current->pps_conf_win_top_offset);
1805  infer(pps_scaling_win_bottom_offset, current->pps_conf_win_bottom_offset);
1806  }
1807 
1808  flag(pps_output_flag_present_flag);
1809  flag(pps_no_pic_partition_flag);
1810  flag(pps_subpic_id_mapping_present_flag);
1811 
1812  if (current->pps_subpic_id_mapping_present_flag) {
1813  if (!current->pps_no_pic_partition_flag) {
1814  ue(pps_num_subpics_minus1,
1815  sps->sps_num_subpics_minus1, sps->sps_num_subpics_minus1);
1816  } else {
1817  infer(pps_num_subpics_minus1, 0);
1818  }
1819  ue(pps_subpic_id_len_minus1, sps->sps_subpic_id_len_minus1,
1820  sps->sps_subpic_id_len_minus1);
1821  for (i = 0; i <= current->pps_num_subpics_minus1; i++) {
1822  ubs(sps->sps_subpic_id_len_minus1 + 1, pps_subpic_id[i], 1, i);
1823  }
1824  }
1825 
1826  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
1827  if (sps->sps_subpic_id_mapping_explicitly_signalled_flag)
1828  current->sub_pic_id_val[i] = current->pps_subpic_id_mapping_present_flag
1829  ? current->pps_subpic_id[i]
1830  : sps->sps_subpic_id[i];
1831  else
1832  current->sub_pic_id_val[i] = i;
1833  }
1834 
1835  pic_width_in_ctbs_y = AV_CEIL_RSHIFT
1836  (current->pps_pic_width_in_luma_samples, (sps->sps_log2_ctu_size_minus5 + 5));
1837  pic_height_in_ctbs_y = AV_CEIL_RSHIFT(
1838  current->pps_pic_height_in_luma_samples,(sps->sps_log2_ctu_size_minus5 + 5));
1839  if (!current->pps_no_pic_partition_flag) {
1840  unsigned int exp_tile_width = 0, exp_tile_height = 0;
1841  unsigned int unified_size, remaining_size;
1842 
1843  u(2, pps_log2_ctu_size_minus5,
1844  sps->sps_log2_ctu_size_minus5, sps->sps_log2_ctu_size_minus5);
1845  ue(pps_num_exp_tile_columns_minus1,
1846  0, FFMIN(pic_width_in_ctbs_y - 1, VVC_MAX_TILE_COLUMNS - 1));
1847  ue(pps_num_exp_tile_rows_minus1,
1848  0, FFMIN(pic_height_in_ctbs_y - 1, VVC_MAX_TILE_ROWS - 1));
1849 
1850  for (i = 0; i <= current->pps_num_exp_tile_columns_minus1; i++) {
1851  ues(pps_tile_column_width_minus1[i],
1852  0, pic_width_in_ctbs_y - exp_tile_width - 1, 1, i);
1853  exp_tile_width += current->pps_tile_column_width_minus1[i] + 1;
1854  }
1855  for (i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++) {
1856  ues(pps_tile_row_height_minus1[i],
1857  0, pic_height_in_ctbs_y - exp_tile_height - 1, 1, i);
1858  exp_tile_height += current->pps_tile_row_height_minus1[i] + 1;
1859  }
1860 
1861  remaining_size = pic_width_in_ctbs_y;
1862  for (i = 0; i <= current->pps_num_exp_tile_columns_minus1; i++) {
1863  if (current->pps_tile_column_width_minus1[i] >= remaining_size) {
1864  av_log(ctx->log_ctx, AV_LOG_ERROR,
1865  "Tile column width(%d) exceeds picture width\n",i);
1866  return AVERROR_INVALIDDATA;
1867  }
1868  current->col_width_val[i] = current->pps_tile_column_width_minus1[i] + 1;
1869  remaining_size -= (current->pps_tile_column_width_minus1[i] + 1);
1870  }
1871  unified_size = current->pps_tile_column_width_minus1[i - 1] + 1;
1872  while (remaining_size > 0) {
1873  if (current->num_tile_columns > VVC_MAX_TILE_COLUMNS) {
1874  av_log(ctx->log_ctx, AV_LOG_ERROR,
1875  "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1876  current->num_tile_columns, VVC_MAX_TILE_COLUMNS);
1877  return AVERROR_INVALIDDATA;
1878  }
1879  unified_size = FFMIN(remaining_size, unified_size);
1880  current->col_width_val[i] = unified_size;
1881  remaining_size -= unified_size;
1882  i++;
1883  }
1884  current->num_tile_columns = i;
1885  if (current->num_tile_columns > VVC_MAX_TILE_COLUMNS) {
1886  av_log(ctx->log_ctx, AV_LOG_ERROR,
1887  "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1888  current->num_tile_columns, VVC_MAX_TILE_COLUMNS);
1889  return AVERROR_INVALIDDATA;
1890  }
1891 
1892  remaining_size = pic_height_in_ctbs_y;
1893  for (i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++) {
1894  if (current->pps_tile_row_height_minus1[i] >= remaining_size) {
1895  av_log(ctx->log_ctx, AV_LOG_ERROR,
1896  "Tile row height(%d) exceeds picture height\n",i);
1897  return AVERROR_INVALIDDATA;
1898  }
1899  current->row_height_val[i] = current->pps_tile_row_height_minus1[i] + 1;
1900  remaining_size -= (current->pps_tile_row_height_minus1[i] + 1);
1901  }
1902  unified_size = current->pps_tile_row_height_minus1[i - 1] + 1;
1903 
1904  while (remaining_size > 0) {
1905  unified_size = FFMIN(remaining_size, unified_size);
1906  current->row_height_val[i] = unified_size;
1907  remaining_size -= unified_size;
1908  i++;
1909  }
1910  current->num_tile_rows=i;
1911  if (current->num_tile_rows > VVC_MAX_TILE_ROWS) {
1912  av_log(ctx->log_ctx, AV_LOG_ERROR,
1913  "NumTileRows(%d) > than VVC_MAX_TILE_ROWS(%d)\n",
1914  current->num_tile_rows, VVC_MAX_TILE_ROWS);
1915  return AVERROR_INVALIDDATA;
1916  }
1917 
1918  current->num_tiles_in_pic = current->num_tile_columns *
1919  current->num_tile_rows;
1920  if (current->num_tiles_in_pic > VVC_MAX_TILES_PER_AU) {
1921  av_log(ctx->log_ctx, AV_LOG_ERROR,
1922  "NumTilesInPic(%d) > than VVC_MAX_TILES_PER_AU(%d)\n",
1923  current->num_tiles_in_pic, VVC_MAX_TILES_PER_AU);
1924  return AVERROR_INVALIDDATA;
1925  }
1926 
1927  if (current->num_tiles_in_pic > 1) {
1928  flag(pps_loop_filter_across_tiles_enabled_flag);
1929  flag(pps_rect_slice_flag);
1930  } else {
1931  infer(pps_loop_filter_across_tiles_enabled_flag, 0);
1932  infer(pps_rect_slice_flag, 1);
1933  }
1934  if (current->pps_rect_slice_flag)
1935  flag(pps_single_slice_per_subpic_flag);
1936  else
1937  infer(pps_single_slice_per_subpic_flag, 1);
1938  if (current->pps_rect_slice_flag &&
1939  !current->pps_single_slice_per_subpic_flag) {
1940  int j;
1941  uint16_t tile_idx = 0, tile_x, tile_y, ctu_x, ctu_y;
1942  uint16_t slice_top_left_ctu_x[VVC_MAX_SLICES];
1943  uint16_t slice_top_left_ctu_y[VVC_MAX_SLICES];
1944  ue(pps_num_slices_in_pic_minus1, 0, VVC_MAX_SLICES - 1);
1945  if (current->pps_num_slices_in_pic_minus1 > 1)
1946  flag(pps_tile_idx_delta_present_flag);
1947  else
1948  infer(pps_tile_idx_delta_present_flag, 0);
1949  for (i = 0; i < current->pps_num_slices_in_pic_minus1; i++) {
1950  tile_x = tile_idx % current->num_tile_columns;
1951  tile_y = tile_idx / current->num_tile_columns;
1952  if (tile_x != current->num_tile_columns - 1) {
1953  ues(pps_slice_width_in_tiles_minus1[i],
1954  0, current->num_tile_columns - 1, 1, i);
1955  } else {
1956  infer(pps_slice_width_in_tiles_minus1[i], 0);
1957  }
1958  if (tile_y != current->num_tile_rows - 1 &&
1959  (current->pps_tile_idx_delta_present_flag || tile_x == 0)) {
1960  ues(pps_slice_height_in_tiles_minus1[i],
1961  0, current->num_tile_rows - 1, 1, i);
1962  } else {
1963  if (tile_y == current->num_tile_rows - 1)
1964  infer(pps_slice_height_in_tiles_minus1[i], 0);
1965  else
1966  infer(pps_slice_height_in_tiles_minus1[i],
1967  current->pps_slice_height_in_tiles_minus1[i - 1]);
1968  }
1969 
1970  ctu_x = ctu_y = 0;
1971  for (j = 0; j < tile_x; j++) {
1972  ctu_x += current->col_width_val[j];
1973  }
1974  for (j = 0; j < tile_y; j++) {
1975  ctu_y += current->row_height_val[j];
1976  }
1977  if (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
1978  current->pps_slice_height_in_tiles_minus1[i] == 0 &&
1979  current->row_height_val[tile_y] > 1) {
1980  int num_slices_in_tile,
1981  uniform_slice_height, remaining_height_in_ctbs_y;
1982  remaining_height_in_ctbs_y =
1983  current->row_height_val[tile_y];
1984  ues(pps_num_exp_slices_in_tile[i],
1985  0, current->row_height_val[tile_y] - 1, 1, i);
1986  if (current->pps_num_exp_slices_in_tile[i] == 0) {
1987  num_slices_in_tile = 1;
1988  current->slice_height_in_ctus[i] = current->row_height_val[tile_y];
1989  slice_top_left_ctu_x[i] = ctu_x;
1990  slice_top_left_ctu_y[i] = ctu_y;
1991  } else {
1992  uint16_t slice_height_in_ctus;
1993  for (j = 0; j < current->pps_num_exp_slices_in_tile[i];
1994  j++) {
1995  ues(pps_exp_slice_height_in_ctus_minus1[i][j], 0,
1996  current->row_height_val[tile_y] - 1, 2,
1997  i, j);
1998  slice_height_in_ctus =
1999  current->
2000  pps_exp_slice_height_in_ctus_minus1[i][j] + 1;
2001 
2002  current->slice_height_in_ctus[i + j] =
2003  slice_height_in_ctus;
2004  slice_top_left_ctu_x[i + j] = ctu_x;
2005  slice_top_left_ctu_y[i + j] = ctu_y;
2006  ctu_y += slice_height_in_ctus;
2007 
2008  remaining_height_in_ctbs_y -= slice_height_in_ctus;
2009  }
2010  uniform_slice_height = 1 +
2011  (j == 0 ? current->row_height_val[tile_y] - 1:
2012  current->pps_exp_slice_height_in_ctus_minus1[i][j-1]);
2013  while (remaining_height_in_ctbs_y > uniform_slice_height) {
2014  current->slice_height_in_ctus[i + j] =
2015  uniform_slice_height;
2016  slice_top_left_ctu_x[i + j] = ctu_x;
2017  slice_top_left_ctu_y[i + j] = ctu_y;
2018  ctu_y += uniform_slice_height;
2019 
2020  remaining_height_in_ctbs_y -= uniform_slice_height;
2021  j++;
2022  }
2023  if (remaining_height_in_ctbs_y > 0) {
2024  current->slice_height_in_ctus[i + j] =
2025  remaining_height_in_ctbs_y;
2026  slice_top_left_ctu_x[i + j] = ctu_x;
2027  slice_top_left_ctu_y[i + j] = ctu_y;
2028  j++;
2029  }
2030  num_slices_in_tile = j;
2031  }
2032  i += num_slices_in_tile - 1;
2033  } else {
2034  uint16_t height = 0;
2035  infer(pps_num_exp_slices_in_tile[i], 0);
2036  for (j = 0;
2037  j <= current->pps_slice_height_in_tiles_minus1[i];
2038  j++) {
2039  height +=
2040  current->row_height_val[tile_y + j];
2041  }
2042  current->slice_height_in_ctus[i] = height;
2043 
2044  slice_top_left_ctu_x[i] = ctu_x;
2045  slice_top_left_ctu_y[i] = ctu_y;
2046  }
2047  if (i < current->pps_num_slices_in_pic_minus1) {
2048  if (current->pps_tile_idx_delta_present_flag) {
2049  // Two conditions must be met:
2050  // 1. −NumTilesInPic + 1 <= pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2051  // 2. 0 <= tile_idx + pps_tile_idx_delta_val[i] <= NumTilesInPic − 1
2052  // Combining these conditions yields: -tile_idx <= pps_tile_idx_delta_val[i] <= NumTilesInPic - 1 - tile_idx
2053  ses(pps_tile_idx_delta_val[i],
2054  -tile_idx, current->num_tiles_in_pic - 1 - tile_idx, 1, i);
2055  if (current->pps_tile_idx_delta_val[i] == 0) {
2056  av_log(ctx->log_ctx, AV_LOG_ERROR,
2057  "pps_tile_idx_delta_val[i] shall not be equal to 0.\n");
2058  }
2059  tile_idx += current->pps_tile_idx_delta_val[i];
2060  } else {
2061  infer(pps_tile_idx_delta_val[i], 0);
2062  tile_idx +=
2063  current->pps_slice_width_in_tiles_minus1[i] + 1;
2064  if (tile_idx % current->num_tile_columns == 0) {
2065  tile_idx +=
2066  current->pps_slice_height_in_tiles_minus1[i] *
2067  current->num_tile_columns;
2068  }
2069  }
2070  }
2071  }
2072  if (i == current->pps_num_slices_in_pic_minus1) {
2073  uint16_t height = 0;
2074 
2075  tile_x = tile_idx % current->num_tile_columns;
2076  tile_y = tile_idx / current->num_tile_columns;
2077  if (tile_y >= current->num_tile_rows)
2078  return AVERROR_INVALIDDATA;
2079 
2080  ctu_x = 0, ctu_y = 0;
2081  for (j = 0; j < tile_x; j++) {
2082  ctu_x += current->col_width_val[j];
2083  }
2084  for (j = 0; j < tile_y; j++) {
2085  ctu_y += current->row_height_val[j];
2086  }
2087  slice_top_left_ctu_x[i] = ctu_x;
2088  slice_top_left_ctu_y[i] = ctu_y;
2089 
2090  current->pps_slice_width_in_tiles_minus1[i] =
2091  current->num_tile_columns - tile_x - 1;
2092  current->pps_slice_height_in_tiles_minus1[i] =
2093  current->num_tile_rows - tile_y - 1;
2094 
2095  for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[i];
2096  j++) {
2097  height +=
2098  current->row_height_val[tile_y + j];
2099  }
2100  current->slice_height_in_ctus[i] = height;
2101 
2102  infer(pps_num_exp_slices_in_tile[i], 0);
2103  }
2104  //now, we got all slice information, let's resolve NumSlicesInSubpic
2105  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
2106  current->num_slices_in_subpic[i] = 0;
2107  for (j = 0; j <= current->pps_num_slices_in_pic_minus1; j++) {
2108  uint16_t pos_x = 0, pos_y = 0;
2109  pos_x = slice_top_left_ctu_x[j];
2110  pos_y = slice_top_left_ctu_y[j];
2111  if ((pos_x >= sps->sps_subpic_ctu_top_left_x[i]) &&
2112  (pos_x <
2113  sps->sps_subpic_ctu_top_left_x[i] +
2114  sps->sps_subpic_width_minus1[i] + 1) &&
2115  (pos_y >= sps->sps_subpic_ctu_top_left_y[i]) &&
2116  (pos_y < sps->sps_subpic_ctu_top_left_y[i] +
2117  sps->sps_subpic_height_minus1[i] + 1)) {
2118  current->num_slices_in_subpic[i]++;
2119  }
2120  }
2121  }
2122  } else {
2123  if (current->pps_no_pic_partition_flag)
2124  infer(pps_num_slices_in_pic_minus1, 0);
2125  else if (current->pps_single_slice_per_subpic_flag) {
2126  for (i = 0; i <= sps->sps_num_subpics_minus1; i++)
2127  current->num_slices_in_subpic[i] = 1;
2128  infer(pps_num_slices_in_pic_minus1,
2129  sps->sps_num_subpics_minus1);
2130  }
2131  // else?
2132  }
2133  if (!current->pps_rect_slice_flag ||
2134  current->pps_single_slice_per_subpic_flag ||
2135  current->pps_num_slices_in_pic_minus1 > 0)
2136  flag(pps_loop_filter_across_slices_enabled_flag);
2137  else
2138  infer(pps_loop_filter_across_slices_enabled_flag, 0);
2139  } else {
2140  infer(pps_num_exp_tile_columns_minus1, 0);
2141  infer(pps_tile_column_width_minus1[0], pic_width_in_ctbs_y - 1);
2142  infer(pps_num_exp_tile_rows_minus1, 0);
2143  infer(pps_tile_row_height_minus1[0], pic_height_in_ctbs_y - 1);
2144  current->col_width_val[0] = pic_width_in_ctbs_y;
2145  current->row_height_val[0] = pic_height_in_ctbs_y;
2146  current->num_tile_columns = 1;
2147  current->num_tile_rows = 1;
2148  current->num_tiles_in_pic = 1;
2149  }
2150 
2151  flag(pps_cabac_init_present_flag);
2152  for (i = 0; i < 2; i++)
2153  ues(pps_num_ref_idx_default_active_minus1[i], 0, 14, 1, i);
2154  flag(pps_rpl1_idx_present_flag);
2155  flag(pps_weighted_pred_flag);
2156  flag(pps_weighted_bipred_flag);
2157  flag(pps_ref_wraparound_enabled_flag);
2158  if (current->pps_ref_wraparound_enabled_flag) {
2159  ue(pps_pic_width_minus_wraparound_offset,
2160  0, (current->pps_pic_width_in_luma_samples / min_cb_size_y)
2161  - (ctb_size_y / min_cb_size_y) - 2);
2162  }
2163 
2164  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2165  se(pps_init_qp_minus26, -(26 + qp_bd_offset), 37);
2166  flag(pps_cu_qp_delta_enabled_flag);
2167  flag(pps_chroma_tool_offsets_present_flag);
2168  if (current->pps_chroma_tool_offsets_present_flag) {
2169  se(pps_cb_qp_offset, -12, 12);
2170  se(pps_cr_qp_offset, -12, 12);
2171  flag(pps_joint_cbcr_qp_offset_present_flag);
2172  if (current->pps_joint_cbcr_qp_offset_present_flag)
2173  se(pps_joint_cbcr_qp_offset_value, -12, 12);
2174  else
2175  infer(pps_joint_cbcr_qp_offset_value, 0);
2176  flag(pps_slice_chroma_qp_offsets_present_flag);
2177  flag(pps_cu_chroma_qp_offset_list_enabled_flag);
2178  if (current->pps_cu_chroma_qp_offset_list_enabled_flag) {
2179  ue(pps_chroma_qp_offset_list_len_minus1, 0, 5);
2180  for (i = 0; i <= current->pps_chroma_qp_offset_list_len_minus1; i++) {
2181  ses(pps_cb_qp_offset_list[i], -12, 12, 1, i);
2182  ses(pps_cr_qp_offset_list[i], -12, 12, 1, i);
2183  if (current->pps_joint_cbcr_qp_offset_present_flag)
2184  ses(pps_joint_cbcr_qp_offset_list[i], -12, 12, 1, i);
2185  else
2186  infer(pps_joint_cbcr_qp_offset_list[i], 0);
2187  }
2188  }
2189  } else {
2190  infer(pps_cb_qp_offset, 0);
2191  infer(pps_cr_qp_offset, 0);
2192  infer(pps_joint_cbcr_qp_offset_present_flag, 0);
2193  infer(pps_joint_cbcr_qp_offset_value, 0);
2194  infer(pps_slice_chroma_qp_offsets_present_flag, 0);
2195  infer(pps_cu_chroma_qp_offset_list_enabled_flag, 0);
2196  }
2197  flag(pps_deblocking_filter_control_present_flag);
2198  if (current->pps_deblocking_filter_control_present_flag) {
2199  flag(pps_deblocking_filter_override_enabled_flag);
2200  flag(pps_deblocking_filter_disabled_flag);
2201  if (!current->pps_no_pic_partition_flag &&
2202  current->pps_deblocking_filter_override_enabled_flag)
2203  flag(pps_dbf_info_in_ph_flag);
2204  else
2205  infer(pps_dbf_info_in_ph_flag, 0);
2206  if (!current->pps_deblocking_filter_disabled_flag) {
2207  se(pps_luma_beta_offset_div2, -12, 12);
2208  se(pps_luma_tc_offset_div2, -12, 12);
2209  if (current->pps_chroma_tool_offsets_present_flag) {
2210  se(pps_cb_beta_offset_div2, -12, 12);
2211  se(pps_cb_tc_offset_div2, -12, 12);
2212  se(pps_cr_beta_offset_div2, -12, 12);
2213  se(pps_cr_tc_offset_div2, -12, 12);
2214  } else {
2215  infer(pps_cb_beta_offset_div2,
2216  current->pps_luma_beta_offset_div2);
2217  infer(pps_cb_tc_offset_div2, current->pps_luma_tc_offset_div2);
2218  infer(pps_cr_beta_offset_div2,
2219  current->pps_luma_beta_offset_div2);
2220  infer(pps_cr_tc_offset_div2, current->pps_luma_tc_offset_div2);
2221  }
2222  } else {
2223  infer(pps_luma_beta_offset_div2, 0);
2224  infer(pps_luma_tc_offset_div2, 0);
2225  infer(pps_cb_beta_offset_div2, 0);
2226  infer(pps_cb_tc_offset_div2, 0);
2227  infer(pps_cr_beta_offset_div2, 0);
2228  infer(pps_cr_tc_offset_div2, 0);
2229  }
2230  } else {
2231  infer(pps_deblocking_filter_override_enabled_flag, 0);
2232  infer(pps_deblocking_filter_disabled_flag, 0);
2233  infer(pps_dbf_info_in_ph_flag, 0);
2234  infer(pps_luma_beta_offset_div2, 0);
2235  infer(pps_luma_tc_offset_div2, 0);
2236  infer(pps_cb_beta_offset_div2, 0);
2237  infer(pps_cb_tc_offset_div2, 0);
2238  infer(pps_cr_beta_offset_div2, 0);
2239  infer(pps_cr_tc_offset_div2, 0);
2240  }
2241 
2242  if (!current->pps_no_pic_partition_flag) {
2243  flag(pps_rpl_info_in_ph_flag);
2244  flag(pps_sao_info_in_ph_flag);
2245  flag(pps_alf_info_in_ph_flag);
2246  if ((current->pps_weighted_pred_flag ||
2247  current->pps_weighted_bipred_flag) &&
2248  current->pps_rpl_info_in_ph_flag)
2249  flag(pps_wp_info_in_ph_flag);
2250  flag(pps_qp_delta_info_in_ph_flag);
2251  }
2252  flag(pps_picture_header_extension_present_flag);
2253  flag(pps_slice_header_extension_present_flag);
2254 
2255  flag(pps_extension_flag);
2256  if (current->pps_extension_flag)
2257  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2258 
2259  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2260  return 0;
2261 }
2262 
2263 static int FUNC(alf_data)(CodedBitstreamContext *ctx, RWContext *rw,
2264  H266RawAPS *current)
2265 {
2266  int err, j, k;
2267 
2268  flag(alf_luma_filter_signal_flag);
2269 
2270  if (current->aps_chroma_present_flag) {
2271  flag(alf_chroma_filter_signal_flag);
2272  flag(alf_cc_cb_filter_signal_flag);
2273  flag(alf_cc_cr_filter_signal_flag);
2274  } else {
2275  infer(alf_chroma_filter_signal_flag, 0);
2276  infer(alf_cc_cb_filter_signal_flag, 0);
2277  infer(alf_cc_cr_filter_signal_flag, 0);
2278  }
2279 
2280  if (current->alf_luma_filter_signal_flag) {
2281  flag(alf_luma_clip_flag);
2282  ue(alf_luma_num_filters_signalled_minus1, 0, VVC_NUM_ALF_FILTERS - 1);
2283  if (current->alf_luma_num_filters_signalled_minus1 > 0) {
2284  unsigned int bits = av_ceil_log2(current->alf_luma_num_filters_signalled_minus1 + 1);
2285  for (int filt_idx = 0; filt_idx < VVC_NUM_ALF_FILTERS; filt_idx++)
2286  us(bits, alf_luma_coeff_delta_idx[filt_idx],
2287  0, current->alf_luma_num_filters_signalled_minus1,
2288  1, filt_idx);
2289  }
2290  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++)
2291  for (j = 0; j < 12; j++) {
2292  ues(alf_luma_coeff_abs[sf_idx][j], 0, 128, 2, sf_idx, j);
2293  if (current->alf_luma_coeff_abs[sf_idx][j])
2294  ubs(1, alf_luma_coeff_sign[sf_idx][j], 2, sf_idx, j);
2295  else
2296  infer(alf_luma_coeff_sign[sf_idx][j], 0);
2297  }
2298  } else {
2299  infer(alf_luma_clip_flag, 0);
2300  infer(alf_luma_num_filters_signalled_minus1, 0);
2301  }
2302  for (int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++) {
2303  for (j = 0; j < 12; j++) {
2304  if (current->alf_luma_clip_flag)
2305  ubs(2, alf_luma_clip_idx[sf_idx][j], 2, sf_idx, j);
2306  else
2307  infer(alf_luma_clip_idx[sf_idx][j], 0);
2308  }
2309  }
2310 
2311  if (current->alf_chroma_filter_signal_flag) {
2312  flag(alf_chroma_clip_flag);
2313  ue(alf_chroma_num_alt_filters_minus1, 0, 7);
2314  } else {
2315  infer(alf_chroma_clip_flag, 0);
2316  infer(alf_chroma_num_alt_filters_minus1, 0);
2317  }
2318  for (int alt_idx = 0; alt_idx <= current->alf_chroma_num_alt_filters_minus1; alt_idx++) {
2319  for (j = 0; j < 6; j++) {
2320  if (current->alf_chroma_filter_signal_flag)
2321  ues(alf_chroma_coeff_abs[alt_idx][j], 0, 128, 2, alt_idx, j);
2322  else
2323  infer(alf_chroma_coeff_abs[alt_idx][j], 0);
2324  if (current->alf_chroma_coeff_abs[alt_idx][j] > 0)
2325  ubs(1, alf_chroma_coeff_sign[alt_idx][j], 2, alt_idx, j);
2326  else
2327  infer(alf_chroma_coeff_sign[alt_idx][j], 0);
2328  }
2329  for (j = 0; j < 6; j++) {
2330  if (current->alf_chroma_clip_flag)
2331  ubs(2, alf_chroma_clip_idx[alt_idx][j], 2, alt_idx, j);
2332  else
2333  infer(alf_chroma_clip_idx[alt_idx][j], 0);
2334  }
2335  }
2336 
2337  if (current->alf_cc_cb_filter_signal_flag)
2338  ue(alf_cc_cb_filters_signalled_minus1, 0, 3);
2339  else
2340  infer(alf_cc_cb_filters_signalled_minus1, 0);
2341  for (k = 0; k <= current->alf_cc_cb_filters_signalled_minus1; k++) {
2342  for (j = 0; j < 7; j++) {
2343  if (current->alf_cc_cb_filter_signal_flag)
2344  ubs(3, alf_cc_cb_mapped_coeff_abs[k][j], 2, k, j);
2345  else
2346  infer(alf_cc_cb_mapped_coeff_abs[k][j], 0);
2347  if (current->alf_cc_cb_mapped_coeff_abs[k][j])
2348  ubs(1, alf_cc_cb_coeff_sign[k][j], 2, k, j);
2349  else
2350  infer(alf_cc_cb_coeff_sign[k][j], 0);
2351  }
2352  }
2353 
2354  if (current->alf_cc_cr_filter_signal_flag)
2355  ue(alf_cc_cr_filters_signalled_minus1, 0, 3);
2356  else
2357  infer(alf_cc_cr_filters_signalled_minus1, 0);
2358  for (k = 0; k < current->alf_cc_cr_filters_signalled_minus1 + 1; k++) {
2359  for (j = 0; j < 7; j++) {
2360  if (current->alf_cc_cr_filter_signal_flag)
2361  ubs(3, alf_cc_cr_mapped_coeff_abs[k][j], 2, k, j);
2362  else
2363  infer(alf_cc_cr_mapped_coeff_abs[k][j], 0);
2364  if (current->alf_cc_cr_mapped_coeff_abs[k][j])
2365  ubs(1, alf_cc_cr_coeff_sign[k][j], 2, k, j);
2366  else
2367  infer(alf_cc_cr_coeff_sign[k][j], 0);
2368  }
2369  }
2370 
2371  return 0;
2372 }
2373 
2374 static int FUNC(lmcs_data)(CodedBitstreamContext *ctx, RWContext *rw,
2375  H266RawAPS *current)
2376 {
2377  int err, i, lmcs_max_bin_idx;
2378 
2379  ue(lmcs_min_bin_idx, 0, 15);
2380  ue(lmcs_delta_max_bin_idx, 0, 15);
2381  ue(lmcs_delta_cw_prec_minus1, 0, 14);
2382 
2383  lmcs_max_bin_idx = 15 - current->lmcs_delta_max_bin_idx;
2384 
2385  if (lmcs_max_bin_idx < current->lmcs_min_bin_idx)
2386  return AVERROR_INVALIDDATA;
2387 
2388  for (i = current->lmcs_min_bin_idx; i <= lmcs_max_bin_idx; i++) {
2389  ubs(current->lmcs_delta_cw_prec_minus1 + 1, lmcs_delta_abs_cw[i], 1, i);
2390  if (current->lmcs_delta_abs_cw[i] > 0)
2391  flags(lmcs_delta_sign_cw_flag[i], 1, i);
2392  else
2393  infer(lmcs_delta_sign_cw_flag[i], 0);
2394  }
2395 
2396  if (current->aps_chroma_present_flag) {
2397  ub(3, lmcs_delta_abs_crs);
2398  if (current->lmcs_delta_abs_crs > 0)
2399  flag(lmcs_delta_sign_crs_flag);
2400  else
2401  infer(lmcs_delta_sign_crs_flag, 0);
2402  } else {
2403  infer(lmcs_delta_abs_crs, 0);
2404  infer(lmcs_delta_sign_crs_flag, 0);
2405  }
2406 
2407  return 0;
2408 }
2409 
2410 static int FUNC(scaling_list_data)(CodedBitstreamContext *ctx, RWContext *rw,
2411  H266RawAPS *current)
2412 {
2413  // 7.4.3.4, deriving DiagScanOrder
2414  static const uint8_t diag_scan_order[64][2] = {
2415  { 0, 0, }, { 0, 1, }, { 1, 0, }, { 0, 2, }, { 1, 1, }, { 2, 0, }, { 0, 3, }, { 1, 2, },
2416  { 2, 1, }, { 3, 0, }, { 0, 4, }, { 1, 3, }, { 2, 2, }, { 3, 1, }, { 4, 0, }, { 0, 5, },
2417  { 1, 4, }, { 2, 3, }, { 3, 2, }, { 4, 1, }, { 5, 0, }, { 0, 6, }, { 1, 5, }, { 2, 4, },
2418  { 3, 3, }, { 4, 2, }, { 5, 1, }, { 6, 0, }, { 0, 7, }, { 1, 6, }, { 2, 5, }, { 3, 4, },
2419  { 4, 3, }, { 5, 2, }, { 6, 1, }, { 7, 0, }, { 1, 7, }, { 2, 6, }, { 3, 5, }, { 4, 4, },
2420  { 5, 3, }, { 6, 2, }, { 7, 1, }, { 2, 7, }, { 3, 6, }, { 4, 5, }, { 5, 4, }, { 6, 3, },
2421  { 7, 2, }, { 3, 7, }, { 4, 6, }, { 5, 5, }, { 6, 4, }, { 7, 3, }, { 4, 7, }, { 5, 6, },
2422  { 6, 5, }, { 7, 4, }, { 5, 7, }, { 6, 6, }, { 7, 5, }, { 6, 7, }, { 7, 6, }, { 7, 7, }, };
2423  int err;
2424 
2425  for (int id = 0; id < 28; id ++) {
2426  if (current->aps_chroma_present_flag || id % 3 == 2 || id == 27) {
2427  flags(scaling_list_copy_mode_flag[id], 1, id);
2428  if (!current->scaling_list_copy_mode_flag[id])
2429  flags(scaling_list_pred_mode_flag[id], 1, id);
2430  else
2431  infer(scaling_list_pred_mode_flag[id], 0);
2432  if ((current->scaling_list_copy_mode_flag[id] ||
2433  current->scaling_list_pred_mode_flag[id]) &&
2434  id != 0 && id != 2 && id != 8) {
2435  int max_id_delta = (id < 2) ? id : ((id < 8) ? (id - 2) : (id - 8));
2436  ues(scaling_list_pred_id_delta[id], 0, max_id_delta, 1, id);
2437  }
2438  if (!current->scaling_list_copy_mode_flag[id]) {
2439  int matrix_size = id < 2 ? 2 : (id < 8 ? 4 : 8);
2440  if (id > 13) {
2441  int idx = id - 14;
2442  ses(scaling_list_dc_coef[idx], -128, 127, 1, idx);
2443  }
2444  for (int i = 0; i < matrix_size * matrix_size; i++) {
2445  int x = diag_scan_order[i][0];
2446  int y = diag_scan_order[i][1];
2447  if (!(id > 25 && x >= 4 && y >= 4))
2448  ses(scaling_list_delta_coef[id][i], -128, 127, 2, id, i);
2449  }
2450  } else if (id > 13) {
2451  int idx = id - 14;
2452  infer(scaling_list_dc_coef[idx], 0);
2453  }
2454  } else {
2455  infer(scaling_list_copy_mode_flag[id], 1);
2456  infer(scaling_list_pred_mode_flag[id], 0);
2457  }
2458  }
2459 
2460  return 0;
2461 }
2462 
2463 static int FUNC(aps)(CodedBitstreamContext *ctx, RWContext *rw,
2464  H266RawAPS *current, int prefix)
2465 {
2466  int aps_id_max = MAX_UINT_BITS(5);
2467  int err;
2468 
2469  if (prefix)
2470  HEADER("Prefix Adaptation parameter set");
2471  else
2472  HEADER("Suffix Adaptation parameter set");
2473 
2474  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
2475  prefix ? VVC_PREFIX_APS_NUT
2476  : VVC_SUFFIX_APS_NUT));
2477 
2478  ub(3, aps_params_type);
2479  if (current->aps_params_type == VVC_ASP_TYPE_ALF ||
2480  current->aps_params_type == VVC_ASP_TYPE_SCALING)
2481  aps_id_max = 7;
2482  else if (current->aps_params_type == VVC_ASP_TYPE_LMCS)
2483  aps_id_max = 3;
2484  u(5, aps_adaptation_parameter_set_id, 0, aps_id_max);
2485  flag(aps_chroma_present_flag);
2486  if (current->aps_params_type == VVC_ASP_TYPE_ALF)
2487  CHECK(FUNC(alf_data)(ctx, rw, current));
2488  else if(current->aps_params_type == VVC_ASP_TYPE_LMCS)
2489  CHECK(FUNC(lmcs_data)(ctx, rw, current));
2490  else if (current->aps_params_type == VVC_ASP_TYPE_SCALING)
2491  CHECK(FUNC(scaling_list_data)(ctx, rw, current));
2492  flag(aps_extension_flag);
2493  if (current->aps_extension_flag)
2494  CHECK(FUNC(extension_data) (ctx, rw, &current->extension_data));
2495  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2496 
2497  return 0;
2498 }
2499 
2500 static int FUNC(aud) (CodedBitstreamContext *ctx, RWContext *rw,
2501  H266RawAUD *current)
2502 {
2503  int err;
2504 
2505  HEADER("Access Unit Delimiter");
2506 
2507  CHECK(FUNC(nal_unit_header) (ctx, rw,
2508  &current->nal_unit_header, VVC_AUD_NUT));
2509 
2510  flag(aud_irap_or_gdr_flag);
2511  u(3, aud_pic_type, 0, 2);
2512 
2513  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
2514  return 0;
2515 }
2516 
2517 static int FUNC(pred_weight_table) (CodedBitstreamContext *ctx, RWContext *rw,
2518  const H266RawSPS *sps,
2519  const H266RawPPS *pps,
2520  const H266RefPicLists *ref_lists,
2521  uint8_t num_ref_idx_active[2],
2522  H266RawPredWeightTable *current)
2523 {
2524  int err, i, j;
2525  ue(luma_log2_weight_denom, 0, 7);
2526  if (sps->sps_chroma_format_idc != 0) {
2527  se(delta_chroma_log2_weight_denom,
2528  -current->luma_log2_weight_denom,
2529  7 - current->luma_log2_weight_denom);
2530  } else {
2531  infer(delta_chroma_log2_weight_denom, 0);
2532  }
2533  if (pps->pps_wp_info_in_ph_flag) {
2534  ue(num_l0_weights, 0,
2535  FFMIN(15, ref_lists->rpl_ref_list[0].num_ref_entries));
2536  infer(num_weights_l0, current->num_l0_weights);
2537  } else {
2538  infer(num_weights_l0, num_ref_idx_active[0]);
2539  }
2540  for (i = 0; i < current->num_weights_l0; i++) {
2541  flags(luma_weight_l0_flag[i], 1, i);
2542  }
2543  if (sps->sps_chroma_format_idc != 0) {
2544  for (i = 0; i < current->num_weights_l0; i++)
2545  flags(chroma_weight_l0_flag[i], 1, i);
2546  }
2547  for (i = 0; i < current->num_weights_l0; i++) {
2548  if (current->luma_weight_l0_flag[i]) {
2549  ses(delta_luma_weight_l0[i], -128, 127, 1, i);
2550  ses(luma_offset_l0[i], -128, 127, 1, i);
2551  } else {
2552  infer(delta_luma_weight_l0[i], 0);
2553  infer(luma_offset_l0[i], 0);
2554  }
2555  if (current->chroma_weight_l0_flag[i]) {
2556  for (j = 0; j < 2; j++) {
2557  ses(delta_chroma_weight_l0[i][j], -128, 127, 2, i, j);
2558  ses(delta_chroma_offset_l0[i][j], -4 * 128, 4 * 127, 2, i, j);
2559  }
2560  }
2561  }
2562 
2563  if (pps->pps_weighted_bipred_flag &&
2564  ref_lists->rpl_ref_list[1].num_ref_entries > 0) {
2565  if (pps->pps_wp_info_in_ph_flag) {
2566  ue(num_l1_weights, 0,
2567  FFMIN(15, ref_lists->rpl_ref_list[1].num_ref_entries));
2568  infer(num_weights_l1, current->num_l1_weights);
2569  } else {
2570  infer(num_weights_l1, num_ref_idx_active[1]);
2571  }
2572  } else {
2573  infer(num_weights_l1, 0);
2574  }
2575 
2576  for (i = 0; i < current->num_weights_l1; i++)
2577  flags(luma_weight_l1_flag[i], 1, i);
2578  if (sps->sps_chroma_format_idc != 0) {
2579  for (i = 0; i < current->num_weights_l1; i++)
2580  flags(chroma_weight_l1_flag[i], 1, i);
2581  }
2582  for (i = 0; i < current->num_weights_l1; i++) {
2583  if (current->luma_weight_l1_flag[i]) {
2584  ses(delta_luma_weight_l1[i], -128, 127, 1, i);
2585  ses(luma_offset_l1[i], -128, 127, 1, i);
2586  } else {
2587  infer(delta_luma_weight_l1[i], 0);
2588  infer(luma_offset_l1[i], 0);
2589  }
2590  if (current->chroma_weight_l1_flag[i]) {
2591  for (j = 0; j < 2; j++) {
2592  ses(delta_chroma_weight_l1[i][j], -128, 127, 2, i, j);
2593  ses(delta_chroma_offset_l1[i][j], -4 * 128, 4 * 127, 2, i, j);
2594  }
2595  }
2596  }
2597  return 0;
2598 }
2599 
2600 static int FUNC(picture_header) (CodedBitstreamContext *ctx, RWContext *rw,
2601  H266RawPictureHeader *current) {
2602  CodedBitstreamH266Context *h266 = ctx->priv_data;
2603  const H266RawVPS *vps;
2604  const H266RawSPS *sps;
2605  const H266RawPPS *pps;
2606  int err, i;
2607  unsigned int ctb_log2_size_y, min_cb_log2_size_y,
2608  min_qt_log2_size_intra_y, min_qt_log2_size_inter_y;
2609  uint8_t qp_bd_offset;
2610 
2611  flag(ph_gdr_or_irap_pic_flag);
2612  flag(ph_non_ref_pic_flag);
2613  if (current->ph_gdr_or_irap_pic_flag)
2614  flag(ph_gdr_pic_flag);
2615  else
2616  infer(ph_gdr_pic_flag, 0);
2617  flag(ph_inter_slice_allowed_flag);
2618  if (current->ph_inter_slice_allowed_flag)
2619  flag(ph_intra_slice_allowed_flag);
2620  else
2621  infer(ph_intra_slice_allowed_flag, 1);
2622  ue(ph_pic_parameter_set_id, 0, VVC_MAX_PPS_COUNT - 1);
2623  pps = h266->pps[current->ph_pic_parameter_set_id];
2624  if (!pps) {
2625  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
2626  current->ph_pic_parameter_set_id);
2627  return AVERROR_INVALIDDATA;
2628  }
2629  sps = h266->sps[pps->pps_seq_parameter_set_id];
2630  if (!sps) {
2631  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
2632  pps->pps_seq_parameter_set_id);
2633  return AVERROR_INVALIDDATA;
2634  }
2635  vps = h266->vps[sps->sps_video_parameter_set_id];
2636  if (!vps) {
2637  av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
2638  sps->sps_video_parameter_set_id);
2639  return AVERROR_INVALIDDATA;
2640  }
2641 
2642  ub(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_pic_order_cnt_lsb);
2643  if (current->ph_gdr_pic_flag)
2644  ue(ph_recovery_poc_cnt, 0,
2645  1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4));
2646 
2647  for (i = 0; i < sps->sps_num_extra_ph_bytes * 8; i++) {
2648  if (sps->sps_extra_ph_bit_present_flag[i])
2649  flags(ph_extra_bit[i], 1, i);
2650  }
2651  if (sps->sps_poc_msb_cycle_flag) {
2652  flag(ph_poc_msb_cycle_present_flag);
2653  if (current->ph_poc_msb_cycle_present_flag)
2654  ub(sps->sps_poc_msb_cycle_len_minus1 + 1, ph_poc_msb_cycle_val);
2655  }
2656  if (sps->sps_alf_enabled_flag && pps->pps_alf_info_in_ph_flag) {
2657  flag(ph_alf_enabled_flag);
2658  if (current->ph_alf_enabled_flag) {
2659 
2660  ub(3, ph_num_alf_aps_ids_luma);
2661  for (i = 0; i < current->ph_num_alf_aps_ids_luma; i++)
2662  ubs(3, ph_alf_aps_id_luma[i], 1, i);
2663 
2664  if (sps->sps_chroma_format_idc != 0) {
2665  flag(ph_alf_cb_enabled_flag);
2666  flag(ph_alf_cr_enabled_flag);
2667  } else {
2668  infer(ph_alf_cb_enabled_flag, 0);
2669  infer(ph_alf_cr_enabled_flag, 0);
2670  }
2671 
2672  if (current->ph_alf_cb_enabled_flag
2673  || current->ph_alf_cr_enabled_flag) {
2674  ub(3, ph_alf_aps_id_chroma);
2675  }
2676 
2677  if (sps->sps_ccalf_enabled_flag) {
2678  flag(ph_alf_cc_cb_enabled_flag);
2679  if (current->ph_alf_cc_cb_enabled_flag)
2680  ub(3, ph_alf_cc_cb_aps_id);
2681  flag(ph_alf_cc_cr_enabled_flag);
2682  if (current->ph_alf_cc_cr_enabled_flag)
2683  ub(3, ph_alf_cc_cr_aps_id);
2684  }
2685  }
2686  } else {
2687  infer(ph_alf_enabled_flag, 0);
2688  }
2689  if (sps->sps_lmcs_enabled_flag) {
2690  flag(ph_lmcs_enabled_flag);
2691  if (current->ph_lmcs_enabled_flag) {
2692  ub(2, ph_lmcs_aps_id);
2693  if (sps->sps_chroma_format_idc != 0)
2694  flag(ph_chroma_residual_scale_flag);
2695  else
2696  infer(ph_chroma_residual_scale_flag, 0);
2697  }
2698  } else {
2699  infer(ph_lmcs_enabled_flag, 0);
2700  infer(ph_chroma_residual_scale_flag, 0);
2701  }
2702 
2703  if (sps->sps_explicit_scaling_list_enabled_flag) {
2704  flag(ph_explicit_scaling_list_enabled_flag);
2705  if (current->ph_explicit_scaling_list_enabled_flag) {
2706  //todo: check the ph_scaling_list_aps_id range, when aps ready
2707  ub(3, ph_scaling_list_aps_id);
2708  }
2709  } else {
2710  infer(ph_explicit_scaling_list_enabled_flag, 0);
2711  }
2712  if (sps->sps_virtual_boundaries_enabled_flag &&
2713  !sps->sps_virtual_boundaries_present_flag) {
2714  flag(ph_virtual_boundaries_present_flag);
2715  if (current->ph_virtual_boundaries_present_flag) {
2716  ue(ph_num_ver_virtual_boundaries,
2717  0, pps->pps_pic_width_in_luma_samples <= 8 ? 0 : 3);
2718  for (i = 0; i < current->ph_num_ver_virtual_boundaries; i++) {
2719  ues(ph_virtual_boundary_pos_x_minus1[i],
2720  0, (pps->pps_pic_width_in_luma_samples + 7) / 8 - 2, 1, i);
2721  }
2722  ue(ph_num_hor_virtual_boundaries,
2723  0, pps->pps_pic_height_in_luma_samples <= 8 ? 0 : 3);
2724  for (i = 0; i < current->ph_num_hor_virtual_boundaries; i++) {
2725  ues(ph_virtual_boundary_pos_y_minus1[i],
2726  0, (pps->pps_pic_height_in_luma_samples + 7) / 8 - 2, 1, i);
2727  }
2728  } else {
2729  infer(ph_num_ver_virtual_boundaries, 0);
2730  infer(ph_num_hor_virtual_boundaries, 0);
2731  }
2732  }
2733  if (pps->pps_output_flag_present_flag && !current->ph_non_ref_pic_flag)
2734  flag(ph_pic_output_flag);
2735  else
2736  infer(ph_pic_output_flag, 1);
2737  if (pps->pps_rpl_info_in_ph_flag) {
2738  CHECK(FUNC(ref_pic_lists)
2739  (ctx, rw, sps, pps, &current->ph_ref_pic_lists));
2740  }
2741  if (sps->sps_partition_constraints_override_enabled_flag)
2742  flag(ph_partition_constraints_override_flag);
2743  else
2744  infer(ph_partition_constraints_override_flag, 0);
2745 
2746  ctb_log2_size_y = sps->sps_log2_ctu_size_minus5 + 5;
2747  min_cb_log2_size_y = sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
2748  if (current->ph_intra_slice_allowed_flag) {
2749  if (current->ph_partition_constraints_override_flag) {
2750  ue(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2751  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2752  ue(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2753  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2754  if (current->ph_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
2755  min_qt_log2_size_intra_y =
2756  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2757  min_cb_log2_size_y;
2758  ue(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2759  0, (sps->sps_qtbtt_dual_tree_intra_flag ?
2760  FFMIN(6, ctb_log2_size_y) :
2761  ctb_log2_size_y) - min_qt_log2_size_intra_y);
2762  ue(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2763  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
2764  } else {
2765  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2766  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2767  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2768  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2769  }
2770  if (sps->sps_qtbtt_dual_tree_intra_flag) {
2771  ue(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2772  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2773  ue(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2774  0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2775  if (sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
2776  unsigned int min_qt_log2_size_intra_c =
2777  sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma +
2778  min_cb_log2_size_y;
2779  ue(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2780  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2781  ue(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2782  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2783  } else {
2784  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2785  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2786  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2787  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2788  }
2789  }
2790  } else {
2791  infer(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2792  sps->sps_log2_diff_min_qt_min_cb_intra_slice_luma);
2793  infer(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2794  sps->sps_max_mtt_hierarchy_depth_intra_slice_luma);
2795  infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2796  sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2797  infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2798  sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2799  infer(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2800  sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma);
2801  infer(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2802  sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma);
2803  infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2804  sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2805  infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2806  sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2807  }
2808 
2809  min_qt_log2_size_intra_y =
2810  current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2811  min_cb_log2_size_y;
2812  if (pps->pps_cu_qp_delta_enabled_flag)
2813  ue(ph_cu_qp_delta_subdiv_intra_slice, 0,
2814  2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2815  current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2816  else
2817  infer(ph_cu_qp_delta_subdiv_intra_slice, 0);
2818 
2819  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2820  ue(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0,
2821  2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2822  current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2823  else
2824  infer(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0);
2825  }
2826  if (current->ph_inter_slice_allowed_flag) {
2827  if (current->ph_partition_constraints_override_flag) {
2828  ue(ph_log2_diff_min_qt_min_cb_inter_slice,
2829  0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2830  min_qt_log2_size_inter_y =
2831  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2832  min_cb_log2_size_y;
2833  ue(ph_max_mtt_hierarchy_depth_inter_slice, 0,
2834  2 * (ctb_log2_size_y - min_cb_log2_size_y));
2835  if (current->ph_max_mtt_hierarchy_depth_inter_slice != 0) {
2836  ue(ph_log2_diff_max_bt_min_qt_inter_slice,
2837  0, ctb_log2_size_y - min_qt_log2_size_inter_y);
2838  ue(ph_log2_diff_max_tt_min_qt_inter_slice,
2839  0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
2840  }
2841  } else {
2842  infer(ph_log2_diff_min_qt_min_cb_inter_slice,
2843  sps->sps_log2_diff_min_qt_min_cb_inter_slice);
2844  min_qt_log2_size_inter_y =
2845  current->ph_log2_diff_min_qt_min_cb_inter_slice +
2846  min_cb_log2_size_y;
2847  infer(ph_max_mtt_hierarchy_depth_inter_slice,
2848  sps->sps_max_mtt_hierarchy_depth_inter_slice);
2849  infer(ph_log2_diff_max_bt_min_qt_inter_slice,
2850  sps->sps_log2_diff_max_bt_min_qt_inter_slice);
2851  infer(ph_log2_diff_max_tt_min_qt_inter_slice,
2852  sps->sps_log2_diff_max_tt_min_qt_inter_slice);
2853  }
2854 
2855  if (pps->pps_cu_qp_delta_enabled_flag)
2856  ue(ph_cu_qp_delta_subdiv_inter_slice, 0,
2857  2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2858  current->ph_max_mtt_hierarchy_depth_inter_slice));
2859  else
2860  infer(ph_cu_qp_delta_subdiv_inter_slice, 0);
2861 
2862  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2863  ue(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0,
2864  2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2865  current->ph_max_mtt_hierarchy_depth_inter_slice));
2866  else
2867  infer(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0);
2868  if (sps->sps_temporal_mvp_enabled_flag) {
2869  flag(ph_temporal_mvp_enabled_flag);
2870  if (current->ph_temporal_mvp_enabled_flag &&
2871  pps->pps_rpl_info_in_ph_flag) {
2872  if (current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0)
2873  flag(ph_collocated_from_l0_flag);
2874  else
2875  infer(ph_collocated_from_l0_flag, 1);
2876  if ((current->ph_collocated_from_l0_flag &&
2877  current->ph_ref_pic_lists.rpl_ref_list[0].num_ref_entries > 1)
2878  || (!current->ph_collocated_from_l0_flag &&
2879  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 1)) {
2880  unsigned int idx =
2881  current->ph_collocated_from_l0_flag ? 0 : 1;
2882  ue(ph_collocated_ref_idx, 0,
2883  current->ph_ref_pic_lists.rpl_ref_list[idx].
2884  num_ref_entries - 1);
2885  } else {
2886  infer(ph_collocated_ref_idx, 0);
2887  }
2888  }
2889  }
2890  if (sps->sps_mmvd_fullpel_only_enabled_flag)
2891  flag(ph_mmvd_fullpel_only_flag);
2892  else
2893  infer(ph_mmvd_fullpel_only_flag, 0);
2894  if (!pps->pps_rpl_info_in_ph_flag ||
2895  current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) {
2896  flag(ph_mvd_l1_zero_flag);
2897  if (sps->sps_bdof_control_present_in_ph_flag) {
2898  flag(ph_bdof_disabled_flag);
2899  } else {
2900  if (!sps->sps_bdof_control_present_in_ph_flag)
2901  infer(ph_bdof_disabled_flag,
2902  1 - sps->sps_bdof_enabled_flag);
2903  else
2904  infer(ph_bdof_disabled_flag, 1);
2905  }
2906  if (sps->sps_dmvr_control_present_in_ph_flag) {
2907  flag(ph_dmvr_disabled_flag);
2908  } else {
2909  if (!sps->sps_dmvr_control_present_in_ph_flag)
2910  infer(ph_dmvr_disabled_flag,
2911  1 - sps->sps_dmvr_enabled_flag);
2912  else
2913  infer(ph_dmvr_disabled_flag, 1);
2914  }
2915  } else {
2916  infer(ph_mvd_l1_zero_flag, 1);
2917  }
2918  if (sps->sps_prof_control_present_in_ph_flag)
2919  flag(ph_prof_disabled_flag);
2920  else
2921  infer(ph_prof_disabled_flag, !sps->sps_affine_prof_enabled_flag);
2922  if ((pps->pps_weighted_pred_flag ||
2923  pps->pps_weighted_bipred_flag) && pps->pps_wp_info_in_ph_flag) {
2924 
2925  // if pps->pps_wp_info_in_ph_fla == 1
2926  // pred_weight_table will not use num_ref_idx_active
2927  uint8_t num_ref_idx_active[2] = { 0, 0 };
2928  CHECK(FUNC(pred_weight_table)
2929  (ctx, rw, sps, pps, &current->ph_ref_pic_lists,
2930  num_ref_idx_active, &current->ph_pred_weight_table));
2931  }
2932  }
2933 
2934  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
2935  if (pps->pps_qp_delta_info_in_ph_flag)
2936  se(ph_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
2937  63 - (26 + pps->pps_init_qp_minus26));
2938 
2939  if (sps->sps_joint_cbcr_enabled_flag)
2940  flag(ph_joint_cbcr_sign_flag);
2941  else
2942  infer(ph_joint_cbcr_sign_flag, 0);
2943  if (sps->sps_sao_enabled_flag && pps->pps_sao_info_in_ph_flag) {
2944  flag(ph_sao_luma_enabled_flag);
2945  if (sps->sps_chroma_format_idc != 0)
2946  flag(ph_sao_chroma_enabled_flag);
2947  else
2948  infer(ph_sao_chroma_enabled_flag, 0);
2949  } else {
2950  infer(ph_sao_luma_enabled_flag, 0);
2951  infer(ph_sao_chroma_enabled_flag, 0);
2952  }
2953 
2954  if (pps->pps_dbf_info_in_ph_flag)
2955  flag(ph_deblocking_params_present_flag);
2956  else
2957  infer(ph_deblocking_params_present_flag, 0);
2958 
2959  if (current->ph_deblocking_params_present_flag) {
2960  if (!pps->pps_deblocking_filter_disabled_flag) {
2961  flag(ph_deblocking_filter_disabled_flag);
2962  if (!current->ph_deblocking_filter_disabled_flag) {
2963  se(ph_luma_beta_offset_div2, -12, 12);
2964  se(ph_luma_tc_offset_div2, -12, 12);
2965  if (pps->pps_chroma_tool_offsets_present_flag) {
2966  se(ph_cb_beta_offset_div2, -12, 12);
2967  se(ph_cb_tc_offset_div2, -12, 12);
2968  se(ph_cr_beta_offset_div2, -12, 12);
2969  se(ph_cr_tc_offset_div2, -12, 12);
2970  } else {
2971  infer(ph_cb_beta_offset_div2,
2972  current->ph_luma_beta_offset_div2);
2973  infer(ph_cb_tc_offset_div2,
2974  current->ph_luma_tc_offset_div2);
2975  infer(ph_cr_beta_offset_div2,
2976  current->ph_luma_beta_offset_div2);
2977  infer(ph_cr_tc_offset_div2,
2978  current->ph_luma_tc_offset_div2);
2979  }
2980  }
2981  } else {
2982  infer(ph_deblocking_filter_disabled_flag, 0);
2983  }
2984  } else {
2985  infer(ph_deblocking_filter_disabled_flag, pps->pps_deblocking_filter_disabled_flag);
2986  if (!current->ph_deblocking_filter_disabled_flag) {
2987  infer(ph_luma_beta_offset_div2, pps->pps_luma_beta_offset_div2);
2988  infer(ph_luma_tc_offset_div2, pps->pps_luma_tc_offset_div2);
2989  infer(ph_cb_beta_offset_div2, pps->pps_cb_beta_offset_div2);
2990  infer(ph_cb_tc_offset_div2, pps->pps_cb_tc_offset_div2);
2991  infer(ph_cr_beta_offset_div2, pps->pps_cr_beta_offset_div2);
2992  infer(ph_cr_tc_offset_div2, pps->pps_cr_tc_offset_div2);
2993  }
2994  }
2995 
2996  if (pps->pps_picture_header_extension_present_flag) {
2997  ue(ph_extension_length, 0, 256);
2998  for (i = 0; i < current->ph_extension_length; i++)
2999  us(8, ph_extension_data_byte[i], 0x00, 0xff, 1, i);
3000  }
3001 
3002  return 0;
3003 }
3004 
3005 static int FUNC(ph) (CodedBitstreamContext *ctx, RWContext *rw,
3006  H266RawPH *current)
3007 {
3008  int err;
3009 
3010  HEADER("Picture Header");
3011 
3012  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, VVC_PH_NUT));
3013  CHECK(FUNC(picture_header) (ctx, rw, &current->ph_picture_header));
3014  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3015  return 0;
3016 }
3017 
3018 static int FUNC(slice_header) (CodedBitstreamContext *ctx, RWContext *rw,
3019  H266RawSliceHeader *current)
3020 {
3021  CodedBitstreamH266Context *h266 = ctx->priv_data;
3022  const H266RawSPS *sps;
3023  const H266RawPPS *pps;
3024  const H266RawPictureHeader *ph;
3025  const H266RefPicLists *ref_pic_lists;
3026  int err, i;
3027  uint8_t nal_unit_type, qp_bd_offset;
3028  uint16_t num_slices_in_subpic;
3029 
3030  HEADER("Slice Header");
3031 
3032  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header, -1));
3033 
3034  flag(sh_picture_header_in_slice_header_flag);
3035  if (current->sh_picture_header_in_slice_header_flag) {
3036  // 7.4.8 if sh_picture_header_in_slice_header_flag is true, we do not have a PH NAL unit
3037  CHECK(FUNC(picture_header) (ctx, rw, &current->sh_picture_header));
3038  ph = &current->sh_picture_header;
3039  } else {
3040  ph = h266->ph;
3041  if (!ph) {
3042  av_log(ctx->log_ctx, AV_LOG_ERROR,
3043  "Picture header not available.\n");
3044  return AVERROR_INVALIDDATA;
3045  }
3046  }
3047 
3048  pps = h266->pps[ph->ph_pic_parameter_set_id];
3049  if (!pps) {
3050  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
3051  ph->ph_pic_parameter_set_id);
3052  return AVERROR_INVALIDDATA;
3053  }
3054  sps = h266->sps[pps->pps_seq_parameter_set_id];
3055  if (!sps) {
3056  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
3057  pps->pps_seq_parameter_set_id);
3058  return AVERROR_INVALIDDATA;
3059  }
3060 
3061  if (sps->sps_subpic_info_present_flag) {
3062  ub(sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id);
3063  for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
3064  if (pps->sub_pic_id_val[i] == current->sh_subpic_id) {
3065  current->curr_subpic_idx = i;
3066  break;
3067  }
3068  }
3069  if (i > sps->sps_num_subpics_minus1) {
3070  av_log(ctx->log_ctx, AV_LOG_ERROR, "invalid CurrSubpicIdx %d\n", i);
3071  return AVERROR_INVALIDDATA;
3072  }
3073  } else {
3074  current->curr_subpic_idx = 0;
3075  }
3076 
3077  num_slices_in_subpic = pps->num_slices_in_subpic[current->curr_subpic_idx];
3078 
3079  if ((pps->pps_rect_slice_flag && num_slices_in_subpic > 1) ||
3080  (!pps->pps_rect_slice_flag && pps->num_tiles_in_pic > 1)) {
3081  unsigned int bits, max;
3082  if (!pps->pps_rect_slice_flag) {
3083  bits = av_ceil_log2(pps->num_tiles_in_pic);
3084  max = pps->num_tiles_in_pic - 1;
3085  } else {
3086  bits = av_ceil_log2(num_slices_in_subpic);
3087  max = num_slices_in_subpic - 1;
3088  }
3089  u(bits, sh_slice_address, 0, max);
3090  } else {
3091  infer(sh_slice_address, 0);
3092  }
3093 
3094  for (i = 0; i < sps->sps_num_extra_sh_bytes * 8; i++) {
3095  if (sps->sps_extra_sh_bit_present_flag[i])
3096  flags(sh_extra_bit[i], 1, i);
3097  }
3098 
3099  if (!pps->pps_rect_slice_flag &&
3100  pps->num_tiles_in_pic - current->sh_slice_address > 1)
3101  ue(sh_num_tiles_in_slice_minus1, 0, pps->num_tiles_in_pic - 1);
3102  else
3103  infer(sh_num_tiles_in_slice_minus1, 0);
3104 
3105  if (ph->ph_inter_slice_allowed_flag)
3106  ue(sh_slice_type, 0, 2);
3107  else
3108  infer(sh_slice_type, 2);
3109 
3110  nal_unit_type = current->nal_unit_header.nal_unit_type;
3111  if (nal_unit_type == VVC_IDR_W_RADL || nal_unit_type == VVC_IDR_N_LP ||
3112  nal_unit_type == VVC_CRA_NUT || nal_unit_type == VVC_GDR_NUT)
3113  flag(sh_no_output_of_prior_pics_flag);
3114 
3115  if (sps->sps_alf_enabled_flag) {
3116  if (!pps->pps_alf_info_in_ph_flag) {
3117  flag(sh_alf_enabled_flag);
3118  if (current->sh_alf_enabled_flag) {
3119  ub(3, sh_num_alf_aps_ids_luma);
3120  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3121  ubs(3, sh_alf_aps_id_luma[i], 1, i);
3122 
3123  if (sps->sps_chroma_format_idc != 0) {
3124  flag(sh_alf_cb_enabled_flag);
3125  flag(sh_alf_cr_enabled_flag);
3126  }
3127  if (current->sh_alf_cb_enabled_flag ||
3128  current->sh_alf_cr_enabled_flag) {
3129  ub(3, sh_alf_aps_id_chroma);
3130  }
3131 
3132  if (sps->sps_ccalf_enabled_flag) {
3133  flag(sh_alf_cc_cb_enabled_flag);
3134  if (current->sh_alf_cc_cb_enabled_flag)
3135  ub(3, sh_alf_cc_cb_aps_id);
3136 
3137  flag(sh_alf_cc_cr_enabled_flag);
3138  if (current->sh_alf_cc_cr_enabled_flag)
3139  ub(3, sh_alf_cc_cr_aps_id);
3140  }
3141  }
3142  } else {
3143  infer(sh_alf_enabled_flag, ph->ph_alf_enabled_flag);
3144  if (current->sh_alf_enabled_flag) {
3145  infer(sh_num_alf_aps_ids_luma, ph->ph_num_alf_aps_ids_luma);
3146  for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++)
3147  infer(sh_alf_aps_id_luma[i], ph->ph_alf_aps_id_luma[i]);
3148 
3149  infer(sh_alf_cb_enabled_flag, ph->ph_alf_cb_enabled_flag);
3150  infer(sh_alf_cr_enabled_flag, ph->ph_alf_cr_enabled_flag);
3151  if (current->sh_alf_cb_enabled_flag ||current->sh_alf_cr_enabled_flag)
3152  infer(sh_alf_aps_id_chroma, ph->ph_alf_aps_id_chroma);
3153 
3154  if (sps->sps_ccalf_enabled_flag) {
3155  infer(sh_alf_cc_cb_enabled_flag, ph->ph_alf_cc_cb_enabled_flag);
3156  if (current->sh_alf_cc_cb_enabled_flag)
3157  infer(sh_alf_cc_cb_aps_id, ph->ph_alf_cc_cb_aps_id);
3158 
3159  infer(sh_alf_cc_cr_enabled_flag, ph->ph_alf_cc_cr_enabled_flag);
3160  if (current->sh_alf_cc_cr_enabled_flag)
3161  infer(sh_alf_cc_cr_aps_id, ph->ph_alf_cc_cr_aps_id);
3162  }
3163  }
3164  }
3165  }
3166 
3167  if (current->sh_picture_header_in_slice_header_flag) {
3168  infer(sh_lmcs_used_flag, ph->ph_lmcs_enabled_flag);
3169  infer(sh_explicit_scaling_list_used_flag,
3170  ph->ph_explicit_scaling_list_enabled_flag);
3171  } else {
3172  if (ph->ph_lmcs_enabled_flag)
3173  flag(sh_lmcs_used_flag);
3174  else
3175  infer(sh_lmcs_used_flag, 0);
3176 
3177  if (ph->ph_explicit_scaling_list_enabled_flag)
3178  flag(sh_explicit_scaling_list_used_flag);
3179  else
3180  infer(sh_explicit_scaling_list_used_flag, 0);
3181  }
3182 
3183  if (!pps->pps_rpl_info_in_ph_flag &&
3184  ((nal_unit_type != VVC_IDR_W_RADL &&
3185  nal_unit_type != VVC_IDR_N_LP) || sps->sps_idr_rpl_present_flag)) {
3186  CHECK(FUNC(ref_pic_lists)
3187  (ctx, rw, sps, pps, &current->sh_ref_pic_lists));
3188  ref_pic_lists = &current->sh_ref_pic_lists;
3189  } else {
3190  ref_pic_lists = &ph->ph_ref_pic_lists;
3191  }
3192  if ((current->sh_slice_type != VVC_SLICE_TYPE_I &&
3193  ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) ||
3194  (current->sh_slice_type == VVC_SLICE_TYPE_B &&
3195  ref_pic_lists->rpl_ref_list[1].num_ref_entries > 1)) {
3196  flag(sh_num_ref_idx_active_override_flag);
3197  if (current->sh_num_ref_idx_active_override_flag) {
3198  for (i = 0;
3199  i < (current->sh_slice_type == VVC_SLICE_TYPE_B ? 2 : 1); i++)
3200  if (ref_pic_lists->rpl_ref_list[i].num_ref_entries > 1)
3201  ues(sh_num_ref_idx_active_minus1[i], 0, 14, 1, i);
3202  else
3203  infer(sh_num_ref_idx_active_minus1[i], 0);
3204  }
3205  } else {
3206  infer(sh_num_ref_idx_active_override_flag, 1);
3207  }
3208 
3209  for (i = 0; i < 2; i++) {
3210  if (current->sh_slice_type == VVC_SLICE_TYPE_B ||
3211  (current->sh_slice_type == VVC_SLICE_TYPE_P && i == 0)) {
3212  if (current->sh_num_ref_idx_active_override_flag) {
3213  current->num_ref_idx_active[i] = current->sh_num_ref_idx_active_minus1[i] + 1;
3214  } else {
3215  current->num_ref_idx_active[i] =
3216  FFMIN(ref_pic_lists->rpl_ref_list[i].num_ref_entries,
3217  pps->pps_num_ref_idx_default_active_minus1[i] + 1);
3218  }
3219  } else {
3220  current->num_ref_idx_active[i] = 0;
3221  }
3222  }
3223 
3224  if (current->sh_slice_type != VVC_SLICE_TYPE_I) {
3225  if (pps->pps_cabac_init_present_flag)
3226  flag(sh_cabac_init_flag);
3227  else
3228  infer(sh_cabac_init_flag, 0);
3229  if (ph->ph_temporal_mvp_enabled_flag) {
3230  if (!pps->pps_rpl_info_in_ph_flag) {
3231  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3232  flag(sh_collocated_from_l0_flag);
3233  else
3234  infer(sh_collocated_from_l0_flag, 1);
3235  if ((current->sh_collocated_from_l0_flag &&
3236  current->num_ref_idx_active[0] > 1) ||
3237  (!current->sh_collocated_from_l0_flag &&
3238  current->num_ref_idx_active[1] > 1)) {
3239  unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1;
3240  ue(sh_collocated_ref_idx, 0, current->num_ref_idx_active[idx] - 1);
3241  } else {
3242  infer(sh_collocated_ref_idx, 0);
3243  }
3244  } else {
3245  if (current->sh_slice_type == VVC_SLICE_TYPE_B)
3246  infer(sh_collocated_from_l0_flag, ph->ph_collocated_from_l0_flag);
3247  else
3248  infer(sh_collocated_from_l0_flag, 1);
3249  infer(sh_collocated_ref_idx, ph->ph_collocated_ref_idx);
3250  }
3251  }
3252  if (!pps->pps_wp_info_in_ph_flag &&
3253  ((pps->pps_weighted_pred_flag &&
3254  current->sh_slice_type == VVC_SLICE_TYPE_P) ||
3255  (pps->pps_weighted_bipred_flag &&
3256  current->sh_slice_type == VVC_SLICE_TYPE_B))) {
3257  CHECK(FUNC(pred_weight_table) (ctx, rw, sps, pps, ref_pic_lists,
3258  current->num_ref_idx_active,
3259  &current->sh_pred_weight_table));
3260  }
3261  }
3262  qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
3263  if (!pps->pps_qp_delta_info_in_ph_flag)
3264  se(sh_qp_delta, -qp_bd_offset - (26 + pps->pps_init_qp_minus26),
3265  63 - (26 + pps->pps_init_qp_minus26));
3266  if (pps->pps_slice_chroma_qp_offsets_present_flag) {
3267  int8_t off;
3268 
3269  se(sh_cb_qp_offset, -12, 12);
3270  off = pps->pps_cb_qp_offset + current->sh_cb_qp_offset;
3271  if (off < -12 || off > 12) {
3272  av_log(ctx->log_ctx, AV_LOG_ERROR,
3273  "pps_cb_qp_offset + sh_cb_qp_offset (%d) not in range [-12, 12].\n",
3274  off);
3275  return AVERROR_INVALIDDATA;
3276  }
3277 
3278  se(sh_cr_qp_offset, -12, 12);
3279  off = pps->pps_cr_qp_offset + current->sh_cr_qp_offset;
3280  if (off < -12 || off > 12) {
3281  av_log(ctx->log_ctx, AV_LOG_ERROR,
3282  "pps_cr_qp_offset + sh_cr_qp_offset (%d) not in range [-12, 12].\n",
3283  off);
3284  return AVERROR_INVALIDDATA;
3285  }
3286 
3287  if (sps->sps_joint_cbcr_enabled_flag) {
3288  se(sh_joint_cbcr_qp_offset, -12, 12);
3289  off =
3290  pps->pps_joint_cbcr_qp_offset_value +
3291  current->sh_joint_cbcr_qp_offset;
3292  if (off < -12 || off > 12) {
3293  av_log(ctx->log_ctx, AV_LOG_ERROR,
3294  "pps_joint_cbcr_qp_offset_value + sh_joint_cbcr_qp_offset (%d)"
3295  "not in range [-12, 12]. \n", off);
3296  return AVERROR_INVALIDDATA;
3297  }
3298  } else {
3299  infer(sh_joint_cbcr_qp_offset, 0);
3300  }
3301  } else {
3302  infer(sh_cb_qp_offset, 0);
3303  infer(sh_cr_qp_offset, 0);
3304  infer(sh_joint_cbcr_qp_offset, 0);
3305  }
3306  if (pps->pps_cu_chroma_qp_offset_list_enabled_flag)
3307  flag(sh_cu_chroma_qp_offset_enabled_flag);
3308  else
3309  infer(sh_cu_chroma_qp_offset_enabled_flag, 0);
3310  if (sps->sps_sao_enabled_flag && !pps->pps_sao_info_in_ph_flag) {
3311  flag(sh_sao_luma_used_flag);
3312  if (sps->sps_chroma_format_idc != 0)
3313  flag(sh_sao_chroma_used_flag);
3314  else
3315  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3316  } else {
3317  infer(sh_sao_luma_used_flag, ph->ph_sao_luma_enabled_flag);
3318  infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag);
3319  }
3320 
3321  if (pps->pps_deblocking_filter_override_enabled_flag &&
3322  !pps->pps_dbf_info_in_ph_flag)
3323  flag(sh_deblocking_params_present_flag);
3324  else
3325  infer(sh_deblocking_params_present_flag, 0);
3326  if (current->sh_deblocking_params_present_flag) {
3327  if (!pps->pps_deblocking_filter_disabled_flag)
3328  flag(sh_deblocking_filter_disabled_flag);
3329  else
3330  infer(sh_deblocking_filter_disabled_flag, 0);
3331  if (!current->sh_deblocking_filter_disabled_flag) {
3332  se(sh_luma_beta_offset_div2, -12, 12);
3333  se(sh_luma_tc_offset_div2, -12, 12);
3334  if (pps->pps_chroma_tool_offsets_present_flag) {
3335  se(sh_cb_beta_offset_div2, -12, 12);
3336  se(sh_cb_tc_offset_div2, -12, 12);
3337  se(sh_cr_beta_offset_div2, -12, 12);
3338  se(sh_cr_tc_offset_div2, -12, 12);
3339  } else {
3340  infer(sh_cb_beta_offset_div2,
3341  current->sh_luma_beta_offset_div2);
3342  infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
3343  infer(sh_cr_beta_offset_div2,
3344  current->sh_luma_beta_offset_div2);
3345  infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
3346  }
3347  }
3348  } else {
3349  infer(sh_deblocking_filter_disabled_flag, ph->ph_deblocking_filter_disabled_flag);
3350  if (!current->sh_deblocking_filter_disabled_flag) {
3351  infer(sh_luma_beta_offset_div2, ph->ph_luma_beta_offset_div2);
3352  infer(sh_luma_tc_offset_div2, ph->ph_luma_tc_offset_div2);
3353  infer(sh_cb_beta_offset_div2, ph->ph_cb_beta_offset_div2);
3354  infer(sh_cb_tc_offset_div2, ph->ph_cb_tc_offset_div2);
3355  infer(sh_cr_beta_offset_div2, ph->ph_cr_beta_offset_div2);
3356  infer(sh_cr_tc_offset_div2, ph->ph_cr_tc_offset_div2);
3357  }
3358  }
3359 
3360  if (sps->sps_dep_quant_enabled_flag)
3361  flag(sh_dep_quant_used_flag);
3362  else
3363  infer(sh_dep_quant_used_flag, 0);
3364 
3365  if (sps->sps_sign_data_hiding_enabled_flag &&
3366  !current->sh_dep_quant_used_flag)
3367  flag(sh_sign_data_hiding_used_flag);
3368  else
3369  infer(sh_sign_data_hiding_used_flag, 0);
3370 
3371  if (sps->sps_transform_skip_enabled_flag &&
3372  !current->sh_dep_quant_used_flag &&
3373  !current->sh_sign_data_hiding_used_flag)
3374  flag(sh_ts_residual_coding_disabled_flag);
3375  else
3376  infer(sh_ts_residual_coding_disabled_flag, 0);
3377 
3378  if (!current->sh_ts_residual_coding_disabled_flag &&
3379  sps->sps_ts_residual_coding_rice_present_in_sh_flag)
3380  ub(3, sh_ts_residual_coding_rice_idx_minus1);
3381  else
3382  infer(sh_ts_residual_coding_rice_idx_minus1, 0);
3383 
3384  if (sps->sps_reverse_last_sig_coeff_enabled_flag)
3385  flag(sh_reverse_last_sig_coeff_flag);
3386  else
3387  infer(sh_reverse_last_sig_coeff_flag, 0);
3388 
3389  if (pps->pps_slice_header_extension_present_flag) {
3390  ue(sh_slice_header_extension_length, 0, 256);
3391  for (i = 0; i < current->sh_slice_header_extension_length; i++)
3392  us(8, sh_slice_header_extension_data_byte[i], 0x00, 0xff, 1, i);
3393  }
3394 
3395  current->num_entry_points = 0;
3396  if (sps->sps_entry_point_offsets_present_flag) {
3397  uint8_t entropy_sync = sps->sps_entropy_coding_sync_enabled_flag;
3398  int height;
3399  if (pps->pps_rect_slice_flag) {
3400  int width_in_tiles;
3401  int slice_idx = current->sh_slice_address;
3402  for (i = 0; i < current->curr_subpic_idx; i++) {
3403  slice_idx += pps->num_slices_in_subpic[i];
3404  }
3405  width_in_tiles =
3406  pps->pps_slice_width_in_tiles_minus1[slice_idx] + 1;
3407 
3408  if (entropy_sync)
3409  height = pps->slice_height_in_ctus[slice_idx];
3410  else
3411  height = pps->pps_slice_height_in_tiles_minus1[slice_idx] + 1;
3412 
3413  current->num_entry_points = width_in_tiles * height;
3414  } else {
3415  int tile_idx;
3416  int tile_y;
3417  for (tile_idx = current->sh_slice_address;
3418  tile_idx <=
3419  current->sh_slice_address +
3420  current->sh_num_tiles_in_slice_minus1; tile_idx++) {
3421  tile_y = tile_idx / pps->num_tile_rows;
3422  height = pps->row_height_val[tile_y];
3423  current->num_entry_points += (entropy_sync ? height : 1);
3424  }
3425  }
3426  current->num_entry_points--;
3427  if (current->num_entry_points > VVC_MAX_ENTRY_POINTS) {
3428  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
3429  "%" PRIu32 ".\n", current->num_entry_points);
3430  return AVERROR_PATCHWELCOME;
3431  }
3432  if (current->num_entry_points > 0) {
3433  ue(sh_entry_offset_len_minus1, 0, 31);
3434  for (i = 0; i < current->num_entry_points; i++) {
3435  ubs(current->sh_entry_offset_len_minus1 + 1,
3436  sh_entry_point_offset_minus1[i], 1, i);
3437  }
3438  }
3439  }
3440  CHECK(FUNC(byte_alignment) (ctx, rw));
3441 
3442  return 0;
3443 }
3444 
3445 SEI_FUNC(sei_decoded_picture_hash, (CodedBitstreamContext *ctx,
3446  RWContext *rw,
3447  H266RawSEIDecodedPictureHash *current,
3448  SEIMessageState *unused))
3449 {
3450  int err, c_idx, i;
3451 
3452  HEADER("Decoded Picture Hash");
3453 
3454  u(8, dph_sei_hash_type, 0, 2);
3455  flag(dph_sei_single_component_flag);
3456  ub(7, dph_sei_reserved_zero_7bits);
3457 
3458  for (c_idx = 0; c_idx < (current->dph_sei_single_component_flag ? 1 : 3);
3459  c_idx++) {
3460  if (current->dph_sei_hash_type == 0) {
3461  for (i = 0; i < 16; i++)
3462  us(8, dph_sei_picture_md5[c_idx][i], 0x00, 0xff, 2, c_idx, i);
3463  } else if (current->dph_sei_hash_type == 1) {
3464  us(16, dph_sei_picture_crc[c_idx], 0x0000, 0xffff, 1, c_idx);
3465  } else if (current->dph_sei_hash_type == 2) {
3466  us(32, dph_sei_picture_checksum[c_idx], 0x00000000, 0xffffffff, 1,
3467  c_idx);
3468  }
3469  }
3470  return 0;
3471 }
3472 
3473 static int FUNC(sei) (CodedBitstreamContext *ctx, RWContext *rw,
3474  H266RawSEI *current, int prefix)
3475 {
3476  int err;
3477 
3478  if (prefix)
3479  HEADER("Prefix Supplemental Enhancement Information");
3480  else
3481  HEADER("Suffix Supplemental Enhancement Information");
3482 
3483  CHECK(FUNC(nal_unit_header) (ctx, rw, &current->nal_unit_header,
3484  prefix ? VVC_PREFIX_SEI_NUT
3485  : VVC_SUFFIX_SEI_NUT));
3486 
3487  CHECK(FUNC_SEI(message_list) (ctx, rw, &current->message_list, prefix));
3488 
3489  CHECK(FUNC(rbsp_trailing_bits) (ctx, rw));
3490 
3491  return 0;
3492 }
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H266RawSEI *current, int prefix)
Definition: cbs_h266_syntax_template.c:3473
bit_position
#define bit_position(rw)
Definition: cbs_h2645.c:443
VVC_GDR_NUT
@ VVC_GDR_NUT
Definition: vvc.h:39
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
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_HEIGHT
@ VVC_MAX_HEIGHT
Definition: vvc.h:133
H266RawDCI
Definition: cbs_h266.h:252
H266RawSEIDecodedPictureHash::dph_sei_hash_type
uint8_t dph_sei_hash_type
Definition: cbs_h266.h:852
VVC_MAX_LAYERS
@ VVC_MAX_LAYERS
Definition: vvc.h:80
ff_ctz
#define ff_ctz
Definition: intmath.h:107
lmcs_data
static int FUNC() lmcs_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current)
Definition: cbs_h266_syntax_template.c:2374
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
VVC_MAX_ENTRY_POINTS
@ VVC_MAX_ENTRY_POINTS
Definition: vvc.h:153
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
HEADER
#define HEADER(name)
Definition: cbs_av1.c:448
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
infer
#define infer(name, value)
Definition: cbs_av1.c:635
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3005
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
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
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
VVC_MAX_VPS_COUNT
@ VVC_MAX_VPS_COUNT
Definition: vvc.h:95
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_SUBLAYERS
@ VVC_MAX_SUBLAYERS
Definition: vvc.h:83
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H266RawAUD *current)
Definition: cbs_h266_syntax_template.c:2500
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
CodedBitstreamH266Context::pps
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:874
CodedBitstreamH266Context::vps
H266RawVPS * vps[VVC_MAX_VPS_COUNT]
RefStruct references.
Definition: cbs_h266.h:872
H266RawAUD
Definition: cbs_h266.h:644
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:3018
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:108
H266RawAPS
Definition: cbs_h266.h:598
VVC_MAX_REF_PIC_LISTS
@ VVC_MAX_REF_PIC_LISTS
Definition: vvc.h:112
ub
#define ub(width, name)
Definition: cbs_h2645.c:401
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:254
H266GeneralConstraintsInfo
Definition: cbs_h266.h:36
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H266RawPPS *current)
Definition: cbs_h266_syntax_template.c:1647
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:253
VVC_MAX_TILE_COLUMNS
@ VVC_MAX_TILE_COLUMNS
Definition: vvc.h:141
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H266RawVUI
Definition: cbs_h266.h:211
H266RawSEI
Definition: cbs_h266.h:861
VVC_MAX_TILE_ROWS
@ VVC_MAX_TILE_ROWS
Definition: vvc.h:139
width
#define width
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
bits
uint8_t bits
Definition: vp3data.h:128
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h266_syntax_template.c:19
VVC_MAX_REF_ENTRIES
@ VVC_MAX_REF_ENTRIES
Definition: vvc.h:115
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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:196
H266RawGeneralTimingHrdParameters
Definition: cbs_h266.h:180
VVC_MAX_DPB_SIZE
@ VVC_MAX_DPB_SIZE
Definition: vvc.h:109
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:2410
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:2463
H266RawOPI
Definition: cbs_h266.h:241
H266RawPictureHeader
Definition: cbs_h266.h:674
bits_left
#define bits_left
Definition: bitstream.h:114
byte_alignment
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h266_syntax_template.c:50
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
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:650
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
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
VVC_MAX_TOTAL_NUM_OLSS
@ VVC_MAX_TOTAL_NUM_OLSS
Definition: vvc.h:92
VVC_SLICE_TYPE_I
@ VVC_SLICE_TYPE_I
Definition: vvc.h:66
VVC_PH_NUT
@ VVC_PH_NUT
Definition: vvc.h:48
SEI_FUNC
SEI_FUNC(sei_decoded_picture_hash,(CodedBitstreamContext *ctx, RWContext *rw, H266RawSEIDecodedPictureHash *current, SEIMessageState *unused))
Definition: cbs_h266_syntax_template.c:3445
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_PPS_COUNT
@ VVC_MAX_PPS_COUNT
Definition: vvc.h:99
VVC_VPS_NUT
@ VVC_VPS_NUT
Definition: vvc.h:43
CodedBitstreamH266Context::ph
H266RawPictureHeader * ph
Definition: cbs_h266.h:875
H266RefPicListStruct
Definition: cbs_h266.h:160
VVC_MAX_TILES_PER_AU
@ VVC_MAX_TILES_PER_AU
Definition: vvc.h:136
H266RawSubLayerHRDParameters
Definition: cbs_h266.h:194
height
#define height
CodedBitstreamH266Context
Definition: cbs_h266.h:866
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:2263
H266RawSliceHeader
Definition: cbs_h266.h:769
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
flag
#define flag(name)
Definition: cbs_av1.c:466
VVC_MAX_WIDTH
@ VVC_MAX_WIDTH
Definition: vvc.h:132
ubs
#define ubs(width, name, subs,...)
Definition: cbs_h2645.c:265
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:2517
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:873
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
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
SEIMessageState
Definition: cbs_sei.h:86
VVC_PREFIX_APS_NUT
@ VVC_PREFIX_APS_NUT
Definition: vvc.h:46
H266RawPH
Definition: cbs_h266.h:764
ref_pic_lists
static int FUNC() ref_pic_lists(CodedBitstreamContext *ctx, RWContext *rw, const H266RawSPS *sps, const H266RawPPS *pps, H266RefPicLists *current)
Definition: cbs_h266_syntax_template.c:491
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
VVC_SUFFIX_APS_NUT
@ VVC_SUFFIX_APS_NUT
Definition: vvc.h:47
VVC_ASP_TYPE_SCALING
@ VVC_ASP_TYPE_SCALING
Definition: vvc.h:72
H266RawOlsTimingHrdParameters
Definition: cbs_h266.h:202
VVC_CRA_NUT
@ VVC_CRA_NUT
Definition: vvc.h:38
dci
static int FUNC() dci(CodedBitstreamContext *ctx, RWContext *rw, H266RawDCI *current)
Definition: cbs_h266_syntax_template.c:670
VVC_OPI_NUT
@ VVC_OPI_NUT
Definition: vvc.h:41
extension_data
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H266RawExtensionData *current)
Definition: cbs_h266_syntax_template.c:367
H266RawSEIDecodedPictureHash::dph_sei_single_component_flag
uint8_t dph_sei_single_component_flag
Definition: cbs_h266.h:853
sh_slice_address
static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
Definition: ps.c:1156
VVC_MAX_SLICES
@ VVC_MAX_SLICES
Definition: vvc.h:144
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:479
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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
H266RawSEIDecodedPictureHash
Definition: cbs_h266.h:851
VVC_NUM_ALF_FILTERS
@ VVC_NUM_ALF_FILTERS
Definition: vvc.h:106
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:406
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
RWContext
#define RWContext
Definition: cbs_av1.c:583
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:1283
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:2600
Generated on Sun Jun 16 2024 19:21:22 for FFmpeg by   doxygen 1.8.17