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