/* packet-h265.c * Routines for H.265 dissection * Copyright 2018, Asaf Kave * Based on the H.264 dissector, thanks! * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later * * References: * https://tools.ietf.org/html/rfc7798 * http://www.itu.int/rec/T-REC-H.265/en */ #include "config.h" #include #include #include #include #include "packet-h265.h" #include "math.h" void proto_register_h265(void); void proto_reg_handoff_h265(void); /* Initialize the protocol and registered fields */ static int proto_h265; static int hf_h265_type; static int hf_h265_nal_unit_type; static int hf_h265_nuh_layer_id; static int hf_h265_nuh_temporal_id_plus1; static int hf_h265_nal_f_bit; static int hf_h265_start_bit; static int hf_h265_end_bit; static int hf_h265_rbsp_stop_bit; static int hf_h265_rbsp_trailing_bits; /* SDP */ static int hf_h265_sdp_parameter_sprop_vps; static int hf_h265_sdp_parameter_sprop_sps; static int hf_h265_sdp_parameter_sprop_pps; /*vps*/ static int hf_h265_vps_video_parameter_set_id; static int hf_h265_vps_base_layer_internal_flag; static int hf_h265_vps_base_layer_available_flag; static int hf_h265_vps_max_layers_minus1; static int hf_h265_vps_max_sub_layers_minus1; static int hf_h265_vps_temporal_id_nesting_flag; static int hf_h265_vps_reserved_0xffff_16bits; static int hf_h265_vps_sub_layer_ordering_info_present_flag; static int hf_h265_vps_max_dec_pic_buffering_minus1; static int hf_h265_vps_max_num_reorder_pics; static int hf_h265_vps_max_latency_increase_plus1; static int hf_h265_vps_max_layer_id; static int hf_h265_vps_num_layer_sets_minus1; static int hf_h265_layer_id_included_flag; static int hf_h265_vps_timing_info_present_flag; static int hf_h265_vps_num_units_in_tick; static int hf_h265_vps_time_scale; static int hf_h265_vps_poc_proportional_to_timing_flag; static int hf_h265_vps_num_ticks_poc_diff_one_minus1; static int hf_h265_vps_num_hrd_parameters; static int hf_h265_hrd_layer_set_idx; static int hf_h265_cprms_present_flag; static int hf_h265_vps_extension_flag; static int hf_h265_vps_extension_data_flag; /* profile_tier_level */ static int hf_h265_general_profile_space; static int hf_h265_general_tier_flag; static int hf_h265_general_profile_idc; static int hf_h265_general_profile_compatibility_flags; static int hf_h265_general_progressive_source_flag; static int hf_h265_general_interlaced_source_flag; static int hf_h265_general_non_packed_constraint_flag; static int hf_h265_general_frame_only_constraint_flag; static int hf_h265_general_max_12bit_constraint_flag; static int hf_h265_general_max_10bit_constraint_flag; static int hf_h265_general_max_8bit_constraint_flag; static int hf_h265_general_max_422chroma_constraint_flag; static int hf_h265_general_max_420chroma_constraint_flag; static int hf_h265_general_max_monochrome_constraint_flag; static int hf_h265_general_intra_constraint_flag; static int hf_h265_general_one_picture_only_constraint_flag; static int hf_h265_general_lower_bit_rate_constraint_flag; static int hf_h265_general_max_14bit_constraint_flag; static int hf_h265_general_reserved_zero_33bits; static int hf_h265_general_reserved_zero_34bits; static int hf_h265_general_reserved_zero_7bits; static int hf_h265_general_reserved_zero_35bits; static int hf_h265_general_reserved_zero_43bits; static int hf_h265_general_inbld_flag; static int hf_h265_general_reserved_zero_bit; static int hf_h265_general_level_idc; static int hf_h265_sub_layer_profile_present_flag; static int hf_h265_sub_layer_level_present_flag; static int hf_h265_reserved_zero_2bits; static int hf_h265_sub_layer_profile_space; static int hf_h265_sub_layer_tier_flag; static int hf_h265_sub_layer_profile_idc; static int hf_h265_sub_layer_profile_compatibility_flag; static int hf_h265_sub_layer_progressive_source_flag; static int hf_h265_sub_layer_interlaced_source_flag; static int hf_h265_sub_layer_non_packed_constraint_flag; static int hf_h265_sub_layer_frame_only_constraint_flag; static int hf_h265_sub_layer_max_12bit_constraint_flag; static int hf_h265_sub_layer_max_10bit_constraint_flag; static int hf_h265_sub_layer_max_8bit_constraint_flag; static int hf_h265_sub_layer_max_422chroma_constraint_flag; static int hf_h265_sub_layer_max_420chroma_constraint_flag; static int hf_h265_sub_layer_max_monochrome_constraint_flag; static int hf_h265_sub_layer_intra_constraint_flag; static int hf_h265_sub_layer_one_picture_only_constraint_flag; static int hf_h265_sub_layer_lower_bit_rate_constraint_flag; static int hf_h265_sub_layer_max_14bit_constraint_flag; static int hf_h265_sub_layer_reserved_zero_33bits; static int hf_h265_sub_layer_reserved_zero_34bits; static int hf_h265_sub_layer_reserved_zero_7bits; static int hf_h265_sub_layer_reserved_zero_35bits; static int hf_h265_sub_layer_reserved_zero_43bits; static int hf_h265_sub_layer_inbld_flag; static int hf_h265_sub_layer_reserved_zero_bit; static int hf_h265_sub_layer_level_idc; /* hrd_parameters */ static int hf_h265_nal_hrd_parameters_present_flag; static int hf_h265_vcl_hrd_parameters_present_flag; static int hf_h265_sub_pic_hrd_params_present_flag; static int hf_h265_tick_divisor_minus2; static int hf_h265_du_cpb_removal_delay_increment_length_minus1; static int hf_h265_sub_pic_cpb_params_in_pic_timing_sei_flag; static int hf_h265_dpb_output_delay_du_length_minus1; static int hf_h265_bit_rate_scale; static int hf_h265_cpb_size_scale; static int hf_h265_cpb_size_du_scale; static int hf_h265_initial_cpb_removal_delay_length_minus1; static int hf_h265_au_cpb_removal_delay_length_minus1; static int hf_h265_dpb_output_delay_length_minus1; static int hf_h265_fixed_pic_rate_general_flag; static int hf_h265_fixed_pic_rate_within_cvs_flag; static int hf_h265_elemental_duration_in_tc_minus1; static int hf_h265_low_delay_hrd_flag; static int hf_h265_cpb_cnt_minus1; /* sub-layer hrd_parameters */ static int hf_h265_bit_rate_value_minus1; static int hf_h265_cpb_size_value_minus1; static int hf_h265_cpb_size_du_value_minus1; static int hf_h265_bit_rate_du_value_minus1; static int hf_h265_cbr_flag; /*sps*/ static int hf_h265_sps_video_parameter_set_id; static int hf_h265_sps_max_sub_layers_minus1; static int hf_h265_sps_temporal_id_nesting_flag; static int hf_h265_sps_seq_parameter_set_id; static int hf_h265_chroma_format_idc; static int hf_h265_separate_colour_plane_flag; static int hf_h265_pic_width_in_luma_samples; static int hf_h265_pic_height_in_luma_samples; static int hf_h265_conformance_window_flag; static int hf_h265_conf_win_left_offset; static int hf_h265_conf_win_right_offset; static int hf_h265_conf_win_top_offset; static int hf_h265_conf_win_bottom_offset; static int hf_h265_bit_depth_luma_minus8; static int hf_h265_bit_depth_chroma_minus8; static int hf_h265_log2_max_pic_order_cnt_lsb_minus4; static int hf_h265_sps_sub_layer_ordering_info_present_flag; static int hf_h265_sps_max_dec_pic_buffering_minus1; static int hf_h265_sps_max_num_reorder_pics; static int hf_h265_sps_max_latency_increase_plus1; static int hf_h265_log2_min_luma_coding_block_size_minus3; static int hf_h265_log2_diff_max_min_luma_coding_block_size; static int hf_h265_log2_min_luma_transform_block_size_minus2; static int hf_h265_log2_diff_max_min_luma_transform_block_size; static int hf_h265_max_transform_hierarchy_depth_inter; static int hf_h265_max_transform_hierarchy_depth_intra; static int hf_h265_scaling_list_enabled_flag; static int hf_h265_sps_scaling_list_data_present_flag; static int hf_h265_amp_enabled_flag; static int hf_h265_sample_adaptive_offset_enabled_flag; static int hf_h265_pcm_enabled_flag; static int hf_h265_pcm_sample_bit_depth_luma_minus1; static int hf_h265_pcm_sample_bit_depth_chroma_minus1; static int hf_h265_log2_min_pcm_luma_coding_block_size_minus3; static int hf_h265_log2_diff_max_min_pcm_luma_coding_block_size; static int hf_h265_pcm_loop_filter_disabled_flag; static int hf_h265_num_short_term_ref_pic_sets; static int hf_h265_long_term_ref_pics_present_flag; static int hf_h265_num_long_term_ref_pics_sps; static int hf_h265_lt_ref_pic_poc_lsb_sps; static int hf_h265_used_by_curr_pic_lt_sps_flag; static int hf_h265_sps_temporal_mvp_enabled_flag; static int hf_h265_strong_intra_smoothing_enabled_flag; static int hf_h265_vui_parameters_present_flag; static int hf_h265_sps_extension_present_flag; static int hf_h265_sps_range_extension_flag; static int hf_h265_sps_multilayer_extension_flag; static int hf_h265_sps_3d_extension_flag; static int hf_h265_sps_scc_extension_flag; static int hf_h265_sps_extension_4bits; static int hf_h265_sps_extension_data_flag; /* scaling_list_data */ static int hf_h265_scaling_list_pred_mode_flag; static int hf_h265_scaling_list_pred_matrix_id_delta; static int hf_h265_scaling_list_dc_coef_minus8; static int hf_h265_scaling_list_delta_coef; /* st_ref_pic_set */ static int hf_h265_inter_ref_pic_set_prediction_flag; static int hf_h265_delta_idx_minus1; static int hf_h265_delta_rps_sign; static int hf_h265_abs_delta_rps_minus1; static int hf_h265_used_by_curr_pic_flag; static int hf_h265_use_delta_flag; static int hf_h265_num_negative_pics; static int hf_h265_num_positive_pics; static int hf_h265_delta_poc_s0_minus1; static int hf_h265_used_by_curr_pic_s0_flag; static int hf_h265_delta_poc_s1_minus1; static int hf_h265_used_by_curr_pic_s1_flag; /* sps_range_extension */ static int hf_h265_transform_skip_rotation_enabled_flag; static int hf_h265_transform_skip_context_enabled_flag; static int hf_h265_implicit_rdpcm_enabled_flag; static int hf_h265_explicit_rdpcm_enabled_flag; static int hf_h265_extended_precision_processing_flag; static int hf_h265_intra_smoothing_disabled_flag; static int hf_h265_high_precision_offsets_enabled_flag; static int hf_h265_persistent_rice_adaptation_enabled_flag; static int hf_h265_cabac_bypass_alignment_enabled_flag; /* sps_scc_extension */ static int hf_h265_sps_curr_pic_ref_enabled_flag; static int hf_h265_palette_mode_enabled_flag; static int hf_h265_palette_max_size; static int hf_h265_delta_palette_max_predictor_size; static int hf_h265_sps_palette_predictor_initializers_present_flag; static int hf_h265_sps_num_palette_predictor_initializers_minus1; static int hf_h265_sps_palette_predictor_initializer; static int hf_h265_motion_vector_resolution_control_idc; static int hf_h265_intra_boundary_filtering_disabled_flag; /* PPS */ static int hf_h265_pps_pic_parameter_set_id; static int hf_h265_pps_seq_parameter_set_id; static int hf_h265_dependent_slice_segments_enabled_flag; static int hf_h265_output_flag_present_flag; static int hf_h265_num_extra_slice_header_bits; static int hf_h265_sign_data_hiding_enabled_flag; static int hf_h265_cabac_init_present_flag; static int hf_h265_num_ref_idx_l0_default_active_minus1; static int hf_h265_num_ref_idx_l1_default_active_minus1; static int hf_h265_init_qp_minus26; static int hf_h265_constrained_intra_pred_flag; static int hf_h265_transform_skip_enabled_flag; static int hf_h265_cu_qp_delta_enabled_flag; static int hf_h265_diff_cu_qp_delta_depth; static int hf_h265_pps_cb_qp_offset; static int hf_h265_pps_cr_qp_offset; static int hf_h265_pps_slice_chroma_qp_offsets_present_flag; static int hf_h265_weighted_pred_flag; static int hf_h265_weighted_bipred_flag; static int hf_h265_transquant_bypass_enabled_flag; static int hf_h265_tiles_enabled_flag; static int hf_h265_entropy_coding_sync_enabled_flag; static int hf_h265_num_tile_columns_minus1; static int hf_h265_num_tile_rows_minus1; static int hf_h265_uniform_spacing_flag; static int hf_h265_column_width_minus1; static int hf_h265_row_height_minus1; static int hf_h265_loop_filter_across_tiles_enabled_flag; static int hf_h265_pps_loop_filter_across_slices_enabled_flag; static int hf_h265_deblocking_filter_control_present_flag; static int hf_h265_deblocking_filter_override_enabled_flag; static int hf_h265_pps_deblocking_filter_disabled_flag; static int hf_h265_pps_beta_offset_div2; static int hf_h265_pps_tc_offset_div2; static int hf_h265_pps_scaling_list_data_present_flag; static int hf_h265_lists_modification_present_flag; static int hf_h265_log2_parallel_merge_level_minus2; static int hf_h265_slice_segment_header_extension_present_flag; static int hf_h265_pps_extension_present_flag; static int hf_h265_pps_range_extension_flag; static int hf_h265_pps_multilayer_extension_flag; static int hf_h265_pps_3d_extension_flag; static int hf_h265_pps_scc_extension_flag; static int hf_h265_pps_extension_4bits; static int hf_h265_pps_extension_data_flag; /*pps_range_extension*/ static int hf_h265_log2_max_transform_skip_block_size_minus2; static int hf_h265_cross_component_prediction_enabled_flag; static int hf_h265_chroma_qp_offset_list_enabled_flag; static int hf_h265_diff_cu_chroma_qp_offset_depth; static int hf_h265_chroma_qp_offset_list_len_minus1; static int hf_h265_cb_qp_offset_list; static int hf_h265_cr_qp_offset_list; static int hf_h265_log2_sao_offset_scale_luma; static int hf_h265_log2_sao_offset_scale_chroma; /*pps_scc_extension*/ static int hf_h265_pps_curr_pic_ref_enabled_flag; static int hf_h265_residual_adaptive_colour_transform_enabled_flag; static int hf_h265_pps_slice_act_qp_offsets_present_flag; static int hf_h265_pps_act_y_qp_offset_plus5; static int hf_h265_pps_act_cb_qp_offset_plus5; static int hf_h265_pps_act_cr_qp_offset_plus3; static int hf_h265_pps_palette_predictor_initializers_present_flag; static int hf_h265_pps_num_palette_predictor_initializers; static int hf_h265_monochrome_palette_flag; static int hf_h265_luma_bit_depth_entry_minus8; static int hf_h265_chroma_bit_depth_entry_minus8; static int hf_h265_pps_palette_predictor_initializer; /* VUI parameters */ static int hf_h265_aspect_ratio_info_present_flag; static int hf_h265_aspect_ratio_idc; static int hf_h265_sar_width; static int hf_h265_sar_height; static int hf_h265_overscan_info_present_flag; static int hf_h265_overscan_appropriate_flag; static int hf_h265_video_signal_type_present_flag; static int hf_h265_video_format; static int hf_h265_video_full_range_flag; static int hf_h265_colour_description_present_flag; static int hf_h265_colour_primaries; static int hf_h265_transfer_characteristics; static int hf_h265_matrix_coeffs; static int hf_h265_chroma_loc_info_present_flag; static int hf_h265_chroma_sample_loc_type_top_field; static int hf_h265_chroma_sample_loc_type_bottom_field; static int hf_h265_neutral_chroma_indication_flag; static int hf_h265_field_seq_flag; static int hf_h265_frame_field_info_present_flag; static int hf_h265_default_display_window_flag; static int hf_h265_def_disp_win_left_offset; static int hf_h265_def_disp_win_right_offset; static int hf_h265_def_disp_win_top_offset; static int hf_h265_def_disp_win_bottom_offset; static int hf_h265_vui_timing_info_present_flag; static int hf_h265_vui_num_units_in_tick; static int hf_h265_vui_time_scale; static int hf_h265_vui_poc_proportional_to_timing_flag; static int hf_h265_vui_num_ticks_poc_diff_one_minus1; static int hf_h265_vui_hrd_parameters_present_flag; static int hf_h265_bitstream_restriction_flag; static int hf_h265_tiles_fixed_structure_flag; static int hf_h265_motion_vectors_over_pic_boundaries_flag; static int hf_h265_restricted_ref_pic_lists_flag; static int hf_h265_min_spatial_segmentation_idc; static int hf_h265_max_bytes_per_pic_denom; static int hf_h265_max_bits_per_min_cu_denom; static int hf_h265_log2_max_mv_length_horizontal; static int hf_h265_log2_max_mv_length_vertical; /* slice_segment_header */ static int hf_h265_slice_pic_parameter_set_id; static int hf_h265_slice_segment_address; static int hf_h265_slice_type; /* SEI */ static int hf_h265_payloadsize; static int hf_h265_payloadtype; /* access unit delimiter */ static int hf_h265_pic_type; /* Initialize the subtree pointers */ static int ett_h265; static int ett_h265_profile; static int ett_h265_nal; static int ett_h265_fu; static int ett_h265_stream; static int ett_h265_sps_multilayer_extension; static int ett_h265_sps_3d_extension; static int ett_h265_pps_multilayer_extension; static int ett_h265_pps_3d_extension; static int ett_h265_access_unit_delimiter_rbsp; static int ett_h265_sei_rbsp; static int ett_h265_filler_data_rbsp; static int ett_h265_end_of_seq_rbsp; static int ett_h265_end_of_bitstream_rbsp; static int ett_h265_profile_tier_level; static int ett_h265_ref_pic_set; static int ett_h265_vui_parameters; static int ett_h265_hrd_parameters; static int ett_h265_sprop_parameters; static expert_field ei_h265_undecoded; static expert_field ei_h265_format_specific_parameter; static expert_field ei_h265_oversized_exp_golomb_code; static expert_field ei_h265_value_to_large; static dissector_handle_t h265_handle; static bool dependent_slice_segments_enabled_flag; static unsigned num_extra_slice_header_bits; static unsigned log2_min_luma_coding_block_size_minus3; static unsigned log2_diff_max_min_luma_coding_block_size; static unsigned pic_width_in_luma_samples; static unsigned pic_height_in_luma_samples; /* syntax tables in subclause 7.3 is equal to * ue(v), me(v), se(v), or te(v). */ typedef enum { H265_UE_V = 0, H265_ME_V = 1, H265_SE_V = 2, H265_TE_V = 3 } h265_golomb_descriptors; static const true_false_string h265_f_bit_vals = { "Bit errors or other syntax violations", "No bit errors or other syntax violations" }; static const true_false_string h265_start_bit_vals = { "the first packet of FU-A picture", "Not the first packet of FU-A picture" }; static const true_false_string h265_end_bit_vals = { "the last packet of FU-A picture", "Not the last packet of FU-A picture" }; static const value_string h265_type_values[] = { { 0, "TRAIL_N - Coded slice segment of a non-TSA, non-STSA trailing picture" }, { 1, "TRAIL_R - Coded slice segment of a non-TSA, non-STSA trailing picture" }, { 2, "TSA_N - Coded slice segment of a TSA picture" }, { 3, "TSA_R - Coded slice segment of a TSA picture" }, { 4, "STSA_N - Coded slice segment of an STSA picture" }, { 5, "STSA_R - Coded slice segment of an STSA picture" }, { 6, "RADL_N - Coded slice segment of a RADL picture" }, { 7, "RADL_R - Coded slice segment of a RADL picture" }, { 8, "RASL_N - Coded slice segment of a RASL picture" }, { 9, "RASL_R - Coded slice segment of a RASL picture" }, { 10, "RSV_VCL_N10 - Reserved non-IRAP SLNR VCL NAL unit types" }, { 11, "RSV_VCL_R11 - Reserved non-IRAP sub-layer reference VCL NAL unit types" }, { 12, "RSV_VCL_N12 - Reserved non-IRAP SLNR VCL NAL unit types" }, { 13, "RSV_VCL_R13 - Reserved non-IRAP sub-layer reference VCL NAL unit types" }, { 14, "RSV_VCL_N14 - Reserved non-IRAP SLNR VCL NAL unit types" }, { 15, "RSV_VCL_R15 - Reserved non-IRAP sub-layer reference VCL NAL unit types" }, { 16, "BLA_W_LP - Coded slice segment of a BLA picture" }, { 17, "BLA_W_RADL - Coded slice segment of a BLA picture" }, { 18, "BLA_N_LP - Coded slice segment of a BLA picture" }, { 19, "IDR_W_RADL - Coded slice segment of an IDR picture" }, { 20, "IDR_N_LP - Coded slice segment of an IDR picture" }, { 21, "CRA_NUT - Coded slice segment of a CRA picture" }, { 22, "RSV_IRAP_VCL22 - Reserved IRAP VCL NAL unit types" }, { 23, "RSV_IRAP_VCL23 - Reserved IRAP VCL NAL unit types" }, { 24, "RSV_VCL24 - Reserved non-IRAP VCL NAL unit types" }, { 25, "RSV_VCL25 - Reserved non-IRAP VCL NAL unit types" }, { 26, "RSV_VCL26 - Reserved non-IRAP VCL NAL unit types" }, { 27, "RSV_VCL27 - Reserved non-IRAP VCL NAL unit types" }, { 28, "RSV_VCL28 - Reserved non-IRAP VCL NAL unit types" }, { 29, "RSV_VCL29 - Reserved non-IRAP VCL NAL unit types" }, { 30, "RSV_VCL30 - Reserved non-IRAP VCL NAL unit types" }, { 31, "RSV_VCL31 - Reserved non-IRAP VCL NAL unit types" }, { 32, "VPS_NUT - Video parameter set" }, { 33, "SPS_NUT - Sequence parameter set" }, { 34, "PPS_NUT - Picture parameter set" }, { 35, "AUD_NUT - Access unit delimiter" }, { 36, "EOS_NUT - End of sequence" }, { 37, "EOB_NUT - End of bitstream" }, { 38, "FD_NUT - Filler data" }, { 39, "PREFIX_SEI_NUT - Supplemental enhancement information" }, { 40, "SUFFIX_SEI_NUT - Supplemental enhancement information" }, { 41, "RSV_NVCL41 - Reserved" }, { 42, "RSV_NVCL42 - Reserved" }, { 43, "RSV_NVCL43 - Reserved" }, { 44, "RSV_NVCL44 - Reserved" }, { 45, "RSV_NVCL45 - Reserved" }, { 46, "RSV_NVCL46 - Reserved" }, { 47, "RSV_NVCL47 - Reserved" }, { 48, "APS - Aggregation Packets" }, { 49, "FU - Fragmentation Units" }, { 50, "PACI - PACI Packets" }, { 51, "UNSPEC51 - Unspecified" }, { 52, "UNSPEC52 - Unspecified" }, { 53, "UNSPEC53 - Unspecified" }, { 54, "UNSPEC54 - Unspecified" }, { 55, "UNSPEC55 - Unspecified" }, { 56, "UNSPEC56 - Unspecified" }, { 57, "UNSPEC57 - Unspecified" }, { 58, "UNSPEC58 - Unspecified" }, { 59, "UNSPEC59 - Unspecified" }, { 60, "UNSPEC60 - Unspecified" }, { 61, "UNSPEC61 - Unspecified" }, { 62, "UNSPEC62 - Unspecified" }, { 63, "UNSPEC63 - Unspecified" }, { 0, NULL } }; static const value_string h265_type_summary_values[] = { { 0, "TRAIL_N" }, { 1, "TRAIL_R" }, { 2, "TSA_N" }, { 3, "TSA_R" }, { 4, "STSA_N" }, { 5, "STSA_R" }, { 6, "RADL_N" }, { 7, "RADL_R" }, { 8, "RASL_N" }, { 9, "RASL_R" }, { 10, "RSV_VCL_N10" }, { 11, "RSV_VCL_R11" }, { 12, "RSV_VCL_N12" }, { 13, "RSV_VCL_R13" }, { 14, "RSV_VCL_N14" }, { 15, "RSV_VCL_R15" }, { 16, "BLA_W_LP" }, { 17, "BLA_W_RADL" }, { 18, "BLA_N_LP" }, { 19, "IDR_W_RADL" }, { 20, "IDR_N_LP" }, { 21, "CRA_NUT" }, { 22, "RSV_IRAP_VCL22" }, { 23, "RSV_IRAP_VCL23" }, { 24, "RSV_VCL24" }, { 25, "RSV_VCL25" }, { 26, "RSV_VCL26" }, { 27, "RSV_VCL27" }, { 28, "RSV_VCL28" }, { 29, "RSV_VCL29" }, { 30, "RSV_VCL30" }, { 31, "RSV_VCL31" }, { 32, "VPS_NUT" }, { 33, "SPS_NUT" }, { 34, "PPS_NUT" }, { 35, "AUD_NUT" }, { 36, "EOS_NUT" }, { 37, "EOB_NUT" }, { 38, "FD_NUT" }, { 39, "PREFIX_SEI_NUT" }, { 40, "SUFFIX_SEI_NUT" }, { 41, "RSV_NVCL41" }, { 42, "RSV_NVCL42" }, { 43, "RSV_NVCL43" }, { 44, "RSV_NVCL44" }, { 45, "RSV_NVCL45" }, { 46, "RSV_NVCL46" }, { 47, "RSV_NVCL47" }, { 48, "APS" }, { 49, "FU" }, { 50, "PACI" }, { 51, "UNSPEC51" }, { 52, "UNSPEC52" }, { 53, "UNSPEC53" }, { 54, "UNSPEC54" }, { 55, "UNSPEC55" }, { 56, "UNSPEC56" }, { 57, "UNSPEC57" }, { 58, "UNSPEC58" }, { 59, "UNSPEC59" }, { 60, "UNSPEC60" }, { 61, "UNSPEC61" }, { 62, "UNSPEC62" }, { 63, "UNSPEC63" }, { 0, NULL } }; /* A.3 Profiles */ static const value_string h265_profile_idc_values[] = { { 1, "Main profile" }, { 2, "Main 10 and Main 10 Still Picture profiles" }, { 3, "Main Still Picture profile" }, { 4, "Format range extensions profiles" }, { 5, "High throughput profiles" }, { 9, "Screen content coding extensions profiles" }, { 0, NULL } }; /* Table A.7-Tier and level limits for the video profiles */ /* XXX - this looks as if the values are 10 times the level value * in Table A.7. */ static const value_string h265_level_main_tier_bitrate_values[] = { { 10, "128 kb/s" }, { 20, "1.5 Mb/s" }, { 21, "3 Mb/s" }, { 30, "6 Mb/s" }, { 31, "10 Mb/s" }, { 40, "12 Mb/s" }, { 41, "20 Mb/s" }, { 50, "25 Mb/s" }, { 51, "40 Mb/s" }, { 52, "60 Mb/s" }, { 60, "60 Mb/s" }, { 61, "120 Mb/s" }, { 62, "240 Mb/s" }, { 0, NULL } }; /*High tier*/ static const value_string h265_level_high_tier_bitrate_values[] = { { 40, "30 Mb/s" }, { 41, "50 Mb/s" }, { 50, "100 Mb/s" }, { 51, "160 Mb/s" }, { 52, "240 Mb/s" }, { 60, "240 Mb/s" }, { 61, "480 Mb/s" }, { 62, "800 Mb/s" }, { 0, NULL } }; /* Table 7-7 - Name association to slice_type */ static const value_string h265_slice_type_vals[] = { { 0, "B (B slice)" }, { 1, "P (P slice)" }, { 2, "I (I slice)" }, { 0, NULL } }; /* D.2 SEI payload syntax */ static const value_string h265_sei_payload_vals[] = { { 0, "buffering_period" }, { 1, "pic_timing" }, { 2, "pan_scan_rect" }, { 3, "filler_payload" }, { 4, "user_data_registered_itu_t_t35" }, { 5, "user_data_unregistered" }, { 6, "recovery_point" }, { 9, "scene_info" }, { 15, "picture_snapshot" }, { 16, "progressive_refinement_segment_start" }, { 17, "progressive_refinement_segment_end" }, { 19, "film_grain_characteristics" }, { 23, "tone_mapping_info" }, { 45, "frame_packing_arrangement" }, { 47, "display_orientation" }, { 56, "green_metadata" }, /* specified in ISO/IEC 23001-11 */ { 128, "structure_of_pictures_info" }, { 129, "active_parameter_sets" }, { 130, "decoding_unit_info" }, { 131, "temporal_sub_layer_zero_idx" }, { 133, "scalable_nesting" }, { 134, "region_refresh_info" }, { 135, "no_display" }, { 136, "time_code" }, { 137, "mastering_display_colour_volume" }, { 138, "segmented_rect_frame_packing_arrangement" }, { 139, "temporal_motion_constrained_tile_sets" }, { 140, "chroma_resampling_filter_hint" }, { 141, "knee_function_info" }, { 142, "colour_remapping_info" }, { 143, "deinterlaced_field_identification" }, { 144, "content_light_level_info" }, { 145, "dependent_rap_indication" }, { 146, "coded_region_completion" }, { 147, "alternative_transfer_characteristics" }, { 148, "ambient_viewing_environment" }, { 149, "content_colour_volume" }, { 150, "equirectangular_projection" }, { 151, "cubemap_projection" }, { 154, "sphere_rotation" }, { 155, "regionwise_packing" }, { 156, "omni_viewport" }, { 157, "regional_nesting" }, { 158, "mcts_extraction_info_sets" }, { 159, "mcts_extraction_info_nesting" }, { 160, "layers_not_present" }, /* specified in Annex F */ { 161, "inter_layer_constrained_tile_sets" }, /* specified in Annex F */ { 162, "bsp_nesting" }, /* specified in Annex F */ { 163, "bsp_initial_arrival_time" }, /* specified in Annex F */ { 164, "sub_bitstream_property" }, /* specified in Annex F */ { 165, "alpha_channel_info" }, /* specified in Annex F */ { 166, "overlay_info" }, /* specified in Annex F */ { 167, "temporal_mv_prediction_constraints" }, /* specified in Annex F */ { 168, "frame_field_info" }, /* specified in Annex F */ { 176, "three_dimensional_reference_displays_info" }, /* specified in Annex G */ { 177, "depth_representation_info" }, /* specified in Annex G */ { 178, "multiview_scene_info" }, /* specified in Annex G */ { 179, "multiview_acquisition_info" }, /* specified in Annex G */ { 180, "multiview_view_position" }, /* specified in Annex G */ { 181, "alternative_depth_info" }, /* specified in Annex I */ { 0, NULL } }; /* Table 7-2 - Interpretation of pic_type */ static const value_string h265_pic_type_vals[] = { { 0, "I" }, { 1, "P, I" }, { 2, "B, P, I" }, { 0, NULL } }; /* Ref 7.3.2.2 Sequence parameter set RBSP syntax * num_short_term_ref_pic_sets specifies the number of st_ref_pic_set( ) syntax structures included in the SPS. The value * of num_short_term_ref_pic_sets shall be in the range of 0 to 64, inclusive */ #define H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS 64 static int dissect_h265(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_); static int dissect_h265_profile_tier_level(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int offset, bool profilePresentFlag, int vps_max_sub_layers_minus1); static int dissect_h265_hrd_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset, bool commonInfPresentFlag, unsigned maxNumSubLayersMinus1); static int dissect_h265_scaling_list_data(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_st_ref_pic_set(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, int stRpsIdx, int num_short_term_ref_pic_sets, int32_t NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS]); static int dissect_h265_vui_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int bit_offset, uint8_t sps_max_sub_layers_minus1); static int dissect_h265_sps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_sps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_sps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_sps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, unsigned chroma_format_idc, unsigned bit_depth_luma_minus8, unsigned bit_depth_chroma_minus8); static int dissect_h265_pps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, unsigned transform_skip_enabled_flag); static int dissect_h265_pps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_pps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_pps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset); static int dissect_h265_sei_message(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, uint8_t nal_unit_type); #if 0 /* byte_aligned( ) is specified as follows. * - If the current position in the bitstream is on a byte boundary, i.e., * the next bit in the bitstream is the first bit in a byte, * the return value of byte_aligned( ) is equal to true. * - Otherwise, the return value of byte_aligned( ) is equal to false. */ static bool h265_byte_aligned(int bit_offset) { if (bit_offset & 0x3) return false; return true; } /* more_data_in_payload( ) is specified as follows: * - If byte_aligned( ) is equal to true and the current position in the sei_payload( ) syntax structure is * 8 * payloadSize bits from the beginning of the sei_payload( ) syntax structure, the return value of * more_data_in_payload( ) is equal to false. * - Otherwise, the return value of more_data_in_payload( ) is equal to true. */ static bool h265_more_data_in_payload(int bit_start, int bit_offset, int payloadSize) { if (h265_byte_aligned(bit_offset) && bit_start + 8 * payloadSize == bit_offset) return false; return true; } /* payload_extension_present( ) is specified as follows: * - If the current position in the sei_payload( ) syntax structure is not the position of the last (least significant, right- * most) bit that is equal to 1 that is less than 8 * payloadSize bits from the beginning of the syntax structure (i.e., * the position of the payload_bit_equal_to_one syntax element), the return value of payload_extension_present( ) is equal to true. * - Otherwise, the return value of payload_extension_present( ) * is equal to false. */ static bool h265_payload_extension_present(tvbuff_t* tvb, int bit_start, int bit_offset, int payloadSize) { if (bit_start + 8 * payloadSize > bit_offset && tvb_get_bits8(tvb, bit_offset, 1)) return true; return false; } #endif /* Expect a tvb and a bit offset into the tvb * returns the value and bit_offset * * This supports 32 bit output values. If the exp-Golomb coded value overflows * the 32 bit type, it will return the actual bit offset but clamp the value * and add an expert info. */ #define cVALS(x) (const value_string*)(x) static uint32_t dissect_h265_exp_golomb_code(proto_tree *tree, int hf_index, tvbuff_t *tvb, packet_info *pinfo, int *start_bit_offset, h265_golomb_descriptors descriptor) /*(tvbuff_t *tvb, int *start_bit_offset) */ { proto_item *ti; int leading_zero_bits, bit_offset, start_offset; uint32_t codenum, mask, value, tmp; int32_t se_value = 0; int b; char *str; int bit; int i; bool overflow = false; header_field_info *hf_field = NULL; start_offset = *start_bit_offset >> 3; if (hf_index > 0) { hf_field = proto_registrar_get_nth(hf_index); } if (hf_field) { /* Allow only int32_t for se(v), uint32_t for others. */ switch (descriptor) { case H265_SE_V: DISSECTOR_ASSERT_FIELD_TYPE(hf_field, FT_INT32); break; default: DISSECTOR_ASSERT_FIELD_TYPE(hf_field, FT_UINT32); break; } } bit_offset = *start_bit_offset; /* prepare the string */ str = (char *)wmem_alloc(pinfo->pool, 256); str[0] = '\0'; for (bit = 0; bit<((int)(bit_offset & 0x07)); bit++) { if (bit && (!(bit % 4))) { (void) g_strlcat(str, " ", 256); } (void) g_strlcat(str, ".", 256); } leading_zero_bits = -1; for (b = 0; !b; leading_zero_bits++) { if (bit && (!(bit % 4))) { (void) g_strlcat(str, " ", 256); } if (bit && (!(bit % 8))) { (void) g_strlcat(str, " ", 256); } b = tvb_get_bits8(tvb, bit_offset, 1); if (b != 0) { (void) g_strlcat(str, "1", 256); } else { (void) g_strlcat(str, "0", 256); } bit++; bit_offset++; } /* XXX: This could be handled in the general case and reduce code * duplication. */ if (leading_zero_bits == 0) { codenum = 0; *start_bit_offset = bit_offset; for (; bit % 8; bit++) { if (bit && (!(bit % 4))) { (void) g_strlcat(str, " ", 256); } (void) g_strlcat(str, ".", 256); } if (hf_field) { (void) g_strlcat(str, " = ", 256); (void) g_strlcat(str, hf_field->name, 256); switch (descriptor) { case H265_SE_V: /* if the syntax element is coded as se(v), * the value of the syntax element is derived by invoking the * mapping process for signed Exp-Golomb codes as specified in * subclause 9.1.1 with codeNum as the input. */ if (hf_field->type == FT_INT32) { if (hf_field->strings) { proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %s (%d)", str, val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "), codenum); } else { switch (hf_field->display) { case BASE_DEC: proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %d", str, codenum); break; default: DISSECTOR_ASSERT_NOT_REACHED(); break; } } } return codenum; default: break; } if (hf_field->type == FT_UINT32) { if (hf_field->strings) { proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %s (%u)", str, val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "), codenum); } else { switch (hf_field->display) { case BASE_DEC: proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %u", str, codenum); break; case BASE_HEX: proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: 0x%x", str, codenum); break; default: DISSECTOR_ASSERT_NOT_REACHED(); break; } } } else { /* Only allow uint32_t */ DISSECTOR_ASSERT_NOT_REACHED(); } } return codenum; } /* Syntax elements coded as ue(v), me(v), or se(v) are Exp-Golomb-coded. Syntax elements coded as te(v) are truncated Exp-Golomb-coded. The parsing process for these syntax elements begins with reading the bits starting at the current location in the bitstream up to and including the first non-zero bit, and counting the number of leading bits that are equal to 0. This process is specified as follows: leadingZeroBits = -1; for (b = 0; !b; leadingZeroBits++) b = read_bits( 1 ) The variable codeNum is then assigned as follows: codeNum = 2leadingZeroBits - 1 + read_bits( leadingZeroBits ) where the value returned from read_bits( leadingZeroBits ) is interpreted as a binary representation of an unsigned integer with most significant bit written first. */ if (leading_zero_bits > 32) { overflow = true; codenum = UINT32_MAX; if (descriptor == H265_SE_V) { /* For signed, must read the last bit to get the sign. */ value = tvb_get_bits32(tvb, bit_offset + 32*(leading_zero_bits / 32), leading_zero_bits % 32, ENC_BIG_ENDIAN); if (value % 2) { se_value = INT32_MIN; } else { se_value = INT32_MAX; } } } else if (leading_zero_bits == 32) { value = tvb_get_bits32(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN); codenum = UINT32_MAX; /* One one value doesn't overflow a 32 bit integer, but they're * different for unsigned and signed (because codenum UINT32_MAX maps * to INT32_MAX + 1 and UINT32_MAX + 1 maps to INT32_MIN.) */ if (descriptor == H265_SE_V) { if (value != 1) { overflow = true; } if (value % 2) { se_value = INT32_MIN; } else { se_value = INT32_MAX; } } else { if (value != 0) { overflow = true; } } mask = 1U << 31; } else { /* Non-overflow general case */ if (leading_zero_bits > 16) value = tvb_get_bits32(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN); else if (leading_zero_bits > 8) value = tvb_get_bits16(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN); else value = tvb_get_bits8(tvb, bit_offset, leading_zero_bits); codenum = 1; codenum = codenum << leading_zero_bits; mask = codenum >> 1; codenum = (codenum - 1) + value; if (descriptor == H265_SE_V) { /* if the syntax element is coded as se(v), * the value of the syntax element is derived by invoking the * mapping process for signed Exp-Golomb codes as specified in * subclause 9.1.1 with codeNum as the input. * k+1 * (-1) Ceil( k/2 ) */ se_value = (codenum + 1) >> 1; if (!(codenum & 1)) { se_value = -se_value; } } } bit_offset = bit_offset + leading_zero_bits; if (overflow) { *start_bit_offset = bit_offset; /* We will probably get a BoundsError later in the packet. */ if (descriptor == H265_SE_V) { ti = proto_tree_add_int_format_value(tree, hf_index, tvb, start_offset, (bit_offset >> 3) - start_offset + 1, codenum, "Invalid value (%d leading zero bits), clamped to %" PRId32, leading_zero_bits, se_value); expert_add_info(NULL, ti, &ei_h265_oversized_exp_golomb_code); return se_value; } else { ti = proto_tree_add_uint_format_value(tree, hf_index, tvb, start_offset, (bit_offset >> 3) - start_offset + 1, codenum, "Invalid value (%d leading zero bits), clamped to %" PRIu32, leading_zero_bits, codenum); expert_add_info(NULL, ti, &ei_h265_oversized_exp_golomb_code); return codenum; } } /* read the bits for the int */ for (i = 0; i> 1; } for (; bit % 8; bit++) { if (bit && (!(bit % 4))) { (void) g_strlcat(str, " ", 256); } (void) g_strlcat(str, ".", 256); } if (hf_field) { (void) g_strlcat(str, " = ", 256); (void) g_strlcat(str, hf_field->name, 256); switch (descriptor) { case H265_SE_V: (void) g_strlcat(str, "(se(v))", 256); /* if the syntax element is coded as se(v), * the value of the syntax element is derived by invoking the * mapping process for signed Exp-Golomb codes as specified in * subclause 9.1.1 with codeNum as the input. */ break; default: break; } if (hf_field->type == FT_UINT32) { if (hf_field->strings) { proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %s (%u)", str, val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "), codenum); } else { switch (hf_field->display) { case BASE_DEC: proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %u", str, codenum); break; case BASE_HEX: proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: 0x%x", str, codenum); break; default: DISSECTOR_ASSERT_NOT_REACHED(); break; } } } else if (hf_field->type == FT_INT32) { if (hf_field->strings) { proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %s (%d)", str, val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "), se_value); } else { switch (hf_field->display) { case BASE_DEC: proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum, "%s: %d", str, se_value); break; default: DISSECTOR_ASSERT_NOT_REACHED(); break; } } *start_bit_offset = bit_offset; return se_value; } else { DISSECTOR_ASSERT_NOT_REACHED(); } } *start_bit_offset = bit_offset; return codenum; } static bool more_rbsp_data(proto_tree *tree _U_, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset) { int offset; int remaining_length; int last_one_bit; uint8_t b = 0; /* XXX might not be the best way of doing things but: * Serch from the end of the tvb for the first '1' bit * assuming that it's the RTBSP stop bit */ /* Set offset to the byte we are treating */ offset = bit_offset >> 3; remaining_length = tvb_reported_length_remaining(tvb, offset); /* If there is more then 2 bytes left there *should* be more data */ if (remaining_length>2) { return true; } /* Start from last bit */ last_one_bit = (tvb_reported_length(tvb) << 3); for (b = 0; !b; ) { last_one_bit--; b = tvb_get_bits8(tvb, last_one_bit, 1); } if (last_one_bit == bit_offset) { return false; } return true; } /* 7.3.2.11 RBSP trailing bits syntax */ static int dissect_h265_rbsp_trailing_bits(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset) { int remaining_bits = 0; proto_tree_add_bits_item(tree, hf_h265_rbsp_stop_bit, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if ((bit_offset & 0x7) != 0) { remaining_bits = 8 - (bit_offset & 0x7); proto_tree_add_bits_item(tree, hf_h265_rbsp_trailing_bits, tvb, bit_offset, remaining_bits, ENC_BIG_ENDIAN); } return bit_offset + remaining_bits; } /* Ref 7.3.2.1 Video parameter set RBSP syntax */ static void dissect_h265_video_parameter_set_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { //proto_item *level_item; int bit_offset; proto_tree *profile_tier_level_tree, *hrd_parameters_tree; bit_offset = offset << 3; proto_tree_add_bits_item(tree, hf_h265_vps_video_parameter_set_id, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; proto_tree_add_bits_item(tree, hf_h265_vps_base_layer_internal_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; proto_tree_add_bits_item(tree, hf_h265_vps_base_layer_available_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; proto_tree_add_bits_item(tree, hf_h265_vps_max_layers_minus1, tvb, bit_offset, 6, ENC_BIG_ENDIAN); bit_offset = bit_offset + 6; uint8_t vps_max_sub_layers_minus1 = tvb_get_bits8(tvb, bit_offset, 3); proto_tree_add_bits_item(tree, hf_h265_vps_max_sub_layers_minus1, tvb, bit_offset, 3, ENC_BIG_ENDIAN); bit_offset = bit_offset + 3; proto_tree_add_bits_item(tree, hf_h265_vps_temporal_id_nesting_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; proto_tree_add_bits_item(tree, hf_h265_vps_reserved_0xffff_16bits, tvb, bit_offset, 16, ENC_BIG_ENDIAN); bit_offset = bit_offset + 16; offset = bit_offset >> 3; profile_tier_level_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_profile_tier_level, NULL, "Profile, tier and level"); offset = dissect_h265_profile_tier_level(profile_tier_level_tree, tvb, pinfo, offset, 1, vps_max_sub_layers_minus1); bit_offset = offset << 3; uint8_t vps_sub_layer_ordering_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_item(tree, hf_h265_vps_sub_layer_ordering_info_present_flag, tvb, offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; for (int i = (vps_sub_layer_ordering_info_present_flag ? 0 : vps_max_sub_layers_minus1); i <= vps_max_sub_layers_minus1; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_vps_max_dec_pic_buffering_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_vps_max_num_reorder_pics, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_vps_max_latency_increase_plus1, tvb, pinfo, &bit_offset, H265_UE_V); } uint8_t vps_max_layer_id = tvb_get_bits8(tvb, bit_offset, 6); proto_tree_add_bits_item(tree, hf_h265_vps_max_layer_id, tvb, bit_offset, 6, ENC_BIG_ENDIAN); bit_offset = bit_offset + 6; uint32_t vps_num_layer_sets_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_vps_num_layer_sets_minus1, tvb, pinfo, &bit_offset, H265_UE_V); for (unsigned i = 1; i <= vps_num_layer_sets_minus1; i++) for (int j = 0; j <= vps_max_layer_id; j++) { proto_tree_add_bits_item(tree, hf_h265_layer_id_included_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; } uint8_t vps_timing_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vps_timing_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; if (vps_timing_info_present_flag) { proto_tree_add_bits_item(tree, hf_h265_vps_num_units_in_tick, tvb, bit_offset, 32, ENC_BIG_ENDIAN); bit_offset = bit_offset + 32; proto_tree_add_bits_item(tree, hf_h265_vps_time_scale, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 32; uint8_t vps_poc_proportional_to_timing_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vps_poc_proportional_to_timing_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; if (vps_poc_proportional_to_timing_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_vps_num_ticks_poc_diff_one_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } uint32_t vps_num_hrd_parameters = dissect_h265_exp_golomb_code(tree, hf_h265_vps_num_hrd_parameters, tvb, pinfo, &bit_offset, H265_UE_V); for (unsigned i = 0; i < vps_num_hrd_parameters; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_hrd_layer_set_idx, tvb, pinfo, &bit_offset, H265_UE_V); if (i > 0) { bool cprms_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_cprms_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; offset = bit_offset >> 3; hrd_parameters_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_hrd_parameters, NULL, "HRD parameters"); bit_offset = offset << 3; bit_offset = dissect_h265_hrd_parameters(hrd_parameters_tree, tvb, pinfo, bit_offset, cprms_present_flag, vps_max_sub_layers_minus1); } } } uint8_t vps_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vps_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; if (vps_extension_flag) { while (more_rbsp_data(tree, tvb, pinfo, bit_offset)) { proto_tree_add_bits_item(tree, hf_h265_vps_extension_data_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 1; } } dissect_h265_rbsp_trailing_bits(tree, tvb, pinfo, bit_offset); } static void dissect_h265_seq_parameter_set_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { int bit_offset; uint8_t i, sps_max_sub_layers_minus1, sps_extension_4bits = 0; uint32_t num_short_term_ref_pic_sets, num_long_term_ref_pics_sps, log2_max_pic_order_cnt_lsb_minus4, bit_depth_luma_minus8, bit_depth_chroma_minus8; bool sps_sub_layer_ordering_info_present_flag = 0, scaling_list_enabled_flag = 0, sps_scaling_list_data_present_flag = 0, pcm_enabled_flag = 0, long_term_ref_pics_present_flag = 0, vui_parameters_present_flag = 0, sps_extension_present_flag = 0, sps_range_extension_flag = 0, sps_multilayer_extension_flag = 0, sps_3d_extension_flag = 0, sps_scc_extension_flag = 0; int32_t NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS] = { 0 }; // num_negative_pics + num_positive_pics; proto_tree *profile_tier_level_tree, *vui_parameters_tree; sps_max_sub_layers_minus1 = tvb_get_bits8(tvb, offset << 3, 8) >> 1 & 0x07; proto_tree_add_item(tree, hf_h265_sps_video_parameter_set_id, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_h265_sps_max_sub_layers_minus1, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_h265_sps_temporal_id_nesting_flag, tvb, offset, 1, ENC_BIG_ENDIAN); offset++; profile_tier_level_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_profile_tier_level, NULL, "Profile, tier and level"); offset = dissect_h265_profile_tier_level(profile_tier_level_tree, tvb, pinfo, offset, 1, sps_max_sub_layers_minus1); bit_offset = offset << 3; dissect_h265_exp_golomb_code(tree, hf_h265_sps_seq_parameter_set_id, tvb, pinfo, &bit_offset, H265_UE_V); unsigned chroma_format_idc = dissect_h265_exp_golomb_code(tree, hf_h265_chroma_format_idc, tvb, pinfo, &bit_offset, H265_UE_V); if (chroma_format_idc == 3) { proto_tree_add_bits_item(tree, hf_h265_separate_colour_plane_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } pic_width_in_luma_samples = dissect_h265_exp_golomb_code(tree, hf_h265_pic_width_in_luma_samples, tvb, pinfo, &bit_offset, H265_UE_V); pic_height_in_luma_samples = dissect_h265_exp_golomb_code(tree, hf_h265_pic_height_in_luma_samples, tvb, pinfo, &bit_offset, H265_UE_V); bool conformance_window_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_conformance_window_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (conformance_window_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_left_offset, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_right_offset, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_top_offset, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_bottom_offset, tvb, pinfo, &bit_offset, H265_UE_V); } bit_depth_luma_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_bit_depth_luma_minus8, tvb, pinfo, &bit_offset, H265_UE_V); bit_depth_chroma_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_bit_depth_chroma_minus8, tvb, pinfo, &bit_offset, H265_UE_V); log2_max_pic_order_cnt_lsb_minus4 = dissect_h265_exp_golomb_code(tree, hf_h265_log2_max_pic_order_cnt_lsb_minus4, tvb, pinfo, &bit_offset, H265_UE_V); sps_sub_layer_ordering_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_sub_layer_ordering_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; for (i = (sps_sub_layer_ordering_info_present_flag ? 0 : sps_max_sub_layers_minus1); i <= sps_max_sub_layers_minus1; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_dec_pic_buffering_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_num_reorder_pics, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_latency_increase_plus1, tvb, pinfo, &bit_offset, H265_UE_V); } // data between packets TODO: move to "conversations" log2_min_luma_coding_block_size_minus3 = dissect_h265_exp_golomb_code(tree, hf_h265_log2_min_luma_coding_block_size_minus3, tvb, pinfo, &bit_offset, H265_UE_V); // data between packets TODO: move to "conversations" log2_diff_max_min_luma_coding_block_size = dissect_h265_exp_golomb_code(tree, hf_h265_log2_diff_max_min_luma_coding_block_size, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_log2_min_luma_transform_block_size_minus2, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_log2_diff_max_min_luma_transform_block_size, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_max_transform_hierarchy_depth_inter, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_max_transform_hierarchy_depth_intra, tvb, pinfo, &bit_offset, H265_UE_V); scaling_list_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_scaling_list_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (scaling_list_enabled_flag) { sps_scaling_list_data_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_scaling_list_data_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sps_scaling_list_data_present_flag) bit_offset = dissect_h265_scaling_list_data(tree, tvb, pinfo, bit_offset); } proto_tree_add_bits_item(tree, hf_h265_amp_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sample_adaptive_offset_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pcm_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pcm_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (pcm_enabled_flag) { proto_tree_add_bits_item(tree, hf_h265_pcm_sample_bit_depth_luma_minus1, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; proto_tree_add_bits_item(tree, hf_h265_pcm_sample_bit_depth_chroma_minus1, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; dissect_h265_exp_golomb_code(tree, hf_h265_log2_min_pcm_luma_coding_block_size_minus3, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_log2_diff_max_min_pcm_luma_coding_block_size, tvb, pinfo, &bit_offset, H265_UE_V); proto_tree_add_bits_item(tree, hf_h265_pcm_loop_filter_disabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } num_short_term_ref_pic_sets = dissect_h265_exp_golomb_code(tree, hf_h265_num_short_term_ref_pic_sets, tvb, pinfo, &bit_offset, H265_UE_V); if (num_short_term_ref_pic_sets > H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS) { proto_tree_add_expert(tree, pinfo, &ei_h265_value_to_large, tvb, bit_offset>>3, 1); return; } for (i = 0; i < num_short_term_ref_pic_sets; i++) bit_offset = dissect_h265_st_ref_pic_set(tree, tvb, pinfo, bit_offset, i, num_short_term_ref_pic_sets, NumDeltaPocs); long_term_ref_pics_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_long_term_ref_pics_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (long_term_ref_pics_present_flag) { num_long_term_ref_pics_sps = dissect_h265_exp_golomb_code(tree, hf_h265_num_long_term_ref_pics_sps, tvb, pinfo, &bit_offset, H265_UE_V); for (i = 0; i < num_long_term_ref_pics_sps; i++) { proto_tree_add_bits_item(tree, hf_h265_lt_ref_pic_poc_lsb_sps, tvb, bit_offset, log2_max_pic_order_cnt_lsb_minus4 + 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + log2_max_pic_order_cnt_lsb_minus4 + 4; proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_lt_sps_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } } proto_tree_add_bits_item(tree, hf_h265_sps_temporal_mvp_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_strong_intra_smoothing_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; vui_parameters_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vui_parameters_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (vui_parameters_present_flag) { vui_parameters_tree = proto_tree_add_subtree(tree, tvb, bit_offset >> 3, 1, ett_h265_vui_parameters, NULL, "VUI parameters"); bit_offset = dissect_h265_vui_parameters(vui_parameters_tree, tvb, pinfo, bit_offset, sps_max_sub_layers_minus1); } sps_extension_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_extension_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sps_extension_present_flag) { sps_range_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_range_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; sps_multilayer_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_multilayer_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; sps_3d_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_3d_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; sps_scc_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_scc_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; sps_extension_4bits = tvb_get_bits8(tvb, bit_offset, 4); proto_tree_add_bits_item(tree, hf_h265_sps_extension_4bits, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; } if (sps_range_extension_flag) bit_offset = dissect_h265_sps_range_extension(tree, tvb, pinfo, bit_offset); if (sps_multilayer_extension_flag) bit_offset = dissect_h265_sps_multilayer_extension(tree, tvb, pinfo, bit_offset); /* specified in Annex F */ if (sps_3d_extension_flag) bit_offset = dissect_h265_sps_3d_extension(tree, tvb, pinfo, bit_offset); /* specified in Annex I */ if (sps_scc_extension_flag) bit_offset = dissect_h265_sps_scc_extension(tree, tvb, pinfo, bit_offset, chroma_format_idc, bit_depth_luma_minus8, bit_depth_chroma_minus8); if (sps_extension_4bits) while (more_rbsp_data(tree, tvb, pinfo, bit_offset)) { proto_tree_add_bits_item(tree, hf_h265_sps_extension_data_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } dissect_h265_rbsp_trailing_bits(tree, tvb, pinfo, bit_offset); } /* Ref 7.3.2.3 Picture parameter set RBSP syntax */ static void dissect_h265_pic_parameter_set_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { int bit_offset; unsigned num_tile_columns_minus1, num_tile_rows_minus1, i; bool cu_qp_delta_enabled_flag, tiles_enabled_flag, uniform_spacing_flag; bool deblocking_filter_control_present_flag, pps_deblocking_filter_disabled_flag; bool pps_scaling_list_data_present_flag, pps_extension_present_flag; bool pps_range_extension_flag = 0, pps_multilayer_extension_flag = 0, pps_3d_extension_flag = 0, pps_scc_extension_flag = 0, pps_extension_4bits = 0, transform_skip_enabled_flag = 0; bit_offset = offset << 3; dissect_h265_exp_golomb_code(tree, hf_h265_pps_pic_parameter_set_id, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_pps_seq_parameter_set_id, tvb, pinfo, &bit_offset, H265_UE_V); // data between packets TODO: move to "conversations" dependent_slice_segments_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_dependent_slice_segments_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_output_flag_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; // data between packets TODO: move to "conversations" num_extra_slice_header_bits = tvb_get_bits8(tvb, bit_offset, 3); proto_tree_add_bits_item(tree, hf_h265_num_extra_slice_header_bits, tvb, bit_offset, 3, ENC_BIG_ENDIAN); bit_offset = bit_offset + 3; proto_tree_add_bits_item(tree, hf_h265_sign_data_hiding_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_cabac_init_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; dissect_h265_exp_golomb_code(tree, hf_h265_num_ref_idx_l0_default_active_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_num_ref_idx_l1_default_active_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_init_qp_minus26, tvb, pinfo, &bit_offset, H265_SE_V); proto_tree_add_bits_item(tree, hf_h265_constrained_intra_pred_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; transform_skip_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_transform_skip_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; cu_qp_delta_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_cu_qp_delta_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (cu_qp_delta_enabled_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_diff_cu_qp_delta_depth, tvb, pinfo, &bit_offset, H265_UE_V); } dissect_h265_exp_golomb_code(tree, hf_h265_pps_cb_qp_offset, tvb, pinfo, &bit_offset, H265_SE_V); dissect_h265_exp_golomb_code(tree, hf_h265_pps_cr_qp_offset, tvb, pinfo, &bit_offset, H265_SE_V); proto_tree_add_bits_item(tree, hf_h265_pps_slice_chroma_qp_offsets_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_weighted_pred_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_weighted_bipred_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_transquant_bypass_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; tiles_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_tiles_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_entropy_coding_sync_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (tiles_enabled_flag) { num_tile_columns_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_num_tile_columns_minus1, tvb, pinfo, &bit_offset, H265_UE_V); num_tile_rows_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_num_tile_rows_minus1, tvb, pinfo, &bit_offset, H265_UE_V); uniform_spacing_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_uniform_spacing_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (!uniform_spacing_flag) { for (i = 0; i < num_tile_columns_minus1; i++) dissect_h265_exp_golomb_code(tree, hf_h265_column_width_minus1, tvb, pinfo, &bit_offset, H265_UE_V); for (i = 0; i < num_tile_rows_minus1; i++) dissect_h265_exp_golomb_code(tree, hf_h265_row_height_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } proto_tree_add_bits_item(tree, hf_h265_loop_filter_across_tiles_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } proto_tree_add_bits_item(tree, hf_h265_pps_loop_filter_across_slices_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; deblocking_filter_control_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_deblocking_filter_control_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (deblocking_filter_control_present_flag) { proto_tree_add_bits_item(tree, hf_h265_deblocking_filter_override_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_deblocking_filter_disabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_deblocking_filter_disabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (!pps_deblocking_filter_disabled_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_pps_beta_offset_div2, tvb, pinfo, &bit_offset, H265_SE_V); dissect_h265_exp_golomb_code(tree, hf_h265_pps_tc_offset_div2, tvb, pinfo, &bit_offset, H265_SE_V); } } pps_scaling_list_data_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_scaling_list_data_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (pps_scaling_list_data_present_flag) { bit_offset = dissect_h265_scaling_list_data(tree, tvb, pinfo, bit_offset); } proto_tree_add_bits_item(tree, hf_h265_lists_modification_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; dissect_h265_exp_golomb_code(tree, hf_h265_log2_parallel_merge_level_minus2, tvb, pinfo, &bit_offset, H265_UE_V); proto_tree_add_bits_item(tree, hf_h265_slice_segment_header_extension_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_extension_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_extension_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (pps_extension_present_flag) { pps_range_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_range_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_multilayer_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_multilayer_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_3d_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_3d_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_scc_extension_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_scc_extension_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; pps_extension_4bits = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_extension_4bits, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } if (pps_range_extension_flag) bit_offset = dissect_h265_pps_range_extension(tree, tvb, pinfo, bit_offset, transform_skip_enabled_flag); if (pps_multilayer_extension_flag) bit_offset = dissect_h265_pps_multilayer_extension(tree, tvb, pinfo, bit_offset); /* specified in Annex F */ if (pps_3d_extension_flag) bit_offset = dissect_h265_pps_3d_extension(tree, tvb, pinfo, bit_offset); /* specified in Annex I */ if (pps_scc_extension_flag) bit_offset = dissect_h265_pps_scc_extension(tree, tvb, pinfo, bit_offset); if (pps_extension_4bits) while (more_rbsp_data(tree, tvb, pinfo, bit_offset)) { proto_tree_add_bits_item(tree, hf_h265_pps_extension_data_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } dissect_h265_rbsp_trailing_bits(tree, tvb, pinfo, bit_offset); } /* Ref 7.3.2.4 Supplemental enhancement information RBSP syntax */ static void dissect_h265_sei_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset, uint8_t nal_unit_type) { proto_tree *sei_rbsp_tree; sei_rbsp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_sei_rbsp, NULL, "Supplemental enhancement information RBSP"); int bit_offset; bit_offset = offset << 3; do { bit_offset = dissect_h265_sei_message(sei_rbsp_tree, tvb, pinfo, bit_offset, nal_unit_type); } while (more_rbsp_data(sei_rbsp_tree, tvb, pinfo, bit_offset)); dissect_h265_rbsp_trailing_bits(sei_rbsp_tree, tvb, pinfo, bit_offset); } /* Ref 7.3.2.5 Access unit delimiter RBSP syntax */ static void dissect_h265_access_unit_delimiter_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { int bit_offset = offset << 3; proto_tree *access_unit_delimiter_rbsp_tree; access_unit_delimiter_rbsp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_access_unit_delimiter_rbsp, NULL, "Access unit delimiter RBSP"); /* pic_type u(3) */ proto_tree_add_bits_item(access_unit_delimiter_rbsp_tree, hf_h265_pic_type, tvb, bit_offset, 3, ENC_BIG_ENDIAN); bit_offset += 3; /* rbsp_trailing_bits */ dissect_h265_rbsp_trailing_bits(access_unit_delimiter_rbsp_tree, tvb, pinfo, bit_offset); } /* Ref 7.3.2.6 End of sequence RBSP syntax*/ static void dissect_h265_end_of_seq_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { proto_tree *end_of_seq_rbsp_tree; end_of_seq_rbsp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_end_of_seq_rbsp, NULL, "End of sequence RBSP"); proto_tree_add_expert(end_of_seq_rbsp_tree, pinfo, &ei_h265_undecoded, tvb, offset, -1); } /* Ref 7.3.2.7 End of bitstream RBSP syntax*/ static void dissect_h265_end_of_bitstream_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { proto_tree *end_of_bitstream_rbsp_tree; end_of_bitstream_rbsp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_end_of_bitstream_rbsp, NULL, "End of bitstream RBSP"); proto_tree_add_expert(end_of_bitstream_rbsp_tree, pinfo, &ei_h265_undecoded, tvb, offset, -1); } /* Ref 7.3.2.8 Filler data RBSP syntax */ static void dissect_h265_filler_data_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset) { proto_tree *filler_data_rbsp_tree; filler_data_rbsp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_h265_filler_data_rbsp, NULL, "Filler data RBSP"); proto_tree_add_expert(filler_data_rbsp_tree, pinfo, &ei_h265_undecoded, tvb, offset, -1); } /* Ref 7.3.3 Profile, tier and level syntax */ static int dissect_h265_profile_tier_level(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int offset, bool profilePresentFlag, int vps_max_sub_layers_minus1) { proto_item *general_level_idc_item; uint32_t general_profile_idc, general_level_idc; uint32_t sub_layer_profile_idc[32] = { 0 }; bool general_tier_flag = 0; bool general_profile_compatibility_flag[32] = { 0 }; bool sub_layer_profile_present_flag[32] = { 0 }; bool sub_layer_level_present_flag[32] = { 0 }; bool sub_layer_profile_compatibility_flag[32][32] = { { 0 } }; if (profilePresentFlag) { proto_tree_add_item(tree, hf_h265_general_profile_space, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item_ret_boolean(tree, hf_h265_general_tier_flag, tvb, offset, 1, ENC_BIG_ENDIAN, &general_tier_flag); proto_tree_add_item_ret_uint(tree, hf_h265_general_profile_idc, tvb, offset, 1, ENC_BIG_ENDIAN, &general_profile_idc); offset++; proto_tree_add_item(tree, hf_h265_general_profile_compatibility_flags, tvb, offset, 4, ENC_BIG_ENDIAN); int bit_offset = offset << 3; for (int j = 0; j < 32; j++) general_profile_compatibility_flag[j] = tvb_get_bits8(tvb, bit_offset + j, 1); bit_offset = bit_offset + 32; proto_tree_add_bits_item(tree, hf_h265_general_progressive_source_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_interlaced_source_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_non_packed_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_frame_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (general_profile_idc == 4 || general_profile_compatibility_flag[4] || general_profile_idc == 5 || general_profile_compatibility_flag[5] || general_profile_idc == 6 || general_profile_compatibility_flag[6] || general_profile_idc == 7 || general_profile_compatibility_flag[7] || general_profile_idc == 8 || general_profile_compatibility_flag[8] || general_profile_idc == 9 || general_profile_compatibility_flag[9] || general_profile_idc == 10 || general_profile_compatibility_flag[10]) { /* The number of bits in this syntax structure is not affected by this condition */ proto_tree_add_bits_item(tree, hf_h265_general_max_12bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_max_10bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_max_8bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_max_422chroma_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_max_420chroma_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_max_monochrome_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_intra_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_one_picture_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_lower_bit_rate_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (general_profile_idc == 5 || general_profile_compatibility_flag[5] || general_profile_idc == 9 || general_profile_compatibility_flag[9] || general_profile_idc == 10 || general_profile_compatibility_flag[10]) { proto_tree_add_bits_item(tree, hf_h265_general_max_14bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_33bits, tvb, bit_offset, 33, ENC_BIG_ENDIAN); bit_offset = bit_offset + 33; } else { proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_34bits, tvb, bit_offset, 34, ENC_BIG_ENDIAN); bit_offset = bit_offset + 34; } } else if (general_profile_idc == 2 || general_profile_compatibility_flag[2]) { proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_7bits, tvb, bit_offset, 7, ENC_BIG_ENDIAN); bit_offset = bit_offset + 7; proto_tree_add_bits_item(tree, hf_h265_general_one_picture_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_35bits, tvb, bit_offset, 35, ENC_BIG_ENDIAN); bit_offset = bit_offset + 35; } else { proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_43bits, tvb, bit_offset, 43, ENC_BIG_ENDIAN); bit_offset = bit_offset + 43; } if ((general_profile_idc >= 1 && general_profile_idc <= 5) || general_profile_idc == 9 || general_profile_compatibility_flag[1] || general_profile_compatibility_flag[2] || general_profile_compatibility_flag[3] || general_profile_compatibility_flag[4] || general_profile_compatibility_flag[5] || general_profile_compatibility_flag[9]) /* The number of bits in this syntax structure is not affected by this condition */ { proto_tree_add_bits_item(tree, hf_h265_general_inbld_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); } else { proto_tree_add_bits_item(tree, hf_h265_general_reserved_zero_bit, tvb, bit_offset, 1, ENC_BIG_ENDIAN); } bit_offset++; general_level_idc_item = proto_tree_add_item_ret_uint(tree, hf_h265_general_level_idc, tvb, bit_offset >> 3, 1, ENC_BIG_ENDIAN, &general_level_idc); if (general_tier_flag) { proto_item_append_text(general_level_idc_item, " [Level %.1f %s]", ((double)general_level_idc / 30), val_to_str_const(general_level_idc / 3, h265_level_high_tier_bitrate_values, "Unknown")); } else { proto_item_append_text(general_level_idc_item, " [Level %.1f %s]", ((double)general_level_idc / 30), val_to_str_const(general_level_idc / 3, h265_level_main_tier_bitrate_values, "Unknown")); } bit_offset += 8; for (int i = 0; i < vps_max_sub_layers_minus1; i++) { sub_layer_profile_present_flag[i] = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sub_layer_profile_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_level_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } if (vps_max_sub_layers_minus1 > 0) for (int i = vps_max_sub_layers_minus1; i < 8; i++) { proto_tree_add_bits_item(tree, hf_h265_reserved_zero_2bits, tvb, bit_offset, 2, ENC_BIG_ENDIAN); bit_offset = bit_offset + 2; } for (int i = 0; i < vps_max_sub_layers_minus1; i++) { if (sub_layer_profile_present_flag[i]) { proto_tree_add_item(tree, hf_h265_sub_layer_profile_space, tvb, bit_offset >> 3, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_h265_sub_layer_tier_flag, tvb, bit_offset >> 3, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_h265_sub_layer_profile_idc, tvb, bit_offset >> 3, 1, ENC_BIG_ENDIAN); sub_layer_profile_idc[i] = tvb_get_bits8(tvb, (bit_offset >> 3) + 3, 5); bit_offset = bit_offset + 8; for (int j = 0; j < 32; j++) { sub_layer_profile_compatibility_flag[i][j] = tvb_get_bits8(tvb, bit_offset, 1); } proto_tree_add_item(tree, hf_h265_sub_layer_profile_compatibility_flag, tvb, bit_offset >> 3, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 32; proto_tree_add_bits_item(tree, hf_h265_sub_layer_progressive_source_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_interlaced_source_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_non_packed_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_frame_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sub_layer_profile_idc[i] == 4 || sub_layer_profile_compatibility_flag[i][4] || sub_layer_profile_idc[i] == 5 || sub_layer_profile_compatibility_flag[i][5] || sub_layer_profile_idc[i] == 6 || sub_layer_profile_compatibility_flag[i][6] || sub_layer_profile_idc[i] == 7 || sub_layer_profile_compatibility_flag[i][7] || sub_layer_profile_idc[i] == 8 || sub_layer_profile_compatibility_flag[i][8] || sub_layer_profile_idc[i] == 9 || sub_layer_profile_compatibility_flag[i][9] || sub_layer_profile_idc[i] == 10 || sub_layer_profile_compatibility_flag[i][10]) { /* The number of bits in this syntax structure is not affected by this condition */ proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_12bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_10bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_8bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_422chroma_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_420chroma_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_monochrome_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_intra_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_one_picture_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_lower_bit_rate_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sub_layer_profile_idc[i] == 5 || sub_layer_profile_compatibility_flag[i][5]) { proto_tree_add_bits_item(tree, hf_h265_sub_layer_max_14bit_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_33bits, tvb, bit_offset + 1, 33, ENC_BIG_ENDIAN); bit_offset = bit_offset + 34; } else { proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_34bits, tvb, bit_offset + 1, 33, ENC_BIG_ENDIAN); bit_offset = bit_offset + 34; } } else if (sub_layer_profile_idc[i] == 2 || sub_layer_profile_compatibility_flag[i][2]) { proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_7bits, tvb, bit_offset, 7, ENC_BIG_ENDIAN); bit_offset = bit_offset + 7; proto_tree_add_bits_item(tree, hf_h265_sub_layer_one_picture_only_constraint_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_35bits, tvb, bit_offset, 35, ENC_BIG_ENDIAN); bit_offset = bit_offset + 35; } else { proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_43bits, tvb, bit_offset, 43, ENC_BIG_ENDIAN); bit_offset = bit_offset + 43; } if ((sub_layer_profile_idc[i] >= 1 && sub_layer_profile_idc[i] <= 5) || sub_layer_profile_idc[i] == 9 || sub_layer_profile_compatibility_flag[i][1] || sub_layer_profile_compatibility_flag[i][2] || sub_layer_profile_compatibility_flag[i][3] || sub_layer_profile_compatibility_flag[i][4] || sub_layer_profile_compatibility_flag[i][5] || sub_layer_profile_compatibility_flag[i][9]) { /* The number of bits in this syntax structure is not affected by this condition */ proto_tree_add_bits_item(tree, hf_h265_sub_layer_inbld_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } else { proto_tree_add_bits_item(tree, hf_h265_sub_layer_reserved_zero_bit, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } } if (sub_layer_level_present_flag[i]) { proto_tree_add_item(tree, hf_h265_sub_layer_level_idc, tvb, bit_offset >> 3, 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; } } offset = bit_offset >> 3; } return offset; } /* 7.3.6 Slice segment header syntax */ /* Just parse a few bits same as in H.264 */ /* TODO: if need more info from slice header, do more parsing */ static int dissect_h265_slice_segment_header(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset, uint8_t nal_unit_type) { bool first_slice_segment_in_pic_flag = 0, /*no_output_of_prior_pics_flag = 0,*/ dependent_slice_segment_flag = 0; unsigned MinCbLog2SizeY = log2_min_luma_coding_block_size_minus3 + 3; unsigned CtbLog2SizeY = MinCbLog2SizeY + log2_diff_max_min_luma_coding_block_size; unsigned CtbSizeY = 1 << CtbLog2SizeY; double PicWidthInCtbsY = ceil(pic_width_in_luma_samples / CtbSizeY); double PicHeightInCtbsY = ceil(pic_height_in_luma_samples / CtbSizeY); double PicSizeInCtbsY = PicWidthInCtbsY * PicHeightInCtbsY; unsigned nBits = (unsigned)(ceil(log2(PicSizeInCtbsY))); unsigned i; first_slice_segment_in_pic_flag = tvb_get_bits8(tvb, bit_offset, 1); bit_offset++; if (nal_unit_type >= str_to_val("BLA_W_LP", h265_type_summary_values, 16) && nal_unit_type <= str_to_val("RSV_IRAP_VCL23", h265_type_summary_values, 23)) { /*no_output_of_prior_pics_flag = tvb_get_bits8(tvb, bit_offset, 1);*/ bit_offset++; } dissect_h265_exp_golomb_code(tree, hf_h265_slice_pic_parameter_set_id, tvb, pinfo, &bit_offset, H265_UE_V); if (!first_slice_segment_in_pic_flag) { if (dependent_slice_segments_enabled_flag){ dependent_slice_segment_flag = tvb_get_bits8(tvb, bit_offset, 1); bit_offset++; } proto_tree_add_bits_item(tree, hf_h265_slice_segment_address, tvb, bit_offset, nBits, ENC_BIG_ENDIAN); bit_offset = bit_offset + nBits; } if (!dependent_slice_segment_flag) { for (i = 0; i < num_extra_slice_header_bits; i++) { /* slice_reserved_flag[i] u(1) */ bit_offset++; } dissect_h265_exp_golomb_code(tree, hf_h265_slice_type, tvb, pinfo, &bit_offset, H265_UE_V); } return bit_offset; } /* 7.3.2.9 Slice segment layer RBSP syntax */ static void dissect_h265_slice_segment_layer_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset, uint8_t nal_unit_type) { int bit_offset; bit_offset = offset << 3; /* slice_segment_header( ) */ dissect_h265_slice_segment_header(tree, tvb, pinfo, bit_offset, nal_unit_type); /* slice_segment_data( ) */ /* rbsp_slice_segment_trailing_bits( ) */ } /* 7.3.4 Scaling list data syntax */ static int dissect_h265_scaling_list_data(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset) { bool scaling_list_pred_mode_flag[4][6] = { { 0 } }; /*int32_t ScalingList[4][6][64] = { 0 };*/ int sizeId, matrixId, nextCoef, coefNum, i; int32_t scaling_list_dc_coef_minus8, scaling_list_delta_coef; for (sizeId = 0; sizeId < 4; sizeId++) for (matrixId = 0; matrixId < 6; matrixId += (sizeId == 3) ? 3 : 1) { scaling_list_pred_mode_flag[sizeId][matrixId] = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_scaling_list_pred_mode_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (!scaling_list_pred_mode_flag[sizeId][matrixId]) dissect_h265_exp_golomb_code(tree, hf_h265_scaling_list_pred_matrix_id_delta, tvb, pinfo, &bit_offset, H265_UE_V); else { nextCoef = 8; coefNum = MIN(64, (1 << (4 + (sizeId << 1)))); if (sizeId > 1) { scaling_list_dc_coef_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_scaling_list_dc_coef_minus8, tvb, pinfo, &bit_offset, H265_SE_V); nextCoef = scaling_list_dc_coef_minus8 + 8; } for (i = 0; i < coefNum; i++) { scaling_list_delta_coef = dissect_h265_exp_golomb_code(tree, hf_h265_scaling_list_delta_coef, tvb, pinfo, &bit_offset, H265_SE_V); nextCoef = (nextCoef + scaling_list_delta_coef + 256) % 256; /*ScalingList[sizeId][matrixId][i] = nextCoef;*/ } } } return bit_offset; } /* D.2.1 General SEI message syntax */ static int dissect_h265_sei_payload(proto_tree* tree _U_, tvbuff_t* tvb _U_, packet_info* pinfo _U_, int bit_offset, unsigned payloadType _U_, unsigned payloadSize, uint8_t nal_unit_type _U_) { //int bit_start = bit_offset; #if 0 if (nal_unit_type == str_to_val("PREFIX_SEI_NUT", h265_type_summary_values, 39)) { if (payloadType == 0) buffering_period(payloadSize); else if (payloadType == 1) pic_timing(payloadSize); else if (payloadType == 2) pan_scan_rect(payloadSize); else if (payloadType == 3) filler_payload(payloadSize); else if (payloadType == 4) user_data_registered_itu_t_t35(payloadSize); else if (payloadType == 5) user_data_unregistered(payloadSize); else if (payloadType == 6) recovery_point(payloadSize); else if (payloadType == 9) scene_info(payloadSize); else if (payloadType == 15) picture_snapshot(payloadSize); else if (payloadType == 16) progressive_refinement_segment_start(payloadSize); else if (payloadType == 17) progressive_refinement_segment_end(payloadSize); else if (payloadType == 19) film_grain_characteristics(payloadSize); else if (payloadType == 22) post_filter_hint(payloadSize); else if (payloadType == 23) tone_mapping_info(payloadSize); else if (payloadType == 45) frame_packing_arrangement(payloadSize); else if (payloadType == 47) display_orientation(payloadSize); else if (payloadType == 56) green_metadata(payloadSize); /* specified in ISO/IEC 23001-11 */ else if (payloadType == 128) structure_of_pictures_info(payloadSize); else if (payloadType == 129) active_parameter_sets(payloadSize); else if (payloadType == 130) decoding_unit_info(payloadSize); else if (payloadType == 131) temporal_sub_layer_zero_idx(payloadSize); else if (payloadType == 133) scalable_nesting(payloadSize); else if (payloadType == 134) region_refresh_info(payloadSize); else if (payloadType == 135) no_display(payloadSize); else if (payloadType == 136) time_code(payloadSize); else if (payloadType == 137) mastering_display_colour_volume(payloadSize); else if (payloadType == 138) segmented_rect_frame_packing_arrangement(payloadSize); else if (payloadType == 139) temporal_motion_constrained_tile_sets(payloadSize); else if (payloadType == 140) chroma_resampling_filter_hint(payloadSize); else if (payloadType == 141) knee_function_info(payloadSize); else if (payloadType == 142) colour_remapping_info(payloadSize); else if (payloadType == 143) deinterlaced_field_identification(payloadSize); else if (payloadType == 144) content_light_level_info(payloadSize); else if (payloadType == 145) dependent_rap_indication(payloadSize); else if (payloadType == 146) coded_region_completion(payloadSize); else if (payloadType == 147) alternative_transfer_characteristics(payloadSize); else if (payloadType == 148) ambient_viewing_environment(payloadSize); else if (payloadType == 149) content_colour_volume(payloadSize); else if (payloadType == 150) equirectangular_projection(payloadSize); else if (payloadType == 151) cubemap_projection(payloadSize); else if (payloadType == 154) sphere_rotation(payloadSize); else if (payloadType == 155) regionwise_packing(payloadSize); else if (payloadType == 156) omni_viewport(payloadSize); else if (payloadType == 157) regional_nesting(payloadSize); else if (payloadType == 158) mcts_extraction_info_sets(payloadSize); else if (payloadType == 159) mcts_extraction_info_nesting(payloadSize); else if (payloadType == 160) layers_not_present(payloadSize); /* specified in Annex F */ else if (payloadType == 161) inter_layer_constrained_tile_sets(payloadSize); /* specified in Annex F */ else if (payloadType == 162) bsp_nesting(payloadSize); /* specified in Annex F */ else if (payloadType == 163) bsp_initial_arrival_time(payloadSize); /* specified in Annex F */ else if (payloadType == 164) sub_bitstream_property(payloadSize); /* specified in Annex F */ else if (payloadType == 165) alpha_channel_info(payloadSize); /* specified in Annex F */ else if (payloadType == 166) overlay_info(payloadSize); /* specified in Annex F */ else if (payloadType == 167) temporal_mv_prediction_constraints(payloadSize); /* specified in Annex F */ else if (payloadType == 168) frame_field_info(payloadSize); /* specified in Annex F */ else if (payloadType == 176) three_dimensional_reference_displays_info(payloadSize); /* specified in Annex G */ else if (payloadType == 177) depth_representation_info(payloadSize); /* specified in Annex G */ else if (payloadType == 178) multiview_scene_info(payloadSize); /* specified in Annex G */ else if (payloadType == 179) multiview_acquisition_info(payloadSize); /* specified in Annex G */ else if (payloadType == 180) multiview_view_position(payloadSize); /* specified in Annex G */ else if (payloadType == 181) alternative_depth_info(payloadSize); /* specified in Annex I */ else reserved_sei_message(payloadSize); } else /* nal_unit_type == SUFFIX_SEI_NUT */ { if (payloadType == 3) filler_payload(payloadSize); else if (payloadType == 4) user_data_registered_itu_t_t35(payloadSize); else if (payloadType == 5) user_data_unregistered(payloadSize); else if (payloadType == 17) progressive_refinement_segment_end(payloadSize); else if (payloadType == 22) post_filter_hint(payloadSize); else if (payloadType == 132) decoded_picture_hash(payloadSize); else if (payloadType == 146) coded_region_completion(payloadSize); else reserved_sei_message(payloadSize); } if (h265_more_data_in_payload(bit_start, bit_offset, payloadSize)) { if (h265_payload_extension_present(tvb, bit_start, bit_offset, payloadSize)) { /*reserved_payload_extension_data u(v) */ unsigned nEarlierBits = bit_offset - bit_start; unsigned v_bits = 8 * payloadSize - nEarlierBits - nPayloadZeroBits - 1; bit_offset = bit_offset + v_bits; } /* payload_bit_equal_to_one (equal to 1) f(1) */ bit_offset++; while (!h265_byte_aligned(bit_offset)) { /* payload_bit_equal_to_zero (equal to 0) f(1)*/ bit_offset++; } } #else bit_offset = bit_offset + (payloadSize << 3); #endif return bit_offset; } /* 7.3.5 Supplemental enhancement information message syntax */ static int dissect_h265_sei_message(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, uint8_t nal_unit_type) { unsigned payloadType = 0, last_payload_type_byte, payloadSize, last_payload_size_byte; int start_bit_offset, length; start_bit_offset = bit_offset; while (tvb_get_bits8(tvb, bit_offset, 8) == 0xFF) { bit_offset = bit_offset + 8; payloadType += 255; } last_payload_type_byte = tvb_get_bits8(tvb, bit_offset, 8); bit_offset = bit_offset + 8; payloadType += last_payload_type_byte; length = (bit_offset - start_bit_offset) >> 3; proto_tree_add_uint(tree, hf_h265_payloadtype, tvb, start_bit_offset >> 3, length, payloadType); payloadSize = 0; start_bit_offset = bit_offset; while (tvb_get_bits8(tvb, bit_offset, 8) == 0xFF) { bit_offset = bit_offset + 8; payloadSize += 255; } last_payload_size_byte = tvb_get_bits8(tvb, bit_offset, 8); bit_offset = bit_offset + 8; payloadSize += last_payload_size_byte; length = (bit_offset - start_bit_offset) >> 3; proto_tree_add_uint(tree, hf_h265_payloadsize, tvb, start_bit_offset >> 3, length, payloadSize); bit_offset = dissect_h265_sei_payload(tree, tvb, pinfo, bit_offset, payloadType, payloadSize, nal_unit_type); return bit_offset; } /* 7.3.7 Short-term reference picture set syntax */ static int dissect_h265_st_ref_pic_set(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset, int stRpsIdx, int num_short_term_ref_pic_sets, int32_t NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS]) { int j; unsigned i; uint32_t num_negative_pics, num_positive_pics; bool inter_ref_pic_set_prediction_flag = 0; bool used_by_curr_pic_flag; int RefRpsIdx; int delta_idx_minus1 = 0; tree = proto_tree_add_subtree_format(tree, tvb, bit_offset >> 3, 1, ett_h265_ref_pic_set, NULL, "ref_pic_set %d", stRpsIdx); if (stRpsIdx != 0) { inter_ref_pic_set_prediction_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_inter_ref_pic_set_prediction_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } if (inter_ref_pic_set_prediction_flag) { if (stRpsIdx == num_short_term_ref_pic_sets) { delta_idx_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_delta_idx_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } proto_tree_add_bits_item(tree, hf_h265_delta_rps_sign, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; dissect_h265_exp_golomb_code(tree, hf_h265_abs_delta_rps_minus1, tvb, pinfo, &bit_offset, H265_UE_V); RefRpsIdx = stRpsIdx - (delta_idx_minus1 + 1); for (j = 0; j <= NumDeltaPocs[RefRpsIdx]; j++) { used_by_curr_pic_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (!used_by_curr_pic_flag) { proto_tree_add_bits_item(tree, hf_h265_use_delta_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } } NumDeltaPocs[stRpsIdx] = NumDeltaPocs[RefRpsIdx]; } else { num_negative_pics = dissect_h265_exp_golomb_code(tree, hf_h265_num_negative_pics, tvb, pinfo, &bit_offset, H265_UE_V); num_positive_pics = dissect_h265_exp_golomb_code(tree, hf_h265_num_positive_pics, tvb, pinfo, &bit_offset, H265_UE_V); NumDeltaPocs[stRpsIdx] = num_negative_pics + num_positive_pics; for (i = 0; i < num_negative_pics; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_delta_poc_s0_minus1, tvb, pinfo, &bit_offset, H265_UE_V); proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_s0_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } for (i = 0; i < num_positive_pics; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_delta_poc_s1_minus1, tvb, pinfo, &bit_offset, H265_UE_V); proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_s1_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } } return bit_offset; } /* E.2.3 Sub-layer HRD parameters syntax */ static int dissect_h265_sub_layer_hrd_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset, unsigned subLayerId _U_, uint32_t CpbCnt, bool sub_pic_hrd_params_present_flag) { /*The variable CpbCnt is set equal to cpb_cnt_minus1[ subLayerId ] + 1.*/ unsigned i; for (i = 0; i < CpbCnt; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_bit_rate_value_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_cpb_size_value_minus1, tvb, pinfo, &bit_offset, H265_UE_V); if (sub_pic_hrd_params_present_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_cpb_size_du_value_minus1, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_bit_rate_du_value_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } proto_tree_add_bits_item(tree, hf_h265_cbr_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } return bit_offset; } /* E.2.2 HRD parameters syntax */ static int dissect_h265_hrd_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset, bool commonInfPresentFlag, unsigned maxNumSubLayersMinus1) { unsigned subLayerId; bool nal_hrd_parameters_present_flag = 0, vcl_hrd_parameters_present_flag = 0, sub_pic_hrd_params_present_flag = 0; bool fixed_pic_rate_general_flag[32] = { 0 }; bool fixed_pic_rate_within_cvs_flag[32] = { 0 }; bool low_delay_hrd_flag[32] = { 0 }; uint32_t cpb_cnt_minus1[32] = { 0 }; if (commonInfPresentFlag) { nal_hrd_parameters_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_nal_hrd_parameters_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; vcl_hrd_parameters_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vcl_hrd_parameters_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) { sub_pic_hrd_params_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sub_pic_hrd_params_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sub_pic_hrd_params_present_flag) { proto_tree_add_bits_item(tree, hf_h265_tick_divisor_minus2, tvb, bit_offset, 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; proto_tree_add_bits_item(tree, hf_h265_du_cpb_removal_delay_increment_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN); bit_offset = bit_offset + 5; proto_tree_add_bits_item(tree, hf_h265_sub_pic_cpb_params_in_pic_timing_sei_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_dpb_output_delay_du_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN); bit_offset = bit_offset + 5; } proto_tree_add_bits_item(tree, hf_h265_bit_rate_scale, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; proto_tree_add_bits_item(tree, hf_h265_cpb_size_scale, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; if (sub_pic_hrd_params_present_flag) { proto_tree_add_bits_item(tree, hf_h265_cpb_size_du_scale, tvb, bit_offset, 4, ENC_BIG_ENDIAN); bit_offset = bit_offset + 4; } proto_tree_add_bits_item(tree, hf_h265_initial_cpb_removal_delay_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN); bit_offset = bit_offset + 5; proto_tree_add_bits_item(tree, hf_h265_au_cpb_removal_delay_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN); bit_offset = bit_offset + 5; proto_tree_add_bits_item(tree, hf_h265_dpb_output_delay_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN); bit_offset = bit_offset + 5; } } for (subLayerId = 0; subLayerId <= maxNumSubLayersMinus1; subLayerId++) { fixed_pic_rate_general_flag[subLayerId] = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_fixed_pic_rate_general_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (!fixed_pic_rate_general_flag[subLayerId]) { fixed_pic_rate_within_cvs_flag[subLayerId] = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_fixed_pic_rate_within_cvs_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } if (fixed_pic_rate_within_cvs_flag[subLayerId]) { dissect_h265_exp_golomb_code(tree, hf_h265_elemental_duration_in_tc_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } else { low_delay_hrd_flag[subLayerId] = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_low_delay_hrd_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } if (!low_delay_hrd_flag[subLayerId]) { cpb_cnt_minus1[subLayerId] = dissect_h265_exp_golomb_code(tree, hf_h265_cpb_cnt_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } if (nal_hrd_parameters_present_flag) { dissect_h265_sub_layer_hrd_parameters(tree, tvb, pinfo, bit_offset, subLayerId, cpb_cnt_minus1[subLayerId] + 1, sub_pic_hrd_params_present_flag); } if (vcl_hrd_parameters_present_flag) { dissect_h265_sub_layer_hrd_parameters(tree, tvb, pinfo, bit_offset, subLayerId, cpb_cnt_minus1[subLayerId] + 1, sub_pic_hrd_params_present_flag); } } return bit_offset; } #define EXTENDED_SAR 255 /* Table E-2 - Meaning of video_format */ static const value_string h265_video_format_vals[] = { { 0, "Component" }, { 1, "PAL" }, { 2, "NTSC" }, { 3, "SECAM" }, { 4, "MAC" }, { 5, "Unspecified video format" }, { 0, NULL } }; /* E.2.1 VUI parameters syntax */ static int dissect_h265_vui_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int bit_offset, uint8_t sps_max_sub_layers_minus1) { uint8_t aspect_ratio_info_present_flag, aspect_ratio_idc, overscan_info_present_flag; uint8_t video_signal_type_present_flag, colour_description_present_flag, chroma_loc_info_present_flag; uint8_t bitstream_restriction_flag, default_display_window_flag, vui_timing_info_present_flag; uint8_t vui_poc_proportional_to_timing_flag, vui_hrd_parameters_present_flag; /* vui_parameters( ) { * aspect_ratio_info_present_flag 0 u(1) */ aspect_ratio_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_aspect_ratio_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (aspect_ratio_info_present_flag) { /* aspect_ratio_idc 0 u(8) */ aspect_ratio_idc = tvb_get_bits8(tvb, bit_offset, 8); proto_tree_add_bits_item(tree, hf_h265_aspect_ratio_idc, tvb, bit_offset, 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; if (aspect_ratio_idc == EXTENDED_SAR) { /* sar_width 0 u(16) */ proto_tree_add_bits_item(tree, hf_h265_sar_width, tvb, bit_offset, 16, ENC_BIG_ENDIAN); bit_offset = bit_offset + 16; /* sar_height 0 u(16) */ proto_tree_add_bits_item(tree, hf_h265_sar_height, tvb, bit_offset, 16, ENC_BIG_ENDIAN); bit_offset = bit_offset + 16; } } /* overscan_info_present_flag 0 u(1) */ overscan_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_overscan_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (overscan_info_present_flag) { /* overscan_appropriate_flag 0 u(1) */ proto_tree_add_bits_item(tree, hf_h265_overscan_appropriate_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; } /* video_signal_type_present_flag 0 u(1) */ video_signal_type_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_video_signal_type_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (video_signal_type_present_flag) { /* video_format 0 u(3) > */ proto_tree_add_bits_item(tree, hf_h265_video_format, tvb, bit_offset, 3, ENC_BIG_ENDIAN); bit_offset = bit_offset + 3; /* video_full_range_flag 0 u(1)*/ proto_tree_add_bits_item(tree, hf_h265_video_full_range_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* colour_description_present_flag 0 u(1) */ colour_description_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_colour_description_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (colour_description_present_flag) { /* colour_primaries 0 u(8) */ proto_tree_add_bits_item(tree, hf_h265_colour_primaries, tvb, bit_offset, 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; /* transfer_characteristics 0 u(8) */ proto_tree_add_bits_item(tree, hf_h265_transfer_characteristics, tvb, bit_offset, 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; /* matrix_coefficients 0 u(8)*/ proto_tree_add_bits_item(tree, hf_h265_matrix_coeffs, tvb, bit_offset, 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + 8; } } /* chroma_loc_info_present_flag 0 u(1) */ chroma_loc_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_chroma_loc_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (chroma_loc_info_present_flag) { /* chroma_sample_loc_type_top_field 0 ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_chroma_sample_loc_type_top_field, tvb, pinfo, &bit_offset, H265_UE_V); /* chroma_sample_loc_type_bottom_field 0 ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_chroma_sample_loc_type_bottom_field, tvb, pinfo, &bit_offset, H265_UE_V); } /* neutral_chroma_indication_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_neutral_chroma_indication_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* field_seq_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_field_seq_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* frame_field_info_present_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_frame_field_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* default_display_window_flag u(1) */ default_display_window_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_default_display_window_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (default_display_window_flag) { /* def_disp_win_left_offset ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_def_disp_win_left_offset, tvb, pinfo, &bit_offset, H265_UE_V); /* def_disp_win_right_offset ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_def_disp_win_right_offset, tvb, pinfo, &bit_offset, H265_UE_V); /* def_disp_win_top_offset ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_def_disp_win_top_offset, tvb, pinfo, &bit_offset, H265_UE_V); /* def_disp_win_bottom_offset ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_def_disp_win_bottom_offset, tvb, pinfo, &bit_offset, H265_UE_V); } /* vui_timing_info_present_flag u(1) */ vui_timing_info_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vui_timing_info_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (vui_timing_info_present_flag) { /* vui_num_units_in_tick u(32) */ proto_tree_add_bits_item(tree, hf_h265_vui_num_units_in_tick, tvb, bit_offset, 32, ENC_BIG_ENDIAN); bit_offset = bit_offset + 32; /* vui_time_scale u(32) */ proto_tree_add_bits_item(tree, hf_h265_vui_time_scale, tvb, bit_offset, 32, ENC_BIG_ENDIAN); bit_offset = bit_offset + 32; /* vui_poc_proportional_to_timing_flag u(1) */ vui_poc_proportional_to_timing_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vui_poc_proportional_to_timing_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (vui_poc_proportional_to_timing_flag) { /* vui_num_ticks_poc_diff_one_minus1 ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_vui_num_ticks_poc_diff_one_minus1, tvb, pinfo, &bit_offset, H265_UE_V); } /* vui_hrd_parameters_present_flag u(1) */ vui_hrd_parameters_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_vui_hrd_parameters_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (vui_hrd_parameters_present_flag) { dissect_h265_hrd_parameters(tree, tvb, pinfo, bit_offset, 1, sps_max_sub_layers_minus1); } } /* bitstream_restriction_flag 0 u(1) */ bitstream_restriction_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_bitstream_restriction_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (bitstream_restriction_flag) { /* tiles_fixed_structure_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_tiles_fixed_structure_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* motion_vectors_over_pic_boundaries_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_motion_vectors_over_pic_boundaries_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* restricted_ref_pic_lists_flag u(1) */ proto_tree_add_bits_item(tree, hf_h265_restricted_ref_pic_lists_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; /* min_spatial_segmentation_idc ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_min_spatial_segmentation_idc, tvb, pinfo, &bit_offset, H265_UE_V); /* max_bytes_per_pic_denom ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_max_bytes_per_pic_denom, tvb, pinfo, &bit_offset, H265_UE_V); /* max_bits_per_min_cu_denom ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_max_bits_per_min_cu_denom, tvb, pinfo, &bit_offset, H265_UE_V); /* log2_max_mv_length_horizontal ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_log2_max_mv_length_horizontal, tvb, pinfo, &bit_offset, H265_UE_V); /* log2_max_mv_length_vertical ue(v) */ dissect_h265_exp_golomb_code(tree, hf_h265_log2_max_mv_length_vertical, tvb, pinfo, &bit_offset, H265_UE_V); } return bit_offset; } /* 7.3.2.2.2 Sequence parameter set range extension syntax */ static int dissect_h265_sps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset) { proto_tree_add_bits_item(tree, hf_h265_transform_skip_rotation_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_transform_skip_context_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_implicit_rdpcm_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_explicit_rdpcm_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_extended_precision_processing_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_intra_smoothing_disabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_high_precision_offsets_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_persistent_rice_adaptation_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; proto_tree_add_bits_item(tree, hf_h265_cabac_bypass_alignment_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; return bit_offset; } /* F.7.3.2.2.4 Sequence parameter set multilayer extension syntax */ static int dissect_h265_sps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset) { proto_tree *sps_multilayer_extension_tree; sps_multilayer_extension_tree = proto_tree_add_subtree(tree, tvb, bit_offset >> 3, 1, ett_h265_sps_multilayer_extension, NULL, "sps_multilayer_extension"); proto_tree_add_expert(sps_multilayer_extension_tree, pinfo, &ei_h265_undecoded, tvb, bit_offset >> 3, -1); return bit_offset; } /* I.7.3.2.2.5 Sequence parameter set 3D extension syntax */ static int dissect_h265_sps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset) { proto_tree *sps_3d_extension_tree; sps_3d_extension_tree = proto_tree_add_subtree(tree, tvb, bit_offset >> 3, 1, ett_h265_sps_3d_extension, NULL, "sps_3d_extension"); proto_tree_add_expert(sps_3d_extension_tree, pinfo, &ei_h265_undecoded, tvb, bit_offset >> 3, -1); return bit_offset; } /* 7.3.2.2.3 Sequence parameter set screen content coding extension syntax */ static int dissect_h265_sps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset, unsigned chroma_format_idc, unsigned bit_depth_luma_minus8, unsigned bit_depth_chroma_minus8) { unsigned BitDepthY = 8 + bit_depth_luma_minus8, BitDepthC = 8 + bit_depth_chroma_minus8; bool palette_mode_enabled_flag, sps_palette_predictor_initializers_present_flag; uint32_t sps_num_palette_predictor_initializers_minus1; uint32_t numComps, comp, i; proto_tree_add_bits_item(tree, hf_h265_sps_curr_pic_ref_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; palette_mode_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_palette_mode_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (palette_mode_enabled_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_palette_max_size, tvb, pinfo, &bit_offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_delta_palette_max_predictor_size, tvb, pinfo, &bit_offset, H265_UE_V); sps_palette_predictor_initializers_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_sps_palette_predictor_initializers_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (sps_palette_predictor_initializers_present_flag) { sps_num_palette_predictor_initializers_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_sps_num_palette_predictor_initializers_minus1, tvb, pinfo, &bit_offset, H265_UE_V); numComps = (chroma_format_idc == 0) ? 1 : 3; for (comp = 0; comp < numComps; comp++) for (i = 0; i <= sps_num_palette_predictor_initializers_minus1; i++) { if (comp == 0) { proto_tree_add_bits_item(tree, hf_h265_sps_palette_predictor_initializer, tvb, bit_offset, (1 << BitDepthY) - 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + (1 << BitDepthY) - 1; } else { proto_tree_add_bits_item(tree, hf_h265_sps_palette_predictor_initializer, tvb, bit_offset, (1 << BitDepthC) - 1, ENC_BIG_ENDIAN); bit_offset = bit_offset + (1 << BitDepthC) - 1; } } } } proto_tree_add_bits_item(tree, hf_h265_motion_vector_resolution_control_idc, tvb, bit_offset, 2, ENC_BIG_ENDIAN); bit_offset = bit_offset + 2; proto_tree_add_bits_item(tree, hf_h265_intra_boundary_filtering_disabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; return bit_offset; } /* 7.3.2.3.2 Picture parameter set range extension syntax */ static int dissect_h265_pps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset, unsigned transform_skip_enabled_flag) { bool chroma_qp_offset_list_enabled_flag; int offset; unsigned i, chroma_qp_offset_list_len_minus1; if (transform_skip_enabled_flag) { offset = bit_offset >> 3; dissect_h265_exp_golomb_code(tree, hf_h265_log2_max_transform_skip_block_size_minus2, tvb, pinfo, &offset, H265_UE_V); bit_offset = offset << 3; } proto_tree_add_bits_item(tree, hf_h265_cross_component_prediction_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; chroma_qp_offset_list_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_chroma_qp_offset_list_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; offset = bit_offset >> 3; if (chroma_qp_offset_list_enabled_flag) { dissect_h265_exp_golomb_code(tree, hf_h265_diff_cu_chroma_qp_offset_depth, tvb, pinfo, &offset, H265_UE_V); chroma_qp_offset_list_len_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_chroma_qp_offset_list_len_minus1, tvb, pinfo, &offset, H265_UE_V); for (i = 0; i <= chroma_qp_offset_list_len_minus1; i++) { dissect_h265_exp_golomb_code(tree, hf_h265_cb_qp_offset_list, tvb, pinfo, &offset, H265_SE_V); dissect_h265_exp_golomb_code(tree, hf_h265_cr_qp_offset_list, tvb, pinfo, &offset, H265_SE_V); } } dissect_h265_exp_golomb_code(tree, hf_h265_log2_sao_offset_scale_luma, tvb, pinfo, &offset, H265_UE_V); dissect_h265_exp_golomb_code(tree, hf_h265_log2_sao_offset_scale_chroma, tvb, pinfo, &offset, H265_UE_V); bit_offset = offset << 3; return bit_offset; } /* 7.3.2.3.3 Picture parameter set screen content coding extension syntax */ static int dissect_h265_pps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_, int bit_offset) { int offset; unsigned pps_num_palette_predictor_initializers, numComps, comp, i; bool residual_adaptive_colour_transform_enabled_flag, pps_palette_predictor_initializers_present_flag, monochrome_palette_flag; uint32_t luma_bit_depth_entry_minus8 = 0, chroma_bit_depth_entry_minus8 = 0; proto_tree_add_bits_item(tree, hf_h265_pps_curr_pic_ref_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; residual_adaptive_colour_transform_enabled_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_residual_adaptive_colour_transform_enabled_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (residual_adaptive_colour_transform_enabled_flag) { proto_tree_add_bits_item(tree, hf_h265_pps_slice_act_qp_offsets_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; offset = bit_offset >> 3; dissect_h265_exp_golomb_code(tree, hf_h265_pps_act_y_qp_offset_plus5, tvb, pinfo, &offset, H265_SE_V); dissect_h265_exp_golomb_code(tree, hf_h265_pps_act_cb_qp_offset_plus5, tvb, pinfo, &offset, H265_SE_V); dissect_h265_exp_golomb_code(tree, hf_h265_pps_act_cr_qp_offset_plus3, tvb, pinfo, &offset, H265_SE_V); bit_offset = offset << 3; } pps_palette_predictor_initializers_present_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_pps_palette_predictor_initializers_present_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; if (pps_palette_predictor_initializers_present_flag) { offset = bit_offset >> 3; pps_num_palette_predictor_initializers = dissect_h265_exp_golomb_code(tree, hf_h265_pps_num_palette_predictor_initializers, tvb, pinfo, &offset, H265_SE_V); if (pps_num_palette_predictor_initializers > 0) { bit_offset = offset << 3; monochrome_palette_flag = tvb_get_bits8(tvb, bit_offset, 1); proto_tree_add_bits_item(tree, hf_h265_monochrome_palette_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN); bit_offset++; offset = bit_offset >> 3; luma_bit_depth_entry_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_luma_bit_depth_entry_minus8, tvb, pinfo, &offset, H265_UE_V); if (!monochrome_palette_flag) { chroma_bit_depth_entry_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_chroma_bit_depth_entry_minus8, tvb, pinfo, &offset, H265_UE_V); } numComps = monochrome_palette_flag ? 1 : 3; for (comp = 0; comp < numComps; comp++) for (i = 0; i < pps_num_palette_predictor_initializers; i++) { bit_offset = offset << 3; if (comp == 0) { proto_tree_add_bits_item(tree, hf_h265_pps_palette_predictor_initializer, tvb, bit_offset, luma_bit_depth_entry_minus8 + 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + luma_bit_depth_entry_minus8 + 8; } else { proto_tree_add_bits_item(tree, hf_h265_pps_palette_predictor_initializer, tvb, bit_offset, chroma_bit_depth_entry_minus8 + 8, ENC_BIG_ENDIAN); bit_offset = bit_offset + chroma_bit_depth_entry_minus8 + 8; } offset = bit_offset >> 3; } } bit_offset = offset << 3; } return bit_offset; } /* F.7.3.2.3.4 Picture parameter set multilayer extension syntax */ static int dissect_h265_pps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset) { proto_tree *pps_multilayer_extension_tree; pps_multilayer_extension_tree = proto_tree_add_subtree(tree, tvb, bit_offset >> 3, 1, ett_h265_pps_multilayer_extension, NULL, "pps_multilayer_extension"); proto_tree_add_expert(pps_multilayer_extension_tree, pinfo, &ei_h265_undecoded, tvb, bit_offset >> 3, -1); return bit_offset; } /* I.7.3.2.3.7 Picture parameter set 3D extension syntax */ static int dissect_h265_pps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset) { proto_tree *pps_3d_extension_tree; pps_3d_extension_tree = proto_tree_add_subtree(tree, tvb, bit_offset >> 3, 1, ett_h265_pps_3d_extension, NULL, "pps_3d_extension"); proto_tree_add_expert(pps_3d_extension_tree, pinfo, &ei_h265_undecoded, tvb, bit_offset >> 3, -1); return bit_offset; } static tvbuff_t * dissect_h265_unescap_nal_unit(tvbuff_t *tvb, packet_info *pinfo, int offset) { tvbuff_t *tvb_rbsp; int length = tvb_reported_length_remaining(tvb, offset); int NumBytesInRBSP = 0; int i; uint8_t *buff; buff = (char *)wmem_alloc(pinfo->pool, length); for (i = 0; i < length; i++) { if ((i + 2 < length) && (tvb_get_ntoh24(tvb, offset) == 0x000003)) { buff[NumBytesInRBSP++] = tvb_get_uint8(tvb, offset); buff[NumBytesInRBSP++] = tvb_get_uint8(tvb, offset + 1); i += 2; offset += 3; } else { buff[NumBytesInRBSP++] = tvb_get_uint8(tvb, offset); offset++; } } tvb_rbsp = tvb_new_child_real_data(tvb, buff, NumBytesInRBSP, NumBytesInRBSP); add_new_data_source(pinfo, tvb_rbsp, "Unescaped RSP Data"); return tvb_rbsp; } void dissect_h265_format_specific_parameter(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo) { int offset = 0; proto_item *item; proto_tree *h265_nal_tree; uint8_t type; tvbuff_t *rbsp_tvb; type = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN) >> 9 & 0x3F; /* Unescape NAL unit */ rbsp_tvb = dissect_h265_unescap_nal_unit(tvb, pinfo, offset + 2); switch (type) { case 32: /* VPS_NUT - Video parameter set */ item = proto_tree_add_item(tree, hf_h265_sdp_parameter_sprop_vps, tvb, offset, -1, ENC_NA); h265_nal_tree = proto_item_add_subtree(item, ett_h265_sprop_parameters); dissect_h265_video_parameter_set_rbsp(h265_nal_tree, rbsp_tvb, pinfo, 0); break; case 33: /* SPS_NUT - Sequence parameter set*/ item = proto_tree_add_item(tree, hf_h265_sdp_parameter_sprop_sps, tvb, offset, -1, ENC_NA); h265_nal_tree = proto_item_add_subtree(item, ett_h265_sprop_parameters); dissect_h265_seq_parameter_set_rbsp(h265_nal_tree, rbsp_tvb, pinfo, 0); break; case 34: /* PPS_NUT - Picture parameter set */ item = proto_tree_add_item(tree, hf_h265_sdp_parameter_sprop_pps, tvb, offset, -1, ENC_NA); h265_nal_tree = proto_item_add_subtree(item, ett_h265_sprop_parameters); dissect_h265_pic_parameter_set_rbsp(h265_nal_tree, rbsp_tvb, pinfo, 0); break; default: proto_tree_add_expert(tree, pinfo, &ei_h265_format_specific_parameter, tvb, offset, -1); break; } } /* Code to actually dissect the packets */ static int dissect_h265(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; proto_item *item; proto_tree *h265_tree, *h265_nal_tree, *stream_tree, *fua_tree; uint8_t type; tvbuff_t *rbsp_tvb; /* Make entries in Protocol column and Info column on summary display */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "H.265"); uint16_t h265_nalu_hextet = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN); type = h265_nalu_hextet >> 9 & 0x3F; col_append_fstr(pinfo->cinfo, COL_INFO, " %s", val_to_str(type, h265_type_summary_values, "Unknown Type (%u)")); /* if (tree) */ { item = proto_tree_add_item(tree, proto_h265, tvb, 0, -1, ENC_NA); h265_tree = proto_item_add_subtree(item, ett_h265); /* if the type is 49, it would be draw another title */ if (type == 49) h265_nal_tree = proto_tree_add_subtree(h265_tree, tvb, offset, 2, ett_h265_nal, NULL, "FU identifier"); else h265_nal_tree = proto_tree_add_subtree(h265_tree, tvb, offset, 2, ett_h265_nal, NULL, "NAL unit header or first two bytes of the payload"); /* decode the HEVC payload header according to section 4: 0 1 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |F| Type | LayerId | TID | +-------------+-----------------+ Forbidden zero (F): 1 bit NAL unit type (Type): 6 bits NUH layer ID (LayerId): 6 bits NUH temporal ID plus 1 (TID): 3 bits */ proto_tree_add_item(h265_nal_tree, hf_h265_nal_f_bit, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(h265_nal_tree, hf_h265_type, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(h265_nal_tree, hf_h265_nuh_layer_id, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(h265_nal_tree, hf_h265_nuh_temporal_id_plus1, tvb, offset, 2, ENC_BIG_ENDIAN); offset++; offset++; if (type == 48) { // Aggregation Packets (APs) } else if (type == 49) { // Fragmentation Units fua_tree = proto_tree_add_subtree(h265_tree, tvb, offset, 1, ett_h265_fu, NULL, "FU Header"); proto_tree_add_item(fua_tree, hf_h265_start_bit, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(fua_tree, hf_h265_end_bit, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(fua_tree, hf_h265_nal_unit_type, tvb, offset, 1, ENC_BIG_ENDIAN); if ((tvb_get_uint8(tvb, offset) & 0x80) == 0x80) { type = tvb_get_uint8(tvb, offset) & 0x1f; col_append_fstr(pinfo->cinfo, COL_INFO, " Start:%s", val_to_str(type, h265_type_summary_values, "Unknown Type (%u)")); offset++; } else { if ((tvb_get_uint8(tvb, offset) & 0x40) == 0x40) { col_append_str(pinfo->cinfo, COL_INFO, " End"); } return offset; } } else if (type == 50) { //PACI Packets } /* Unescape NAL unit */ rbsp_tvb = dissect_h265_unescap_nal_unit(tvb, pinfo, offset); stream_tree = proto_tree_add_subtree(h265_tree, tvb, offset, -1, ett_h265_stream, NULL, "H265 NAL Unit Payload"); switch (type) { case 0: case 1: /* Coded slice segment of a non-TSA, non-STSA trailing picture */ case 2: case 3: /* Coded slice segment of a TSA picture */ case 4: case 5: /* Coded slice segment of an STSA picture */ case 6: case 7: /* Coded slice segment of a RADL picture */ case 8: case 9: /* Coded slice segment of a RASL picture */ dissect_h265_slice_segment_layer_rbsp(stream_tree, rbsp_tvb, pinfo, 0, type); break; case 10: case 12: case 14: /* Reserved non-IRAP SLNR VCL NAL unit types */ case 11: case 13: case 15: /* Reserved non-IRAP sub-layer reference VCL NAL unit types */ break; case 16: case 17: case 18: /* Coded slice segment of a BLA picture */ case 19: case 20: /* Coded slice segment of an IDR picture */ case 21: /* CRA_NUT - Coded slice segment of a CRA picture */ dissect_h265_slice_segment_layer_rbsp(stream_tree, rbsp_tvb, pinfo, 0, type); break; //case 22..31 case 32 : /* VPS_NUT - Video parameter set */ dissect_h265_video_parameter_set_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 33: /* SPS_NUT - Sequence parameter set*/ dissect_h265_seq_parameter_set_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 34: /* PPS_NUT - Picture parameter set */ dissect_h265_pic_parameter_set_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 35: /*AUD_NUT - Access unit delimiter*/ dissect_h265_access_unit_delimiter_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 36: /*EOS_NUT - End of sequence*/ dissect_h265_end_of_seq_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 37: /*EOB_NUT - End of bitstream*/ dissect_h265_end_of_bitstream_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 38: /*FD_NUT - Filler data*/ dissect_h265_filler_data_rbsp(stream_tree, rbsp_tvb, pinfo, 0); break; case 39: /*PREFIX_SEI_NUT - Supplemental enhancement information*/ case 40: /*SUFFIX_SEI_NUT - Supplemental enhancement information*/ dissect_h265_sei_rbsp(stream_tree, rbsp_tvb, pinfo, 0, type); break; case 49: /* FU - Fragmentation Units */ break; case 50: /* PACI - PACI Packets */ break; } } /* if (tree) */ return tvb_captured_length(tvb); } /* Annex B "Byte stream format" */ static int dissect_h265_bytestream(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { tvbuff_t *next_tvb; //, *rbsp_tvb; int offset = 0, end_offset; uint32_t dword; /* Look for the first start word. Assume byte aligned. */ while (1) { if (tvb_reported_length(tvb) < 4) { return 0; } dword = tvb_get_uint32(tvb, offset, ENC_BIG_ENDIAN); if ((dword >> 8) == 1 || dword == 1) { break; } else if (dword != 0) { return 0; } offset += 2; } col_set_str(pinfo->cinfo, COL_PROTOCOL, "H.265"); col_clear(pinfo->cinfo, COL_INFO); while (tvb_reported_length_remaining(tvb, offset)) { dword = tvb_get_uint32(tvb, offset, ENC_BIG_ENDIAN); if ((dword >> 8) != 1) { /* zero_byte */ offset++; } /* start_code_prefix_one_3bytes */ offset += 3; int nal_length = tvb_reported_length_remaining(tvb, offset); /* Search for \0\0\1 or \0\0\0\1 */ end_offset = tvb_find_uint16(tvb, offset, -1, 0); while (end_offset != -1) { if (tvb_find_uint16(tvb, end_offset + 1, 3, 1) != -1) { nal_length = end_offset - offset; break; } end_offset = tvb_find_uint16(tvb, end_offset + 1, -1, 0); } /* If end_offset is -1, we got to the end; assume this is the * end of the NAL. Handling NALs split across lower level * packets requires something like epan/stream.h */ next_tvb = tvb_new_subset_length(tvb, offset, nal_length); dissect_h265(next_tvb, pinfo, tree, data); offset += nal_length; } return tvb_reported_length(tvb); } void proto_register_h265(void) { module_t *h265_module; expert_module_t* expert_h265; /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { { &hf_h265_nal_f_bit, { "F bit", "h265.f", FT_BOOLEAN, 16, TFS(&h265_f_bit_vals), 0x8000, NULL, HFILL } }, { &hf_h265_type, { "Type", "h265.nal_unit_type", FT_UINT16, BASE_DEC, VALS(h265_type_values), 0x7E00, NULL, HFILL } }, { &hf_h265_nuh_layer_id, { "LayerId", "h265.layer_id", FT_UINT16, BASE_DEC, NULL, 0x01F8, NULL, HFILL } }, { &hf_h265_nuh_temporal_id_plus1, { "TID", "h265.temporal_id", FT_UINT16, BASE_DEC, NULL, 0x0007, NULL, HFILL } }, { &hf_h265_start_bit, { "Start bit", "h265.start.bit", FT_BOOLEAN, 8, TFS(&h265_start_bit_vals), 0x80, NULL, HFILL } }, { &hf_h265_end_bit, { "End bit", "h265.end.bit", FT_BOOLEAN, 8, TFS(&h265_end_bit_vals), 0x40, NULL, HFILL } }, { &hf_h265_nal_unit_type, { "Nal_unit_type", "h265.nal_unit_type", FT_UINT8, BASE_DEC, VALS(h265_type_values), 0x1f, NULL, HFILL } }, { &hf_h265_rbsp_stop_bit, { "rbsp_stop_bit", "h265.rbsp_stop_bit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_rbsp_trailing_bits, { "rbsp_trailing_bits", "h265.rbsp_trailing_bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*VPS*/ { &hf_h265_vps_video_parameter_set_id, { "vps_video_parameter_set_id", "h265.vps_video_parameter_set_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_base_layer_internal_flag, { "vps_base_layer_internal_flag", "h265.vps_base_layer_internal_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_base_layer_available_flag, { "vps_base_layer_available_flag", "h265.vps_base_layer_available_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_max_layers_minus1, { "vps_max_layers_minus1", "h265.vps_max_layers_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_max_sub_layers_minus1, { "vps_max_sub_layers_minus1", "h265.vps_max_sub_layers_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_temporal_id_nesting_flag, { "vps_temporal_id_nesting_flag", "h265.vps_temporal_id_nesting_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_reserved_0xffff_16bits, { "vps_reserved_0xffff_16bits", "h265.vps_reserved_0xffff_16bits", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, /* profile, level and tier*/ { &hf_h265_general_profile_space, { "general_profile_space", "h265.general_profile_space", FT_UINT8, BASE_DEC, NULL, 0xC0, NULL, HFILL } }, { &hf_h265_general_tier_flag, { "general_tier_flag", "h265.general_tier_flag", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL } }, { &hf_h265_general_profile_idc, { "general_profile_idc", "h265.general_profile_idc", FT_UINT8, BASE_DEC, VALS(h265_profile_idc_values), 0x1F, NULL, HFILL } }, { &hf_h265_general_profile_compatibility_flags, { "general_profile_compatibility_flags", "h265.general_profile_compatibility_flags", FT_UINT32, BASE_HEX, NULL, 0xFFFFFFFF, NULL, HFILL } }, { &hf_h265_general_progressive_source_flag, { "general_progressive_source_flag", "h265.general_progressive_source_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_interlaced_source_flag, { "general_interlaced_source_flag", "h265.general_interlaced_source_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_non_packed_constraint_flag, { "general_non_packed_constraint_flag", "h265.general_non_packed_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_frame_only_constraint_flag, { "general_frame_only_constraint_flag", "h265.general_frame_only_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_12bit_constraint_flag, { "general_max_12bit_constraint_flag", "h265.general_max_12bit_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_10bit_constraint_flag, { "general_max_10bit_constraint_flag", "h265.general_max_10bit_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_8bit_constraint_flag, { "general_max_8bit_constraint_flag", "h265.general_max_8bit_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_422chroma_constraint_flag, { "general_max_422chroma_constraint_flag", "h265.general_max_422chroma_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_420chroma_constraint_flag, { "general_max_420chroma_constraint_flag", "h265.general_max_420chroma_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_monochrome_constraint_flag, { "general_max_monochrome_constraint_flag", "h265.general_max_monochrome_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_intra_constraint_flag, { "general_intra_constraint_flag", "h265.general_intra_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_one_picture_only_constraint_flag, { "general_one_picture_only_constraint_flag", "h265.general_one_picture_only_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_lower_bit_rate_constraint_flag, { "general_lower_bit_rate_constraint_flag", "h265.general_lower_bit_rate_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_max_14bit_constraint_flag, { "general_max_14bit_constraint_flag", "h265.general_max_14bit_constraint_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_33bits, { "general_reserved_zero_33bits", "h265.general_reserved_zero_33bits", FT_UINT40, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_34bits, { "general_reserved_zero_34bits", "h265.general_reserved_zero_34bits", FT_UINT40, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_7bits, { "general_reserved_zero_7bits", "h265.general_reserved_zero_7bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_35bits, { "general_reserved_zero_35bits", "h265.general_reserved_zero_35bits", FT_UINT40, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_43bits, { "general_reserved_zero_43bits", "h265.general_reserved_zero_43bits", FT_UINT48, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_inbld_flag, { "general_inbld_flag", "h265.general_inbld_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_reserved_zero_bit, { "general_reserved_zero_bit", "h265.general_reserved_zero_bit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_general_level_idc, { "general_level_idc", "h265.general_level_idc", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_profile_present_flag, { "sub_layer_profile_present_flag", "h265.sub_layer_profile_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_level_present_flag, { "sub_layer_level_present_flag", "h265.sub_layer_level_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_reserved_zero_2bits, { "reserved_zero_2bits", "h265.reserved_zero_2bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_profile_space, { "sub_layer_profile_space", "h265.sub_layer_profile_space", FT_UINT8, BASE_DEC, NULL, 0x03, NULL, HFILL } }, { &hf_h265_sub_layer_tier_flag, { "sub_layer_tier_flag", "h265.sub_layer_tier_flag", FT_UINT8, BASE_DEC, NULL, 0x04, NULL, HFILL } }, { &hf_h265_sub_layer_profile_idc, { "sub_layer_profile_idc", "h265.sub_layer_profile_idc", FT_UINT8, BASE_DEC, NULL, 0xF8, NULL, HFILL } }, { &hf_h265_sub_layer_profile_compatibility_flag, { "sub_layer_profile_compatibility_flag", "h265.sub_layer_profile_compatibility_flag", FT_UINT32, BASE_DEC, NULL, 0xFF, NULL, HFILL } }, { &hf_h265_sub_layer_progressive_source_flag, { "sub_layer_progressive_source_flag", "h265.sub_layer_progressive_source_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_interlaced_source_flag, { "sub_layer_interlaced_source_flag", "h265.sub_layer_interlaced_source_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_non_packed_constraint_flag, { "sub_layer_non_packed_constraint_flag", "h265.sub_layer_non_packed_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_frame_only_constraint_flag, { "sub_layer_frame_only_constraint_flag", "h265.sub_layer_frame_only_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_12bit_constraint_flag, { "sub_layer_max_12bit_constraint_flag", "h265.sub_layer_max_12bit_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_10bit_constraint_flag, { "sub_layer_max_10bit_constraint_flag", "h265.sub_layer_max_10bit_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_8bit_constraint_flag, { "sub_layer_max_8bit_constraint_flag", "h265.sub_layer_max_8bit_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_422chroma_constraint_flag, { "sub_layer_max_422chroma_constraint_flag", "h265.sub_layer_max_422chroma_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_420chroma_constraint_flag, { "sub_layer_max_420chroma_constraint_flag", "h265.sub_layer_max_420chroma_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_monochrome_constraint_flag, { "sub_layer_max_monochrome_constraint_flag", "h265.sub_layer_max_monochrome_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_intra_constraint_flag, { "sub_layer_intra_constraint_flag", "h265.sub_layer_intra_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_one_picture_only_constraint_flag, { "sub_layer_one_picture_only_constraint_flag", "h265.sub_layer_one_picture_only_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_lower_bit_rate_constraint_flag, { "sub_layer_lower_bit_rate_constraint_flag", "h265.sub_layer_lower_bit_rate_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_max_14bit_constraint_flag, { "sub_layer_max_14bit_constraint_flag", "h265.sub_layer_max_14bit_constraint_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_33bits, { "sub_layer_reserved_zero_33bits", "h265.sub_layer_reserved_zero_33bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_34bits, { "sub_layer_reserved_zero_34bits", "h265.sub_layer_reserved_zero_34bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_7bits, { "sub_layer_reserved_zero_7bits", "h265.sub_layer_reserved_zero_7bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_35bits, { "sub_layer_reserved_zero_35bits", "h265.sub_layer_reserved_zero_35bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_43bits, { "sub_layer_reserved_zero_43bits", "h265.sub_layer_reserved_zero_43bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_inbld_flag, { "sub_layer_inbld_flag", "h265.sub_layer_inbld_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_reserved_zero_bit, { "sub_layer_reserved_zero_bit", "h265.sub_layer_reserved_zero_bit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_layer_level_idc, { "sub_layer_level_idc", "h265.sub_layer_level_idc", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_sub_layer_ordering_info_present_flag, { "vps_sub_layer_ordering_info_present_flag", "h265.vps_sub_layer_ordering_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x01, NULL, HFILL } }, { &hf_h265_vps_max_dec_pic_buffering_minus1, { "vps_max_dec_pic_buffering_minus1", "h265.vps_max_dec_pic_buffering_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_max_num_reorder_pics, { "vps_max_num_reorder_pics", "h265.vps_max_num_reorder_pics", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_max_latency_increase_plus1, { "vps_max_latency_increase_plus1", "h265.vps_max_latency_increase_plus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_max_layer_id, { "vps_max_layer_id", "h265.vps_max_layer_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_num_layer_sets_minus1, { "vps_num_layer_sets_minus1", "h265.vps_num_layer_sets_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_layer_id_included_flag, { "layer_id_included_flag", "h265.layer_id_included_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_timing_info_present_flag, { "vps_timing_info_present_flag", "h265.vps_timing_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_num_units_in_tick, { "vps_num_units_in_tick", "h265.vps_num_units_in_tick", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_time_scale, { "vps_time_scale", "h265.vps_time_scale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_poc_proportional_to_timing_flag, { "vps_poc_proportional_to_timing_flag", "h265.vps_poc_proportional_to_timing_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_num_ticks_poc_diff_one_minus1, { "vps_num_ticks_poc_diff_one_minus1", "h265.vps_num_ticks_poc_diff_one_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_num_hrd_parameters, { "vps_num_hrd_parameters", "h265.vps_num_hrd_parameters", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_hrd_layer_set_idx, { "hrd_layer_set_idx", "h265.hrd_layer_set_idx", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cprms_present_flag, { "cprms_present_flag", "h265.cprms_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_extension_flag, { "vps_extension_flag", "h265.vps_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vps_extension_data_flag, { "vps_extension_data_flag", "h265.vps_extension_data_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*hrd_parameters*/ { &hf_h265_nal_hrd_parameters_present_flag, { "nal_hrd_parameters_present_flag", "h265.nal_hrd_parameters_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vcl_hrd_parameters_present_flag, { "vcl_hrd_parameters_present_flag", "h265.vcl_hrd_parameters_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_pic_hrd_params_present_flag, { "sub_pic_hrd_params_present_flag", "h265.sub_pic_hrd_params_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_tick_divisor_minus2, { "tick_divisor_minus2", "h265.tick_divisor_minus2", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_du_cpb_removal_delay_increment_length_minus1, { "du_cpb_removal_delay_increment_length_minus1", "h265.du_cpb_removal_delay_increment_length_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sub_pic_cpb_params_in_pic_timing_sei_flag, { "sub_pic_cpb_params_in_pic_timing_sei_flag", "h265.sub_pic_cpb_params_in_pic_timing_sei_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_dpb_output_delay_du_length_minus1, { "dpb_output_delay_du_length_minus1", "h265.dpb_output_delay_du_length_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_bit_rate_scale, { "bit_rate_scale", "h265.bit_rate_scale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cpb_size_scale, { "cpb_size_scale", "h265.cpb_size_scale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cpb_size_du_scale, { "cpb_size_du_scale", "h265.cpb_size_du_scale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_initial_cpb_removal_delay_length_minus1, { "initial_cpb_removal_delay_length_minus1", "h265.initial_cpb_removal_delay_length_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_au_cpb_removal_delay_length_minus1, { "au_cpb_removal_delay_length_minus1", "h265.au_cpb_removal_delay_length_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_dpb_output_delay_length_minus1, { "dpb_output_delay_length_minus1", "h265.dpb_output_delay_length_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_fixed_pic_rate_general_flag, { "fixed_pic_rate_general_flag", "h265.fixed_pic_rate_general_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_fixed_pic_rate_within_cvs_flag, { "fixed_pic_rate_within_cvs_flag", "h265.fixed_pic_rate_within_cvs_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_elemental_duration_in_tc_minus1, { "elemental_duration_in_tc_minus1", "h265.elemental_duration_in_tc_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_low_delay_hrd_flag, { "low_delay_hrd_flag", "h265.low_delay_hrd_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cpb_cnt_minus1, { "cpb_cnt_minus1", "h265.cpb_cnt_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*sub_layer_hrd_parameters*/ { &hf_h265_bit_rate_value_minus1, { "bit_rate_value_minus1", "h265.bit_rate_value_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cpb_size_value_minus1, { "cpb_size_value_minus1", "h265.cpb_size_value_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cpb_size_du_value_minus1, { "cpb_size_du_value_minus1", "h265.cpb_size_du_value_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_bit_rate_du_value_minus1, { "bit_rate_du_value_minus1", "h265.bit_rate_du_value_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cbr_flag, { "cbr_flag", "h265.cbr_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*SPS*/ { &hf_h265_sps_video_parameter_set_id, { "sps_video_parameter_set_id", "h265.sps_video_parameter_set_id", FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL } }, { &hf_h265_sps_max_sub_layers_minus1, { "sps_max_sub_layers_minus1", "h265.sps_max_sub_layers_minus1", FT_UINT8, BASE_DEC, NULL, 0x0E, NULL, HFILL } }, { &hf_h265_sps_temporal_id_nesting_flag, { "sps_temporal_id_nesting_flag", "h265.sps_temporal_id_nesting_flag", FT_UINT8, BASE_DEC, NULL, 0x01, NULL, HFILL } }, { &hf_h265_sps_seq_parameter_set_id, { "sps_seq_parameter_set_id", "h265.sps_seq_parameter_set_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_format_idc, { "chroma_format_idc", "h265.chroma_format_idc", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_separate_colour_plane_flag, { "separate_colour_plane_flag", "h265.separate_colour_plane_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pic_width_in_luma_samples, { "pic_width_in_luma_samples", "h265.pic_width_in_luma_samples", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pic_height_in_luma_samples, { "pic_height_in_luma_samples", "h265.pic_height_in_luma_samples", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_conformance_window_flag, { "conformance_window_flag", "h265.conformance_window_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_conf_win_left_offset, { "conf_win_left_offset", "h265.conf_win_left_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_conf_win_right_offset, { "conf_win_right_offset", "h265.conf_win_right_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_conf_win_top_offset, { "conf_win_top_offset", "h265.conf_win_top_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_conf_win_bottom_offset, { "conf_win_bottom_offset", "h265.conf_win_bottom_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_bit_depth_luma_minus8, { "bit_depth_luma_minus8", "h265.bit_depth_luma_minus8", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_bit_depth_chroma_minus8, { "bit_depth_chroma_minus8", "h265.bit_depth_chroma_minus8", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_max_pic_order_cnt_lsb_minus4, { "log2_max_pic_order_cnt_lsb_minus4", "h265.log2_max_pic_order_cnt_lsb_minus4", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_sub_layer_ordering_info_present_flag, { "sps_sub_layer_ordering_info_present_flag", "h265.sps_sub_layer_ordering_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_max_dec_pic_buffering_minus1, { "sps_max_dec_pic_buffering_minus1", "h265.sps_max_dec_pic_buffering_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_max_num_reorder_pics, { "sps_max_num_reorder_pics", "h265.sps_max_num_reorder_pics", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_max_latency_increase_plus1, { "sps_max_latency_increase_plus1", "h265.sps_max_latency_increase_plus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_min_luma_coding_block_size_minus3, { "log2_min_luma_coding_block_size_minus3", "h265.log2_min_luma_coding_block_size_minus3", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_diff_max_min_luma_coding_block_size, { "log2_diff_max_min_luma_coding_block_size", "h265.log2_diff_max_min_luma_coding_block_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_min_luma_transform_block_size_minus2, { "log2_min_luma_transform_block_size_minus2", "h265.log2_min_luma_transform_block_size_minus2", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_diff_max_min_luma_transform_block_size, { "log2_diff_max_min_luma_transform_block_size", "h265.log2_diff_max_min_luma_transform_block_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_max_transform_hierarchy_depth_inter, { "max_transform_hierarchy_depth_inter", "h265.max_transform_hierarchy_depth_inter", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_max_transform_hierarchy_depth_intra, { "max_transform_hierarchy_depth_intra", "h265.max_transform_hierarchy_depth_intra", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_scaling_list_enabled_flag, { "scaling_list_enabled_flag", "h265.scaling_list_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_scaling_list_data_present_flag, { "sps_scaling_list_data_present_flag", "h265.sps_scaling_list_data_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_amp_enabled_flag, { "amp_enabled_flag", "h265.amp_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sample_adaptive_offset_enabled_flag, { "sample_adaptive_offset_enabled_flag", "h265.sample_adaptive_offset_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pcm_enabled_flag, { "pcm_enabled_flag", "h265.pcm_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pcm_sample_bit_depth_luma_minus1, { "pcm_sample_bit_depth_luma_minus1", "h265.pcm_sample_bit_depth_luma_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pcm_sample_bit_depth_chroma_minus1, { "pcm_sample_bit_depth_chroma_minus1", "h265.pcm_sample_bit_depth_chroma_minus1", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_min_pcm_luma_coding_block_size_minus3, { "log2_min_pcm_luma_coding_block_size_minus3", "h265.log2_min_pcm_luma_coding_block_size_minus3", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_diff_max_min_pcm_luma_coding_block_size, { "log2_diff_max_min_pcm_luma_coding_block_size", "h265.log2_diff_max_min_pcm_luma_coding_block_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pcm_loop_filter_disabled_flag, { "pcm_loop_filter_disabled_flag", "h265.pcm_loop_filter_disabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_short_term_ref_pic_sets, { "num_short_term_ref_pic_sets", "h265.num_short_term_ref_pic_sets", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_long_term_ref_pics_present_flag, { "long_term_ref_pics_present_flag", "h265.long_term_ref_pics_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_long_term_ref_pics_sps, { "num_long_term_ref_pics_sps", "h265.num_long_term_ref_pics_sps", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_lt_ref_pic_poc_lsb_sps, { "lt_ref_pic_poc_lsb_sps", "h265.lt_ref_pic_poc_lsb_sps", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_used_by_curr_pic_lt_sps_flag, { "used_by_curr_pic_lt_sps_flag", "h265.used_by_curr_pic_lt_sps_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_temporal_mvp_enabled_flag, { "sps_temporal_mvp_enabled_flag", "h265.sps_temporal_mvp_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_strong_intra_smoothing_enabled_flag, { "strong_intra_smoothing_enabled_flag", "h265.strong_intra_smoothing_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_parameters_present_flag, { "vui_parameters_present_flag", "h265.vui_parameters_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_extension_present_flag, { "sps_extension_present_flag", "h265.sps_extension_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_range_extension_flag, { "sps_range_extension_flag", "h265.sps_range_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_multilayer_extension_flag, { "sps_multilayer_extension_flag", "h265.sps_multilayer_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_3d_extension_flag, { "sps_3d_extension_flag", "h265.sps_3d_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_scc_extension_flag, { "sps_scc_extension_flag", "h265.sps_scc_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_extension_4bits, { "sps_extension_4bits", "h265.sps_extension_4bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_extension_data_flag, { "sps_extension_data_flag", "h265.sps_extension_data_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /* scaling_list_data */ { &hf_h265_scaling_list_pred_mode_flag, { "scaling_list_pred_mode_flag", "h265.scaling_list_pred_mode_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_scaling_list_pred_matrix_id_delta, { "scaling_list_pred_matrix_id_delta", "h265.scaling_list_pred_matrix_id_delta", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_scaling_list_dc_coef_minus8, { "scaling_list_dc_coef_minus8", "h265.scaling_list_dc_coef_minus8", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_scaling_list_delta_coef, { "scaling_list_delta_coef", "h265.scaling_list_delta_coef", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*st_ref_pic_set*/ { &hf_h265_inter_ref_pic_set_prediction_flag, { "inter_ref_pic_set_prediction_flag", "h265.inter_ref_pic_set_prediction_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_delta_idx_minus1, { "delta_idx_minus1", "h265.delta_idx_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_delta_rps_sign, { "delta_rps_sign", "h265.delta_rps_sign", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_abs_delta_rps_minus1, { "abs_delta_rps_minus1", "h265.abs_delta_rps_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_used_by_curr_pic_flag, { "used_by_curr_pic_flag", "h265.used_by_curr_pic_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_use_delta_flag, { "use_delta_flag", "h265.use_delta_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_negative_pics, { "num_negative_pics", "h265.num_negative_pics", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_positive_pics, { "num_positive_pics", "h265.num_positive_pics", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_delta_poc_s0_minus1, { "delta_poc_s0_minus1", "h265.delta_poc_s0_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_used_by_curr_pic_s0_flag, { "used_by_curr_pic_s0_flag", "h265.used_by_curr_pic_s0_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_delta_poc_s1_minus1, { "delta_poc_s1_minus1", "h265.delta_poc_s1_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_used_by_curr_pic_s1_flag, { "used_by_curr_pic_s1_flag", "h265.used_by_curr_pic_s1_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*vui*/ { &hf_h265_aspect_ratio_info_present_flag, { "aspect_ratio_info_present_flag", "h265.aspect_ratio_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_aspect_ratio_idc, { "aspect_ratio_idc", "h265.aspect_ratio_idc", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sar_width, { "sar_width", "h265.sar_width", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sar_height, { "sar_height", "h265.sar_height", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_overscan_info_present_flag, { "overscan_info_present_flag", "h265.overscan_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_overscan_appropriate_flag, { "overscan_appropriate_flag", "h265.overscan_appropriate_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_video_signal_type_present_flag, { "video_signal_type_present_flag", "h265.video_signal_type_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_video_format, { "video_format", "h265.video_format", FT_UINT8, BASE_DEC, VALS(h265_video_format_vals), 0x0, NULL, HFILL } }, { &hf_h265_video_full_range_flag, { "video_full_range_flag", "h265.video_full_range_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_colour_description_present_flag, { "colour_description_present_flag", "h265.colour_description_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_colour_primaries, { "colour_primaries", "h265.colour_primaries", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_transfer_characteristics, { "transfer_characteristics", "h265.transfer_characteristics", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_matrix_coeffs, { "matrix_coefficients", "h265.matrix_coefficients", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_loc_info_present_flag, { "chroma_loc_info_present_flag", "h265.chroma_loc_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_sample_loc_type_top_field, { "chroma_sample_loc_type_top_field", "h265.chroma_sample_loc_type_top_field", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_sample_loc_type_bottom_field, { "chroma_sample_loc_type_bottom_field", "h265.chroma_sample_loc_type_bottom_field", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_neutral_chroma_indication_flag, { "neutral_chroma_indication_flag", "h265.neutral_chroma_indication_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_field_seq_flag, { "field_seq_flag", "h265.field_seq_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_frame_field_info_present_flag, { "frame_field_info_present_flag", "h265.frame_field_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_default_display_window_flag, { "default_display_window_flag", "h265.default_display_window_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_def_disp_win_left_offset, { "def_disp_win_left_offset", "h265.def_disp_win_left_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_def_disp_win_right_offset, { "def_disp_win_right_offset", "h265.def_disp_win_right_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_def_disp_win_top_offset, { "def_disp_win_top_offset", "h265.def_disp_win_top_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_def_disp_win_bottom_offset, { "def_disp_win_bottom_offset", "h265.def_disp_win_bottom_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_timing_info_present_flag, { "vui_timing_info_present_flag", "h265.vui_timing_info_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_num_units_in_tick, { "vui_num_units_in_tick", "h265.vui_num_units_in_tick", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_time_scale, { "vui_time_scale", "h265.vui_time_scale", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_poc_proportional_to_timing_flag, { "vui_poc_proportional_to_timing_flag", "h265.vui_poc_proportional_to_timing_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_num_ticks_poc_diff_one_minus1, { "vui_num_ticks_poc_diff_one_minus1", "h265.vui_num_ticks_poc_diff_one_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_vui_hrd_parameters_present_flag, { "vui_hrd_parameters_present_flag", "h265.vui_hrd_parameters_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_bitstream_restriction_flag, { "bitstream_restriction_flag", "h265.bitstream_restriction_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_tiles_fixed_structure_flag, { "tiles_fixed_structure_flag", "h265.tiles_fixed_structure_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_motion_vectors_over_pic_boundaries_flag, { "motion_vectors_over_pic_boundaries_flag", "h265.motion_vectors_over_pic_boundaries_flag", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_restricted_ref_pic_lists_flag, { "restricted_ref_pic_lists_flag", "h265.restricted_ref_pic_lists_flag", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_min_spatial_segmentation_idc, { "min_spatial_segmentation_idc", "h265.min_spatial_segmentation_idc", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_max_bytes_per_pic_denom, { "max_bytes_per_pic_denom", "h265.max_bytes_per_pic_denom", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_max_bits_per_min_cu_denom, { "max_bits_per_mb_denom", "h265.max_bits_per_mb_denom", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_max_mv_length_horizontal, { "max_mv_length_horizontal", "h265.max_mv_length_horizontal", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_max_mv_length_vertical, { "log2_max_mv_length_vertical", "h265.log2_max_mv_length_vertical", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /* sps_range_extension */ { &hf_h265_transform_skip_rotation_enabled_flag, { "transform_skip_rotation_enabled_flag", "h265.transform_skip_rotation_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_transform_skip_context_enabled_flag, { "transform_skip_context_enabled_flag", "h265.transform_skip_context_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_implicit_rdpcm_enabled_flag, { "implicit_rdpcm_enabled_flag", "h265.implicit_rdpcm_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_explicit_rdpcm_enabled_flag, { "explicit_rdpcm_enabled_flag", "h265.explicit_rdpcm_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_extended_precision_processing_flag, { "extended_precision_processing_flag", "h265.extended_precision_processing_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_intra_smoothing_disabled_flag, { "intra_smoothing_disabled_flag", "h265.intra_smoothing_disabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_high_precision_offsets_enabled_flag, { "high_precision_offsets_enabled_flag", "h265.high_precision_offsets_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_persistent_rice_adaptation_enabled_flag, { "persistent_rice_adaptation_enabled_flag", "h265.persistent_rice_adaptation_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cabac_bypass_alignment_enabled_flag, { "cabac_bypass_alignment_enabled_flag", "h265.cabac_bypass_alignment_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /* sps_scc_extension */ { &hf_h265_sps_curr_pic_ref_enabled_flag, { "sps_curr_pic_ref_enabled_flag", "h265.sps_curr_pic_ref_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_palette_mode_enabled_flag, { "palette_mode_enabled_flag", "h265.palette_mode_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_palette_max_size, { "palette_max_size", "h265.palette_max_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_delta_palette_max_predictor_size, { "delta_palette_max_predictor_size", "h265.delta_palette_max_predictor_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_palette_predictor_initializers_present_flag, { "sps_palette_predictor_initializers_present_flag", "h265.sps_palette_predictor_initializers_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_num_palette_predictor_initializers_minus1, { "sps_num_palette_predictor_initializers_minus1", "h265.sps_num_palette_predictor_initializers_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sps_palette_predictor_initializer, { "sps_palette_predictor_initializer", "h265.sps_palette_predictor_initializer", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_motion_vector_resolution_control_idc, { "motion_vector_resolution_control_idc", "h265.motion_vector_resolution_control_idc", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_intra_boundary_filtering_disabled_flag, { "intra_boundary_filtering_disabled_flag", "h265.intra_boundary_filtering_disabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /* PPS */ { &hf_h265_pps_pic_parameter_set_id, { "pps_pic_parameter_set_id", "h265.pps_pic_parameter_set_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_seq_parameter_set_id, { "pps_seq_parameter_set_id", "h265.pps_seq_parameter_set_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_dependent_slice_segments_enabled_flag, { "dependent_slice_segments_enabled_flag", "h265.dependent_slice_segments_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_output_flag_present_flag, { "output_flag_present_flag", "h265.output_flag_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_extra_slice_header_bits, { "num_extra_slice_header_bits", "h265.num_extra_slice_header_bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sign_data_hiding_enabled_flag, { "sign_data_hiding_enabled_flag", "h265.sign_data_hiding_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cabac_init_present_flag, { "cabac_init_present_flag", "h265.cabac_init_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_ref_idx_l0_default_active_minus1, { "num_ref_idx_l0_default_active_minus1", "h265.num_ref_idx_l0_default_active_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_ref_idx_l1_default_active_minus1, { "num_ref_idx_l1_default_active_minus1", "h265.num_ref_idx_l1_default_active_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_init_qp_minus26, { "init_qp_minus26", "h265.init_qp_minus26", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_constrained_intra_pred_flag, { "constrained_intra_pred_flag", "h265.constrained_intra_pred_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_transform_skip_enabled_flag, { "transform_skip_enabled_flag", "h265.transform_skip_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cu_qp_delta_enabled_flag, { "cu_qp_delta_enabled_flag", "h265.cu_qp_delta_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_diff_cu_qp_delta_depth, { "diff_cu_qp_delta_depth", "h265.diff_cu_qp_delta_depth", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_cb_qp_offset, { "pps_cb_qp_offset", "h265.pps_cb_qp_offset", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_cr_qp_offset, { "pps_cr_qp_offset", "h265.pps_cr_qp_offset", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_slice_chroma_qp_offsets_present_flag, { "pps_slice_chroma_qp_offsets_present_flag", "h265.pps_slice_chroma_qp_offsets_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_weighted_pred_flag, { "weighted_pred_flag", "h265.weighted_pred_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_weighted_bipred_flag, { "weighted_bipred_flag", "h265.weighted_bipred_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_transquant_bypass_enabled_flag, { "transquant_bypass_enabled_flag", "h265.transquant_bypass_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_tiles_enabled_flag, { "tiles_enabled_flag", "h265.tiles_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_entropy_coding_sync_enabled_flag, { "entropy_coding_sync_enabled_flag", "h265.entropy_coding_sync_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_tile_columns_minus1, { "num_tile_columns_minus1", "h265.num_tile_columns_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_num_tile_rows_minus1, { "num_tile_rows_minus1", "h265.num_tile_rows_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_uniform_spacing_flag, { "uniform_spacing_flag", "h265.uniform_spacing_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_column_width_minus1, { "column_width_minus1", "h265.column_width_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_row_height_minus1, { "row_height_minus1", "h265.row_height_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_loop_filter_across_tiles_enabled_flag, { "loop_filter_across_tiles_enabled_flag", "h265.loop_filter_across_tiles_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_loop_filter_across_slices_enabled_flag, { "pps_loop_filter_across_slices_enabled_flag", "h265.pps_loop_filter_across_slices_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_deblocking_filter_control_present_flag, { "deblocking_filter_control_present_flag", "h265.deblocking_filter_control_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_deblocking_filter_override_enabled_flag, { "deblocking_filter_override_enabled_flag", "h265.deblocking_filter_override_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_deblocking_filter_disabled_flag, { "pps_deblocking_filter_disabled_flag", "h265.pps_deblocking_filter_disabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_beta_offset_div2, { "pps_beta_offset_div2", "h265.pps_beta_offset_div2", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_tc_offset_div2, { "pps_tc_offset_div2", "h265.pps_tc_offset_div2", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_scaling_list_data_present_flag, { "pps_scaling_list_data_present_flag", "h265.pps_scaling_list_data_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_lists_modification_present_flag, { "lists_modification_present_flag", "h265.lists_modification_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_parallel_merge_level_minus2, { "log2_parallel_merge_level_minus2", "h265.log2_parallel_merge_level_minus2", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_slice_segment_header_extension_present_flag, { "slice_segment_header_extension_present_flag", "h265.slice_segment_header_extension_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_extension_present_flag, { "pps_extension_present_flag", "h265.pps_extension_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_range_extension_flag, { "pps_range_extension_flag", "h265.pps_range_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_multilayer_extension_flag, { "pps_multilayer_extension_flag", "h265.pps_multilayer_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_3d_extension_flag, { "pps_3d_extension_flag", "h265.pps_3d_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_scc_extension_flag, { "pps_scc_extension_flag", "h265.pps_scc_extension_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_extension_4bits, { "pps_extension_4bits", "h265.pps_extension_4bits", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_extension_data_flag, { "pps_extension_data_flag", "h265.pps_extension_data_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_max_transform_skip_block_size_minus2, { "log2_max_transform_skip_block_size_minus2", "h265.log2_max_transform_skip_block_size_minus2", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cross_component_prediction_enabled_flag, { "cross_component_prediction_enabled_flag", "h265.cross_component_prediction_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_qp_offset_list_enabled_flag, { "chroma_qp_offset_list_enabled_flag", "h265.chroma_qp_offset_list_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_diff_cu_chroma_qp_offset_depth, { "diff_cu_chroma_qp_offset_depth", "h265.diff_cu_chroma_qp_offset_depth", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_qp_offset_list_len_minus1, { "chroma_qp_offset_list_len_minus1", "h265.chroma_qp_offset_list_len_minus1", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cb_qp_offset_list, { "cb_qp_offset_list", "h265.cb_qp_offset_list", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_cr_qp_offset_list, { "cr_qp_offset_list", "h265.cr_qp_offset_list", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_sao_offset_scale_luma, { "log2_sao_offset_scale_luma", "h265.log2_sao_offset_scale_luma", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_log2_sao_offset_scale_chroma, { "log2_sao_offset_scale_chroma", "h265.log2_sao_offset_scale_chroma", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*pps_scc_extension*/ { &hf_h265_pps_curr_pic_ref_enabled_flag, { "pps_curr_pic_ref_enabled_flag", "h265.pps_curr_pic_ref_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_residual_adaptive_colour_transform_enabled_flag, { "residual_adaptive_colour_transform_enabled_flag", "h265.residual_adaptive_colour_transform_enabled_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_slice_act_qp_offsets_present_flag, { "pps_slice_act_qp_offsets_present_flag", "h265.pps_slice_act_qp_offsets_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_act_y_qp_offset_plus5, { "pps_act_y_qp_offset_plus5", "h265.pps_act_y_qp_offset_plus5", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_act_cb_qp_offset_plus5, { "pps_act_cb_qp_offset_plus5", "h265.pps_act_cb_qp_offset_plus5", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_act_cr_qp_offset_plus3, { "pps_act_cr_qp_offset_plus3", "h265.pps_act_cr_qp_offset_plus3", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_palette_predictor_initializers_present_flag, { "pps_palette_predictor_initializers_present_flag", "h265.pps_palette_predictor_initializers_present_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_num_palette_predictor_initializers, { "pps_num_palette_predictor_initializers", "h265.pps_num_palette_predictor_initializers", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_monochrome_palette_flag, { "monochrome_palette_flag", "h265.monochrome_palette_flag", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_luma_bit_depth_entry_minus8, { "luma_bit_depth_entry_minus8", "h265.luma_bit_depth_entry_minus8", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_chroma_bit_depth_entry_minus8, { "chroma_bit_depth_entry_minus8", "h265.chroma_bit_depth_entry_minus8", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_pps_palette_predictor_initializer, { "pps_palette_predictor_initializer", "h265.pps_palette_predictor_initializer", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /*Slice*/ { &hf_h265_slice_pic_parameter_set_id, { "slice_pic_parameter_set_id", "h265.slice_pic_parameter_set_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_slice_segment_address, { "slice_segment_address", "h265.slice_segment_address", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_slice_type, { "slice_type", "h265.slice_type", FT_UINT32, BASE_DEC, VALS(h265_slice_type_vals), 0x0, NULL, HFILL } }, /* SEI */ { &hf_h265_payloadsize, { "PayloadSize", "h265.payloadsize", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_h265_payloadtype, { "payloadType", "h265.payloadtype", FT_UINT32, BASE_DEC, VALS(h265_sei_payload_vals), 0x0, NULL, HFILL } }, { &hf_h265_pic_type, { "pic_type", "h265.pic_type", FT_UINT8, BASE_DEC, VALS(h265_pic_type_vals), 0x0, "slice_type values that may be present in the coded picture", HFILL } }, /* SDP parameters*/ { &hf_h265_sdp_parameter_sprop_vps, { "sprop-vps", "h265.sdp.sprop_vps", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sdp_parameter_sprop_sps, { "sprop-sps", "h265.sdp.sprop_sps", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_h265_sdp_parameter_sprop_pps, { "sprop-pps", "h265.sdp.sprop_pps", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static int *ett[] = { &ett_h265, &ett_h265_profile, &ett_h265_nal, &ett_h265_fu, &ett_h265_stream, &ett_h265_sps_multilayer_extension, &ett_h265_sps_3d_extension, &ett_h265_pps_multilayer_extension, &ett_h265_pps_3d_extension, &ett_h265_access_unit_delimiter_rbsp, &ett_h265_sei_rbsp, &ett_h265_filler_data_rbsp, &ett_h265_end_of_seq_rbsp, &ett_h265_end_of_bitstream_rbsp, &ett_h265_profile_tier_level, &ett_h265_ref_pic_set, &ett_h265_vui_parameters, &ett_h265_hrd_parameters, &ett_h265_sprop_parameters }; static ei_register_info ei[] = { { &ei_h265_undecoded,{ "h265.undecoded", PI_UNDECODED, PI_WARN, "[Not decoded yet]", EXPFILL } }, { &ei_h265_oversized_exp_golomb_code, {"h265.oversized_exp_golomb_code", PI_MALFORMED, PI_ERROR, "Exponential Golomb encoded value greater than 32 bit integer, clamped", EXPFILL } }, { &ei_h265_value_to_large,{ "h265.value_to_large", PI_PROTOCOL, PI_ERROR, "[Value to large, protocol violation]", EXPFILL } }, { &ei_h265_format_specific_parameter,{ "h265.format_specific_parameter", PI_UNDECODED, PI_WARN, "[Unspecified media format specific parameter]", EXPFILL } }, }; /* Register the protocol name and description */ proto_h265 = proto_register_protocol("H.265", "H.265", "h265"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_h265, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_h265 = expert_register_protocol(proto_h265); expert_register_field_array(expert_h265, ei, array_length(ei)); /* Register a configuration option for port */ h265_module = prefs_register_protocol(proto_h265, NULL); prefs_register_obsolete_preference(h265_module, "dynamic.payload.type"); h265_handle = register_dissector("h265", dissect_h265, proto_h265); register_dissector_with_description("h265_bytestream", "H.265 Annex B Byte stream format", dissect_h265_bytestream, proto_h265); } /* Register the protocol with Wireshark */ void proto_reg_handoff_h265(void) { dissector_add_string("rtp_dyn_payload_type", "H265", h265_handle); dissector_add_uint_range_with_preference("rtp.pt", "", h265_handle); } /* * Editor modelines - https://www.wireshark.org/tools/modelines.html * * Local variables: * c-basic-offset: 4 * tab-width: 8 * indent-tabs-mode: nil * End: * * vi: set shiftwidth=4 tabstop=8 expandtab: * :indentSize=4:tabSize=8:noTabs=true: */