24 fixed(1, rbsp_stop_one_bit, 1);
26 fixed(1, rbsp_alignment_zero_bit, 0);
32 int expected_nal_unit_type)
36 fixed(1, forbidden_zero_bit, 0);
37 flag(nuh_reserved_zero_bit);
39 u(6, nuh_layer_id, 0, 55);
41 if (expected_nal_unit_type >= 0)
42 u(5, nal_unit_type, expected_nal_unit_type, expected_nal_unit_type);
46 u(3, nuh_temporal_id_plus1, 1, 7);
54 fixed(1, byte_alignment_bit_equal_to_one, 1);
56 fixed(1, byte_alignment_bit_equal_to_zero, 0);
64 int err,
i, num_additional_bits_used;
66 flag(gci_present_flag);
67 if (current->gci_present_flag) {
69 flag(gci_intra_only_constraint_flag);
70 flag(gci_all_layers_independent_constraint_flag);
71 flag(gci_one_au_only_constraint_flag);
74 u(4, gci_sixteen_minus_max_bitdepth_constraint_idc, 0, 8);
75 ub(2, gci_three_minus_max_chroma_format_constraint_idc);
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);
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);
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);
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);
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);
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);
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;
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;
170 for (
i = 0;
i < current->gci_num_additional_bits - num_additional_bits_used;
i++)
171 flags(gci_reserved_bit[
i], 1,
i);
174 fixed(1, gci_alignment_zero_bit, 0);
181 int profile_tier_present_flag,
182 int max_num_sub_layers_minus1)
186 if (profile_tier_present_flag) {
187 ub(7, general_profile_idc);
188 flag(general_tier_flag);
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) {
198 for (
i = max_num_sub_layers_minus1 - 1;
i >= 0;
i--)
199 flags(ptl_sublayer_level_present_flag[
i], 1,
i);
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);
217 infer(vui_progressive_source_flag, 0);
218 infer(vui_interlaced_source_flag, 0);
220 infer(vui_non_packed_constraint_flag, 0);
221 infer(vui_non_projected_constraint_flag, 0);
223 infer(vui_aspect_ratio_constant_flag, 0);
224 infer(vui_aspect_ratio_idc, 0);
226 infer(vui_overscan_info_present_flag, 0);
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);
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);
241 uint8_t chroma_format_idc)
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);
258 infer(vui_aspect_ratio_constant_flag, 0);
259 infer(vui_aspect_ratio_idc, 0);
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);
268 current->vui_colour_primaries);
269 ub(8, vui_transfer_characteristics);
271 "vui_transfer_characteristics == %d \n",
272 current->vui_transfer_characteristics);
273 ub(8, vui_matrix_coeffs);
275 current->vui_matrix_coeffs);
276 flag(vui_full_range_flag);
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);
283 flag(vui_chroma_loc_info_present_flag);
284 if (chroma_format_idc != 1 && current->vui_chroma_loc_info_present_flag) {
286 "vui_chroma_loc_info_present_flag can't not be true",
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);
295 ue(vui_chroma_sample_loc_type_top_field, 0, 6);
296 ue(vui_chroma_sample_loc_type_bottom_field, 0, 6);
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);
312 uint32_t payload_size,
int cur_pos)
315 size_t byte_length, k;
329 if (!payload_zero_bits)
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);
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],
347 H266RawVUI *current, uint16_t vui_payload_size,
348 uint8_t chroma_format_idc)
351 int start_position, current_position;
357 if (current_position < 8 * vui_payload_size) {
359 vui_payload_size, current_position));
360 fixed(1, vui_payload_bit_equal_to_one, 1);
362 fixed(1, vui_payload_bit_equal_to_zero, 0);
378 current->bit_length = k;
381 allocate(current->data, (current->bit_length + 7) / 8);
382 for (k = 0; k < current->bit_length; k++) {
384 current->data[k / 8] |=
bit << (7 - k % 8);
388 for (k = 0; k < current->bit_length; k++)
396 uint8_t max_sublayers_minus1,
397 uint8_t sublayer_info_flag)
400 for (
i = (sublayer_info_flag ? 0 : max_sublayers_minus1);
401 i <= max_sublayers_minus1;
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);
413 uint8_t list_idx, uint8_t rpls_idx,
417 int err,
i, j, general_layer_idx = -1, num_direct_ref_layers = 0;
422 "VPS id %d not available.\n",
sps->sps_video_parameter_set_id);
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;
432 if (general_layer_idx < 0) {
434 sps->nal_unit_header.nuh_layer_id);
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++;
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);
455 infer(inter_layer_ref_pic_flag[
i], 0);
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);
461 infer(st_ref_pic_flag[
i], 1);
462 if (current->st_ref_pic_flag[
i]) {
463 int abs_delta_poc_st;
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];
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);
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);
480 if (num_direct_ref_layers == 0) {
482 "num_direct_ref_layers needs > 0.\n");
485 ues(ilrp_idx[
i], 0, num_direct_ref_layers - 1, 1,
i);
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))) {
501 if (
sps->sps_num_ref_pic_lists[
i] == 0) {
502 infer(rpl_sps_flag[
i], 0);
504 if (!
pps->pps_rpl1_idx_present_flag &&
i == 1)
505 infer(rpl_sps_flag[1], current->rpl_sps_flag[0]);
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))) {
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) {
515 }
else if (
i == 1 && !
pps->pps_rpl1_idx_present_flag) {
516 infer(rpl_idx[1], current->rpl_idx[0]);
520 "can't infer the rpl_idx[i]\n");
523 memcpy(¤t->rpl_ref_list[
i],
524 &
sps->sps_ref_pic_list_struct[
i][current->rpl_idx[
i]],
525 sizeof(current->rpl_ref_list[
i]));
528 i,
sps->sps_num_ref_pic_lists[
i],
531 ref_list = ¤t->rpl_ref_list[
i];
533 num_ltrp_entries = 0;
542 for (j = 0; j < num_ltrp_entries; j++) {
544 ubs(
sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4,
545 poc_lsb_lt[
i][j], 2,
i, j);
547 flags(delta_poc_msb_cycle_present_flag[
i][j], 2,
i, j);
548 if (current->delta_poc_msb_cycle_present_flag[
i][j]) {
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);
563 ub(32, num_units_in_tick);
565 flag(general_nal_hrd_params_present_flag);
566 flag(general_vcl_hrd_params_present_flag);
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);
581 infer(general_du_hrd_params_present_flag, 0);
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,
596 ues(cpb_size_value_minus1[sublayer_id][
i], 0, UINT32_MAX - 1, 2,
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);
604 flags(cbr_flag[sublayer_id][
i], 2, sublayer_id,
i);
611 uint8_t first_sublayer, uint8_t max_sublayers_minus1,
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);
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);
629 infer(low_delay_hrd_flag[
i], 0);
631 if (general->general_nal_hrd_params_present_flag)
633 ¤t->nal_sub_layer_hrd_parameters,
635 if (general->general_vcl_hrd_params_present_flag)
637 ¤t->nal_sub_layer_hrd_parameters,
648 HEADER(
"Operating point information");
653 flag(opi_ols_info_present_flag);
654 flag(opi_htid_info_present_flag);
656 if(current->opi_ols_info_present_flag)
659 if(current->opi_htid_info_present_flag)
660 ub(3, opi_htid_plus1);
662 flag(opi_extension_flag);
663 if (current->opi_extension_flag)
675 HEADER(
"Decoding capability information");
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++)
684 current->dci_profile_tier_level +
i, 1, 0));
686 flag(dci_extension_flag);
687 if (current->dci_extension_flag)
698 uint16_t total_num_olss = 0;
699 uint8_t ols_mode_idc = 0;
700 uint16_t num_multi_layer_olss = 0;
705 HEADER(
"Video Parameter Set");
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);
717 infer(vps_default_ptl_dpb_hrd_max_tid_flag, 1);
719 if (current->vps_max_layers_minus1 > 0)
720 flag(vps_all_independent_layers_flag);
722 infer(vps_all_independent_layers_flag, 1);
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]) {
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]);
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);
743 infer(vps_max_tid_il_ref_pics_plus1[
i][j],
744 current->vps_max_sublayers_minus1 + 1);
748 for (j = 0; j <
i; j++) {
749 infer(vps_direct_ref_layer_flag[
i][j], 0);
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);
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);
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);
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;
774 for (j = 0; j <= current->vps_max_layers_minus1; j++)
775 flags(vps_ols_output_layer_flag[
i][j], 2,
i, j);
777 ols_mode_idc = current->vps_ols_mode_idc;
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;
787 "ols_mode_idc == 3, patch welcome");
788 u(8, vps_num_ptls_minus1, 0, total_num_olss - 1);
790 infer(vps_each_layer_is_an_ols_flag, 1);
791 infer(vps_num_ptls_minus1, 0);
794 for (
i = 0;
i <= current->vps_num_ptls_minus1;
i++) {
796 flags(vps_pt_present_flag[
i], 1,
i);
798 infer(vps_pt_present_flag[
i], 1);
800 if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
801 us(3, vps_ptl_max_tid[
i], 0, current->vps_max_sublayers_minus1, 1,
i);
803 infer(vps_ptl_max_tid[
i], current->vps_max_sublayers_minus1);
806 fixed(1, vps_ptl_alignment_zero_bit, 0);
817 for (
i = 0;
i <= current->vps_max_layers_minus1;
i++) {
818 for (j = 0; j <= current->vps_max_layers_minus1; j++) {
819 dependency_flag[
i][j] = current->vps_direct_ref_layer_flag[
i][j];
820 for (k = 0; k <
i; k++) {
821 if (current->vps_direct_ref_layer_flag[
i][k] &&
822 dependency_flag[k][j])
823 dependency_flag[
i][j] = 1;
827 for (
i = 0;
i <= current->vps_max_layers_minus1;
i++) {
829 for (j = 0,
r = 0; j <= current->vps_max_layers_minus1; j++) {
830 if (dependency_flag[
i][j])
831 reference_layer_idx[
i][
r++] = j;
833 num_ref_layers[
i] =
r;
837 num_output_layers_in_ols[0] = 1;
838 num_sub_layers_in_layer_in_ols[0][0] =
839 current->vps_ptl_max_tid[current->vps_ols_ptl_idx[0]] + 1;
840 for (
i = 1;
i < total_num_olss;
i++) {
841 if (ols_mode_idc == 4 || ols_mode_idc == 0) {
842 num_output_layers_in_ols[
i] = 1;
843 if (current->vps_each_layer_is_an_ols_flag) {
844 num_sub_layers_in_layer_in_ols[
i][0] =
845 current->vps_ptl_max_tid[current->vps_ols_ptl_idx[
i]] + 1;
847 num_sub_layers_in_layer_in_ols[
i][
i] =
848 current->vps_ptl_max_tid[current->vps_ols_ptl_idx[
i]] + 1;
849 for (k =
i - 1; k >= 0; k--) {
850 num_sub_layers_in_layer_in_ols[
i][k] = 0;
851 for (m = k + 1; m <=
i; m++) {
852 uint8_t max_sublayer_needed =
853 FFMIN(num_sub_layers_in_layer_in_ols[
i][m],
854 current->vps_max_tid_il_ref_pics_plus1[m][k]);
855 if (current->vps_direct_ref_layer_flag[m][k] &&
856 num_sub_layers_in_layer_in_ols[
i][k] < max_sublayer_needed)
857 num_sub_layers_in_layer_in_ols[
i][k] = max_sublayer_needed;
861 }
else if (current->vps_ols_mode_idc == 1) {
862 num_output_layers_in_ols[
i] =
i + 1;
863 for (j = 0; j < num_output_layers_in_ols[
i]; j++) {
864 num_sub_layers_in_layer_in_ols[
i][j] =
865 current->vps_ptl_max_tid[current->vps_ols_ptl_idx[
i]] + 1;
867 }
else if (current->vps_ols_mode_idc == 2) {
868 uint8_t highest_included_layer = 0;
869 for (j = 0; j <= current->vps_max_layers_minus1; j++) {
870 layer_included_in_ols_flag[
i][j] = 0;
871 num_sub_layers_in_layer_in_ols[
i][j] = 0;
873 for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++) {
874 if (current->vps_ols_output_layer_flag[
i][k]) {
875 layer_included_in_ols_flag[
i][k] = 1;
876 highest_included_layer = k;
877 output_layer_idx[
i][j] = k;
878 num_sub_layers_in_layer_in_ols[
i][k] =
879 current->vps_ptl_max_tid[current->
880 vps_ols_ptl_idx[
i]] + 1;
884 num_output_layers_in_ols[
i] = j;
885 for (j = 0; j < num_output_layers_in_ols[
i]; j++) {
886 int idx = output_layer_idx[
i][j];
887 for (k = 0; k < num_ref_layers[idx]; k++) {
888 if (!layer_included_in_ols_flag[
i][reference_layer_idx[idx][k]])
889 layer_included_in_ols_flag[
i][reference_layer_idx[idx][k]] = 1;
892 for (k = highest_included_layer - 1; k >= 0; k--) {
893 if (layer_included_in_ols_flag[
i][k] &&
894 !current->vps_ols_output_layer_flag[
i][k]) {
895 for (m = k + 1; m <= highest_included_layer; m++) {
896 uint8_t max_sublayer_needed =
897 FFMIN(num_sub_layers_in_layer_in_ols[
i][m],
898 current->vps_max_tid_il_ref_pics_plus1[m][k]);
899 if (current->vps_direct_ref_layer_flag[m][k] &&
900 layer_included_in_ols_flag[
i][m] &&
901 num_sub_layers_in_layer_in_ols[
i][k] <
903 num_sub_layers_in_layer_in_ols[
i][k] =
909 if (!num_output_layers_in_ols[
i])
912 for (
i = 1;
i < total_num_olss;
i++) {
913 int num_layers_in_ols = 0;
914 if (current->vps_each_layer_is_an_ols_flag) {
915 num_layers_in_ols = 1;
916 }
else if (current->vps_ols_mode_idc == 0 ||
917 current->vps_ols_mode_idc == 1) {
918 num_layers_in_ols =
i + 1;
919 }
else if (current->vps_ols_mode_idc == 2) {
920 for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++)
921 if (layer_included_in_ols_flag[
i][k])
923 num_layers_in_ols = j;
925 if (num_layers_in_ols > 1) {
926 num_multi_layer_olss++;
929 if (!current->vps_each_layer_is_an_ols_flag && num_multi_layer_olss == 0)
933 for (
i = 0;
i <= current->vps_num_ptls_minus1;
i++) {
935 current->vps_profile_tier_level +
i,
936 current->vps_pt_present_flag[
i],
937 current->vps_ptl_max_tid[
i]));
939 for (
i = 0;
i < total_num_olss;
i++) {
940 if (current->vps_num_ptls_minus1 > 0 &&
941 current->vps_num_ptls_minus1 + 1 != total_num_olss) {
942 us(8, vps_ols_ptl_idx[
i], 0, current->vps_num_ptls_minus1, 1,
i);
943 }
else if (current->vps_num_ptls_minus1 == 0) {
944 infer(vps_ols_ptl_idx[
i], 0);
950 if (!current->vps_each_layer_is_an_ols_flag) {
951 uint16_t vps_num_dpb_params;
952 ue(vps_num_dpb_params_minus1, 0, num_multi_layer_olss - 1);
953 if (current->vps_each_layer_is_an_ols_flag)
954 vps_num_dpb_params = 0;
956 vps_num_dpb_params = current->vps_num_dpb_params_minus1 + 1;
958 if (current->vps_max_sublayers_minus1 > 0)
959 flag(vps_sublayer_dpb_params_present_flag);
961 infer(vps_sublayer_dpb_params_present_flag, 0);
963 for (
i = 0;
i < vps_num_dpb_params;
i++) {
964 if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
965 us(3, vps_dpb_max_tid[
i], 0, current->vps_max_sublayers_minus1,
968 infer(vps_dpb_max_tid[
i], current->vps_max_sublayers_minus1);
970 current->vps_dpb_max_tid[
i],
972 vps_sublayer_dpb_params_present_flag));
974 for (
i = 0;
i < num_multi_layer_olss;
i++) {
975 ues(vps_ols_dpb_pic_width[
i], 0, UINT16_MAX, 1,
i);
976 ues(vps_ols_dpb_pic_height[
i], 0, UINT16_MAX, 1,
i);
977 ubs(2, vps_ols_dpb_chroma_format[
i], 1,
i);
978 ues(vps_ols_dpb_bitdepth_minus8[
i], 0, 8, 1,
i);
979 if (vps_num_dpb_params > 1
980 && vps_num_dpb_params != num_multi_layer_olss)
981 ues(vps_ols_dpb_params_idx[
i], 0, vps_num_dpb_params - 1, 1,
i);
982 else if (vps_num_dpb_params == 1)
983 infer(vps_ols_dpb_params_idx[
i], 0);
985 infer(vps_ols_dpb_params_idx[
i],
i);
987 flag(vps_timing_hrd_params_present_flag);
988 if (current->vps_timing_hrd_params_present_flag) {
991 vps_general_timing_hrd_parameters));
992 if (current->vps_max_sublayers_minus1 > 0)
993 flag(vps_sublayer_cpb_params_present_flag);
995 infer(vps_sublayer_cpb_params_present_flag, 0);
996 ue(vps_num_ols_timing_hrd_params_minus1, 0,
997 num_multi_layer_olss - 1);
998 for (
i = 0;
i <= current->vps_num_ols_timing_hrd_params_minus1;
i++) {
999 uint8_t first_sublayer;
1000 if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
1001 us(3, vps_hrd_max_tid[
i], 0,
1002 current->vps_max_sublayers_minus1, 1,
i);
1004 infer(vps_hrd_max_tid[
i],
1005 current->vps_max_sublayers_minus1);
1006 first_sublayer = current->vps_sublayer_cpb_params_present_flag ?
1007 0 : current->vps_hrd_max_tid[
i];
1009 (
ctx, rw, ¤t->vps_ols_timing_hrd_parameters,
1010 first_sublayer, current->vps_max_sublayers_minus1,
1011 ¤t->vps_general_timing_hrd_parameters));
1014 if (current->vps_num_ols_timing_hrd_params_minus1 > 0 &&
1015 current->vps_num_ols_timing_hrd_params_minus1 + 1 !=
1016 num_multi_layer_olss) {
1017 for (
i = 0;
i < num_multi_layer_olss;
i++) {
1018 ues(vps_ols_timing_hrd_idx[
i], 0,
1019 current->vps_num_ols_timing_hrd_params_minus1, 1,
i);
1021 }
else if (current->vps_num_ols_timing_hrd_params_minus1 == 0) {
1022 for (
i = 0;
i < num_multi_layer_olss;
i++)
1023 infer(vps_ols_timing_hrd_idx[
i], 0);
1025 for (
i = 0;
i < num_multi_layer_olss;
i++)
1026 infer(vps_ols_timing_hrd_idx[
i],
i);
1031 flag(vps_extension_flag);
1032 if (current->vps_extension_flag)
1044 flag(sps_extended_precision_flag);
1045 if (current->sps_transform_skip_enabled_flag)
1046 flag(sps_ts_residual_coding_rice_present_in_sh_flag);
1048 infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1049 flag(sps_rrc_rice_extension_flag);
1050 flag(sps_persistent_rice_adaptation_enabled_flag);
1051 flag(sps_reverse_last_sig_coeff_enabled_flag);
1060 int err,
i, j, max_width_minus1, max_height_minus1;
1061 unsigned int ctb_log2_size_y, min_cb_log2_size_y,
1062 min_qt_log2_size_intra_y, min_qt_log2_size_inter_y,
1063 ctb_size_y, max_num_merge_cand, tmp_width_val, tmp_height_val;
1064 uint8_t qp_bd_offset, sub_width_c, sub_height_c;
1066 static const uint8_t h266_sub_width_c[] = {
1069 static const uint8_t h266_sub_height_c[] = {
1073 HEADER(
"Sequence Parameter Set");
1078 ub(4, sps_seq_parameter_set_id);
1079 ub(4, sps_video_parameter_set_id);
1080 if (current->sps_video_parameter_set_id == 0 && !h266->
vps[0]) {
1084 vps->vps_max_layers_minus1 = 0;
1085 vps->vps_independent_layer_flag[0] = 1;
1086 vps->vps_layer_id[0] = current->nal_unit_header.nuh_layer_id;
1091 u(2, sps_chroma_format_idc, 0, 3);
1092 sub_width_c = h266_sub_width_c[current->sps_chroma_format_idc];
1093 sub_height_c = h266_sub_height_c[current->sps_chroma_format_idc];
1095 u(2, sps_log2_ctu_size_minus5, 0, 3);
1096 ctb_log2_size_y = current->sps_log2_ctu_size_minus5 + 5;
1097 ctb_size_y = 1 << ctb_log2_size_y;
1099 flag(sps_ptl_dpb_hrd_params_present_flag);
1100 if (current->sps_ptl_dpb_hrd_params_present_flag) {
1102 1, current->sps_max_sublayers_minus1));
1104 flag(sps_gdr_enabled_flag);
1105 flag(sps_ref_pic_resampling_enabled_flag);
1106 if (current->sps_ref_pic_resampling_enabled_flag)
1107 flag(sps_res_change_in_clvs_allowed_flag);
1109 infer(sps_res_change_in_clvs_allowed_flag, 0);
1114 flag(sps_conformance_window_flag);
1115 if (current->sps_conformance_window_flag) {
1116 uint16_t
width = current->sps_pic_width_max_in_luma_samples / sub_width_c;
1117 uint16_t
height = current->sps_pic_height_max_in_luma_samples / sub_height_c;
1118 ue(sps_conf_win_left_offset, 0,
width);
1119 ue(sps_conf_win_right_offset, 0,
width - current->sps_conf_win_left_offset);
1120 ue(sps_conf_win_top_offset, 0,
height);
1121 ue(sps_conf_win_bottom_offset, 0,
height - current->sps_conf_win_top_offset);
1123 infer(sps_conf_win_left_offset, 0);
1124 infer(sps_conf_win_right_offset, 0);
1125 infer(sps_conf_win_top_offset, 0);
1126 infer(sps_conf_win_bottom_offset, 0);
1129 tmp_width_val =
AV_CEIL_RSHIFT(current->sps_pic_width_max_in_luma_samples,
1131 tmp_height_val =
AV_CEIL_RSHIFT(current->sps_pic_height_max_in_luma_samples,
1133 max_width_minus1 = tmp_width_val - 1;
1134 max_height_minus1 = tmp_height_val - 1;
1136 flag(sps_subpic_info_present_flag);
1137 if (current->sps_subpic_info_present_flag) {
1139 if (current->sps_num_subpics_minus1 > 0) {
1140 flag(sps_independent_subpics_flag);
1141 flag(sps_subpic_same_size_flag);
1144 if (current->sps_num_subpics_minus1 > 0) {
1147 infer(sps_subpic_ctu_top_left_x[0], 0);
1148 infer(sps_subpic_ctu_top_left_y[0], 0);
1149 if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1150 us(wlen, sps_subpic_width_minus1[0], 0, max_width_minus1, 1, 0);
1152 infer(sps_subpic_width_minus1[0], max_width_minus1);
1153 if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
1154 us(hlen, sps_subpic_height_minus1[0], 0, max_height_minus1, 1, 0);
1156 infer(sps_subpic_height_minus1[0], max_height_minus1);
1157 if (!current->sps_independent_subpics_flag) {
1158 flags(sps_subpic_treated_as_pic_flag[0], 1, 0);
1159 flags(sps_loop_filter_across_subpic_enabled_flag[0], 1, 0);
1161 infer(sps_subpic_treated_as_pic_flag[0], 1);
1162 infer(sps_loop_filter_across_subpic_enabled_flag[0], 1);
1164 for (
i = 1;
i <= current->sps_num_subpics_minus1;
i++) {
1165 if (!current->sps_subpic_same_size_flag) {
1166 const int win_right_edge =
1167 current->sps_pic_width_max_in_luma_samples -
1168 current->sps_conf_win_right_offset * sub_width_c;
1169 const int win_bottom_edge =
1170 current->sps_pic_height_max_in_luma_samples -
1171 current->sps_conf_win_bottom_offset * sub_height_c;
1172 const int win_left_edge =
1173 current->sps_conf_win_left_offset * sub_width_c;
1174 const int win_top_edge =
1175 current->sps_conf_win_top_offset * sub_height_c;
1176 const int win_left_edge_ctus =
1178 const int win_right_edge_ctus =
1180 const int win_top_edge_ctus =
1182 const int win_bottom_edge_ctus =
1184 const int min_width =
1185 FFMAX(win_left_edge_ctus - current->sps_subpic_ctu_top_left_x[
i], 0);
1186 const int min_height =
1187 FFMAX(win_top_edge_ctus - current->sps_subpic_ctu_top_left_y[
i], 0);
1189 if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
1190 us(wlen, sps_subpic_ctu_top_left_x[
i], 0, win_right_edge_ctus - 1, 1,
i);
1192 infer(sps_subpic_ctu_top_left_x[
i], 0);
1194 if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
1195 us(hlen, sps_subpic_ctu_top_left_y[
i], 0, win_bottom_edge_ctus - 1, 1,
i);
1197 infer(sps_subpic_ctu_top_left_y[
i], 0);
1199 max_width_minus1 = tmp_width_val - current->sps_subpic_ctu_top_left_x[
i] - 1;
1200 max_height_minus1 = tmp_height_val - current->sps_subpic_ctu_top_left_y[
i] - 1;
1202 if (i < current->sps_num_subpics_minus1 &&
1203 current->sps_pic_width_max_in_luma_samples > ctb_size_y) {
1204 us(wlen, sps_subpic_width_minus1[
i], min_width, max_width_minus1, 1,
i);
1206 infer(sps_subpic_width_minus1[
i], max_width_minus1);
1209 if (i < current->sps_num_subpics_minus1 &&
1210 current->sps_pic_height_max_in_luma_samples > ctb_size_y) {
1211 us(hlen, sps_subpic_height_minus1[
i], min_height, max_height_minus1, 1,
i);
1213 infer(sps_subpic_height_minus1[
i], max_height_minus1);
1216 int num_subpic_cols = tmp_width_val /
1217 (current->sps_subpic_width_minus1[0] + 1);
1218 if (tmp_width_val % (current->sps_subpic_width_minus1[0] + 1) ||
1219 tmp_height_val % (current->sps_subpic_width_minus1[0] + 1) ||
1220 current->sps_num_subpics_minus1 !=
1221 (num_subpic_cols * tmp_height_val /
1222 (current->sps_subpic_height_minus1[0] + 1) - 1))
1224 infer(sps_subpic_ctu_top_left_x[
i],
1225 (
i % num_subpic_cols) *
1226 (current->sps_subpic_width_minus1[0] + 1));
1227 infer(sps_subpic_ctu_top_left_y[
i],
1228 (
i / num_subpic_cols) *
1229 (current->sps_subpic_height_minus1[0] + 1));
1230 infer(sps_subpic_width_minus1[
i],
1231 current->sps_subpic_width_minus1[0]);
1232 infer(sps_subpic_height_minus1[
i],
1233 current->sps_subpic_height_minus1[0]);
1235 if (!current->sps_independent_subpics_flag) {
1236 flags(sps_subpic_treated_as_pic_flag[
i], 1,
i);
1237 flags(sps_loop_filter_across_subpic_enabled_flag[
i], 1,
i);
1239 infer(sps_subpic_treated_as_pic_flag[
i], 1);
1240 infer(sps_loop_filter_across_subpic_enabled_flag[
i], 0);
1244 infer(sps_subpic_ctu_top_left_x[0], 0);
1245 infer(sps_subpic_ctu_top_left_y[0], 0);
1246 infer(sps_subpic_width_minus1[0], max_width_minus1);
1247 infer(sps_subpic_height_minus1[0], max_height_minus1);
1249 ue(sps_subpic_id_len_minus1, 0, 15);
1250 if ((1 << (current->sps_subpic_id_len_minus1 + 1)) <
1251 current->sps_num_subpics_minus1 + 1) {
1253 "sps_subpic_id_len_minus1(%d) is too small\n",
1254 current->sps_subpic_id_len_minus1);
1257 flag(sps_subpic_id_mapping_explicitly_signalled_flag);
1258 if (current->sps_subpic_id_mapping_explicitly_signalled_flag) {
1259 flag(sps_subpic_id_mapping_present_flag);
1260 if (current->sps_subpic_id_mapping_present_flag) {
1261 for (
i = 0;
i <= current->sps_num_subpics_minus1;
i++) {
1262 ubs(current->sps_subpic_id_len_minus1 + 1,
1263 sps_subpic_id[
i], 1,
i);
1268 infer(sps_num_subpics_minus1, 0);
1269 infer(sps_independent_subpics_flag, 1);
1270 infer(sps_subpic_same_size_flag, 0);
1271 infer(sps_subpic_id_mapping_explicitly_signalled_flag, 0);
1272 infer(sps_subpic_ctu_top_left_x[0], 0);
1273 infer(sps_subpic_ctu_top_left_y[0], 0);
1274 infer(sps_subpic_width_minus1[0], max_width_minus1);
1275 infer(sps_subpic_height_minus1[0], max_height_minus1);
1279 ue(sps_bitdepth_minus8, 0, 8);
1280 qp_bd_offset = 6 * current->sps_bitdepth_minus8;
1282 flag(sps_entropy_coding_sync_enabled_flag);
1283 flag(sps_entry_point_offsets_present_flag);
1285 u(4, sps_log2_max_pic_order_cnt_lsb_minus4, 0, 12);
1286 flag(sps_poc_msb_cycle_flag);
1287 if (current->sps_poc_msb_cycle_flag)
1288 ue(sps_poc_msb_cycle_len_minus1,
1289 0, 32 - current->sps_log2_max_pic_order_cnt_lsb_minus4 - 5);
1291 u(2, sps_num_extra_ph_bytes, 0, 2);
1292 for (
i = 0;
i < (current->sps_num_extra_ph_bytes * 8);
i++) {
1293 flags(sps_extra_ph_bit_present_flag[
i], 1,
i);
1296 u(2, sps_num_extra_sh_bytes, 0, 2);
1297 for (
i = 0;
i < (current->sps_num_extra_sh_bytes * 8);
i++) {
1298 flags(sps_extra_sh_bit_present_flag[
i], 1,
i);
1301 if (current->sps_ptl_dpb_hrd_params_present_flag) {
1302 if (current->sps_max_sublayers_minus1 > 0)
1303 flag(sps_sublayer_dpb_params_flag);
1305 infer(sps_sublayer_dpb_params_flag, 0);
1307 current->sps_max_sublayers_minus1,
1308 current->sps_sublayer_dpb_params_flag));
1311 ue(sps_log2_min_luma_coding_block_size_minus2,
1312 0,
FFMIN(4, current->sps_log2_ctu_size_minus5 + 3));
1313 min_cb_log2_size_y =
1314 current->sps_log2_min_luma_coding_block_size_minus2 + 2;
1316 flag(sps_partition_constraints_override_enabled_flag);
1318 ue(sps_log2_diff_min_qt_min_cb_intra_slice_luma,
1319 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1320 min_qt_log2_size_intra_y =
1321 current->sps_log2_diff_min_qt_min_cb_intra_slice_luma +
1324 ue(sps_max_mtt_hierarchy_depth_intra_slice_luma,
1325 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1327 if (current->sps_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
1328 ue(sps_log2_diff_max_bt_min_qt_intra_slice_luma,
1329 0, ctb_log2_size_y - min_qt_log2_size_intra_y);
1330 ue(sps_log2_diff_max_tt_min_qt_intra_slice_luma,
1331 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
1333 infer(sps_log2_diff_max_bt_min_qt_intra_slice_luma, 0);
1334 infer(sps_log2_diff_max_tt_min_qt_intra_slice_luma, 0);
1337 if (current->sps_chroma_format_idc != 0) {
1338 flag(sps_qtbtt_dual_tree_intra_flag);
1340 infer(sps_qtbtt_dual_tree_intra_flag, 0);
1343 if (current->sps_qtbtt_dual_tree_intra_flag) {
1344 ue(sps_log2_diff_min_qt_min_cb_intra_slice_chroma,
1345 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1346 ue(sps_max_mtt_hierarchy_depth_intra_slice_chroma,
1347 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1348 if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
1349 unsigned int min_qt_log2_size_intra_c =
1350 current->sps_log2_diff_min_qt_min_cb_intra_slice_chroma +
1352 ue(sps_log2_diff_max_bt_min_qt_intra_slice_chroma,
1353 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1354 ue(sps_log2_diff_max_tt_min_qt_intra_slice_chroma,
1355 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
1358 infer(sps_log2_diff_min_qt_min_cb_intra_slice_chroma, 0);
1359 infer(sps_max_mtt_hierarchy_depth_intra_slice_chroma, 0);
1361 if (current->sps_max_mtt_hierarchy_depth_intra_slice_chroma == 0) {
1362 infer(sps_log2_diff_max_bt_min_qt_intra_slice_chroma, 0);
1363 infer(sps_log2_diff_max_tt_min_qt_intra_slice_chroma, 0);
1366 ue(sps_log2_diff_min_qt_min_cb_inter_slice,
1367 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
1368 min_qt_log2_size_inter_y =
1369 current->sps_log2_diff_min_qt_min_cb_inter_slice + min_cb_log2_size_y;
1371 ue(sps_max_mtt_hierarchy_depth_inter_slice,
1372 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
1373 if (current->sps_max_mtt_hierarchy_depth_inter_slice != 0) {
1374 ue(sps_log2_diff_max_bt_min_qt_inter_slice,
1375 0, ctb_log2_size_y - min_qt_log2_size_inter_y);
1376 ue(sps_log2_diff_max_tt_min_qt_inter_slice,
1377 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
1379 infer(sps_log2_diff_max_bt_min_qt_inter_slice, 0);
1380 infer(sps_log2_diff_max_tt_min_qt_inter_slice, 0);
1383 if (ctb_size_y > 32)
1384 flag(sps_max_luma_transform_size_64_flag);
1386 infer(sps_max_luma_transform_size_64_flag, 0);
1388 flag(sps_transform_skip_enabled_flag);
1389 if (current->sps_transform_skip_enabled_flag) {
1390 ue(sps_log2_transform_skip_max_size_minus2, 0, 3);
1391 flag(sps_bdpcm_enabled_flag);
1394 flag(sps_mts_enabled_flag);
1395 if (current->sps_mts_enabled_flag) {
1396 flag(sps_explicit_mts_intra_enabled_flag);
1397 flag(sps_explicit_mts_inter_enabled_flag);
1399 infer(sps_explicit_mts_intra_enabled_flag, 0);
1400 infer(sps_explicit_mts_inter_enabled_flag, 0);
1403 flag(sps_lfnst_enabled_flag);
1405 if (current->sps_chroma_format_idc != 0) {
1406 uint8_t num_qp_tables;
1407 flag(sps_joint_cbcr_enabled_flag);
1408 flag(sps_same_qp_table_for_chroma_flag);
1409 num_qp_tables = current->sps_same_qp_table_for_chroma_flag ?
1410 1 : (current->sps_joint_cbcr_enabled_flag ? 3 : 2);
1411 for (
i = 0;
i < num_qp_tables;
i++) {
1412 ses(sps_qp_table_start_minus26[
i], -26 - qp_bd_offset, 36, 1,
i);
1413 ues(sps_num_points_in_qp_table_minus1[
i],
1414 0, 36 - current->sps_qp_table_start_minus26[
i], 1,
i);
1415 for (j = 0; j <= current->sps_num_points_in_qp_table_minus1[
i]; j++) {
1417 ues(sps_delta_qp_in_val_minus1[
i][j], 0,
max, 2,
i, j);
1418 ues(sps_delta_qp_diff_val[
i][j], 0,
max, 2,
i, j);
1422 infer(sps_joint_cbcr_enabled_flag, 0);
1423 infer(sps_same_qp_table_for_chroma_flag, 0);
1426 flag(sps_sao_enabled_flag);
1427 flag(sps_alf_enabled_flag);
1428 if (current->sps_alf_enabled_flag && current->sps_chroma_format_idc)
1429 flag(sps_ccalf_enabled_flag);
1431 infer(sps_ccalf_enabled_flag, 0);
1432 flag(sps_lmcs_enabled_flag);
1433 flag(sps_weighted_pred_flag);
1434 flag(sps_weighted_bipred_flag);
1435 flag(sps_long_term_ref_pics_flag);
1436 if (current->sps_video_parameter_set_id > 0)
1437 flag(sps_inter_layer_prediction_enabled_flag);
1439 infer(sps_inter_layer_prediction_enabled_flag, 0);
1440 flag(sps_idr_rpl_present_flag);
1441 flag(sps_rpl1_same_as_rpl0_flag);
1443 for (
i = 0;
i < (current->sps_rpl1_same_as_rpl0_flag ? 1 : 2);
i++) {
1445 for (j = 0; j < current->sps_num_ref_pic_lists[
i]; j++)
1448 sps_ref_pic_list_struct[
i][j],
i,
1452 if (current->sps_rpl1_same_as_rpl0_flag) {
1453 current->sps_num_ref_pic_lists[1] = current->sps_num_ref_pic_lists[0];
1454 for (j = 0; j < current->sps_num_ref_pic_lists[0]; j++)
1455 memcpy(¤t->sps_ref_pic_list_struct[1][j],
1456 ¤t->sps_ref_pic_list_struct[0][j],
1457 sizeof(current->sps_ref_pic_list_struct[0][j]));
1460 flag(sps_ref_wraparound_enabled_flag);
1462 flag(sps_temporal_mvp_enabled_flag);
1463 if (current->sps_temporal_mvp_enabled_flag)
1464 flag(sps_sbtmvp_enabled_flag);
1466 infer(sps_sbtmvp_enabled_flag, 0);
1468 flag(sps_amvr_enabled_flag);
1469 flag(sps_bdof_enabled_flag);
1470 if (current->sps_bdof_enabled_flag)
1471 flag(sps_bdof_control_present_in_ph_flag);
1473 infer(sps_bdof_control_present_in_ph_flag, 0);
1475 flag(sps_smvd_enabled_flag);
1476 flag(sps_dmvr_enabled_flag);
1477 if (current->sps_dmvr_enabled_flag)
1478 flag(sps_dmvr_control_present_in_ph_flag);
1480 infer(sps_dmvr_control_present_in_ph_flag, 0);
1482 flag(sps_mmvd_enabled_flag);
1483 if (current->sps_mmvd_enabled_flag)
1484 flag(sps_mmvd_fullpel_only_enabled_flag);
1486 infer(sps_mmvd_fullpel_only_enabled_flag, 0);
1488 ue(sps_six_minus_max_num_merge_cand, 0, 5);
1489 max_num_merge_cand = 6 - current->sps_six_minus_max_num_merge_cand;
1491 flag(sps_sbt_enabled_flag);
1493 flag(sps_affine_enabled_flag);
1494 if (current->sps_affine_enabled_flag) {
1495 ue(sps_five_minus_max_num_subblock_merge_cand,
1496 0, 5 - current->sps_sbtmvp_enabled_flag);
1497 flag(sps_6param_affine_enabled_flag);
1498 if (current->sps_amvr_enabled_flag)
1499 flag(sps_affine_amvr_enabled_flag);
1501 infer(sps_affine_amvr_enabled_flag, 0);
1502 flag(sps_affine_prof_enabled_flag);
1503 if (current->sps_affine_prof_enabled_flag)
1504 flag(sps_prof_control_present_in_ph_flag);
1506 infer(sps_prof_control_present_in_ph_flag, 0);
1508 infer(sps_6param_affine_enabled_flag, 0);
1509 infer(sps_affine_amvr_enabled_flag, 0);
1510 infer(sps_affine_prof_enabled_flag, 0);
1511 infer(sps_prof_control_present_in_ph_flag, 0);
1514 flag(sps_bcw_enabled_flag);
1515 flag(sps_ciip_enabled_flag);
1517 if (max_num_merge_cand >= 2) {
1518 flag(sps_gpm_enabled_flag);
1519 if (current->sps_gpm_enabled_flag && max_num_merge_cand >= 3)
1520 ue(sps_max_num_merge_cand_minus_max_num_gpm_cand,
1521 0, max_num_merge_cand - 2);
1523 infer(sps_gpm_enabled_flag, 0);
1526 ue(sps_log2_parallel_merge_level_minus2, 0, ctb_log2_size_y - 2);
1528 flag(sps_isp_enabled_flag);
1529 flag(sps_mrl_enabled_flag);
1530 flag(sps_mip_enabled_flag);
1532 if (current->sps_chroma_format_idc != 0)
1533 flag(sps_cclm_enabled_flag);
1535 infer(sps_cclm_enabled_flag, 0);
1536 if (current->sps_chroma_format_idc == 1) {
1537 flag(sps_chroma_horizontal_collocated_flag);
1538 flag(sps_chroma_vertical_collocated_flag);
1540 infer(sps_chroma_horizontal_collocated_flag, 1);
1541 infer(sps_chroma_vertical_collocated_flag, 1);
1544 flag(sps_palette_enabled_flag);
1545 if (current->sps_chroma_format_idc == 3 &&
1546 !current->sps_max_luma_transform_size_64_flag)
1547 flag(sps_act_enabled_flag);
1549 infer(sps_act_enabled_flag, 0);
1550 if (current->sps_transform_skip_enabled_flag ||
1551 current->sps_palette_enabled_flag)
1552 ue(sps_min_qp_prime_ts, 0, 8);
1554 flag(sps_ibc_enabled_flag);
1555 if (current->sps_ibc_enabled_flag)
1556 ue(sps_six_minus_max_num_ibc_merge_cand, 0, 5);
1558 flag(sps_ladf_enabled_flag);
1559 if (current->sps_ladf_enabled_flag) {
1560 ub(2, sps_num_ladf_intervals_minus2);
1561 se(sps_ladf_lowest_interval_qp_offset, -63, 63);
1562 for (
i = 0;
i < current->sps_num_ladf_intervals_minus2 + 1;
i++) {
1563 ses(sps_ladf_qp_offset[
i], -63, 63, 1,
i);
1564 ues(sps_ladf_delta_threshold_minus1[
i],
1565 0, (2 << (8 + current->sps_bitdepth_minus8)) - 3, 1,
i);
1569 flag(sps_explicit_scaling_list_enabled_flag);
1570 if (current->sps_lfnst_enabled_flag &&
1571 current->sps_explicit_scaling_list_enabled_flag)
1572 flag(sps_scaling_matrix_for_lfnst_disabled_flag);
1574 if (current->sps_act_enabled_flag &&
1575 current->sps_explicit_scaling_list_enabled_flag)
1576 flag(sps_scaling_matrix_for_alternative_colour_space_disabled_flag);
1578 infer(sps_scaling_matrix_for_alternative_colour_space_disabled_flag, 0);
1579 if (current->sps_scaling_matrix_for_alternative_colour_space_disabled_flag)
1580 flag(sps_scaling_matrix_designated_colour_space_flag);
1582 flag(sps_dep_quant_enabled_flag);
1583 flag(sps_sign_data_hiding_enabled_flag);
1585 flag(sps_virtual_boundaries_enabled_flag);
1586 if (current->sps_virtual_boundaries_enabled_flag) {
1587 flag(sps_virtual_boundaries_present_flag);
1588 if (current->sps_virtual_boundaries_present_flag) {
1589 ue(sps_num_ver_virtual_boundaries,
1590 0, current->sps_pic_width_max_in_luma_samples <= 8 ? 0 :
VVC_MAX_VBS);
1591 for (
i = 0;
i < current->sps_num_ver_virtual_boundaries;
i++)
1592 ues(sps_virtual_boundary_pos_x_minus1[
i],
1593 0, (current->sps_pic_width_max_in_luma_samples + 7) / 8 - 2,
1595 ue(sps_num_hor_virtual_boundaries,
1596 0, current->sps_pic_height_max_in_luma_samples <= 8 ? 0 :
VVC_MAX_VBS);
1597 for (
i = 0;
i < current->sps_num_hor_virtual_boundaries;
i++)
1598 ues(sps_virtual_boundary_pos_y_minus1[
i],
1599 0, (current->sps_pic_height_max_in_luma_samples + 7) /
1603 infer(sps_virtual_boundaries_present_flag, 0);
1604 infer(sps_num_ver_virtual_boundaries, 0);
1605 infer(sps_num_hor_virtual_boundaries, 0);
1608 if (current->sps_ptl_dpb_hrd_params_present_flag) {
1609 flag(sps_timing_hrd_params_present_flag);
1610 if (current->sps_timing_hrd_params_present_flag) {
1611 uint8_t first_sublayer;
1613 ¤t->sps_general_timing_hrd_parameters));
1614 if (current->sps_max_sublayers_minus1 > 0)
1615 flag(sps_sublayer_cpb_params_present_flag);
1617 infer(sps_sublayer_cpb_params_present_flag, 0);
1618 first_sublayer = current->sps_sublayer_cpb_params_present_flag ?
1619 0 : current->sps_max_sublayers_minus1;
1621 ¤t->sps_ols_timing_hrd_parameters, first_sublayer,
1622 current->sps_max_sublayers_minus1,
1623 ¤t->sps_general_timing_hrd_parameters));
1627 flag(sps_field_seq_flag);
1628 flag(sps_vui_parameters_present_flag);
1629 if (current->sps_vui_parameters_present_flag) {
1630 ue(sps_vui_payload_size_minus1, 0, 1023);
1632 fixed(1, sps_vui_alignment_zero_bit, 0);
1634 current->sps_vui_payload_size_minus1 + 1,
1635 current->sps_chroma_format_idc));
1640 flag(sps_extension_flag);
1641 if (current->sps_extension_flag) {
1642 flag(sps_range_extension_flag);
1643 ub(7, sps_extension_7bits);
1645 if (current->sps_range_extension_flag) {
1646 if (current->sps_bitdepth_minus8 <= 10 - 8)
1650 infer(sps_extended_precision_flag, 0);
1651 infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1652 infer(sps_rrc_rice_extension_flag, 0);
1653 infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1654 infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1657 infer(sps_range_extension_flag, 0);
1658 infer(sps_extension_7bits, 0);
1659 infer(sps_extended_precision_flag, 0);
1660 infer(sps_ts_residual_coding_rice_present_in_sh_flag, 0);
1661 infer(sps_rrc_rice_extension_flag, 0);
1662 infer(sps_persistent_rice_adaptation_enabled_flag, 0);
1663 infer(sps_reverse_last_sig_coeff_enabled_flag, 0);
1666 if (current->sps_extension_7bits)
1680 unsigned int min_cb_size_y, divisor, ctb_size_y,
1681 pic_width_in_ctbs_y, pic_height_in_ctbs_y;
1682 uint8_t sub_width_c, sub_height_c, qp_bd_offset;
1684 static const uint8_t h266_sub_width_c[] = {
1687 static const uint8_t h266_sub_height_c[] = {
1691 HEADER(
"Picture Parameter Set");
1696 ub(6, pps_pic_parameter_set_id);
1697 ub(4, pps_seq_parameter_set_id);
1698 sps = h266->
sps[current->pps_seq_parameter_set_id];
1701 current->pps_seq_parameter_set_id);
1705 flag(pps_mixed_nalu_types_in_pic_flag);
1706 ue(pps_pic_width_in_luma_samples,
1707 1,
sps->sps_pic_width_max_in_luma_samples);
1708 ue(pps_pic_height_in_luma_samples,
1709 1,
sps->sps_pic_height_max_in_luma_samples);
1711 min_cb_size_y = 1 << (
sps->sps_log2_min_luma_coding_block_size_minus2 + 2);
1712 divisor =
FFMAX(min_cb_size_y, 8);
1713 if (current->pps_pic_width_in_luma_samples % divisor ||
1714 current->pps_pic_height_in_luma_samples % divisor) {
1716 "Invalid dimensions: %ux%u not divisible "
1717 "by %u, MinCbSizeY = %u.\n",
1718 current->pps_pic_width_in_luma_samples,
1719 current->pps_pic_height_in_luma_samples, divisor, min_cb_size_y);
1722 if (!
sps->sps_res_change_in_clvs_allowed_flag &&
1723 (current->pps_pic_width_in_luma_samples !=
1724 sps->sps_pic_width_max_in_luma_samples ||
1725 current->pps_pic_height_in_luma_samples !=
1726 sps->sps_pic_height_max_in_luma_samples)) {
1728 "Resoltuion change is not allowed, "
1729 "in max resolution (%ux%u) mismatched with pps(%ux%u).\n",
1730 sps->sps_pic_width_max_in_luma_samples,
1731 sps->sps_pic_height_max_in_luma_samples,
1732 current->pps_pic_width_in_luma_samples,
1733 current->pps_pic_height_in_luma_samples);
1737 ctb_size_y = 1 << (
sps->sps_log2_ctu_size_minus5 + 5);
1738 if (
sps->sps_ref_wraparound_enabled_flag) {
1739 if ((ctb_size_y / min_cb_size_y + 1) >
1740 (current->pps_pic_width_in_luma_samples / min_cb_size_y - 1)) {
1742 "Invalid width(%u), ctb_size_y = %u, min_cb_size_y = %u.\n",
1743 current->pps_pic_width_in_luma_samples,
1744 ctb_size_y, min_cb_size_y);
1749 flag(pps_conformance_window_flag);
1750 if (current->pps_pic_width_in_luma_samples ==
1751 sps->sps_pic_width_max_in_luma_samples &&
1752 current->pps_pic_height_in_luma_samples ==
1753 sps->sps_pic_height_max_in_luma_samples &&
1754 current->pps_conformance_window_flag) {
1756 "Conformance window flag should not true.\n");
1760 sub_width_c = h266_sub_width_c[
sps->sps_chroma_format_idc];
1761 sub_height_c = h266_sub_height_c[
sps->sps_chroma_format_idc];
1762 if (current->pps_conformance_window_flag) {
1763 ue(pps_conf_win_left_offset, 0, current->pps_pic_width_in_luma_samples);
1764 ue(pps_conf_win_right_offset,
1765 0, current->pps_pic_width_in_luma_samples);
1766 ue(pps_conf_win_top_offset, 0, current->pps_pic_height_in_luma_samples);
1767 ue(pps_conf_win_bottom_offset,
1768 0, current->pps_pic_height_in_luma_samples);
1770 (current->pps_conf_win_left_offset +
1771 current->pps_conf_win_right_offset) >=
1772 current->pps_pic_width_in_luma_samples ||
1774 (current->pps_conf_win_top_offset +
1775 current->pps_conf_win_bottom_offset) >=
1776 current->pps_pic_height_in_luma_samples) {
1778 "Invalid pps conformance window: (%u, %u, %u, %u), "
1779 "resolution is %ux%u, sub wxh is %ux%u.\n",
1780 current->pps_conf_win_left_offset,
1781 current->pps_conf_win_right_offset,
1782 current->pps_conf_win_top_offset,
1783 current->pps_conf_win_bottom_offset,
1784 current->pps_pic_width_in_luma_samples,
1785 current->pps_pic_height_in_luma_samples,
1786 sub_width_c, sub_height_c);
1790 if (current->pps_pic_width_in_luma_samples ==
1791 sps->sps_pic_width_max_in_luma_samples &&
1792 current->pps_pic_height_in_luma_samples ==
1793 sps->sps_pic_height_max_in_luma_samples) {
1794 infer(pps_conf_win_left_offset,
sps->sps_conf_win_left_offset);
1795 infer(pps_conf_win_right_offset,
sps->sps_conf_win_right_offset);
1796 infer(pps_conf_win_top_offset,
sps->sps_conf_win_top_offset);
1797 infer(pps_conf_win_bottom_offset,
sps->sps_conf_win_bottom_offset);
1799 infer(pps_conf_win_left_offset, 0);
1800 infer(pps_conf_win_right_offset, 0);
1801 infer(pps_conf_win_top_offset, 0);
1802 infer(pps_conf_win_bottom_offset, 0);
1807 flag(pps_scaling_window_explicit_signalling_flag);
1808 if (!
sps->sps_ref_pic_resampling_enabled_flag &&
1809 current->pps_scaling_window_explicit_signalling_flag) {
1811 "Invalid data: sps_ref_pic_resampling_enabled_flag is false, "
1812 "but pps_scaling_window_explicit_signalling_flag is true.\n");
1815 if (current->pps_scaling_window_explicit_signalling_flag) {
1816 se(pps_scaling_win_left_offset,
1817 -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1818 current->pps_pic_width_in_luma_samples / sub_width_c);
1819 se(pps_scaling_win_right_offset,
1820 -current->pps_pic_width_in_luma_samples * 15 / sub_width_c,
1821 current->pps_pic_width_in_luma_samples / sub_width_c);
1822 se(pps_scaling_win_top_offset,
1823 -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1824 current->pps_pic_height_in_luma_samples / sub_height_c);
1825 se(pps_scaling_win_bottom_offset,
1826 -current->pps_pic_height_in_luma_samples * 15 / sub_height_c,
1827 current->pps_pic_height_in_luma_samples / sub_height_c);
1829 infer(pps_scaling_win_left_offset, current->pps_conf_win_left_offset);
1830 infer(pps_scaling_win_right_offset, current->pps_conf_win_right_offset);
1831 infer(pps_scaling_win_top_offset, current->pps_conf_win_top_offset);
1832 infer(pps_scaling_win_bottom_offset, current->pps_conf_win_bottom_offset);
1835 flag(pps_output_flag_present_flag);
1836 flag(pps_no_pic_partition_flag);
1837 flag(pps_subpic_id_mapping_present_flag);
1839 if (current->pps_subpic_id_mapping_present_flag) {
1840 if (!current->pps_no_pic_partition_flag) {
1841 ue(pps_num_subpics_minus1,
1842 sps->sps_num_subpics_minus1,
sps->sps_num_subpics_minus1);
1844 infer(pps_num_subpics_minus1, 0);
1846 ue(pps_subpic_id_len_minus1,
sps->sps_subpic_id_len_minus1,
1847 sps->sps_subpic_id_len_minus1);
1848 for (
i = 0;
i <= current->pps_num_subpics_minus1;
i++) {
1849 ubs(
sps->sps_subpic_id_len_minus1 + 1, pps_subpic_id[
i], 1,
i);
1853 for (
i = 0;
i <=
sps->sps_num_subpics_minus1;
i++) {
1854 if (
sps->sps_subpic_id_mapping_explicitly_signalled_flag)
1855 current->sub_pic_id_val[
i] = current->pps_subpic_id_mapping_present_flag
1856 ? current->pps_subpic_id[
i]
1857 :
sps->sps_subpic_id[
i];
1859 current->sub_pic_id_val[
i] =
i;
1863 (current->pps_pic_width_in_luma_samples, (
sps->sps_log2_ctu_size_minus5 + 5));
1865 current->pps_pic_height_in_luma_samples,(
sps->sps_log2_ctu_size_minus5 + 5));
1866 if (!current->pps_no_pic_partition_flag) {
1867 unsigned int exp_tile_width = 0, exp_tile_height = 0;
1868 unsigned int unified_size, remaining_size;
1870 u(2, pps_log2_ctu_size_minus5,
1871 sps->sps_log2_ctu_size_minus5,
sps->sps_log2_ctu_size_minus5);
1872 ue(pps_num_exp_tile_columns_minus1,
1874 ue(pps_num_exp_tile_rows_minus1,
1877 for (
i = 0;
i <= current->pps_num_exp_tile_columns_minus1;
i++) {
1878 ues(pps_tile_column_width_minus1[
i],
1879 0, pic_width_in_ctbs_y - exp_tile_width - 1, 1,
i);
1880 exp_tile_width += current->pps_tile_column_width_minus1[
i] + 1;
1882 for (
i = 0;
i <= current->pps_num_exp_tile_rows_minus1;
i++) {
1883 ues(pps_tile_row_height_minus1[
i],
1884 0, pic_height_in_ctbs_y - exp_tile_height - 1, 1,
i);
1885 exp_tile_height += current->pps_tile_row_height_minus1[
i] + 1;
1888 remaining_size = pic_width_in_ctbs_y;
1889 for (
i = 0;
i <= current->pps_num_exp_tile_columns_minus1;
i++) {
1890 if (current->pps_tile_column_width_minus1[
i] >= remaining_size) {
1892 "Tile column width(%d) exceeds picture width\n",
i);
1895 current->col_width_val[
i] = current->pps_tile_column_width_minus1[
i] + 1;
1896 remaining_size -= (current->pps_tile_column_width_minus1[
i] + 1);
1898 unified_size = current->pps_tile_column_width_minus1[
i - 1] + 1;
1899 while (remaining_size > 0) {
1902 "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1906 unified_size =
FFMIN(remaining_size, unified_size);
1907 current->col_width_val[
i] = unified_size;
1908 remaining_size -= unified_size;
1911 current->num_tile_columns =
i;
1914 "NumTileColumns(%d) > than VVC_MAX_TILE_COLUMNS(%d)\n",
1919 remaining_size = pic_height_in_ctbs_y;
1920 for (
i = 0;
i <= current->pps_num_exp_tile_rows_minus1;
i++) {
1921 if (current->pps_tile_row_height_minus1[
i] >= remaining_size) {
1923 "Tile row height(%d) exceeds picture height\n",
i);
1926 current->row_height_val[
i] = current->pps_tile_row_height_minus1[
i] + 1;
1927 remaining_size -= (current->pps_tile_row_height_minus1[
i] + 1);
1929 unified_size = current->pps_tile_row_height_minus1[
i - 1] + 1;
1931 while (remaining_size > 0) {
1932 unified_size =
FFMIN(remaining_size, unified_size);
1933 current->row_height_val[
i] = unified_size;
1934 remaining_size -= unified_size;
1937 current->num_tile_rows=
i;
1940 "NumTileRows(%d) > than VVC_MAX_TILE_ROWS(%d)\n",
1945 current->num_tiles_in_pic = current->num_tile_columns *
1946 current->num_tile_rows;
1949 "NumTilesInPic(%d) > than VVC_MAX_TILES_PER_AU(%d)\n",
1954 if (current->num_tiles_in_pic > 1) {
1955 flag(pps_loop_filter_across_tiles_enabled_flag);
1956 flag(pps_rect_slice_flag);
1958 infer(pps_loop_filter_across_tiles_enabled_flag, 0);
1959 infer(pps_rect_slice_flag, 1);
1961 if (current->pps_rect_slice_flag)
1962 flag(pps_single_slice_per_subpic_flag);
1964 infer(pps_single_slice_per_subpic_flag, 1);
1965 if (current->pps_rect_slice_flag &&
1966 !current->pps_single_slice_per_subpic_flag) {
1967 int j, num_slices = 0;
1968 uint16_t tile_idx = 0, tile_x, tile_y, ctu_x, ctu_y;
1972 if (current->pps_num_slices_in_pic_minus1 > 1)
1973 flag(pps_tile_idx_delta_present_flag);
1975 infer(pps_tile_idx_delta_present_flag, 0);
1976 for (
i = 0;
i < current->pps_num_slices_in_pic_minus1;
i++) {
1977 current->slice_top_left_tile_idx[
i] = tile_idx;
1978 tile_x = tile_idx % current->num_tile_columns;
1979 tile_y = tile_idx / current->num_tile_columns;
1980 if (tile_x != current->num_tile_columns - 1) {
1981 ues(pps_slice_width_in_tiles_minus1[
i],
1982 0, current->num_tile_columns - 1, 1,
i);
1984 infer(pps_slice_width_in_tiles_minus1[
i], 0);
1986 if (tile_y != current->num_tile_rows - 1 &&
1987 (current->pps_tile_idx_delta_present_flag || tile_x == 0)) {
1988 ues(pps_slice_height_in_tiles_minus1[
i],
1989 0, current->num_tile_rows - 1, 1,
i);
1991 if (tile_y == current->num_tile_rows - 1)
1992 infer(pps_slice_height_in_tiles_minus1[
i], 0);
1994 infer(pps_slice_height_in_tiles_minus1[
i],
1995 current->pps_slice_height_in_tiles_minus1[
i - 1]);
1999 for (j = 0; j < tile_x; j++) {
2000 ctu_x += current->col_width_val[j];
2002 for (j = 0; j < tile_y; j++) {
2003 ctu_y += current->row_height_val[j];
2005 if (current->pps_slice_width_in_tiles_minus1[
i] == 0 &&
2006 current->pps_slice_height_in_tiles_minus1[
i] == 0 &&
2007 current->row_height_val[tile_y] > 1) {
2008 int uniform_slice_height, remaining_height_in_ctbs_y;
2009 remaining_height_in_ctbs_y =
2010 current->row_height_val[tile_y];
2011 ues(pps_num_exp_slices_in_tile[
i],
2012 0, current->row_height_val[tile_y] - 1, 1,
i);
2013 if (current->pps_num_exp_slices_in_tile[
i] == 0) {
2014 current->num_slices_in_tile[
i] = 1;
2015 current->slice_height_in_ctus[
i] = current->row_height_val[tile_y];
2016 slice_top_left_ctu_x[
i] = ctu_x;
2017 slice_top_left_ctu_y[
i] = ctu_y;
2019 uint16_t slice_height_in_ctus;
2020 for (j = 0; j < current->pps_num_exp_slices_in_tile[
i];
2022 ues(pps_exp_slice_height_in_ctus_minus1[
i][j], 0,
2023 current->row_height_val[tile_y] - 1, 2,
2025 slice_height_in_ctus =
2027 pps_exp_slice_height_in_ctus_minus1[
i][j] + 1;
2029 current->slice_height_in_ctus[
i + j] =
2030 slice_height_in_ctus;
2031 slice_top_left_ctu_x[
i + j] = ctu_x;
2032 slice_top_left_ctu_y[
i + j] = ctu_y;
2033 ctu_y += slice_height_in_ctus;
2035 remaining_height_in_ctbs_y -= slice_height_in_ctus;
2037 uniform_slice_height = 1 +
2038 (j == 0 ? current->row_height_val[tile_y] - 1:
2039 current->pps_exp_slice_height_in_ctus_minus1[
i][j-1]);
2040 while (remaining_height_in_ctbs_y > uniform_slice_height) {
2041 current->slice_height_in_ctus[
i + j] =
2042 uniform_slice_height;
2043 slice_top_left_ctu_x[
i + j] = ctu_x;
2044 slice_top_left_ctu_y[
i + j] = ctu_y;
2045 ctu_y += uniform_slice_height;
2047 remaining_height_in_ctbs_y -= uniform_slice_height;
2050 if (remaining_height_in_ctbs_y > 0) {
2051 current->slice_height_in_ctus[
i + j] =
2052 remaining_height_in_ctbs_y;
2053 slice_top_left_ctu_x[
i + j] = ctu_x;
2054 slice_top_left_ctu_y[
i + j] = ctu_y;
2057 current->num_slices_in_tile[
i] = j;
2059 for (
int k = 0; k < current->num_slices_in_tile[
i]; k++)
2060 current->slice_top_left_tile_idx[
i + k] = tile_idx;
2061 i += current->num_slices_in_tile[
i] - 1;
2064 infer(pps_num_exp_slices_in_tile[
i], 0);
2065 if (current->pps_slice_width_in_tiles_minus1[
i] == 0 &&
2066 current->pps_slice_height_in_tiles_minus1[
i] == 0)
2067 current->num_slices_in_tile[
i] = 1;
2070 j <= current->pps_slice_height_in_tiles_minus1[
i];
2073 current->row_height_val[tile_y + j];
2075 current->slice_height_in_ctus[
i] =
height;
2077 slice_top_left_ctu_x[
i] = ctu_x;
2078 slice_top_left_ctu_y[
i] = ctu_y;
2080 if (i < current->pps_num_slices_in_pic_minus1) {
2081 if (current->pps_tile_idx_delta_present_flag) {
2086 ses(pps_tile_idx_delta_val[
i],
2087 -tile_idx, current->num_tiles_in_pic - 1 - tile_idx, 1,
i);
2088 if (current->pps_tile_idx_delta_val[
i] == 0) {
2090 "pps_tile_idx_delta_val[i] shall not be equal to 0.\n");
2092 tile_idx += current->pps_tile_idx_delta_val[
i];
2094 infer(pps_tile_idx_delta_val[
i], 0);
2096 current->pps_slice_width_in_tiles_minus1[
i] + 1;
2097 if (tile_idx % current->num_tile_columns == 0) {
2099 current->pps_slice_height_in_tiles_minus1[
i] *
2100 current->num_tile_columns;
2105 if (
i == current->pps_num_slices_in_pic_minus1) {
2108 current->slice_top_left_tile_idx[
i] = tile_idx;
2109 current->num_slices_in_tile[
i] = 1;
2110 tile_x = tile_idx % current->num_tile_columns;
2111 tile_y = tile_idx / current->num_tile_columns;
2112 if (tile_y >= current->num_tile_rows)
2115 ctu_x = 0, ctu_y = 0;
2116 for (j = 0; j < tile_x; j++) {
2117 ctu_x += current->col_width_val[j];
2119 for (j = 0; j < tile_y; j++) {
2120 ctu_y += current->row_height_val[j];
2122 slice_top_left_ctu_x[
i] = ctu_x;
2123 slice_top_left_ctu_y[
i] = ctu_y;
2125 current->pps_slice_width_in_tiles_minus1[
i] =
2126 current->num_tile_columns - tile_x - 1;
2127 current->pps_slice_height_in_tiles_minus1[
i] =
2128 current->num_tile_rows - tile_y - 1;
2130 for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[
i];
2133 current->row_height_val[tile_y + j];
2135 current->slice_height_in_ctus[
i] =
height;
2137 infer(pps_num_exp_slices_in_tile[
i], 0);
2140 for (
i = 0;
i <=
sps->sps_num_subpics_minus1;
i++) {
2141 current->num_slices_in_subpic[
i] = 0;
2142 for (j = 0; j <= current->pps_num_slices_in_pic_minus1; j++) {
2143 uint16_t pos_x = 0, pos_y = 0;
2144 pos_x = slice_top_left_ctu_x[j];
2145 pos_y = slice_top_left_ctu_y[j];
2146 if ((pos_x >=
sps->sps_subpic_ctu_top_left_x[
i]) &&
2148 sps->sps_subpic_ctu_top_left_x[
i] +
2149 sps->sps_subpic_width_minus1[
i] + 1) &&
2150 (pos_y >=
sps->sps_subpic_ctu_top_left_y[
i]) &&
2151 (pos_y < sps->sps_subpic_ctu_top_left_y[
i] +
2152 sps->sps_subpic_height_minus1[
i] + 1)) {
2153 current->num_slices_in_subpic[
i]++;
2156 num_slices += current->num_slices_in_subpic[
i];
2158 if (current->pps_num_slices_in_pic_minus1 + 1 != num_slices)
2161 if (current->pps_no_pic_partition_flag)
2162 infer(pps_num_slices_in_pic_minus1, 0);
2163 else if (current->pps_single_slice_per_subpic_flag) {
2164 for (
i = 0;
i <=
sps->sps_num_subpics_minus1;
i++)
2165 current->num_slices_in_subpic[
i] = 1;
2166 infer(pps_num_slices_in_pic_minus1,
2167 sps->sps_num_subpics_minus1);
2171 if (!current->pps_rect_slice_flag ||
2172 current->pps_single_slice_per_subpic_flag ||
2173 current->pps_num_slices_in_pic_minus1 > 0)
2174 flag(pps_loop_filter_across_slices_enabled_flag);
2176 infer(pps_loop_filter_across_slices_enabled_flag, 0);
2178 infer(pps_num_exp_tile_columns_minus1, 0);
2179 infer(pps_tile_column_width_minus1[0], pic_width_in_ctbs_y - 1);
2180 infer(pps_num_exp_tile_rows_minus1, 0);
2181 infer(pps_tile_row_height_minus1[0], pic_height_in_ctbs_y - 1);
2182 current->col_width_val[0] = pic_width_in_ctbs_y;
2183 current->row_height_val[0] = pic_height_in_ctbs_y;
2184 current->num_tile_columns = 1;
2185 current->num_tile_rows = 1;
2186 current->num_tiles_in_pic = 1;
2189 flag(pps_cabac_init_present_flag);
2190 for (
i = 0;
i < 2;
i++)
2191 ues(pps_num_ref_idx_default_active_minus1[
i], 0, 14, 1,
i);
2192 flag(pps_rpl1_idx_present_flag);
2193 flag(pps_weighted_pred_flag);
2194 flag(pps_weighted_bipred_flag);
2195 flag(pps_ref_wraparound_enabled_flag);
2196 if (current->pps_ref_wraparound_enabled_flag) {
2197 ue(pps_pic_width_minus_wraparound_offset,
2198 0, (current->pps_pic_width_in_luma_samples / min_cb_size_y)
2199 - (ctb_size_y / min_cb_size_y) - 2);
2202 qp_bd_offset = 6 *
sps->sps_bitdepth_minus8;
2203 se(pps_init_qp_minus26, -(26 + qp_bd_offset), 37);
2204 flag(pps_cu_qp_delta_enabled_flag);
2205 flag(pps_chroma_tool_offsets_present_flag);
2206 if (current->pps_chroma_tool_offsets_present_flag) {
2207 se(pps_cb_qp_offset, -12, 12);
2208 se(pps_cr_qp_offset, -12, 12);
2209 flag(pps_joint_cbcr_qp_offset_present_flag);
2210 if (current->pps_joint_cbcr_qp_offset_present_flag)
2211 se(pps_joint_cbcr_qp_offset_value, -12, 12);
2213 infer(pps_joint_cbcr_qp_offset_value, 0);
2214 flag(pps_slice_chroma_qp_offsets_present_flag);
2215 flag(pps_cu_chroma_qp_offset_list_enabled_flag);
2216 if (current->pps_cu_chroma_qp_offset_list_enabled_flag) {
2217 ue(pps_chroma_qp_offset_list_len_minus1, 0, 5);
2218 for (
i = 0;
i <= current->pps_chroma_qp_offset_list_len_minus1;
i++) {
2219 ses(pps_cb_qp_offset_list[
i], -12, 12, 1,
i);
2220 ses(pps_cr_qp_offset_list[
i], -12, 12, 1,
i);
2221 if (current->pps_joint_cbcr_qp_offset_present_flag)
2222 ses(pps_joint_cbcr_qp_offset_list[
i], -12, 12, 1,
i);
2224 infer(pps_joint_cbcr_qp_offset_list[
i], 0);
2228 infer(pps_cb_qp_offset, 0);
2229 infer(pps_cr_qp_offset, 0);
2230 infer(pps_joint_cbcr_qp_offset_present_flag, 0);
2231 infer(pps_joint_cbcr_qp_offset_value, 0);
2232 infer(pps_slice_chroma_qp_offsets_present_flag, 0);
2233 infer(pps_cu_chroma_qp_offset_list_enabled_flag, 0);
2235 flag(pps_deblocking_filter_control_present_flag);
2236 if (current->pps_deblocking_filter_control_present_flag) {
2237 flag(pps_deblocking_filter_override_enabled_flag);
2238 flag(pps_deblocking_filter_disabled_flag);
2239 if (!current->pps_no_pic_partition_flag &&
2240 current->pps_deblocking_filter_override_enabled_flag)
2241 flag(pps_dbf_info_in_ph_flag);
2243 infer(pps_dbf_info_in_ph_flag, 0);
2244 if (!current->pps_deblocking_filter_disabled_flag) {
2245 se(pps_luma_beta_offset_div2, -12, 12);
2246 se(pps_luma_tc_offset_div2, -12, 12);
2247 if (current->pps_chroma_tool_offsets_present_flag) {
2248 se(pps_cb_beta_offset_div2, -12, 12);
2249 se(pps_cb_tc_offset_div2, -12, 12);
2250 se(pps_cr_beta_offset_div2, -12, 12);
2251 se(pps_cr_tc_offset_div2, -12, 12);
2253 infer(pps_cb_beta_offset_div2,
2254 current->pps_luma_beta_offset_div2);
2255 infer(pps_cb_tc_offset_div2, current->pps_luma_tc_offset_div2);
2256 infer(pps_cr_beta_offset_div2,
2257 current->pps_luma_beta_offset_div2);
2258 infer(pps_cr_tc_offset_div2, current->pps_luma_tc_offset_div2);
2261 infer(pps_luma_beta_offset_div2, 0);
2262 infer(pps_luma_tc_offset_div2, 0);
2263 infer(pps_cb_beta_offset_div2, 0);
2264 infer(pps_cb_tc_offset_div2, 0);
2265 infer(pps_cr_beta_offset_div2, 0);
2266 infer(pps_cr_tc_offset_div2, 0);
2269 infer(pps_deblocking_filter_override_enabled_flag, 0);
2270 infer(pps_deblocking_filter_disabled_flag, 0);
2271 infer(pps_dbf_info_in_ph_flag, 0);
2272 infer(pps_luma_beta_offset_div2, 0);
2273 infer(pps_luma_tc_offset_div2, 0);
2274 infer(pps_cb_beta_offset_div2, 0);
2275 infer(pps_cb_tc_offset_div2, 0);
2276 infer(pps_cr_beta_offset_div2, 0);
2277 infer(pps_cr_tc_offset_div2, 0);
2280 if (!current->pps_no_pic_partition_flag) {
2281 flag(pps_rpl_info_in_ph_flag);
2282 flag(pps_sao_info_in_ph_flag);
2283 flag(pps_alf_info_in_ph_flag);
2284 if ((current->pps_weighted_pred_flag ||
2285 current->pps_weighted_bipred_flag) &&
2286 current->pps_rpl_info_in_ph_flag)
2287 flag(pps_wp_info_in_ph_flag);
2288 flag(pps_qp_delta_info_in_ph_flag);
2290 flag(pps_picture_header_extension_present_flag);
2291 flag(pps_slice_header_extension_present_flag);
2293 flag(pps_extension_flag);
2294 if (current->pps_extension_flag)
2306 flag(alf_luma_filter_signal_flag);
2308 if (current->aps_chroma_present_flag) {
2309 flag(alf_chroma_filter_signal_flag);
2310 flag(alf_cc_cb_filter_signal_flag);
2311 flag(alf_cc_cr_filter_signal_flag);
2313 infer(alf_chroma_filter_signal_flag, 0);
2314 infer(alf_cc_cb_filter_signal_flag, 0);
2315 infer(alf_cc_cr_filter_signal_flag, 0);
2318 if (current->alf_luma_filter_signal_flag) {
2319 flag(alf_luma_clip_flag);
2321 if (current->alf_luma_num_filters_signalled_minus1 > 0) {
2322 unsigned int bits =
av_ceil_log2(current->alf_luma_num_filters_signalled_minus1 + 1);
2324 us(
bits, alf_luma_coeff_delta_idx[filt_idx],
2325 0, current->alf_luma_num_filters_signalled_minus1,
2328 for (
int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++)
2329 for (j = 0; j < 12; j++) {
2330 ues(alf_luma_coeff_abs[sf_idx][j], 0, 128, 2, sf_idx, j);
2331 if (current->alf_luma_coeff_abs[sf_idx][j])
2332 ubs(1, alf_luma_coeff_sign[sf_idx][j], 2, sf_idx, j);
2334 infer(alf_luma_coeff_sign[sf_idx][j], 0);
2337 infer(alf_luma_clip_flag, 0);
2338 infer(alf_luma_num_filters_signalled_minus1, 0);
2340 for (
int sf_idx = 0; sf_idx <= current->alf_luma_num_filters_signalled_minus1; sf_idx++) {
2341 for (j = 0; j < 12; j++) {
2342 if (current->alf_luma_clip_flag)
2343 ubs(2, alf_luma_clip_idx[sf_idx][j], 2, sf_idx, j);
2345 infer(alf_luma_clip_idx[sf_idx][j], 0);
2349 if (current->alf_chroma_filter_signal_flag) {
2350 flag(alf_chroma_clip_flag);
2351 ue(alf_chroma_num_alt_filters_minus1, 0, 7);
2353 infer(alf_chroma_clip_flag, 0);
2354 infer(alf_chroma_num_alt_filters_minus1, 0);
2356 for (
int alt_idx = 0; alt_idx <= current->alf_chroma_num_alt_filters_minus1; alt_idx++) {
2357 for (j = 0; j < 6; j++) {
2358 if (current->alf_chroma_filter_signal_flag)
2359 ues(alf_chroma_coeff_abs[alt_idx][j], 0, 128, 2, alt_idx, j);
2361 infer(alf_chroma_coeff_abs[alt_idx][j], 0);
2362 if (current->alf_chroma_coeff_abs[alt_idx][j] > 0)
2363 ubs(1, alf_chroma_coeff_sign[alt_idx][j], 2, alt_idx, j);
2365 infer(alf_chroma_coeff_sign[alt_idx][j], 0);
2367 for (j = 0; j < 6; j++) {
2368 if (current->alf_chroma_clip_flag)
2369 ubs(2, alf_chroma_clip_idx[alt_idx][j], 2, alt_idx, j);
2371 infer(alf_chroma_clip_idx[alt_idx][j], 0);
2375 if (current->alf_cc_cb_filter_signal_flag)
2376 ue(alf_cc_cb_filters_signalled_minus1, 0, 3);
2378 infer(alf_cc_cb_filters_signalled_minus1, 0);
2379 for (k = 0; k <= current->alf_cc_cb_filters_signalled_minus1; k++) {
2380 for (j = 0; j < 7; j++) {
2381 if (current->alf_cc_cb_filter_signal_flag)
2382 ubs(3, alf_cc_cb_mapped_coeff_abs[k][j], 2, k, j);
2384 infer(alf_cc_cb_mapped_coeff_abs[k][j], 0);
2385 if (current->alf_cc_cb_mapped_coeff_abs[k][j])
2386 ubs(1, alf_cc_cb_coeff_sign[k][j], 2, k, j);
2388 infer(alf_cc_cb_coeff_sign[k][j], 0);
2392 if (current->alf_cc_cr_filter_signal_flag)
2393 ue(alf_cc_cr_filters_signalled_minus1, 0, 3);
2395 infer(alf_cc_cr_filters_signalled_minus1, 0);
2396 for (k = 0; k < current->alf_cc_cr_filters_signalled_minus1 + 1; k++) {
2397 for (j = 0; j < 7; j++) {
2398 if (current->alf_cc_cr_filter_signal_flag)
2399 ubs(3, alf_cc_cr_mapped_coeff_abs[k][j], 2, k, j);
2401 infer(alf_cc_cr_mapped_coeff_abs[k][j], 0);
2402 if (current->alf_cc_cr_mapped_coeff_abs[k][j])
2403 ubs(1, alf_cc_cr_coeff_sign[k][j], 2, k, j);
2405 infer(alf_cc_cr_coeff_sign[k][j], 0);
2415 int err,
i, lmcs_max_bin_idx;
2417 ue(lmcs_min_bin_idx, 0, 15);
2418 ue(lmcs_delta_max_bin_idx, 0, 15);
2419 ue(lmcs_delta_cw_prec_minus1, 0, 14);
2421 lmcs_max_bin_idx = 15 - current->lmcs_delta_max_bin_idx;
2423 if (lmcs_max_bin_idx < current->lmcs_min_bin_idx)
2426 for (
i = current->lmcs_min_bin_idx;
i <= lmcs_max_bin_idx;
i++) {
2427 ubs(current->lmcs_delta_cw_prec_minus1 + 1, lmcs_delta_abs_cw[
i], 1,
i);
2428 if (current->lmcs_delta_abs_cw[
i] > 0)
2429 flags(lmcs_delta_sign_cw_flag[
i], 1,
i);
2431 infer(lmcs_delta_sign_cw_flag[
i], 0);
2434 if (current->aps_chroma_present_flag) {
2435 ub(3, lmcs_delta_abs_crs);
2436 if (current->lmcs_delta_abs_crs > 0)
2437 flag(lmcs_delta_sign_crs_flag);
2439 infer(lmcs_delta_sign_crs_flag, 0);
2441 infer(lmcs_delta_abs_crs, 0);
2442 infer(lmcs_delta_sign_crs_flag, 0);
2452 static const uint8_t diag_scan_order[64][2] = {
2453 { 0, 0, }, { 0, 1, }, { 1, 0, }, { 0, 2, }, { 1, 1, }, { 2, 0, }, { 0, 3, }, { 1, 2, },
2454 { 2, 1, }, { 3, 0, }, { 0, 4, }, { 1, 3, }, { 2, 2, }, { 3, 1, }, { 4, 0, }, { 0, 5, },
2455 { 1, 4, }, { 2, 3, }, { 3, 2, }, { 4, 1, }, { 5, 0, }, { 0, 6, }, { 1, 5, }, { 2, 4, },
2456 { 3, 3, }, { 4, 2, }, { 5, 1, }, { 6, 0, }, { 0, 7, }, { 1, 6, }, { 2, 5, }, { 3, 4, },
2457 { 4, 3, }, { 5, 2, }, { 6, 1, }, { 7, 0, }, { 1, 7, }, { 2, 6, }, { 3, 5, }, { 4, 4, },
2458 { 5, 3, }, { 6, 2, }, { 7, 1, }, { 2, 7, }, { 3, 6, }, { 4, 5, }, { 5, 4, }, { 6, 3, },
2459 { 7, 2, }, { 3, 7, }, { 4, 6, }, { 5, 5, }, { 6, 4, }, { 7, 3, }, { 4, 7, }, { 5, 6, },
2460 { 6, 5, }, { 7, 4, }, { 5, 7, }, { 6, 6, }, { 7, 5, }, { 6, 7, }, { 7, 6, }, { 7, 7, }, };
2463 for (
int id = 0;
id < 28;
id ++) {
2464 if (current->aps_chroma_present_flag ||
id % 3 == 2 ||
id == 27) {
2465 flags(scaling_list_copy_mode_flag[
id], 1,
id);
2466 if (!current->scaling_list_copy_mode_flag[
id])
2467 flags(scaling_list_pred_mode_flag[
id], 1,
id);
2469 infer(scaling_list_pred_mode_flag[
id], 0);
2470 if ((current->scaling_list_copy_mode_flag[
id] ||
2471 current->scaling_list_pred_mode_flag[
id]) &&
2472 id != 0 &&
id != 2 &&
id != 8) {
2473 int max_id_delta = (
id < 2) ?
id : ((
id < 8) ? (
id - 2) : (
id - 8));
2474 ues(scaling_list_pred_id_delta[
id], 0, max_id_delta, 1,
id);
2476 if (!current->scaling_list_copy_mode_flag[
id]) {
2477 int matrix_size =
id < 2 ? 2 : (
id < 8 ? 4 : 8);
2480 ses(scaling_list_dc_coef[idx], -128, 127, 1, idx);
2482 for (
int i = 0;
i < matrix_size * matrix_size;
i++) {
2483 int x = diag_scan_order[
i][0];
2484 int y = diag_scan_order[
i][1];
2485 if (!(
id > 25 && x >= 4 && y >= 4))
2486 ses(scaling_list_delta_coef[
id][
i], -128, 127, 2,
id,
i);
2488 }
else if (
id > 13) {
2490 infer(scaling_list_dc_coef[idx], 0);
2493 infer(scaling_list_copy_mode_flag[
id], 1);
2494 infer(scaling_list_pred_mode_flag[
id], 0);
2508 HEADER(
"Prefix Adaptation parameter set");
2510 HEADER(
"Suffix Adaptation parameter set");
2516 ub(3, aps_params_type);
2522 u(5, aps_adaptation_parameter_set_id, 0, aps_id_max);
2523 flag(aps_chroma_present_flag);
2530 flag(aps_extension_flag);
2531 if (current->aps_extension_flag)
2543 HEADER(
"Access Unit Delimiter");
2548 flag(aud_irap_or_gdr_flag);
2549 u(3, aud_pic_type, 0, 2);
2559 uint8_t num_ref_idx_active[2],
2563 ue(luma_log2_weight_denom, 0, 7);
2564 if (
sps->sps_chroma_format_idc != 0) {
2565 se(delta_chroma_log2_weight_denom,
2566 -current->luma_log2_weight_denom,
2567 7 - current->luma_log2_weight_denom);
2569 infer(delta_chroma_log2_weight_denom, 0);
2571 if (
pps->pps_wp_info_in_ph_flag) {
2572 ue(num_l0_weights, 0,
2573 FFMIN(15, ref_lists->rpl_ref_list[0].num_ref_entries));
2574 infer(num_weights_l0, current->num_l0_weights);
2576 infer(num_weights_l0, num_ref_idx_active[0]);
2578 for (
i = 0;
i < current->num_weights_l0;
i++) {
2579 flags(luma_weight_l0_flag[
i], 1,
i);
2581 if (
sps->sps_chroma_format_idc != 0) {
2582 for (
i = 0;
i < current->num_weights_l0;
i++)
2583 flags(chroma_weight_l0_flag[
i], 1,
i);
2585 for (
i = 0;
i < current->num_weights_l0;
i++) {
2586 if (current->luma_weight_l0_flag[
i]) {
2587 ses(delta_luma_weight_l0[
i], -128, 127, 1,
i);
2588 ses(luma_offset_l0[
i], -128, 127, 1,
i);
2590 infer(delta_luma_weight_l0[
i], 0);
2591 infer(luma_offset_l0[
i], 0);
2593 if (current->chroma_weight_l0_flag[
i]) {
2594 for (j = 0; j < 2; j++) {
2595 ses(delta_chroma_weight_l0[
i][j], -128, 127, 2,
i, j);
2596 ses(delta_chroma_offset_l0[
i][j], -4 * 128, 4 * 127, 2,
i, j);
2601 if (
pps->pps_weighted_bipred_flag &&
2602 ref_lists->rpl_ref_list[1].num_ref_entries > 0) {
2603 if (
pps->pps_wp_info_in_ph_flag) {
2604 ue(num_l1_weights, 0,
2605 FFMIN(15, ref_lists->rpl_ref_list[1].num_ref_entries));
2606 infer(num_weights_l1, current->num_l1_weights);
2608 infer(num_weights_l1, num_ref_idx_active[1]);
2611 infer(num_weights_l1, 0);
2614 for (
i = 0;
i < current->num_weights_l1;
i++)
2615 flags(luma_weight_l1_flag[
i], 1,
i);
2616 if (
sps->sps_chroma_format_idc != 0) {
2617 for (
i = 0;
i < current->num_weights_l1;
i++)
2618 flags(chroma_weight_l1_flag[
i], 1,
i);
2620 for (
i = 0;
i < current->num_weights_l1;
i++) {
2621 if (current->luma_weight_l1_flag[
i]) {
2622 ses(delta_luma_weight_l1[
i], -128, 127, 1,
i);
2623 ses(luma_offset_l1[
i], -128, 127, 1,
i);
2625 infer(delta_luma_weight_l1[
i], 0);
2626 infer(luma_offset_l1[
i], 0);
2628 if (current->chroma_weight_l1_flag[
i]) {
2629 for (j = 0; j < 2; j++) {
2630 ses(delta_chroma_weight_l1[
i][j], -128, 127, 2,
i, j);
2631 ses(delta_chroma_offset_l1[
i][j], -4 * 128, 4 * 127, 2,
i, j);
2645 unsigned int ctb_log2_size_y, min_cb_log2_size_y,
2646 min_qt_log2_size_intra_y, min_qt_log2_size_inter_y;
2647 uint8_t qp_bd_offset;
2649 flag(ph_gdr_or_irap_pic_flag);
2650 flag(ph_non_ref_pic_flag);
2651 if (current->ph_gdr_or_irap_pic_flag)
2652 flag(ph_gdr_pic_flag);
2654 infer(ph_gdr_pic_flag, 0);
2655 flag(ph_inter_slice_allowed_flag);
2656 if (current->ph_inter_slice_allowed_flag)
2657 flag(ph_intra_slice_allowed_flag);
2659 infer(ph_intra_slice_allowed_flag, 1);
2661 pps = h266->
pps[current->ph_pic_parameter_set_id];
2664 current->ph_pic_parameter_set_id);
2667 sps = h266->
sps[
pps->pps_seq_parameter_set_id];
2670 pps->pps_seq_parameter_set_id);
2673 vps = h266->
vps[
sps->sps_video_parameter_set_id];
2676 sps->sps_video_parameter_set_id);
2680 ub(
sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_pic_order_cnt_lsb);
2681 if (current->ph_gdr_pic_flag)
2682 ue(ph_recovery_poc_cnt, 0,
2683 1 << (
sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4));
2685 for (
i = 0;
i <
sps->sps_num_extra_ph_bytes * 8;
i++) {
2686 if (
sps->sps_extra_ph_bit_present_flag[
i])
2689 if (
sps->sps_poc_msb_cycle_flag) {
2690 flag(ph_poc_msb_cycle_present_flag);
2691 if (current->ph_poc_msb_cycle_present_flag)
2692 ub(
sps->sps_poc_msb_cycle_len_minus1 + 1, ph_poc_msb_cycle_val);
2694 if (
sps->sps_alf_enabled_flag &&
pps->pps_alf_info_in_ph_flag) {
2695 flag(ph_alf_enabled_flag);
2696 if (current->ph_alf_enabled_flag) {
2698 ub(3, ph_num_alf_aps_ids_luma);
2699 for (
i = 0;
i < current->ph_num_alf_aps_ids_luma;
i++)
2700 ubs(3, ph_alf_aps_id_luma[
i], 1,
i);
2702 if (
sps->sps_chroma_format_idc != 0) {
2703 flag(ph_alf_cb_enabled_flag);
2704 flag(ph_alf_cr_enabled_flag);
2706 infer(ph_alf_cb_enabled_flag, 0);
2707 infer(ph_alf_cr_enabled_flag, 0);
2710 if (current->ph_alf_cb_enabled_flag
2711 || current->ph_alf_cr_enabled_flag) {
2712 ub(3, ph_alf_aps_id_chroma);
2715 if (
sps->sps_ccalf_enabled_flag) {
2716 flag(ph_alf_cc_cb_enabled_flag);
2717 if (current->ph_alf_cc_cb_enabled_flag)
2718 ub(3, ph_alf_cc_cb_aps_id);
2719 flag(ph_alf_cc_cr_enabled_flag);
2720 if (current->ph_alf_cc_cr_enabled_flag)
2721 ub(3, ph_alf_cc_cr_aps_id);
2725 infer(ph_alf_enabled_flag, 0);
2727 if (
sps->sps_lmcs_enabled_flag) {
2728 flag(ph_lmcs_enabled_flag);
2729 if (current->ph_lmcs_enabled_flag) {
2730 ub(2, ph_lmcs_aps_id);
2731 if (
sps->sps_chroma_format_idc != 0)
2732 flag(ph_chroma_residual_scale_flag);
2734 infer(ph_chroma_residual_scale_flag, 0);
2737 infer(ph_lmcs_enabled_flag, 0);
2738 infer(ph_chroma_residual_scale_flag, 0);
2741 if (
sps->sps_explicit_scaling_list_enabled_flag) {
2742 flag(ph_explicit_scaling_list_enabled_flag);
2743 if (current->ph_explicit_scaling_list_enabled_flag) {
2745 ub(3, ph_scaling_list_aps_id);
2748 infer(ph_explicit_scaling_list_enabled_flag, 0);
2750 if (
sps->sps_virtual_boundaries_enabled_flag &&
2751 !
sps->sps_virtual_boundaries_present_flag) {
2752 flag(ph_virtual_boundaries_present_flag);
2753 if (current->ph_virtual_boundaries_present_flag) {
2754 ue(ph_num_ver_virtual_boundaries,
2756 for (
i = 0;
i < current->ph_num_ver_virtual_boundaries;
i++) {
2757 ues(ph_virtual_boundary_pos_x_minus1[
i],
2758 0, (
pps->pps_pic_width_in_luma_samples + 7) / 8 - 2, 1,
i);
2760 ue(ph_num_hor_virtual_boundaries,
2762 for (
i = 0;
i < current->ph_num_hor_virtual_boundaries;
i++) {
2763 ues(ph_virtual_boundary_pos_y_minus1[
i],
2764 0, (
pps->pps_pic_height_in_luma_samples + 7) / 8 - 2, 1,
i);
2767 infer(ph_num_ver_virtual_boundaries, 0);
2768 infer(ph_num_hor_virtual_boundaries, 0);
2771 if (
pps->pps_output_flag_present_flag && !current->ph_non_ref_pic_flag)
2772 flag(ph_pic_output_flag);
2774 infer(ph_pic_output_flag, 1);
2775 if (
pps->pps_rpl_info_in_ph_flag) {
2777 (
ctx, rw,
sps,
pps, ¤t->ph_ref_pic_lists));
2779 if (
sps->sps_partition_constraints_override_enabled_flag)
2780 flag(ph_partition_constraints_override_flag);
2782 infer(ph_partition_constraints_override_flag, 0);
2784 ctb_log2_size_y =
sps->sps_log2_ctu_size_minus5 + 5;
2785 min_cb_log2_size_y =
sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
2786 if (current->ph_intra_slice_allowed_flag) {
2787 if (current->ph_partition_constraints_override_flag) {
2788 ue(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2789 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2790 ue(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2791 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2792 if (current->ph_max_mtt_hierarchy_depth_intra_slice_luma != 0) {
2793 min_qt_log2_size_intra_y =
2794 current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2796 ue(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2797 0, (
sps->sps_qtbtt_dual_tree_intra_flag ?
2798 FFMIN(6, ctb_log2_size_y) :
2799 ctb_log2_size_y) - min_qt_log2_size_intra_y);
2800 ue(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2801 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y);
2803 infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2804 sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2805 infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2806 sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2808 if (
sps->sps_qtbtt_dual_tree_intra_flag) {
2809 ue(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2810 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2811 ue(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2812 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2813 if (
sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0) {
2814 unsigned int min_qt_log2_size_intra_c =
2815 current->ph_log2_diff_min_qt_min_cb_intra_slice_chroma +
2817 ue(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2818 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2819 ue(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2820 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c);
2822 infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2823 sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2824 infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2825 sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2829 infer(ph_log2_diff_min_qt_min_cb_intra_slice_luma,
2830 sps->sps_log2_diff_min_qt_min_cb_intra_slice_luma);
2831 infer(ph_max_mtt_hierarchy_depth_intra_slice_luma,
2832 sps->sps_max_mtt_hierarchy_depth_intra_slice_luma);
2833 infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma,
2834 sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma);
2835 infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma,
2836 sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma);
2837 infer(ph_log2_diff_min_qt_min_cb_intra_slice_chroma,
2838 sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma);
2839 infer(ph_max_mtt_hierarchy_depth_intra_slice_chroma,
2840 sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma);
2841 infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma,
2842 sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma);
2843 infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma,
2844 sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma);
2847 min_qt_log2_size_intra_y =
2848 current->ph_log2_diff_min_qt_min_cb_intra_slice_luma +
2850 if (
pps->pps_cu_qp_delta_enabled_flag)
2851 ue(ph_cu_qp_delta_subdiv_intra_slice, 0,
2852 2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2853 current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2855 infer(ph_cu_qp_delta_subdiv_intra_slice, 0);
2857 if (
pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2858 ue(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0,
2859 2 * (ctb_log2_size_y - min_qt_log2_size_intra_y +
2860 current->ph_max_mtt_hierarchy_depth_intra_slice_luma));
2862 infer(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0);
2864 if (current->ph_inter_slice_allowed_flag) {
2865 if (current->ph_partition_constraints_override_flag) {
2866 ue(ph_log2_diff_min_qt_min_cb_inter_slice,
2867 0,
FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y);
2868 min_qt_log2_size_inter_y =
2869 current->ph_log2_diff_min_qt_min_cb_inter_slice +
2871 ue(ph_max_mtt_hierarchy_depth_inter_slice, 0,
2872 2 * (ctb_log2_size_y - min_cb_log2_size_y));
2873 if (current->ph_max_mtt_hierarchy_depth_inter_slice != 0) {
2874 ue(ph_log2_diff_max_bt_min_qt_inter_slice,
2875 0, ctb_log2_size_y - min_qt_log2_size_inter_y);
2876 ue(ph_log2_diff_max_tt_min_qt_inter_slice,
2877 0,
FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y);
2880 infer(ph_log2_diff_min_qt_min_cb_inter_slice,
2881 sps->sps_log2_diff_min_qt_min_cb_inter_slice);
2882 min_qt_log2_size_inter_y =
2883 current->ph_log2_diff_min_qt_min_cb_inter_slice +
2885 infer(ph_max_mtt_hierarchy_depth_inter_slice,
2886 sps->sps_max_mtt_hierarchy_depth_inter_slice);
2887 infer(ph_log2_diff_max_bt_min_qt_inter_slice,
2888 sps->sps_log2_diff_max_bt_min_qt_inter_slice);
2889 infer(ph_log2_diff_max_tt_min_qt_inter_slice,
2890 sps->sps_log2_diff_max_tt_min_qt_inter_slice);
2893 if (
pps->pps_cu_qp_delta_enabled_flag)
2894 ue(ph_cu_qp_delta_subdiv_inter_slice, 0,
2895 2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2896 current->ph_max_mtt_hierarchy_depth_inter_slice));
2898 infer(ph_cu_qp_delta_subdiv_inter_slice, 0);
2900 if (
pps->pps_cu_chroma_qp_offset_list_enabled_flag)
2901 ue(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0,
2902 2 * (ctb_log2_size_y - min_qt_log2_size_inter_y +
2903 current->ph_max_mtt_hierarchy_depth_inter_slice));
2905 infer(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0);
2906 if (
sps->sps_temporal_mvp_enabled_flag) {
2907 flag(ph_temporal_mvp_enabled_flag);
2908 if (current->ph_temporal_mvp_enabled_flag &&
2909 pps->pps_rpl_info_in_ph_flag) {
2910 if (current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0)
2911 flag(ph_collocated_from_l0_flag);
2913 infer(ph_collocated_from_l0_flag, 1);
2914 if ((current->ph_collocated_from_l0_flag &&
2915 current->ph_ref_pic_lists.rpl_ref_list[0].num_ref_entries > 1)
2916 || (!current->ph_collocated_from_l0_flag &&
2917 current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 1)) {
2919 current->ph_collocated_from_l0_flag ? 0 : 1;
2920 ue(ph_collocated_ref_idx, 0,
2921 current->ph_ref_pic_lists.rpl_ref_list[idx].
2922 num_ref_entries - 1);
2924 infer(ph_collocated_ref_idx, 0);
2928 if (
sps->sps_mmvd_fullpel_only_enabled_flag)
2929 flag(ph_mmvd_fullpel_only_flag);
2931 infer(ph_mmvd_fullpel_only_flag, 0);
2932 if (!
pps->pps_rpl_info_in_ph_flag ||
2933 current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) {
2934 flag(ph_mvd_l1_zero_flag);
2935 if (
sps->sps_bdof_control_present_in_ph_flag) {
2936 flag(ph_bdof_disabled_flag);
2938 if (!
sps->sps_bdof_control_present_in_ph_flag)
2939 infer(ph_bdof_disabled_flag,
2940 1 -
sps->sps_bdof_enabled_flag);
2942 infer(ph_bdof_disabled_flag, 1);
2944 if (
sps->sps_dmvr_control_present_in_ph_flag) {
2945 flag(ph_dmvr_disabled_flag);
2947 if (!
sps->sps_dmvr_control_present_in_ph_flag)
2948 infer(ph_dmvr_disabled_flag,
2949 1 -
sps->sps_dmvr_enabled_flag);
2951 infer(ph_dmvr_disabled_flag, 1);
2954 infer(ph_mvd_l1_zero_flag, 1);
2956 if (
sps->sps_prof_control_present_in_ph_flag)
2957 flag(ph_prof_disabled_flag);
2959 infer(ph_prof_disabled_flag, !
sps->sps_affine_prof_enabled_flag);
2960 if ((
pps->pps_weighted_pred_flag ||
2961 pps->pps_weighted_bipred_flag) &&
pps->pps_wp_info_in_ph_flag) {
2965 uint8_t num_ref_idx_active[2] = { 0, 0 };
2967 (
ctx, rw,
sps,
pps, ¤t->ph_ref_pic_lists,
2968 num_ref_idx_active, ¤t->ph_pred_weight_table));
2972 qp_bd_offset = 6 *
sps->sps_bitdepth_minus8;
2973 if (
pps->pps_qp_delta_info_in_ph_flag)
2974 se(ph_qp_delta, -qp_bd_offset - (26 +
pps->pps_init_qp_minus26),
2975 63 - (26 +
pps->pps_init_qp_minus26));
2977 if (
sps->sps_joint_cbcr_enabled_flag)
2978 flag(ph_joint_cbcr_sign_flag);
2980 infer(ph_joint_cbcr_sign_flag, 0);
2981 if (
sps->sps_sao_enabled_flag &&
pps->pps_sao_info_in_ph_flag) {
2982 flag(ph_sao_luma_enabled_flag);
2983 if (
sps->sps_chroma_format_idc != 0)
2984 flag(ph_sao_chroma_enabled_flag);
2986 infer(ph_sao_chroma_enabled_flag, 0);
2988 infer(ph_sao_luma_enabled_flag, 0);
2989 infer(ph_sao_chroma_enabled_flag, 0);
2992 if (
pps->pps_dbf_info_in_ph_flag)
2993 flag(ph_deblocking_params_present_flag);
2995 infer(ph_deblocking_params_present_flag, 0);
2997 if (current->ph_deblocking_params_present_flag) {
2998 if (!
pps->pps_deblocking_filter_disabled_flag) {
2999 flag(ph_deblocking_filter_disabled_flag);
3000 if (!current->ph_deblocking_filter_disabled_flag) {
3001 se(ph_luma_beta_offset_div2, -12, 12);
3002 se(ph_luma_tc_offset_div2, -12, 12);
3003 if (
pps->pps_chroma_tool_offsets_present_flag) {
3004 se(ph_cb_beta_offset_div2, -12, 12);
3005 se(ph_cb_tc_offset_div2, -12, 12);
3006 se(ph_cr_beta_offset_div2, -12, 12);
3007 se(ph_cr_tc_offset_div2, -12, 12);
3009 infer(ph_cb_beta_offset_div2,
3010 current->ph_luma_beta_offset_div2);
3011 infer(ph_cb_tc_offset_div2,
3012 current->ph_luma_tc_offset_div2);
3013 infer(ph_cr_beta_offset_div2,
3014 current->ph_luma_beta_offset_div2);
3015 infer(ph_cr_tc_offset_div2,
3016 current->ph_luma_tc_offset_div2);
3020 infer(ph_deblocking_filter_disabled_flag, 0);
3023 infer(ph_deblocking_filter_disabled_flag,
pps->pps_deblocking_filter_disabled_flag);
3024 if (!current->ph_deblocking_filter_disabled_flag) {
3025 infer(ph_luma_beta_offset_div2,
pps->pps_luma_beta_offset_div2);
3026 infer(ph_luma_tc_offset_div2,
pps->pps_luma_tc_offset_div2);
3027 infer(ph_cb_beta_offset_div2,
pps->pps_cb_beta_offset_div2);
3028 infer(ph_cb_tc_offset_div2,
pps->pps_cb_tc_offset_div2);
3029 infer(ph_cr_beta_offset_div2,
pps->pps_cr_beta_offset_div2);
3030 infer(ph_cr_tc_offset_div2,
pps->pps_cr_tc_offset_div2);
3034 if (
pps->pps_picture_header_extension_present_flag) {
3035 ue(ph_extension_length, 0, 256);
3036 for (
i = 0;
i < current->ph_extension_length;
i++)
3037 us(8, ph_extension_data_byte[
i], 0x00, 0xff, 1,
i);
3048 HEADER(
"Picture Header");
3065 uint8_t nal_unit_type, qp_bd_offset;
3066 uint16_t num_slices_in_subpic;
3072 flag(sh_picture_header_in_slice_header_flag);
3073 if (current->sh_picture_header_in_slice_header_flag) {
3076 ph = ¤t->sh_picture_header;
3081 "Picture header not available.\n");
3086 pps = h266->
pps[
ph->ph_pic_parameter_set_id];
3089 ph->ph_pic_parameter_set_id);
3092 sps = h266->
sps[
pps->pps_seq_parameter_set_id];
3095 pps->pps_seq_parameter_set_id);
3099 if (
sps->sps_subpic_info_present_flag) {
3100 ub(
sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id);
3101 for (
i = 0;
i <=
sps->sps_num_subpics_minus1;
i++) {
3102 if (
pps->sub_pic_id_val[
i] == current->sh_subpic_id) {
3103 current->curr_subpic_idx =
i;
3107 if (
i >
sps->sps_num_subpics_minus1) {
3112 current->curr_subpic_idx = 0;
3115 num_slices_in_subpic =
pps->num_slices_in_subpic[current->curr_subpic_idx];
3117 if ((
pps->pps_rect_slice_flag && num_slices_in_subpic > 1) ||
3118 (!
pps->pps_rect_slice_flag &&
pps->num_tiles_in_pic > 1)) {
3120 if (!
pps->pps_rect_slice_flag) {
3122 max =
pps->num_tiles_in_pic - 1;
3125 max = num_slices_in_subpic - 1;
3132 for (
i = 0;
i <
sps->sps_num_extra_sh_bytes * 8;
i++) {
3133 if (
sps->sps_extra_sh_bit_present_flag[
i])
3137 if (!
pps->pps_rect_slice_flag &&
3138 pps->num_tiles_in_pic - current->sh_slice_address > 1)
3139 ue(sh_num_tiles_in_slice_minus1, 0,
pps->num_tiles_in_pic - 1);
3141 infer(sh_num_tiles_in_slice_minus1, 0);
3143 if (
ph->ph_inter_slice_allowed_flag)
3144 ue(sh_slice_type, 0, 2);
3146 infer(sh_slice_type, 2);
3148 nal_unit_type = current->nal_unit_header.nal_unit_type;
3151 flag(sh_no_output_of_prior_pics_flag);
3153 if (
sps->sps_alf_enabled_flag) {
3154 if (!
pps->pps_alf_info_in_ph_flag) {
3155 flag(sh_alf_enabled_flag);
3156 if (current->sh_alf_enabled_flag) {
3157 ub(3, sh_num_alf_aps_ids_luma);
3158 for (
i = 0;
i < current->sh_num_alf_aps_ids_luma;
i++)
3159 ubs(3, sh_alf_aps_id_luma[
i], 1,
i);
3161 if (
sps->sps_chroma_format_idc != 0) {
3162 flag(sh_alf_cb_enabled_flag);
3163 flag(sh_alf_cr_enabled_flag);
3165 if (current->sh_alf_cb_enabled_flag ||
3166 current->sh_alf_cr_enabled_flag) {
3167 ub(3, sh_alf_aps_id_chroma);
3170 if (
sps->sps_ccalf_enabled_flag) {
3171 flag(sh_alf_cc_cb_enabled_flag);
3172 if (current->sh_alf_cc_cb_enabled_flag)
3173 ub(3, sh_alf_cc_cb_aps_id);
3175 flag(sh_alf_cc_cr_enabled_flag);
3176 if (current->sh_alf_cc_cr_enabled_flag)
3177 ub(3, sh_alf_cc_cr_aps_id);
3181 infer(sh_alf_enabled_flag,
ph->ph_alf_enabled_flag);
3182 if (current->sh_alf_enabled_flag) {
3183 infer(sh_num_alf_aps_ids_luma,
ph->ph_num_alf_aps_ids_luma);
3184 for (
i = 0;
i < current->sh_num_alf_aps_ids_luma;
i++)
3185 infer(sh_alf_aps_id_luma[
i],
ph->ph_alf_aps_id_luma[
i]);
3187 infer(sh_alf_cb_enabled_flag,
ph->ph_alf_cb_enabled_flag);
3188 infer(sh_alf_cr_enabled_flag,
ph->ph_alf_cr_enabled_flag);
3189 if (current->sh_alf_cb_enabled_flag ||current->sh_alf_cr_enabled_flag)
3190 infer(sh_alf_aps_id_chroma,
ph->ph_alf_aps_id_chroma);
3192 if (
sps->sps_ccalf_enabled_flag) {
3193 infer(sh_alf_cc_cb_enabled_flag,
ph->ph_alf_cc_cb_enabled_flag);
3194 if (current->sh_alf_cc_cb_enabled_flag)
3195 infer(sh_alf_cc_cb_aps_id,
ph->ph_alf_cc_cb_aps_id);
3197 infer(sh_alf_cc_cr_enabled_flag,
ph->ph_alf_cc_cr_enabled_flag);
3198 if (current->sh_alf_cc_cr_enabled_flag)
3199 infer(sh_alf_cc_cr_aps_id,
ph->ph_alf_cc_cr_aps_id);
3205 if (current->sh_picture_header_in_slice_header_flag) {
3206 infer(sh_lmcs_used_flag,
ph->ph_lmcs_enabled_flag);
3207 infer(sh_explicit_scaling_list_used_flag,
3208 ph->ph_explicit_scaling_list_enabled_flag);
3210 if (
ph->ph_lmcs_enabled_flag)
3211 flag(sh_lmcs_used_flag);
3213 infer(sh_lmcs_used_flag, 0);
3215 if (
ph->ph_explicit_scaling_list_enabled_flag)
3216 flag(sh_explicit_scaling_list_used_flag);
3218 infer(sh_explicit_scaling_list_used_flag, 0);
3221 if (!
pps->pps_rpl_info_in_ph_flag &&
3225 (
ctx, rw,
sps,
pps, ¤t->sh_ref_pic_lists));
3234 flag(sh_num_ref_idx_active_override_flag);
3235 if (current->sh_num_ref_idx_active_override_flag) {
3239 ues(sh_num_ref_idx_active_minus1[
i], 0, 14, 1,
i);
3241 infer(sh_num_ref_idx_active_minus1[
i], 0);
3244 infer(sh_num_ref_idx_active_override_flag, 1);
3247 for (
i = 0;
i < 2;
i++) {
3250 if (current->sh_num_ref_idx_active_override_flag) {
3251 current->num_ref_idx_active[
i] = current->sh_num_ref_idx_active_minus1[
i] + 1;
3253 current->num_ref_idx_active[
i] =
3255 pps->pps_num_ref_idx_default_active_minus1[
i] + 1);
3258 current->num_ref_idx_active[
i] = 0;
3263 if (
pps->pps_cabac_init_present_flag)
3264 flag(sh_cabac_init_flag);
3266 infer(sh_cabac_init_flag, 0);
3267 if (
ph->ph_temporal_mvp_enabled_flag) {
3268 if (!
pps->pps_rpl_info_in_ph_flag) {
3270 flag(sh_collocated_from_l0_flag);
3272 infer(sh_collocated_from_l0_flag, 1);
3273 if ((current->sh_collocated_from_l0_flag &&
3274 current->num_ref_idx_active[0] > 1) ||
3275 (!current->sh_collocated_from_l0_flag &&
3276 current->num_ref_idx_active[1] > 1)) {
3277 unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1;
3278 ue(sh_collocated_ref_idx, 0, current->num_ref_idx_active[idx] - 1);
3280 infer(sh_collocated_ref_idx, 0);
3284 infer(sh_collocated_from_l0_flag,
ph->ph_collocated_from_l0_flag);
3286 infer(sh_collocated_from_l0_flag, 1);
3287 infer(sh_collocated_ref_idx,
ph->ph_collocated_ref_idx);
3290 if (!
pps->pps_wp_info_in_ph_flag &&
3291 ((
pps->pps_weighted_pred_flag &&
3293 (
pps->pps_weighted_bipred_flag &&
3296 current->num_ref_idx_active,
3297 ¤t->sh_pred_weight_table));
3300 qp_bd_offset = 6 *
sps->sps_bitdepth_minus8;
3301 if (!
pps->pps_qp_delta_info_in_ph_flag)
3302 se(sh_qp_delta, -qp_bd_offset - (26 +
pps->pps_init_qp_minus26),
3303 63 - (26 +
pps->pps_init_qp_minus26));
3304 if (
pps->pps_slice_chroma_qp_offsets_present_flag) {
3307 se(sh_cb_qp_offset, -12, 12);
3308 off =
pps->pps_cb_qp_offset + current->sh_cb_qp_offset;
3309 if (off < -12 || off > 12) {
3311 "pps_cb_qp_offset + sh_cb_qp_offset (%d) not in range [-12, 12].\n",
3316 se(sh_cr_qp_offset, -12, 12);
3317 off =
pps->pps_cr_qp_offset + current->sh_cr_qp_offset;
3318 if (off < -12 || off > 12) {
3320 "pps_cr_qp_offset + sh_cr_qp_offset (%d) not in range [-12, 12].\n",
3325 if (
sps->sps_joint_cbcr_enabled_flag) {
3326 se(sh_joint_cbcr_qp_offset, -12, 12);
3328 pps->pps_joint_cbcr_qp_offset_value +
3329 current->sh_joint_cbcr_qp_offset;
3330 if (off < -12 || off > 12) {
3332 "pps_joint_cbcr_qp_offset_value + sh_joint_cbcr_qp_offset (%d)"
3333 "not in range [-12, 12]. \n", off);
3337 infer(sh_joint_cbcr_qp_offset, 0);
3340 infer(sh_cb_qp_offset, 0);
3341 infer(sh_cr_qp_offset, 0);
3342 infer(sh_joint_cbcr_qp_offset, 0);
3344 if (
pps->pps_cu_chroma_qp_offset_list_enabled_flag)
3345 flag(sh_cu_chroma_qp_offset_enabled_flag);
3347 infer(sh_cu_chroma_qp_offset_enabled_flag, 0);
3348 if (
sps->sps_sao_enabled_flag && !
pps->pps_sao_info_in_ph_flag) {
3349 flag(sh_sao_luma_used_flag);
3350 if (
sps->sps_chroma_format_idc != 0)
3351 flag(sh_sao_chroma_used_flag);
3353 infer(sh_sao_chroma_used_flag,
ph->ph_sao_chroma_enabled_flag);
3355 infer(sh_sao_luma_used_flag,
ph->ph_sao_luma_enabled_flag);
3356 infer(sh_sao_chroma_used_flag,
ph->ph_sao_chroma_enabled_flag);
3359 if (
pps->pps_deblocking_filter_override_enabled_flag &&
3360 !
pps->pps_dbf_info_in_ph_flag)
3361 flag(sh_deblocking_params_present_flag);
3363 infer(sh_deblocking_params_present_flag, 0);
3364 if (current->sh_deblocking_params_present_flag) {
3365 if (!
pps->pps_deblocking_filter_disabled_flag)
3366 flag(sh_deblocking_filter_disabled_flag);
3368 infer(sh_deblocking_filter_disabled_flag, 0);
3369 if (!current->sh_deblocking_filter_disabled_flag) {
3370 se(sh_luma_beta_offset_div2, -12, 12);
3371 se(sh_luma_tc_offset_div2, -12, 12);
3372 if (
pps->pps_chroma_tool_offsets_present_flag) {
3373 se(sh_cb_beta_offset_div2, -12, 12);
3374 se(sh_cb_tc_offset_div2, -12, 12);
3375 se(sh_cr_beta_offset_div2, -12, 12);
3376 se(sh_cr_tc_offset_div2, -12, 12);
3378 infer(sh_cb_beta_offset_div2,
3379 current->sh_luma_beta_offset_div2);
3380 infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
3381 infer(sh_cr_beta_offset_div2,
3382 current->sh_luma_beta_offset_div2);
3383 infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
3387 infer(sh_deblocking_filter_disabled_flag,
ph->ph_deblocking_filter_disabled_flag);
3388 if (!current->sh_deblocking_filter_disabled_flag) {
3389 infer(sh_luma_beta_offset_div2,
ph->ph_luma_beta_offset_div2);
3390 infer(sh_luma_tc_offset_div2,
ph->ph_luma_tc_offset_div2);
3391 infer(sh_cb_beta_offset_div2,
ph->ph_cb_beta_offset_div2);
3392 infer(sh_cb_tc_offset_div2,
ph->ph_cb_tc_offset_div2);
3393 infer(sh_cr_beta_offset_div2,
ph->ph_cr_beta_offset_div2);
3394 infer(sh_cr_tc_offset_div2,
ph->ph_cr_tc_offset_div2);
3398 if (
sps->sps_dep_quant_enabled_flag)
3399 flag(sh_dep_quant_used_flag);
3401 infer(sh_dep_quant_used_flag, 0);
3403 if (
sps->sps_sign_data_hiding_enabled_flag &&
3404 !current->sh_dep_quant_used_flag)
3405 flag(sh_sign_data_hiding_used_flag);
3407 infer(sh_sign_data_hiding_used_flag, 0);
3409 if (
sps->sps_transform_skip_enabled_flag &&
3410 !current->sh_dep_quant_used_flag &&
3411 !current->sh_sign_data_hiding_used_flag)
3412 flag(sh_ts_residual_coding_disabled_flag);
3414 infer(sh_ts_residual_coding_disabled_flag, 0);
3416 if (!current->sh_ts_residual_coding_disabled_flag &&
3417 sps->sps_ts_residual_coding_rice_present_in_sh_flag)
3418 ub(3, sh_ts_residual_coding_rice_idx_minus1);
3420 infer(sh_ts_residual_coding_rice_idx_minus1, 0);
3422 if (
sps->sps_reverse_last_sig_coeff_enabled_flag)
3423 flag(sh_reverse_last_sig_coeff_flag);
3425 infer(sh_reverse_last_sig_coeff_flag, 0);
3427 if (
pps->pps_slice_header_extension_present_flag) {
3428 ue(sh_slice_header_extension_length, 0, 256);
3429 for (
i = 0;
i < current->sh_slice_header_extension_length;
i++)
3430 us(8, sh_slice_header_extension_data_byte[
i], 0x00, 0xff, 1,
i);
3433 current->num_entry_points = 0;
3434 if (
sps->sps_entry_point_offsets_present_flag) {
3435 uint8_t entropy_sync =
sps->sps_entropy_coding_sync_enabled_flag;
3437 if (
pps->pps_rect_slice_flag) {
3439 int slice_idx = current->sh_slice_address;
3440 for (
i = 0;
i < current->curr_subpic_idx;
i++) {
3441 slice_idx +=
pps->num_slices_in_subpic[
i];
3444 pps->pps_slice_width_in_tiles_minus1[slice_idx] + 1;
3447 height =
pps->slice_height_in_ctus[slice_idx];
3449 height =
pps->pps_slice_height_in_tiles_minus1[slice_idx] + 1;
3451 current->num_entry_points = width_in_tiles *
height;
3455 for (tile_idx = current->sh_slice_address;
3457 current->sh_slice_address +
3458 current->sh_num_tiles_in_slice_minus1; tile_idx++) {
3459 tile_y = tile_idx /
pps->num_tile_rows;
3461 current->num_entry_points += (entropy_sync ?
height : 1);
3464 current->num_entry_points--;
3467 "%" PRIu32
".\n", current->num_entry_points);
3470 if (current->num_entry_points > 0) {
3471 ue(sh_entry_offset_len_minus1, 0, 31);
3472 for (
i = 0;
i < current->num_entry_points;
i++) {
3473 ubs(current->sh_entry_offset_len_minus1 + 1,
3474 sh_entry_point_offset_minus1[
i], 1,
i);
3489 HEADER(
"Prefix Supplemental Enhancement Information");
3491 HEADER(
"Suffix Supplemental Enhancement Information");