23 fixed(1, rbsp_stop_one_bit, 1);
25 fixed(1, rbsp_alignment_zero_bit, 0);
32 int expected_nal_unit_type)
36 fixed(1, forbidden_zero_bit, 0);
38 if (expected_nal_unit_type >= 0)
39 u(6, nal_unit_type, expected_nal_unit_type,
40 expected_nal_unit_type);
44 u(6, nuh_layer_id, 0, 62);
45 u(3, nuh_temporal_id_plus1, 1, 7);
54 fixed(1, alignment_bit_equal_to_one, 1);
56 fixed(1, alignment_bit_equal_to_zero, 0);
72 current->bit_length = k;
75 allocate(current->data, (current->bit_length + 7) / 8);
76 for (k = 0; k < current->bit_length; k++) {
78 current->data[k / 8] |= bit << (7 - k % 8);
82 for (k = 0; k < current->bit_length; k++)
90 int profile_present_flag,
91 int max_num_sub_layers_minus1)
95 if (profile_present_flag) {
96 u(2, general_profile_space, 0, 0);
97 flag(general_tier_flag);
98 ub(5, general_profile_idc);
100 for (j = 0; j < 32; j++)
101 flags(general_profile_compatibility_flag[j], 1, j);
103 flag(general_progressive_source_flag);
104 flag(general_interlaced_source_flag);
105 flag(general_non_packed_constraint_flag);
106 flag(general_frame_only_constraint_flag);
108 #define profile_compatible(x) (current->general_profile_idc == (x) || \ 109 current->general_profile_compatibility_flag[x]) 114 flag(general_max_12bit_constraint_flag);
115 flag(general_max_10bit_constraint_flag);
116 flag(general_max_8bit_constraint_flag);
117 flag(general_max_422chroma_constraint_flag);
118 flag(general_max_420chroma_constraint_flag);
119 flag(general_max_monochrome_constraint_flag);
120 flag(general_intra_constraint_flag);
121 flag(general_one_picture_only_constraint_flag);
122 flag(general_lower_bit_rate_constraint_flag);
126 flag(general_max_14bit_constraint_flag);
127 fixed(24, general_reserved_zero_33bits, 0);
128 fixed( 9, general_reserved_zero_33bits, 0);
130 fixed(24, general_reserved_zero_34bits, 0);
131 fixed(10, general_reserved_zero_34bits, 0);
134 fixed(7, general_reserved_zero_7bits, 0);
135 flag(general_one_picture_only_constraint_flag);
136 fixed(24, general_reserved_zero_35bits, 0);
137 fixed(11, general_reserved_zero_35bits, 0);
139 fixed(24, general_reserved_zero_43bits, 0);
140 fixed(19, general_reserved_zero_43bits, 0);
146 flag(general_inbld_flag);
148 fixed(1, general_reserved_zero_bit, 0);
150 #undef profile_compatible 153 ub(8, general_level_idc);
155 for (i = 0; i < max_num_sub_layers_minus1; i++) {
156 flags(sub_layer_profile_present_flag[i], 1, i);
157 flags(sub_layer_level_present_flag[i], 1, i);
160 if (max_num_sub_layers_minus1 > 0) {
161 for (i = max_num_sub_layers_minus1; i < 8; i++)
162 fixed(2, reserved_zero_2bits, 0);
165 for (i = 0; i < max_num_sub_layers_minus1; i++) {
166 if (current->sub_layer_profile_present_flag[i]) {
167 us(2, sub_layer_profile_space[i], 0, 0, 1, i);
168 flags(sub_layer_tier_flag[i], 1, i);
169 ubs(5, sub_layer_profile_idc[i], 1, i);
171 for (j = 0; j < 32; j++)
172 flags(sub_layer_profile_compatibility_flag[i][j], 2, i, j);
174 flags(sub_layer_progressive_source_flag[i], 1, i);
175 flags(sub_layer_interlaced_source_flag[i], 1, i);
176 flags(sub_layer_non_packed_constraint_flag[i], 1, i);
177 flags(sub_layer_frame_only_constraint_flag[i], 1, i);
179 #define profile_compatible(x) (current->sub_layer_profile_idc[i] == (x) || \ 180 current->sub_layer_profile_compatibility_flag[i][x]) 185 flags(sub_layer_max_12bit_constraint_flag[i], 1, i);
186 flags(sub_layer_max_10bit_constraint_flag[i], 1, i);
187 flags(sub_layer_max_8bit_constraint_flag[i], 1, i);
188 flags(sub_layer_max_422chroma_constraint_flag[i], 1, i);
189 flags(sub_layer_max_420chroma_constraint_flag[i], 1, i);
190 flags(sub_layer_max_monochrome_constraint_flag[i], 1, i);
191 flags(sub_layer_intra_constraint_flag[i], 1, i);
192 flags(sub_layer_one_picture_only_constraint_flag[i], 1, i);
193 flags(sub_layer_lower_bit_rate_constraint_flag[i], 1, i);
196 flags(sub_layer_max_14bit_constraint_flag[i], 1, i);
197 fixed(24, sub_layer_reserved_zero_33bits, 0);
198 fixed( 9, sub_layer_reserved_zero_33bits, 0);
200 fixed(24, sub_layer_reserved_zero_34bits, 0);
201 fixed(10, sub_layer_reserved_zero_34bits, 0);
204 fixed(7, sub_layer_reserved_zero_7bits, 0);
205 flags(sub_layer_one_picture_only_constraint_flag[i], 1, i);
206 fixed(24, sub_layer_reserved_zero_43bits, 0);
207 fixed(11, sub_layer_reserved_zero_43bits, 0);
209 fixed(24, sub_layer_reserved_zero_43bits, 0);
210 fixed(19, sub_layer_reserved_zero_43bits, 0);
216 flags(sub_layer_inbld_flag[i], 1, i);
218 fixed(1, sub_layer_reserved_zero_bit, 0);
220 #undef profile_compatible 222 if (current->sub_layer_level_present_flag[i])
223 ubs(8, sub_layer_level_idc[i], 1, i);
231 int nal,
int sub_layer_id)
237 current = &hrd->nal_sub_layer_hrd_parameters[sub_layer_id];
239 current = &hrd->vcl_sub_layer_hrd_parameters[sub_layer_id];
241 for (i = 0; i <= hrd->cpb_cnt_minus1[sub_layer_id]; i++) {
242 ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
243 ues(cpb_size_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
244 if (hrd->sub_pic_hrd_params_present_flag) {
245 ues(cpb_size_du_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
246 ues(bit_rate_du_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
248 flags(cbr_flag[i], 1, i);
256 int max_num_sub_layers_minus1)
260 if (common_inf_present_flag) {
261 flag(nal_hrd_parameters_present_flag);
262 flag(vcl_hrd_parameters_present_flag);
264 if (current->nal_hrd_parameters_present_flag ||
265 current->vcl_hrd_parameters_present_flag) {
266 flag(sub_pic_hrd_params_present_flag);
267 if (current->sub_pic_hrd_params_present_flag) {
268 ub(8, tick_divisor_minus2);
269 ub(5, du_cpb_removal_delay_increment_length_minus1);
270 flag(sub_pic_cpb_params_in_pic_timing_sei_flag);
271 ub(5, dpb_output_delay_du_length_minus1);
274 ub(4, bit_rate_scale);
275 ub(4, cpb_size_scale);
276 if (current->sub_pic_hrd_params_present_flag)
277 ub(4, cpb_size_du_scale);
279 ub(5, initial_cpb_removal_delay_length_minus1);
280 ub(5, au_cpb_removal_delay_length_minus1);
281 ub(5, dpb_output_delay_length_minus1);
283 infer(sub_pic_hrd_params_present_flag, 0);
285 infer(initial_cpb_removal_delay_length_minus1, 23);
286 infer(au_cpb_removal_delay_length_minus1, 23);
287 infer(dpb_output_delay_length_minus1, 23);
291 for (i = 0; i <= max_num_sub_layers_minus1; i++) {
292 flags(fixed_pic_rate_general_flag[i], 1, i);
294 if (!current->fixed_pic_rate_general_flag[i])
295 flags(fixed_pic_rate_within_cvs_flag[i], 1, i);
297 infer(fixed_pic_rate_within_cvs_flag[i], 1);
299 if (current->fixed_pic_rate_within_cvs_flag[i]) {
300 ues(elemental_duration_in_tc_minus1[i], 0, 2047, 1, i);
301 infer(low_delay_hrd_flag[i], 0);
303 flags(low_delay_hrd_flag[i], 1, i);
305 if (!current->low_delay_hrd_flag[i])
306 ues(cpb_cnt_minus1[i], 0, 31, 1, i);
308 infer(cpb_cnt_minus1[i], 0);
310 if (current->nal_hrd_parameters_present_flag)
312 if (current->vcl_hrd_parameters_present_flag)
324 flag(aspect_ratio_info_present_flag);
325 if (current->aspect_ratio_info_present_flag) {
326 ub(8, aspect_ratio_idc);
327 if (current->aspect_ratio_idc == 255) {
332 infer(aspect_ratio_idc, 0);
335 flag(overscan_info_present_flag);
336 if (current->overscan_info_present_flag)
337 flag(overscan_appropriate_flag);
339 flag(video_signal_type_present_flag);
340 if (current->video_signal_type_present_flag) {
342 flag(video_full_range_flag);
343 flag(colour_description_present_flag);
344 if (current->colour_description_present_flag) {
345 ub(8, colour_primaries);
347 ub(8, matrix_coefficients);
349 infer(colour_primaries, 2);
351 infer(matrix_coefficients, 2);
354 infer(video_format, 5);
355 infer(video_full_range_flag, 0);
356 infer(colour_primaries, 2);
358 infer(matrix_coefficients, 2);
361 flag(chroma_loc_info_present_flag);
362 if (current->chroma_loc_info_present_flag) {
363 ue(chroma_sample_loc_type_top_field, 0, 5);
364 ue(chroma_sample_loc_type_bottom_field, 0, 5);
366 infer(chroma_sample_loc_type_top_field, 0);
367 infer(chroma_sample_loc_type_bottom_field, 0);
370 flag(neutral_chroma_indication_flag);
371 flag(field_seq_flag);
372 flag(frame_field_info_present_flag);
374 flag(default_display_window_flag);
375 if (current->default_display_window_flag) {
376 ue(def_disp_win_left_offset, 0, 16384);
377 ue(def_disp_win_right_offset, 0, 16384);
378 ue(def_disp_win_top_offset, 0, 16384);
379 ue(def_disp_win_bottom_offset, 0, 16384);
382 flag(vui_timing_info_present_flag);
383 if (current->vui_timing_info_present_flag) {
384 u(32, vui_num_units_in_tick, 1, UINT32_MAX);
385 u(32, vui_time_scale, 1, UINT32_MAX);
386 flag(vui_poc_proportional_to_timing_flag);
387 if (current->vui_poc_proportional_to_timing_flag)
388 ue(vui_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
390 flag(vui_hrd_parameters_present_flag);
391 if (current->vui_hrd_parameters_present_flag) {
393 1,
sps->sps_max_sub_layers_minus1));
397 flag(bitstream_restriction_flag);
398 if (current->bitstream_restriction_flag) {
399 flag(tiles_fixed_structure_flag);
400 flag(motion_vectors_over_pic_boundaries_flag);
401 flag(restricted_ref_pic_lists_flag);
402 ue(min_spatial_segmentation_idc, 0, 4095);
403 ue(max_bytes_per_pic_denom, 0, 16);
404 ue(max_bits_per_min_cu_denom, 0, 16);
405 ue(log2_max_mv_length_horizontal, 0, 16);
406 ue(log2_max_mv_length_vertical, 0, 16);
408 infer(tiles_fixed_structure_flag, 0);
409 infer(motion_vectors_over_pic_boundaries_flag, 1);
410 infer(min_spatial_segmentation_idc, 0);
411 infer(max_bytes_per_pic_denom, 2);
412 infer(max_bits_per_min_cu_denom, 1);
413 infer(log2_max_mv_length_horizontal, 15);
414 infer(log2_max_mv_length_vertical, 15);
425 HEADER(
"Video Parameter Set");
429 ub(4, vps_video_parameter_set_id);
431 flag(vps_base_layer_internal_flag);
432 flag(vps_base_layer_available_flag);
435 flag(vps_temporal_id_nesting_flag);
437 if (current->vps_max_sub_layers_minus1 == 0 &&
438 current->vps_temporal_id_nesting_flag != 1) {
440 "vps_temporal_id_nesting_flag must be 1 if " 441 "vps_max_sub_layers_minus1 is 0.\n");
445 fixed(16, vps_reserved_0xffff_16bits, 0xffff);
448 1, current->vps_max_sub_layers_minus1));
450 flag(vps_sub_layer_ordering_info_present_flag);
451 for (i = (current->vps_sub_layer_ordering_info_present_flag ?
452 0 : current->vps_max_sub_layers_minus1);
453 i <= current->vps_max_sub_layers_minus1; i++) {
454 ues(vps_max_dec_pic_buffering_minus1[i],
456 ues(vps_max_num_reorder_pics[i],
457 0, current->vps_max_dec_pic_buffering_minus1[i], 1, i);
458 ues(vps_max_latency_increase_plus1[i],
459 0, UINT32_MAX - 1, 1, i);
461 if (!current->vps_sub_layer_ordering_info_present_flag) {
462 for (i = 0; i < current->vps_max_sub_layers_minus1; i++) {
463 infer(vps_max_dec_pic_buffering_minus1[i],
464 current->vps_max_dec_pic_buffering_minus1[current->vps_max_sub_layers_minus1]);
465 infer(vps_max_num_reorder_pics[i],
466 current->vps_max_num_reorder_pics[current->vps_max_sub_layers_minus1]);
467 infer(vps_max_latency_increase_plus1[i],
468 current->vps_max_latency_increase_plus1[current->vps_max_sub_layers_minus1]);
474 for (i = 1; i <= current->vps_num_layer_sets_minus1; i++) {
475 for (j = 0; j <= current->vps_max_layer_id; j++)
476 flags(layer_id_included_flag[i][j], 2, i, j);
478 for (j = 0; j <= current->vps_max_layer_id; j++)
479 infer(layer_id_included_flag[0][j], j == 0);
481 flag(vps_timing_info_present_flag);
482 if (current->vps_timing_info_present_flag) {
483 u(32, vps_num_units_in_tick, 1, UINT32_MAX);
484 u(32, vps_time_scale, 1, UINT32_MAX);
485 flag(vps_poc_proportional_to_timing_flag);
486 if (current->vps_poc_proportional_to_timing_flag)
487 ue(vps_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
488 ue(vps_num_hrd_parameters, 0, current->vps_num_layer_sets_minus1 + 1);
489 for (i = 0; i < current->vps_num_hrd_parameters; i++) {
490 ues(hrd_layer_set_idx[i],
491 current->vps_base_layer_internal_flag ? 0 : 1,
492 current->vps_num_layer_sets_minus1, 1, i);
494 flags(cprms_present_flag[i], 1, i);
496 infer(cprms_present_flag[0], 1);
499 current->cprms_present_flag[i],
500 current->vps_max_sub_layers_minus1));
504 flag(vps_extension_flag);
505 if (current->vps_extension_flag)
520 flag(inter_ref_pic_set_prediction_flag);
522 infer(inter_ref_pic_set_prediction_flag, 0);
524 if (current->inter_ref_pic_set_prediction_flag) {
525 unsigned int ref_rps_idx, num_delta_pocs, num_ref_pics;
527 int delta_rps, d_poc;
533 if (st_rps_idx ==
sps->num_short_term_ref_pic_sets)
534 ue(delta_idx_minus1, 0, st_rps_idx - 1);
536 infer(delta_idx_minus1, 0);
538 ref_rps_idx = st_rps_idx - (current->delta_idx_minus1 + 1);
539 ref = &
sps->st_ref_pic_set[ref_rps_idx];
540 num_delta_pocs = ref->num_negative_pics + ref->num_positive_pics;
543 flag(delta_rps_sign);
544 ue(abs_delta_rps_minus1, 0, INT16_MAX);
545 delta_rps = (1 - 2 * current->delta_rps_sign) *
546 (current->abs_delta_rps_minus1 + 1);
549 for (j = 0; j <= num_delta_pocs; j++) {
550 flags(used_by_curr_pic_flag[j], 1, j);
551 if (!current->used_by_curr_pic_flag[j])
552 flags(use_delta_flag[j], 1, j);
554 infer(use_delta_flag[j], 1);
555 if (current->use_delta_flag[j])
560 "short-term ref pic set %d " 561 "contains too many pictures.\n", st_rps_idx);
582 for (i = 0; i < ref->num_negative_pics; i++) {
583 d_poc -= ref->delta_poc_s0_minus1[
i] + 1;
584 ref_delta_poc_s0[
i] = d_poc;
587 for (i = 0; i < ref->num_positive_pics; i++) {
588 d_poc += ref->delta_poc_s1_minus1[
i] + 1;
589 ref_delta_poc_s1[
i] = d_poc;
593 for (j = ref->num_positive_pics - 1; j >= 0; j--) {
594 d_poc = ref_delta_poc_s1[j] + delta_rps;
595 if (d_poc < 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
596 delta_poc_s0[
i] = d_poc;
597 used_by_curr_pic_s0[i++] =
598 current->used_by_curr_pic_flag[ref->num_negative_pics + j];
601 if (delta_rps < 0 && current->use_delta_flag[num_delta_pocs]) {
602 delta_poc_s0[
i] = delta_rps;
603 used_by_curr_pic_s0[i++] =
604 current->used_by_curr_pic_flag[num_delta_pocs];
606 for (j = 0; j < ref->num_negative_pics; j++) {
607 d_poc = ref_delta_poc_s0[j] + delta_rps;
608 if (d_poc < 0 && current->use_delta_flag[j]) {
609 delta_poc_s0[
i] = d_poc;
610 used_by_curr_pic_s0[i++] = current->used_by_curr_pic_flag[j];
614 infer(num_negative_pics, i);
615 for (i = 0; i < current->num_negative_pics; i++) {
616 infer(delta_poc_s0_minus1[i],
617 -(delta_poc_s0[i] - (i == 0 ? 0 : delta_poc_s0[i - 1])) - 1);
618 infer(used_by_curr_pic_s0_flag[i], used_by_curr_pic_s0[i]);
622 for (j = ref->num_negative_pics - 1; j >= 0; j--) {
623 d_poc = ref_delta_poc_s0[j] + delta_rps;
624 if (d_poc > 0 && current->use_delta_flag[j]) {
625 delta_poc_s1[
i] = d_poc;
626 used_by_curr_pic_s1[i++] = current->used_by_curr_pic_flag[j];
629 if (delta_rps > 0 && current->use_delta_flag[num_delta_pocs]) {
630 delta_poc_s1[
i] = delta_rps;
631 used_by_curr_pic_s1[i++] =
632 current->used_by_curr_pic_flag[num_delta_pocs];
634 for (j = 0; j < ref->num_positive_pics; j++) {
635 d_poc = ref_delta_poc_s1[j] + delta_rps;
636 if (d_poc > 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
637 delta_poc_s1[
i] = d_poc;
638 used_by_curr_pic_s1[i++] =
639 current->used_by_curr_pic_flag[ref->num_negative_pics + j];
643 infer(num_positive_pics, i);
644 for (i = 0; i < current->num_positive_pics; i++) {
645 infer(delta_poc_s1_minus1[i],
646 delta_poc_s1[i] - (i == 0 ? 0 : delta_poc_s1[i - 1]) - 1);
647 infer(used_by_curr_pic_s1_flag[i], used_by_curr_pic_s1[i]);
651 ue(num_negative_pics, 0, 15);
652 ue(num_positive_pics, 0, 15 - current->num_negative_pics);
654 for (i = 0; i < current->num_negative_pics; i++) {
655 ues(delta_poc_s0_minus1[i], 0, INT16_MAX, 1, i);
656 flags(used_by_curr_pic_s0_flag[i], 1, i);
659 for (i = 0; i < current->num_positive_pics; i++) {
660 ues(delta_poc_s1_minus1[i], 0, INT16_MAX, 1, i);
661 flags(used_by_curr_pic_s1_flag[i], 1, i);
671 int sizeId, matrixId;
674 for (sizeId = 0; sizeId < 4; sizeId++) {
675 for (matrixId = 0; matrixId < 6; matrixId += (sizeId == 3 ? 3 : 1)) {
676 flags(scaling_list_pred_mode_flag[sizeId][matrixId],
677 2, sizeId, matrixId);
678 if (!current->scaling_list_pred_mode_flag[sizeId][matrixId]) {
679 ues(scaling_list_pred_matrix_id_delta[sizeId][matrixId],
680 0, sizeId == 3 ? matrixId / 3 : matrixId,
681 2, sizeId, matrixId);
683 n =
FFMIN(64, 1 << (4 + (sizeId << 1)));
685 ses(scaling_list_dc_coef_minus8[sizeId - 2][matrixId], -7, +247,
686 2, sizeId - 2, matrixId);
688 for (i = 0; i < n; i++) {
689 ses(scaling_list_delta_coeff[sizeId][matrixId][i],
690 -128, +127, 3, sizeId, matrixId, i);
704 flag(transform_skip_rotation_enabled_flag);
705 flag(transform_skip_context_enabled_flag);
706 flag(implicit_rdpcm_enabled_flag);
707 flag(explicit_rdpcm_enabled_flag);
708 flag(extended_precision_processing_flag);
709 flag(intra_smoothing_disabled_flag);
710 flag(high_precision_offsets_enabled_flag);
711 flag(persistent_rice_adaptation_enabled_flag);
712 flag(cabac_bypass_alignment_enabled_flag);
722 flag(sps_curr_pic_ref_enabled_flag);
724 flag(palette_mode_enabled_flag);
725 if (current->palette_mode_enabled_flag) {
726 ue(palette_max_size, 0, 64);
727 ue(delta_palette_max_predictor_size, 0, 128);
729 flag(sps_palette_predictor_initializer_present_flag);
730 if (current->sps_palette_predictor_initializer_present_flag) {
731 ue(sps_num_palette_predictor_initializer_minus1, 0, 128);
732 for (comp = 0; comp < (current->chroma_format_idc ? 3 : 1); comp++) {
733 int bit_depth = comp == 0 ? current->bit_depth_luma_minus8 + 8
734 : current->bit_depth_chroma_minus8 + 8;
735 for (i = 0; i <= current->sps_num_palette_predictor_initializer_minus1; i++)
736 ubs(bit_depth, sps_palette_predictor_initializers[comp][i], 2, comp, i);
741 u(2, motion_vector_resolution_control_idc, 0, 2);
742 flag(intra_boundary_filtering_disable_flag);
751 infer(aspect_ratio_idc, 0);
753 infer(video_format, 5);
754 infer(video_full_range_flag, 0);
755 infer(colour_primaries, 2);
757 infer(matrix_coefficients, 2);
759 infer(chroma_sample_loc_type_top_field, 0);
760 infer(chroma_sample_loc_type_bottom_field, 0);
762 infer(tiles_fixed_structure_flag, 0);
763 infer(motion_vectors_over_pic_boundaries_flag, 1);
764 infer(min_spatial_segmentation_idc, 0);
765 infer(max_bytes_per_pic_denom, 2);
766 infer(max_bits_per_min_cu_denom, 1);
767 infer(log2_max_mv_length_horizontal, 15);
768 infer(log2_max_mv_length_vertical, 15);
779 unsigned int min_cb_log2_size_y, ctb_log2_size_y,
780 min_cb_size_y, min_tb_log2_size_y;
782 HEADER(
"Sequence Parameter Set");
786 ub(4, sps_video_parameter_set_id);
787 h265->
active_vps = vps = h265->
vps[current->sps_video_parameter_set_id];
790 flag(sps_temporal_id_nesting_flag);
794 "sps_max_sub_layers_minus1 (%d) must be less than or equal to " 795 "vps_max_sub_layers_minus1 (%d).\n",
797 current->sps_max_sub_layers_minus1);
801 !current->sps_temporal_id_nesting_flag) {
803 "sps_temporal_id_nesting_flag must be 1 if " 804 "vps_temporal_id_nesting_flag is 1.\n");
810 1, current->sps_max_sub_layers_minus1));
812 ue(sps_seq_parameter_set_id, 0, 15);
814 ue(chroma_format_idc, 0, 3);
815 if (current->chroma_format_idc == 3)
816 flag(separate_colour_plane_flag);
818 infer(separate_colour_plane_flag, 0);
823 flag(conformance_window_flag);
824 if (current->conformance_window_flag) {
825 ue(conf_win_left_offset, 0, current->pic_width_in_luma_samples);
826 ue(conf_win_right_offset, 0, current->pic_width_in_luma_samples);
827 ue(conf_win_top_offset, 0, current->pic_height_in_luma_samples);
828 ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
830 infer(conf_win_left_offset, 0);
831 infer(conf_win_right_offset, 0);
832 infer(conf_win_top_offset, 0);
833 infer(conf_win_bottom_offset, 0);
836 ue(bit_depth_luma_minus8, 0, 8);
837 ue(bit_depth_chroma_minus8, 0, 8);
839 ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
841 flag(sps_sub_layer_ordering_info_present_flag);
842 for (i = (current->sps_sub_layer_ordering_info_present_flag ?
843 0 : current->sps_max_sub_layers_minus1);
844 i <= current->sps_max_sub_layers_minus1; i++) {
845 ues(sps_max_dec_pic_buffering_minus1[i],
847 ues(sps_max_num_reorder_pics[i],
848 0, current->sps_max_dec_pic_buffering_minus1[i], 1, i);
849 ues(sps_max_latency_increase_plus1[i],
850 0, UINT32_MAX - 1, 1, i);
852 if (!current->sps_sub_layer_ordering_info_present_flag) {
853 for (i = 0; i < current->sps_max_sub_layers_minus1; i++) {
854 infer(sps_max_dec_pic_buffering_minus1[i],
855 current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
856 infer(sps_max_num_reorder_pics[i],
857 current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
858 infer(sps_max_latency_increase_plus1[i],
859 current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
863 ue(log2_min_luma_coding_block_size_minus3, 0, 3);
864 min_cb_log2_size_y = current->log2_min_luma_coding_block_size_minus3 + 3;
866 ue(log2_diff_max_min_luma_coding_block_size, 0, 3);
867 ctb_log2_size_y = min_cb_log2_size_y +
868 current->log2_diff_max_min_luma_coding_block_size;
870 min_cb_size_y = 1 << min_cb_log2_size_y;
871 if (current->pic_width_in_luma_samples % min_cb_size_y ||
872 current->pic_height_in_luma_samples % min_cb_size_y) {
874 "by MinCbSizeY = %u.\n", current->pic_width_in_luma_samples,
875 current->pic_height_in_luma_samples, min_cb_size_y);
879 ue(log2_min_luma_transform_block_size_minus2, 0, min_cb_log2_size_y - 3);
880 min_tb_log2_size_y = current->log2_min_luma_transform_block_size_minus2 + 2;
882 ue(log2_diff_max_min_luma_transform_block_size,
883 0,
FFMIN(ctb_log2_size_y, 5) - min_tb_log2_size_y);
885 ue(max_transform_hierarchy_depth_inter,
886 0, ctb_log2_size_y - min_tb_log2_size_y);
887 ue(max_transform_hierarchy_depth_intra,
888 0, ctb_log2_size_y - min_tb_log2_size_y);
890 flag(scaling_list_enabled_flag);
891 if (current->scaling_list_enabled_flag) {
892 flag(sps_scaling_list_data_present_flag);
893 if (current->sps_scaling_list_data_present_flag)
896 infer(sps_scaling_list_data_present_flag, 0);
899 flag(amp_enabled_flag);
900 flag(sample_adaptive_offset_enabled_flag);
902 flag(pcm_enabled_flag);
903 if (current->pcm_enabled_flag) {
904 u(4, pcm_sample_bit_depth_luma_minus1,
905 0, current->bit_depth_luma_minus8 + 8 - 1);
906 u(4, pcm_sample_bit_depth_chroma_minus1,
907 0, current->bit_depth_chroma_minus8 + 8 - 1);
909 ue(log2_min_pcm_luma_coding_block_size_minus3,
910 FFMIN(min_cb_log2_size_y, 5) - 3,
FFMIN(ctb_log2_size_y, 5) - 3);
911 ue(log2_diff_max_min_pcm_luma_coding_block_size,
912 0,
FFMIN(ctb_log2_size_y, 5) - (current->log2_min_pcm_luma_coding_block_size_minus3 + 3));
914 flag(pcm_loop_filter_disabled_flag);
918 for (i = 0; i < current->num_short_term_ref_pic_sets; i++)
921 flag(long_term_ref_pics_present_flag);
922 if (current->long_term_ref_pics_present_flag) {
924 for (i = 0; i < current->num_long_term_ref_pics_sps; i++) {
925 ubs(current->log2_max_pic_order_cnt_lsb_minus4 + 4,
926 lt_ref_pic_poc_lsb_sps[i], 1, i);
927 flags(used_by_curr_pic_lt_sps_flag[i], 1, i);
931 flag(sps_temporal_mvp_enabled_flag);
932 flag(strong_intra_smoothing_enabled_flag);
934 flag(vui_parameters_present_flag);
935 if (current->vui_parameters_present_flag)
940 flag(sps_extension_present_flag);
941 if (current->sps_extension_present_flag) {
942 flag(sps_range_extension_flag);
943 flag(sps_multilayer_extension_flag);
944 flag(sps_3d_extension_flag);
945 flag(sps_scc_extension_flag);
946 ub(4, sps_extension_4bits);
949 if (current->sps_range_extension_flag)
951 if (current->sps_multilayer_extension_flag)
953 if (current->sps_3d_extension_flag)
955 if (current->sps_scc_extension_flag)
957 if (current->sps_extension_4bits)
972 if (current->transform_skip_enabled_flag)
973 ue(log2_max_transform_skip_block_size_minus2, 0, 3);
974 flag(cross_component_prediction_enabled_flag);
976 flag(chroma_qp_offset_list_enabled_flag);
977 if (current->chroma_qp_offset_list_enabled_flag) {
978 ue(diff_cu_chroma_qp_offset_depth,
980 ue(chroma_qp_offset_list_len_minus1, 0, 5);
981 for (i = 0; i <= current->chroma_qp_offset_list_len_minus1; i++) {
982 ses(cb_qp_offset_list[i], -12, +12, 1, i);
983 ses(cr_qp_offset_list[i], -12, +12, 1, i);
998 flag(pps_curr_pic_ref_enabled_flag);
1000 flag(residual_adaptive_colour_transform_enabled_flag);
1001 if (current->residual_adaptive_colour_transform_enabled_flag) {
1002 flag(pps_slice_act_qp_offsets_present_flag);
1003 se(pps_act_y_qp_offset_plus5, -7, +17);
1004 se(pps_act_cb_qp_offset_plus5, -7, +17);
1005 se(pps_act_cr_qp_offset_plus3, -9, +15);
1007 infer(pps_slice_act_qp_offsets_present_flag, 0);
1008 infer(pps_act_y_qp_offset_plus5, 0);
1009 infer(pps_act_cb_qp_offset_plus5, 0);
1010 infer(pps_act_cr_qp_offset_plus3, 0);
1013 flag(pps_palette_predictor_initializer_present_flag);
1014 if (current->pps_palette_predictor_initializer_present_flag) {
1015 ue(pps_num_palette_predictor_initializer, 0, 128);
1016 if (current->pps_num_palette_predictor_initializer > 0) {
1017 flag(monochrome_palette_flag);
1018 ue(luma_bit_depth_entry_minus8, 0, 8);
1019 if (!current->monochrome_palette_flag)
1020 ue(chroma_bit_depth_entry_minus8, 0, 8);
1021 for (comp = 0; comp < (current->monochrome_palette_flag ? 1 : 3); comp++) {
1022 int bit_depth = comp == 0 ? current->luma_bit_depth_entry_minus8 + 8
1023 : current->chroma_bit_depth_entry_minus8 + 8;
1024 for (i = 0; i < current->pps_num_palette_predictor_initializer; i++)
1025 ubs(bit_depth, pps_palette_predictor_initializers[comp][i], 2, comp, i);
1040 HEADER(
"Picture Parameter Set");
1044 ue(pps_pic_parameter_set_id, 0, 63);
1045 ue(pps_seq_parameter_set_id, 0, 15);
1046 sps = h265->
sps[current->pps_seq_parameter_set_id];
1049 current->pps_seq_parameter_set_id);
1054 flag(dependent_slice_segments_enabled_flag);
1055 flag(output_flag_present_flag);
1056 ub(3, num_extra_slice_header_bits);
1057 flag(sign_data_hiding_enabled_flag);
1058 flag(cabac_init_present_flag);
1060 ue(num_ref_idx_l0_default_active_minus1, 0, 14);
1061 ue(num_ref_idx_l1_default_active_minus1, 0, 14);
1065 flag(constrained_intra_pred_flag);
1066 flag(transform_skip_enabled_flag);
1067 flag(cu_qp_delta_enabled_flag);
1068 if (current->cu_qp_delta_enabled_flag)
1069 ue(diff_cu_qp_delta_depth,
1072 infer(diff_cu_qp_delta_depth, 0);
1074 se(pps_cb_qp_offset, -12, +12);
1075 se(pps_cr_qp_offset, -12, +12);
1076 flag(pps_slice_chroma_qp_offsets_present_flag);
1078 flag(weighted_pred_flag);
1079 flag(weighted_bipred_flag);
1081 flag(transquant_bypass_enabled_flag);
1082 flag(tiles_enabled_flag);
1083 flag(entropy_coding_sync_enabled_flag);
1085 if (current->tiles_enabled_flag) {
1088 flag(uniform_spacing_flag);
1089 if (!current->uniform_spacing_flag) {
1090 for (i = 0; i < current->num_tile_columns_minus1; i++)
1092 for (i = 0; i < current->num_tile_rows_minus1; i++)
1095 flag(loop_filter_across_tiles_enabled_flag);
1097 infer(num_tile_columns_minus1, 0);
1098 infer(num_tile_rows_minus1, 0);
1101 flag(pps_loop_filter_across_slices_enabled_flag);
1102 flag(deblocking_filter_control_present_flag);
1103 if (current->deblocking_filter_control_present_flag) {
1104 flag(deblocking_filter_override_enabled_flag);
1105 flag(pps_deblocking_filter_disabled_flag);
1106 if (!current->pps_deblocking_filter_disabled_flag) {
1107 se(pps_beta_offset_div2, -6, +6);
1108 se(pps_tc_offset_div2, -6, +6);
1110 infer(pps_beta_offset_div2, 0);
1111 infer(pps_tc_offset_div2, 0);
1114 infer(deblocking_filter_override_enabled_flag, 0);
1115 infer(pps_deblocking_filter_disabled_flag, 0);
1116 infer(pps_beta_offset_div2, 0);
1117 infer(pps_tc_offset_div2, 0);
1120 flag(pps_scaling_list_data_present_flag);
1121 if (current->pps_scaling_list_data_present_flag)
1124 flag(lists_modification_present_flag);
1126 ue(log2_parallel_merge_level_minus2,
1130 flag(slice_segment_header_extension_present_flag);
1132 flag(pps_extension_present_flag);
1133 if (current->pps_extension_present_flag) {
1134 flag(pps_range_extension_flag);
1135 flag(pps_multilayer_extension_flag);
1136 flag(pps_3d_extension_flag);
1137 flag(pps_scc_extension_flag);
1138 ub(4, pps_extension_4bits);
1140 if (current->pps_range_extension_flag)
1142 if (current->pps_multilayer_extension_flag)
1144 if (current->pps_3d_extension_flag)
1146 if (current->pps_scc_extension_flag)
1148 if (current->pps_extension_4bits)
1161 HEADER(
"Access Unit Delimiter");
1165 u(3, pic_type, 0, 2);
1174 unsigned int num_pic_total_curr)
1176 unsigned int entry_size;
1179 entry_size =
av_log2(num_pic_total_curr - 1) + 1;
1181 flag(ref_pic_list_modification_flag_l0);
1182 if (current->ref_pic_list_modification_flag_l0) {
1183 for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++)
1184 us(entry_size, list_entry_l0[i], 0, num_pic_total_curr - 1, 1, i);
1188 flag(ref_pic_list_modification_flag_l1);
1189 if (current->ref_pic_list_modification_flag_l1) {
1190 for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++)
1191 us(entry_size, list_entry_l1[i], 0, num_pic_total_curr - 1, 1, i);
1207 ue(luma_log2_weight_denom, 0, 7);
1209 se(delta_chroma_log2_weight_denom, -7, 7);
1211 infer(delta_chroma_log2_weight_denom, 0);
1213 for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1215 flags(luma_weight_l0_flag[i], 1, i);
1217 infer(luma_weight_l0_flag[i], 0);
1220 for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1222 flags(chroma_weight_l0_flag[i], 1, i);
1224 infer(chroma_weight_l0_flag[i], 0);
1228 for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1229 if (current->luma_weight_l0_flag[i]) {
1230 ses(delta_luma_weight_l0[i], -128, +127, 1, i);
1231 ses(luma_offset_l0[i],
1235 infer(delta_luma_weight_l0[i], 0);
1236 infer(luma_offset_l0[i], 0);
1238 if (current->chroma_weight_l0_flag[i]) {
1239 for (j = 0; j < 2; j++) {
1240 ses(delta_chroma_weight_l0[i][j], -128, +127, 2, i, j);
1241 ses(chroma_offset_l0[i][j],
1246 for (j = 0; j < 2; j++) {
1247 infer(delta_chroma_weight_l0[i][j], 0);
1248 infer(chroma_offset_l0[i][j], 0);
1254 for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1256 flags(luma_weight_l1_flag[i], 1, i);
1258 infer(luma_weight_l1_flag[i], 0);
1261 for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1263 flags(chroma_weight_l1_flag[i], 1, i);
1265 infer(chroma_weight_l1_flag[i], 0);
1269 for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1270 if (current->luma_weight_l1_flag[i]) {
1271 ses(delta_luma_weight_l1[i], -128, +127, 1, i);
1272 ses(luma_offset_l1[i],
1276 infer(delta_luma_weight_l1[i], 0);
1277 infer(luma_offset_l1[i], 0);
1279 if (current->chroma_weight_l1_flag[i]) {
1280 for (j = 0; j < 2; j++) {
1281 ses(delta_chroma_weight_l1[i][j], -128, +127, 2, i, j);
1282 ses(chroma_offset_l1[i][j],
1287 for (j = 0; j < 2; j++) {
1288 infer(delta_chroma_weight_l1[i][j], 0);
1289 infer(chroma_offset_l1[i][j], 0);
1304 unsigned int min_cb_log2_size_y, ctb_log2_size_y, ctb_size_y;
1305 unsigned int pic_width_in_ctbs_y, pic_height_in_ctbs_y, pic_size_in_ctbs_y;
1306 unsigned int num_pic_total_curr = 0;
1309 HEADER(
"Slice Segment Header");
1313 flag(first_slice_segment_in_pic_flag);
1317 flag(no_output_of_prior_pics_flag);
1319 ue(slice_pic_parameter_set_id, 0, 63);
1321 pps = h265->
pps[current->slice_pic_parameter_set_id];
1324 current->slice_pic_parameter_set_id);
1339 ctb_size_y = 1 << ctb_log2_size_y;
1340 pic_width_in_ctbs_y =
1342 pic_height_in_ctbs_y =
1344 pic_size_in_ctbs_y = pic_width_in_ctbs_y * pic_height_in_ctbs_y;
1346 if (!current->first_slice_segment_in_pic_flag) {
1347 unsigned int address_size =
av_log2(pic_size_in_ctbs_y - 1) + 1;
1349 flag(dependent_slice_segment_flag);
1351 infer(dependent_slice_segment_flag, 0);
1352 u(address_size, slice_segment_address, 0, pic_size_in_ctbs_y - 1);
1354 infer(dependent_slice_segment_flag, 0);
1357 if (!current->dependent_slice_segment_flag) {
1359 flags(slice_reserved_flag[i], 1, i);
1361 ue(slice_type, 0, 2);
1364 flag(pic_output_flag);
1367 u(2, colour_plane_id, 0, 2);
1372 int dpb_slots_remaining;
1376 flag(short_term_ref_pic_set_sps_flag);
1377 if (!current->short_term_ref_pic_set_sps_flag) {
1380 rps = ¤t->short_term_ref_pic_set;
1383 u(idx_size, short_term_ref_pic_set_idx,
1387 infer(short_term_ref_pic_set_idx, 0);
1398 if (dpb_slots_remaining == 0) {
1400 "short-term ref pic set contains too many pictures " 1401 "to use with current picture reference enabled.\n");
1404 --dpb_slots_remaining;
1407 num_pic_total_curr = 0;
1410 ++num_pic_total_curr;
1413 ++num_pic_total_curr;
1416 unsigned int idx_size;
1420 dpb_slots_remaining));
1422 dpb_slots_remaining -= current->num_long_term_sps;
1424 infer(num_long_term_sps, 0);
1427 ue(num_long_term_pics, 0, dpb_slots_remaining);
1429 for (i = 0; i < current->num_long_term_sps +
1430 current->num_long_term_pics; i++) {
1431 if (i < current->num_long_term_sps) {
1433 us(idx_size, lt_idx_sps[i],
1436 ++num_pic_total_curr;
1439 flags(used_by_curr_pic_lt_flag[i], 1, i);
1440 if (current->used_by_curr_pic_lt_flag[i])
1441 ++num_pic_total_curr;
1443 flags(delta_poc_msb_present_flag[i], 1, i);
1444 if (current->delta_poc_msb_present_flag[i])
1445 ues(delta_poc_msb_cycle_lt[i], 0, UINT32_MAX - 1, 1, i);
1447 infer(delta_poc_msb_cycle_lt[i], 0);
1452 flag(slice_temporal_mvp_enabled_flag);
1454 infer(slice_temporal_mvp_enabled_flag, 0);
1457 ++num_pic_total_curr;
1461 flag(slice_sao_luma_flag);
1463 flag(slice_sao_chroma_flag);
1465 infer(slice_sao_chroma_flag, 0);
1467 infer(slice_sao_luma_flag, 0);
1468 infer(slice_sao_chroma_flag, 0);
1473 flag(num_ref_idx_active_override_flag);
1474 if (current->num_ref_idx_active_override_flag) {
1475 ue(num_ref_idx_l0_active_minus1, 0, 14);
1477 ue(num_ref_idx_l1_active_minus1, 0, 14);
1487 num_pic_total_curr));
1490 flag(mvd_l1_zero_flag);
1492 flag(cabac_init_flag);
1494 infer(cabac_init_flag, 0);
1495 if (current->slice_temporal_mvp_enabled_flag) {
1497 flag(collocated_from_l0_flag);
1499 infer(collocated_from_l0_flag, 1);
1500 if (current->collocated_from_l0_flag) {
1501 if (current->num_ref_idx_l0_active_minus1 > 0)
1502 ue(collocated_ref_idx, 0, current->num_ref_idx_l0_active_minus1);
1504 infer(collocated_ref_idx, 0);
1506 if (current->num_ref_idx_l1_active_minus1 > 0)
1507 ue(collocated_ref_idx, 0, current->num_ref_idx_l1_active_minus1);
1509 infer(collocated_ref_idx, 0);
1517 ue(five_minus_max_num_merge_cand, 0, 4);
1519 flag(use_integer_mv_flag);
1528 se(slice_cb_qp_offset, -12, +12);
1529 se(slice_cr_qp_offset, -12, +12);
1531 infer(slice_cb_qp_offset, 0);
1532 infer(slice_cr_qp_offset, 0);
1535 se(slice_act_y_qp_offset,
1538 se(slice_act_cb_qp_offset,
1541 se(slice_act_cr_qp_offset,
1545 infer(slice_act_y_qp_offset, 0);
1546 infer(slice_act_cb_qp_offset, 0);
1547 infer(slice_act_cr_qp_offset, 0);
1550 flag(cu_chroma_qp_offset_enabled_flag);
1552 infer(cu_chroma_qp_offset_enabled_flag, 0);
1555 flag(deblocking_filter_override_flag);
1557 infer(deblocking_filter_override_flag, 0);
1558 if (current->deblocking_filter_override_flag) {
1559 flag(slice_deblocking_filter_disabled_flag);
1560 if (!current->slice_deblocking_filter_disabled_flag) {
1561 se(slice_beta_offset_div2, -6, +6);
1562 se(slice_tc_offset_div2, -6, +6);
1568 infer(slice_deblocking_filter_disabled_flag,
1574 (current->slice_sao_luma_flag || current->slice_sao_chroma_flag ||
1575 !current->slice_deblocking_filter_disabled_flag))
1576 flag(slice_loop_filter_across_slices_enabled_flag);
1578 infer(slice_loop_filter_across_slices_enabled_flag,
1583 unsigned int num_entry_point_offsets_limit;
1585 num_entry_point_offsets_limit = pic_height_in_ctbs_y - 1;
1587 num_entry_point_offsets_limit =
1590 num_entry_point_offsets_limit =
1592 ue(num_entry_point_offsets, 0, num_entry_point_offsets_limit);
1596 "%"PRIu16
".\n", current->num_entry_point_offsets);
1600 if (current->num_entry_point_offsets > 0) {
1601 ue(offset_len_minus1, 0, 31);
1602 for (i = 0; i < current->num_entry_point_offsets; i++)
1603 ubs(current->offset_len_minus1 + 1, entry_point_offset_minus1[i], 1, i);
1608 ue(slice_segment_header_extension_length, 0, 256);
1609 for (i = 0; i < current->slice_segment_header_extension_length; i++)
1610 us(8, slice_segment_header_extension_data_byte[i], 0x00, 0xff, 1, i);
1628 int start_pos, end_pos;
1632 HEADER(
"Buffering Period");
1636 sps = h265->
sps[current->bp_seq_parameter_set_id];
1639 current->bp_seq_parameter_set_id);
1647 "HRD parameters to be present in SPS.\n");
1654 "NAL or VCL HRD parameters to be present.\n");
1659 flag(irap_cpb_params_present_flag);
1661 infer(irap_cpb_params_present_flag, 0);
1662 if (current->irap_cpb_params_present_flag) {
1664 ub(length, cpb_delay_offset);
1666 ub(length, dpb_delay_offset);
1668 infer(cpb_delay_offset, 0);
1669 infer(dpb_delay_offset, 0);
1672 flag(concatenation_flag);
1675 ub(length, au_cpb_removal_delay_delta_minus1);
1681 ubs(length, nal_initial_cpb_removal_delay[i], 1, i);
1682 ubs(length, nal_initial_cpb_removal_offset[i], 1, i);
1685 current->irap_cpb_params_present_flag) {
1686 ubs(length, nal_initial_alt_cpb_removal_delay[i], 1, i);
1687 ubs(length, nal_initial_alt_cpb_removal_offset[i], 1, i);
1695 ubs(length, vcl_initial_cpb_removal_delay[i], 1, i);
1696 ubs(length, vcl_initial_cpb_removal_offset[i], 1, i);
1699 current->irap_cpb_params_present_flag) {
1700 ubs(length, vcl_initial_alt_cpb_removal_delay[i], 1, i);
1701 ubs(length, vcl_initial_alt_cpb_removal_offset[i], 1, i);
1709 end_pos - start_pos))
1710 flag(use_alt_cpb_params_flag);
1712 infer(use_alt_cpb_params_flag, 0);
1716 if (current->use_alt_cpb_params_flag ||
sei->extension_present) {
1717 flag(use_alt_cpb_params_flag);
1721 sei->extension_present = 1;
1735 int err, expected_source_scan_type,
i,
length;
1737 HEADER(
"Picture Timing");
1742 "No active SPS for pic_timing.\n");
1746 expected_source_scan_type = 2 -
1751 u(4, pic_struct, 0, 12);
1752 u(2, source_scan_type,
1753 expected_source_scan_type >= 0 ? expected_source_scan_type : 0,
1754 expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1755 flag(duplicate_flag);
1757 infer(pic_struct, 0);
1758 infer(source_scan_type,
1759 expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1760 infer(duplicate_flag, 0);
1771 ub(length, au_cpb_removal_delay_minus1);
1774 ub(length, pic_dpb_output_delay);
1778 ub(length, pic_dpb_output_du_delay);
1785 flag(du_common_cpb_removal_delay_flag);
1788 if (current->du_common_cpb_removal_delay_flag)
1789 ub(length, du_common_cpb_removal_delay_increment_minus1);
1791 for (i = 0; i <= current->num_decoding_units_minus1; i++) {
1792 ues(num_nalus_in_du_minus1[i],
1794 if (!current->du_common_cpb_removal_delay_flag &&
1795 i < current->num_decoding_units_minus1)
1796 ubs(length, du_cpb_removal_delay_increment_minus1[i], 1, i);
1810 HEADER(
"Pan-Scan Rectangle");
1812 ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
1813 flag(pan_scan_rect_cancel_flag);
1815 if (!current->pan_scan_rect_cancel_flag) {
1816 ue(pan_scan_cnt_minus1, 0, 2);
1818 for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
1819 ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1820 ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1821 ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1822 ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1825 flag(pan_scan_rect_persistence_flag);
1837 HEADER(
"Recovery Point");
1839 se(recovery_poc_cnt, -32768, 32767);
1841 flag(exact_match_flag);
1842 flag(broken_link_flag);
1853 HEADER(
"Display Orientation");
1855 flag(display_orientation_cancel_flag);
1856 if (!current->display_orientation_cancel_flag) {
1859 ub(16, anticlockwise_rotation);
1860 flag(display_orientation_persistence_flag);
1874 HEADER(
"Active Parameter Sets");
1877 vps = h265->
vps[current->active_video_parameter_set_id];
1880 "parameter sets.\n", current->active_video_parameter_set_id);
1885 flag(self_contained_cvs_flag);
1886 flag(no_parameter_set_update_flag);
1889 for (i = 0; i <= current->num_sps_ids_minus1; i++)
1894 ues(layer_sps_idx[i], 0, current->num_sps_ids_minus1, 1, i);
1897 h265->
active_sps = h265->
sps[current->active_seq_parameter_set_id[current->layer_sps_idx[0]]];
1911 HEADER(
"Decoded Picture Hash");
1915 "No active SPS for decoded picture hash.\n");
1919 u(8, hash_type, 0, 2);
1922 if (current->hash_type == 0) {
1923 for (i = 0; i < 16; i++)
1924 us(8, picture_md5[c][i], 0x00, 0xff, 2, c, i);
1925 }
else if (current->hash_type == 1) {
1926 us(16, picture_crc[c], 0x0000, 0xffff, 1, c);
1927 }
else if (current->hash_type == 2) {
1928 us(32, picture_checksum[c], 0x00000000, 0xffffffff, 1, c);
1943 u(2, num_clock_ts, 1, 3);
1945 for (i = 0; i < current->num_clock_ts; i++) {
1946 flags(clock_timestamp_flag[i], 1, i);
1948 if (current->clock_timestamp_flag[i]) {
1949 flags(units_field_based_flag[i], 1, i);
1950 us(5, counting_type[i], 0, 6, 1, i);
1951 flags(full_timestamp_flag[i], 1, i);
1952 flags(discontinuity_flag[i], 1, i);
1953 flags(cnt_dropped_flag[i], 1, i);
1955 ubs(9, n_frames[i], 1, i);
1957 if (current->full_timestamp_flag[i]) {
1958 us(6, seconds_value[i], 0, 59, 1, i);
1959 us(6, minutes_value[i], 0, 59, 1, i);
1960 us(5, hours_value[i], 0, 23, 1, i);
1962 flags(seconds_flag[i], 1, i);
1963 if (current->seconds_flag[i]) {
1964 us(6, seconds_value[i], 0, 59, 1, i);
1965 flags(minutes_flag[i], 1, i);
1966 if (current->minutes_flag[i]) {
1967 us(6, minutes_value[i], 0, 59, 1, i);
1968 flags(hours_flag[i], 1, i);
1969 if (current->hours_flag[i])
1970 us(5, hours_value[i], 0, 23, 1, i);
1975 ubs(5, time_offset_length[i], 1, i);
1976 if (current->time_offset_length[i] > 0)
1977 ibs(current->time_offset_length[i], time_offset_value[i], 1, i);
1979 infer(time_offset_value[i], 0);
1992 HEADER(
"Alpha Channel Information");
1994 flag(alpha_channel_cancel_flag);
1995 if (!current->alpha_channel_cancel_flag) {
1996 ub(3, alpha_channel_use_idc);
1997 ub(3, alpha_channel_bit_depth_minus8);
1998 length = current->alpha_channel_bit_depth_minus8 + 9;
1999 ub(length, alpha_transparent_value);
2000 ub(length, alpha_opaque_value);
2001 flag(alpha_channel_incr_flag);
2002 flag(alpha_channel_clip_flag);
2003 if (current->alpha_channel_clip_flag)
2004 flag(alpha_channel_clip_type_flag);
2006 infer(alpha_channel_use_idc, 2);
2007 infer(alpha_channel_incr_flag, 0);
2008 infer(alpha_channel_clip_flag, 0);
2020 HEADER(
"Prefix Supplemental Enhancement Information");
2022 HEADER(
"Suffix Supplemental Enhancement Information");
#define allocate(name, size)
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
#define se(name, range_min, range_max)
uint8_t deblocking_filter_override_enabled_flag
uint8_t num_ref_idx_l0_default_active_minus1
#define fixed(width, name, value)
static int FUNC() sub_layer_hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawHRDParameters *hrd, int nal, int sub_layer_id)
H265RawHRDParameters hrd_parameters
uint8_t nal_hrd_parameters_present_flag
uint8_t chroma_qp_offset_list_enabled_flag
uint8_t bit_depth_luma_minus8
static int FUNC() sps_scc_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)
uint8_t frame_field_info_present_flag
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIRecoveryPoint *current, SEIMessageState *sei)
int8_t pps_act_y_qp_offset_plus5
static int FUNC() hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawHRDParameters *current, int common_inf_present_flag, int max_num_sub_layers_minus1)
#define us(width, name, range_min, range_max, subs,...)
uint8_t tiles_enabled_flag
H265RawSTRefPicSet st_ref_pic_set[HEVC_MAX_SHORT_TERM_REF_PIC_SETS]
static int FUNC() slice_segment_header(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
H265RawProfileTierLevel profile_tier_level
uint8_t pps_slice_chroma_qp_offsets_present_flag
static int FUNC() pps_scc_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
uint8_t sample_adaptive_offset_enabled_flag
uint8_t vui_parameters_present_flag
uint8_t bit_depth_chroma_minus8
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPanScanRect *current, SEIMessageState *sei)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
uint16_t pic_height_in_luma_samples
static int FUNC() pps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
static int FUNC() ref_pic_lists_modification(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current, unsigned int num_pic_total_curr)
uint8_t au_cpb_removal_delay_length_minus1
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
#define u(width, name, range_min, range_max)
uint8_t log2_max_pic_order_cnt_lsb_minus4
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawVUI *current, const H265RawSPS *sps)
uint8_t dpb_output_delay_length_minus1
CHECK(-1) CHECK(-2)}}}}CHECK(1) CHECK(2)}}}}}if(diff0+diff1 > 0) temp-
#define ses(name, range_min, range_max, subs,...)
static int get_bits_count(const GetBitContext *s)
uint8_t vps_max_sub_layers_minus1
static int FUNC() sei_active_parameter_sets(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIActiveParameterSets *current, SEIMessageState *sei)
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEI *current, int prefix)
static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size, int cur_pos)
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawExtensionData *current)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t pps_slice_act_qp_offsets_present_flag
static int FUNC() st_ref_pic_set(CodedBitstreamContext *ctx, RWContext *rw, H265RawSTRefPicSet *current, int st_rps_idx, const H265RawSPS *sps)
#define ue(name, range_min, range_max)
uint8_t num_negative_pics
uint8_t du_cpb_removal_delay_increment_length_minus1
uint8_t general_interlaced_source_flag
uint8_t vps_max_layers_minus1
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
uint8_t motion_vector_resolution_control_idc
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
#define profile_compatible(x)
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDisplayOrientation *current, SEIMessageState *sei)
uint8_t vui_hrd_parameters_present_flag
uint8_t num_long_term_ref_pics_sps
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
int8_t pps_beta_offset_div2
uint8_t pps_deblocking_filter_disabled_flag
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
uint16_t pic_width_in_luma_samples
uint8_t lists_modification_present_flag
uint8_t log2_min_luma_coding_block_size_minus3
uint8_t vcl_hrd_parameters_present_flag
uint8_t pps_seq_parameter_set_id
uint8_t cabac_init_present_flag
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H265RawAUD *current)
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
uint8_t num_extra_slice_header_bits
const H265RawSPS * active_sps
static int FUNC() scaling_list_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawScalingList *current)
uint8_t entropy_coding_sync_enabled_flag
uint8_t output_flag_present_flag
uint8_t weighted_bipred_flag
uint8_t dependent_slice_segments_enabled_flag
uint8_t sps_temporal_mvp_enabled_flag
#define xu(width, name, var, range_min, range_max, subs,...)
uint8_t pps_loop_filter_across_slices_enabled_flag
uint8_t weighted_pred_flag
static int FUNC() sei_alpha_channel_info(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIAlphaChannelInfo *current, SEIMessageState *sei)
static void skip_bits(GetBitContext *s, int n)
Context structure for coded bitstream operations.
const H265RawVPS * active_vps
static int FUNC() profile_tier_level(CodedBitstreamContext *ctx, RWContext *rw, H265RawProfileTierLevel *current, int profile_present_flag, int max_num_sub_layers_minus1)
uint8_t chroma_format_idc
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
const H265RawPPS * active_pps
uint8_t vps_base_layer_internal_flag
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIBufferingPeriod *current, SEIMessageState *sei)
#define flags(name, subs,...)
uint8_t num_positive_pics
void * priv_data
Internal codec-specific data.
static int FUNC() nal_unit_header(CodedBitstreamContext *ctx, RWContext *rw, H265RawNALUnitHeader *current, int expected_nal_unit_type)
uint8_t general_progressive_source_flag
static int ref[MAX_W *MAX_W]
#define bit(string, value)
uint8_t num_tile_rows_minus1
int8_t pps_act_cb_qp_offset_plus5
#define ubs(width, name, subs,...)
uint8_t sub_pic_hrd_params_present_flag
uint8_t num_tile_columns_minus1
uint8_t log2_diff_max_min_luma_coding_block_size
uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag
uint8_t cpb_cnt_minus1[HEVC_MAX_SUB_LAYERS]
uint8_t dpb_output_delay_du_length_minus1
uint8_t used_by_curr_pic_lt_sps_flag[HEVC_MAX_LONG_TERM_REF_PICS]
void * priv_data
Format private data.
uint8_t num_short_term_ref_pic_sets
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
uint8_t vps_temporal_id_nesting_flag
#define ibs(width, name, subs,...)
int8_t pps_tc_offset_div2
static int FUNC() sps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
static int FUNC() sei_decoded_picture_hash(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDecodedPictureHash *current, SEIMessageState *sei)
uint8_t pps_curr_pic_ref_enabled_flag
uint8_t slice_segment_header_extension_present_flag
#define infer(name, value)
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
uint8_t separate_colour_plane_flag
uint8_t initial_cpb_removal_delay_length_minus1
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
uint8_t long_term_ref_pics_present_flag
#define ues(name, range_min, range_max, subs,...)
static int FUNC() sei_time_code(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEITimeCode *current, SEIMessageState *sei)
int8_t pps_act_cr_qp_offset_plus3
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPicTiming *current, SEIMessageState *sei)
static int FUNC() vui_parameters_default(CodedBitstreamContext *ctx, RWContext *rw, H265RawVUI *current, H265RawSPS *sps)
uint8_t num_ref_idx_l1_default_active_minus1