forked from osmocom/wireshark
4698 lines
181 KiB
C
4698 lines
181 KiB
C
/* packet-h265.c
|
|
* Routines for H.265 dissection
|
|
* Copyright 2018, Asaf Kave <kave.asaf[at]gmail.com>
|
|
* Based on the H.264 dissector, thanks!
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* 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 <epan/packet.h>
|
|
#include <epan/asn1.h>
|
|
#include <epan/expert.h>
|
|
#include <epan/prefs.h>
|
|
#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 = -1;
|
|
static int hf_h265_type = -1;
|
|
static int hf_h265_nal_unit_type = -1;
|
|
static int hf_h265_nuh_layer_id = -1;
|
|
static int hf_h265_nuh_temporal_id_plus1 = -1;
|
|
static int hf_h265_nal_f_bit = -1;
|
|
static int hf_h265_start_bit = -1;
|
|
static int hf_h265_end_bit = -1;
|
|
static int hf_h265_rbsp_stop_bit = -1;
|
|
static int hf_h265_rbsp_trailing_bits = -1;
|
|
|
|
/* SDP */
|
|
static int hf_h265_sdp_parameter_sprop_vps = -1;
|
|
static int hf_h265_sdp_parameter_sprop_sps = -1;
|
|
static int hf_h265_sdp_parameter_sprop_pps = -1;
|
|
|
|
/*vps*/
|
|
static int hf_h265_vps_video_parameter_set_id = -1;
|
|
static int hf_h265_vps_base_layer_internal_flag = -1;
|
|
static int hf_h265_vps_base_layer_available_flag = -1;
|
|
static int hf_h265_vps_max_layers_minus1 = -1;
|
|
static int hf_h265_vps_max_sub_layers_minus1 = -1;
|
|
static int hf_h265_vps_temporal_id_nesting_flag = -1;
|
|
static int hf_h265_vps_reserved_0xffff_16bits = -1;
|
|
static int hf_h265_vps_sub_layer_ordering_info_present_flag = -1;
|
|
static int hf_h265_vps_max_dec_pic_buffering_minus1/*[i]*/ = -1;
|
|
static int hf_h265_vps_max_num_reorder_pics/*[i]*/ = -1;
|
|
static int hf_h265_vps_max_latency_increase_plus1/*[i]*/ = -1;
|
|
static int hf_h265_vps_max_layer_id = -1;
|
|
static int hf_h265_vps_num_layer_sets_minus1 = -1;
|
|
static int hf_h265_layer_id_included_flag/*[i][j]*/ = -1;
|
|
static int hf_h265_vps_timing_info_present_flag = -1;
|
|
static int hf_h265_vps_num_units_in_tick = -1;
|
|
static int hf_h265_vps_time_scale = -1;
|
|
static int hf_h265_vps_poc_proportional_to_timing_flag = -1;
|
|
static int hf_h265_vps_num_ticks_poc_diff_one_minus1 = -1;
|
|
static int hf_h265_vps_num_hrd_parameters = -1;
|
|
static int hf_h265_hrd_layer_set_idx/*[i]*/ = -1;
|
|
static int hf_h265_cprms_present_flag/*[i]*/ = -1;
|
|
static int hf_h265_vps_extension_flag = -1;
|
|
static int hf_h265_vps_extension_data_flag = -1;
|
|
|
|
/* profile_tier_level */
|
|
static int hf_h265_general_profile_space = -1;
|
|
static int hf_h265_general_tier_flag = -1;
|
|
static int hf_h265_general_profile_idc = -1;
|
|
static int hf_h265_general_profile_compatibility_flags/*[j]*/ = -1;
|
|
static int hf_h265_general_progressive_source_flag = -1;
|
|
static int hf_h265_general_interlaced_source_flag = -1;
|
|
static int hf_h265_general_non_packed_constraint_flag = -1;
|
|
static int hf_h265_general_frame_only_constraint_flag = -1;
|
|
static int hf_h265_general_max_12bit_constraint_flag = -1;
|
|
static int hf_h265_general_max_10bit_constraint_flag = -1;
|
|
static int hf_h265_general_max_8bit_constraint_flag = -1;
|
|
static int hf_h265_general_max_422chroma_constraint_flag = -1;
|
|
static int hf_h265_general_max_420chroma_constraint_flag = -1;
|
|
static int hf_h265_general_max_monochrome_constraint_flag = -1;
|
|
static int hf_h265_general_intra_constraint_flag = -1;
|
|
static int hf_h265_general_one_picture_only_constraint_flag = -1;
|
|
static int hf_h265_general_lower_bit_rate_constraint_flag = -1;
|
|
static int hf_h265_general_max_14bit_constraint_flag = -1;
|
|
static int hf_h265_general_reserved_zero_33bits = -1;
|
|
static int hf_h265_general_reserved_zero_34bits = -1;
|
|
static int hf_h265_general_reserved_zero_7bits = -1;
|
|
static int hf_h265_general_reserved_zero_35bits = -1;
|
|
static int hf_h265_general_reserved_zero_43bits = -1;
|
|
static int hf_h265_general_inbld_flag = -1;
|
|
static int hf_h265_general_reserved_zero_bit = -1;
|
|
static int hf_h265_general_level_idc = -1;
|
|
static int hf_h265_sub_layer_profile_present_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_level_present_flag/*[i]*/ = -1;
|
|
static int hf_h265_reserved_zero_2bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_profile_space/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_tier_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_profile_idc/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_profile_compatibility_flag/*[i][j]*/ = -1;
|
|
static int hf_h265_sub_layer_progressive_source_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_interlaced_source_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_non_packed_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_frame_only_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_12bit_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_10bit_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_8bit_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_422chroma_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_420chroma_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_monochrome_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_intra_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_one_picture_only_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_lower_bit_rate_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_max_14bit_constraint_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_33bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_34bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_7bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_35bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_43bits/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_inbld_flag/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_reserved_zero_bit/*[i]*/ = -1;
|
|
static int hf_h265_sub_layer_level_idc/*[i]*/ = -1;
|
|
|
|
/* hrd_parameters */
|
|
static int hf_h265_nal_hrd_parameters_present_flag = -1;
|
|
static int hf_h265_vcl_hrd_parameters_present_flag = -1;
|
|
static int hf_h265_sub_pic_hrd_params_present_flag = -1;
|
|
static int hf_h265_tick_divisor_minus2 = -1;
|
|
static int hf_h265_du_cpb_removal_delay_increment_length_minus1 = -1;
|
|
static int hf_h265_sub_pic_cpb_params_in_pic_timing_sei_flag = -1;
|
|
static int hf_h265_dpb_output_delay_du_length_minus1 = -1;
|
|
static int hf_h265_bit_rate_scale = -1;
|
|
static int hf_h265_cpb_size_scale = -1;
|
|
static int hf_h265_cpb_size_du_scale = -1;
|
|
static int hf_h265_initial_cpb_removal_delay_length_minus1 = -1;
|
|
static int hf_h265_au_cpb_removal_delay_length_minus1 = -1;
|
|
static int hf_h265_dpb_output_delay_length_minus1 = -1;
|
|
static int hf_h265_fixed_pic_rate_general_flag/*[i]*/ = -1;
|
|
static int hf_h265_fixed_pic_rate_within_cvs_flag/*[i]*/ = -1;
|
|
static int hf_h265_elemental_duration_in_tc_minus1/*[i]*/ = -1;
|
|
static int hf_h265_low_delay_hrd_flag/*[i]*/ = -1;
|
|
static int hf_h265_cpb_cnt_minus1/*[i]*/ = -1;
|
|
/* sub-layer hrd_parameters */
|
|
static int hf_h265_bit_rate_value_minus1/*[i]*/ = -1;
|
|
static int hf_h265_cpb_size_value_minus1/*[i]*/ = -1;
|
|
static int hf_h265_cpb_size_du_value_minus1/*[i]*/ = -1;
|
|
static int hf_h265_bit_rate_du_value_minus1/*[i]*/ = -1;
|
|
static int hf_h265_cbr_flag/*[i]*/ = -1;
|
|
|
|
/*sps*/
|
|
static int hf_h265_sps_video_parameter_set_id = -1;
|
|
static int hf_h265_sps_max_sub_layers_minus1 = -1;
|
|
static int hf_h265_sps_temporal_id_nesting_flag = -1;
|
|
static int hf_h265_sps_seq_parameter_set_id = -1;
|
|
static int hf_h265_chroma_format_idc = -1;
|
|
static int hf_h265_separate_colour_plane_flag = -1;
|
|
static int hf_h265_pic_width_in_luma_samples = -1;
|
|
static int hf_h265_pic_height_in_luma_samples = -1;
|
|
static int hf_h265_conformance_window_flag = -1;
|
|
static int hf_h265_conf_win_left_offset = -1;
|
|
static int hf_h265_conf_win_right_offset = -1;
|
|
static int hf_h265_conf_win_top_offset = -1;
|
|
static int hf_h265_conf_win_bottom_offset = -1;
|
|
static int hf_h265_bit_depth_luma_minus8 = -1;
|
|
static int hf_h265_bit_depth_chroma_minus8 = -1;
|
|
static int hf_h265_log2_max_pic_order_cnt_lsb_minus4 = -1;
|
|
static int hf_h265_sps_sub_layer_ordering_info_present_flag = -1;
|
|
static int hf_h265_sps_max_dec_pic_buffering_minus1/*[i]*/ = -1;
|
|
static int hf_h265_sps_max_num_reorder_pics/*[i]*/ = -1;
|
|
static int hf_h265_sps_max_latency_increase_plus1/*[i]*/ = -1;
|
|
static int hf_h265_log2_min_luma_coding_block_size_minus3 = -1;
|
|
static int hf_h265_log2_diff_max_min_luma_coding_block_size = -1;
|
|
static int hf_h265_log2_min_luma_transform_block_size_minus2 = -1;
|
|
static int hf_h265_log2_diff_max_min_luma_transform_block_size = -1;
|
|
static int hf_h265_max_transform_hierarchy_depth_inter = -1;
|
|
static int hf_h265_max_transform_hierarchy_depth_intra = -1;
|
|
static int hf_h265_scaling_list_enabled_flag = -1;
|
|
static int hf_h265_sps_scaling_list_data_present_flag = -1;
|
|
static int hf_h265_amp_enabled_flag = -1;
|
|
static int hf_h265_sample_adaptive_offset_enabled_flag = -1;
|
|
static int hf_h265_pcm_enabled_flag = -1;
|
|
static int hf_h265_pcm_sample_bit_depth_luma_minus1 = -1;
|
|
static int hf_h265_pcm_sample_bit_depth_chroma_minus1 = -1;
|
|
static int hf_h265_log2_min_pcm_luma_coding_block_size_minus3 = -1;
|
|
static int hf_h265_log2_diff_max_min_pcm_luma_coding_block_size = -1;
|
|
static int hf_h265_pcm_loop_filter_disabled_flag = -1;
|
|
static int hf_h265_num_short_term_ref_pic_sets = -1;
|
|
static int hf_h265_long_term_ref_pics_present_flag = -1;
|
|
static int hf_h265_num_long_term_ref_pics_sps = -1;
|
|
static int hf_h265_lt_ref_pic_poc_lsb_sps/*[i]*/ = -1;
|
|
static int hf_h265_used_by_curr_pic_lt_sps_flag/*[i]*/ = -1;
|
|
static int hf_h265_sps_temporal_mvp_enabled_flag = -1;
|
|
static int hf_h265_strong_intra_smoothing_enabled_flag = -1;
|
|
static int hf_h265_vui_parameters_present_flag = -1;
|
|
static int hf_h265_sps_extension_present_flag = -1;
|
|
static int hf_h265_sps_range_extension_flag = -1;
|
|
static int hf_h265_sps_multilayer_extension_flag = -1;
|
|
static int hf_h265_sps_3d_extension_flag = -1;
|
|
static int hf_h265_sps_scc_extension_flag = -1;
|
|
static int hf_h265_sps_extension_4bits = -1;
|
|
static int hf_h265_sps_extension_data_flag = -1;
|
|
/* scaling_list_data */
|
|
static int hf_h265_scaling_list_pred_mode_flag/*[sizeId][matrixId]*/ = -1;
|
|
static int hf_h265_scaling_list_pred_matrix_id_delta/*[sizeId][matrixId]*/ = -1;
|
|
static int hf_h265_scaling_list_dc_coef_minus8/*[sizeId - 2][matrixId]*/ = -1;
|
|
static int hf_h265_scaling_list_delta_coef = -1;
|
|
/* st_ref_pic_set */
|
|
static int hf_h265_inter_ref_pic_set_prediction_flag = -1;
|
|
static int hf_h265_delta_idx_minus1 = -1;
|
|
static int hf_h265_delta_rps_sign = -1;
|
|
static int hf_h265_abs_delta_rps_minus1 = -1;
|
|
static int hf_h265_used_by_curr_pic_flag/*[j]*/ = -1;
|
|
static int hf_h265_use_delta_flag/*[j]*/ = -1;
|
|
static int hf_h265_num_negative_pics = -1;
|
|
static int hf_h265_num_positive_pics = -1;
|
|
static int hf_h265_delta_poc_s0_minus1/*[i]*/ = -1;
|
|
static int hf_h265_used_by_curr_pic_s0_flag/*[i]*/ = -1;
|
|
static int hf_h265_delta_poc_s1_minus1/*[i]*/ = -1;
|
|
static int hf_h265_used_by_curr_pic_s1_flag/*[i]*/ = -1;
|
|
/* sps_range_extension */
|
|
static int hf_h265_transform_skip_rotation_enabled_flag = -1;
|
|
static int hf_h265_transform_skip_context_enabled_flag = -1;
|
|
static int hf_h265_implicit_rdpcm_enabled_flag = -1;
|
|
static int hf_h265_explicit_rdpcm_enabled_flag = -1;
|
|
static int hf_h265_extended_precision_processing_flag = -1;
|
|
static int hf_h265_intra_smoothing_disabled_flag = -1;
|
|
static int hf_h265_high_precision_offsets_enabled_flag = -1;
|
|
static int hf_h265_persistent_rice_adaptation_enabled_flag = -1;
|
|
static int hf_h265_cabac_bypass_alignment_enabled_flag = -1;
|
|
/* sps_scc_extension */
|
|
static int hf_h265_sps_curr_pic_ref_enabled_flag = -1;
|
|
static int hf_h265_palette_mode_enabled_flag = -1;
|
|
static int hf_h265_palette_max_size = -1;
|
|
static int hf_h265_delta_palette_max_predictor_size = -1;
|
|
static int hf_h265_sps_palette_predictor_initializers_present_flag = -1;
|
|
static int hf_h265_sps_num_palette_predictor_initializers_minus1 = -1;
|
|
static int hf_h265_sps_palette_predictor_initializer/*[comp][i]*/ = -1;
|
|
static int hf_h265_motion_vector_resolution_control_idc = -1;
|
|
static int hf_h265_intra_boundary_filtering_disabled_flag = -1;
|
|
|
|
/* PPS */
|
|
static int hf_h265_pps_pic_parameter_set_id = -1;
|
|
static int hf_h265_pps_seq_parameter_set_id = -1;
|
|
static int hf_h265_dependent_slice_segments_enabled_flag = -1;
|
|
static int hf_h265_output_flag_present_flag = -1;
|
|
static int hf_h265_num_extra_slice_header_bits = -1;
|
|
static int hf_h265_sign_data_hiding_enabled_flag = -1;
|
|
static int hf_h265_cabac_init_present_flag = -1;
|
|
static int hf_h265_num_ref_idx_l0_default_active_minus1 = -1;
|
|
static int hf_h265_num_ref_idx_l1_default_active_minus1 = -1;
|
|
static int hf_h265_init_qp_minus26 = -1;
|
|
static int hf_h265_constrained_intra_pred_flag = -1;
|
|
static int hf_h265_transform_skip_enabled_flag = -1;
|
|
static int hf_h265_cu_qp_delta_enabled_flag = -1;
|
|
static int hf_h265_diff_cu_qp_delta_depth = -1;
|
|
static int hf_h265_pps_cb_qp_offset = -1;
|
|
static int hf_h265_pps_cr_qp_offset = -1;
|
|
static int hf_h265_pps_slice_chroma_qp_offsets_present_flag = -1;
|
|
static int hf_h265_weighted_pred_flag = -1;
|
|
static int hf_h265_weighted_bipred_flag = -1;
|
|
static int hf_h265_transquant_bypass_enabled_flag = -1;
|
|
static int hf_h265_tiles_enabled_flag = -1;
|
|
static int hf_h265_entropy_coding_sync_enabled_flag = -1;
|
|
static int hf_h265_num_tile_columns_minus1 = -1;
|
|
static int hf_h265_num_tile_rows_minus1 = -1;
|
|
static int hf_h265_uniform_spacing_flag = -1;
|
|
static int hf_h265_column_width_minus1/*[i]*/ = -1;
|
|
static int hf_h265_row_height_minus1/*[i]*/ = -1;
|
|
static int hf_h265_loop_filter_across_tiles_enabled_flag = -1;
|
|
static int hf_h265_pps_loop_filter_across_slices_enabled_flag = -1;
|
|
static int hf_h265_deblocking_filter_control_present_flag = -1;
|
|
static int hf_h265_deblocking_filter_override_enabled_flag = -1;
|
|
static int hf_h265_pps_deblocking_filter_disabled_flag = -1;
|
|
static int hf_h265_pps_beta_offset_div2 = -1;
|
|
static int hf_h265_pps_tc_offset_div2 = -1;
|
|
static int hf_h265_pps_scaling_list_data_present_flag = -1;
|
|
static int hf_h265_lists_modification_present_flag = -1;
|
|
static int hf_h265_log2_parallel_merge_level_minus2 = -1;
|
|
static int hf_h265_slice_segment_header_extension_present_flag = -1;
|
|
static int hf_h265_pps_extension_present_flag = -1;
|
|
static int hf_h265_pps_range_extension_flag = -1;
|
|
static int hf_h265_pps_multilayer_extension_flag = -1;
|
|
static int hf_h265_pps_3d_extension_flag = -1;
|
|
static int hf_h265_pps_scc_extension_flag = -1;
|
|
static int hf_h265_pps_extension_4bits = -1;
|
|
static int hf_h265_pps_extension_data_flag = -1;
|
|
/*pps_range_extension*/
|
|
static int hf_h265_log2_max_transform_skip_block_size_minus2 = -1;
|
|
static int hf_h265_cross_component_prediction_enabled_flag = -1;
|
|
static int hf_h265_chroma_qp_offset_list_enabled_flag = -1;
|
|
static int hf_h265_diff_cu_chroma_qp_offset_depth = -1;
|
|
static int hf_h265_chroma_qp_offset_list_len_minus1 = -1;
|
|
static int hf_h265_cb_qp_offset_list/*[i]*/ = -1;
|
|
static int hf_h265_cr_qp_offset_list/*[i]*/ = -1;
|
|
static int hf_h265_log2_sao_offset_scale_luma = -1;
|
|
static int hf_h265_log2_sao_offset_scale_chroma = -1;
|
|
/*pps_scc_extension*/
|
|
static int hf_h265_pps_curr_pic_ref_enabled_flag = -1;
|
|
static int hf_h265_residual_adaptive_colour_transform_enabled_flag = -1;
|
|
static int hf_h265_pps_slice_act_qp_offsets_present_flag = -1;
|
|
static int hf_h265_pps_act_y_qp_offset_plus5 = -1;
|
|
static int hf_h265_pps_act_cb_qp_offset_plus5 = -1;
|
|
static int hf_h265_pps_act_cr_qp_offset_plus3 = -1;
|
|
static int hf_h265_pps_palette_predictor_initializers_present_flag = -1;
|
|
static int hf_h265_pps_num_palette_predictor_initializers = -1;
|
|
static int hf_h265_monochrome_palette_flag = -1;
|
|
static int hf_h265_luma_bit_depth_entry_minus8 = -1;
|
|
static int hf_h265_chroma_bit_depth_entry_minus8 = -1;
|
|
static int hf_h265_pps_palette_predictor_initializer/*[comp][i]*/ = -1;
|
|
|
|
/* VUI parameters */
|
|
static int hf_h265_aspect_ratio_info_present_flag = -1;
|
|
static int hf_h265_aspect_ratio_idc = -1;
|
|
static int hf_h265_sar_width = -1;
|
|
static int hf_h265_sar_height = -1;
|
|
static int hf_h265_overscan_info_present_flag = -1;
|
|
static int hf_h265_overscan_appropriate_flag = -1;
|
|
static int hf_h265_video_signal_type_present_flag = -1;
|
|
static int hf_h265_video_format = -1;
|
|
static int hf_h265_video_full_range_flag = -1;
|
|
static int hf_h265_colour_description_present_flag = -1;
|
|
static int hf_h265_colour_primaries = -1;
|
|
static int hf_h265_transfer_characteristics = -1;
|
|
static int hf_h265_matrix_coeffs = -1;
|
|
static int hf_h265_chroma_loc_info_present_flag = -1;
|
|
static int hf_h265_chroma_sample_loc_type_top_field = -1;
|
|
static int hf_h265_chroma_sample_loc_type_bottom_field = -1;
|
|
static int hf_h265_neutral_chroma_indication_flag = -1;
|
|
static int hf_h265_field_seq_flag = -1;
|
|
static int hf_h265_frame_field_info_present_flag = -1;
|
|
static int hf_h265_default_display_window_flag = -1;
|
|
static int hf_h265_def_disp_win_left_offset = -1;
|
|
static int hf_h265_def_disp_win_right_offset = -1;
|
|
static int hf_h265_def_disp_win_top_offset = -1;
|
|
static int hf_h265_def_disp_win_bottom_offset = -1;
|
|
static int hf_h265_vui_timing_info_present_flag = -1;
|
|
static int hf_h265_vui_num_units_in_tick = -1;
|
|
static int hf_h265_vui_time_scale = -1;
|
|
static int hf_h265_vui_poc_proportional_to_timing_flag = -1;
|
|
static int hf_h265_vui_num_ticks_poc_diff_one_minus1 = -1;
|
|
static int hf_h265_vui_hrd_parameters_present_flag = -1;
|
|
static int hf_h265_bitstream_restriction_flag = -1;
|
|
static int hf_h265_tiles_fixed_structure_flag = -1;
|
|
static int hf_h265_motion_vectors_over_pic_boundaries_flag = -1;
|
|
static int hf_h265_restricted_ref_pic_lists_flag = -1;
|
|
static int hf_h265_min_spatial_segmentation_idc = -1;
|
|
static int hf_h265_max_bytes_per_pic_denom = -1;
|
|
static int hf_h265_max_bits_per_min_cu_denom = -1;
|
|
static int hf_h265_log2_max_mv_length_horizontal = -1;
|
|
static int hf_h265_log2_max_mv_length_vertical = -1;
|
|
|
|
/* slice_segment_header */
|
|
static int hf_h265_slice_pic_parameter_set_id = -1;
|
|
static int hf_h265_slice_segment_address = -1;
|
|
static int hf_h265_slice_type = -1;
|
|
|
|
/* SEI */
|
|
static int hf_h265_payloadsize = -1;
|
|
static int hf_h265_payloadtype = -1;
|
|
|
|
/* Initialize the subtree pointers */
|
|
static int ett_h265 = -1;
|
|
static int ett_h265_profile = -1;
|
|
static int ett_h265_nal = -1;
|
|
static int ett_h265_fu = -1;
|
|
static int ett_h265_stream = -1;
|
|
|
|
static int ett_h265_sps_multilayer_extension = -1;
|
|
static int ett_h265_sps_3d_extension = -1;
|
|
static int ett_h265_pps_multilayer_extension = -1;
|
|
static int ett_h265_pps_3d_extension = -1;
|
|
static int ett_h265_access_unit_delimiter_rbsp = -1;
|
|
static int ett_h265_sei_rbsp = -1;
|
|
static int ett_h265_filler_data_rbsp = -1;
|
|
static int ett_h265_end_of_seq_rbsp = -1;
|
|
static int ett_h265_end_of_bitstream_rbsp = -1;
|
|
static int ett_h265_profile_tier_level = -1;
|
|
static int ett_h265_ref_pic_set = -1;
|
|
static int ett_h265_vui_parameters = -1;
|
|
static int ett_h265_hrd_parameters = -1;
|
|
static int ett_h265_sprop_parameters = -1;
|
|
|
|
static expert_field ei_h265_undecoded = EI_INIT;
|
|
static expert_field ei_h265_format_specific_parameter = EI_INIT;
|
|
static expert_field ei_h265_oversized_exp_golomb_code = EI_INIT;
|
|
static expert_field ei_h265_value_to_large = EI_INIT;
|
|
|
|
static dissector_handle_t h265_handle;
|
|
|
|
static gboolean dependent_slice_segments_enabled_flag = 0;
|
|
static guint num_extra_slice_header_bits = 0;
|
|
static guint log2_min_luma_coding_block_size_minus3 = 0;
|
|
static guint log2_diff_max_min_luma_coding_block_size = 0;
|
|
static guint pic_width_in_luma_samples = 0;
|
|
static guint pic_height_in_luma_samples = 0;
|
|
|
|
/* 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 }
|
|
};
|
|
|
|
/* 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, gint offset, gboolean profilePresentFlag, gint vps_max_sub_layers_minus1);
|
|
static int
|
|
dissect_h265_hrd_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, gint bit_offset, gboolean commonInfPresentFlag, guint maxNumSubLayersMinus1);
|
|
static int
|
|
dissect_h265_scaling_list_data(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_st_ref_pic_set(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset, gint stRpsIdx, gint num_short_term_ref_pic_sets, gint32 NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS]);
|
|
static int
|
|
dissect_h265_vui_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, gint bit_offset, guint8 sps_max_sub_layers_minus1);
|
|
static int
|
|
dissect_h265_sps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_sps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_sps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_sps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset, guint chroma_format_idc, guint bit_depth_luma_minus8, guint bit_depth_chroma_minus8);
|
|
static int
|
|
dissect_h265_pps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset, guint transform_skip_enabled_flag);
|
|
static int
|
|
dissect_h265_pps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_pps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_pps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset);
|
|
static int
|
|
dissect_h265_sei_message(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, gint bit_offset, guint8 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 gboolean
|
|
h265_byte_aligned(gint 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 gboolean
|
|
h265_more_data_in_payload(gint bit_start, gint bit_offset, gint 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 gboolean
|
|
h265_payload_extension_present(tvbuff_t* tvb, gint bit_start, gint bit_offset, gint 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 guint32
|
|
dissect_h265_exp_golomb_code(proto_tree *tree, int hf_index, tvbuff_t *tvb, packet_info *pinfo, gint *start_bit_offset, h265_golomb_descriptors descriptor)
|
|
/*(tvbuff_t *tvb, gint *start_bit_offset) */
|
|
{
|
|
proto_item *ti;
|
|
|
|
gint leading_zero_bits, bit_offset, start_offset;
|
|
guint32 codenum, mask, value, tmp;
|
|
gint32 se_value = 0;
|
|
gint b;
|
|
char *str;
|
|
int bit;
|
|
int i;
|
|
gboolean overflow = FALSE;
|
|
header_field_info *hf_field = NULL;
|
|
|
|
start_offset = *start_bit_offset >> 3;
|
|
|
|
if (hf_index > -1)
|
|
hf_field = proto_registrar_get_nth(hf_index);
|
|
|
|
/* Allow only gint32 for se(v), guint32 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 guint32 */
|
|
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 = G_MAXUINT32;
|
|
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 = G_MININT32;
|
|
} else {
|
|
se_value = G_MAXINT32;
|
|
}
|
|
}
|
|
} else if (leading_zero_bits == 32) {
|
|
value = tvb_get_bits32(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN);
|
|
codenum = G_MAXUINT32;
|
|
/* One one value doesn't overflow a 32 bit integer, but they're
|
|
* different for unsigned and signed (because codenum G_MAXUINT32 maps
|
|
* to G_MAXINT32 + 1 and G_MAXUINT32 + 1 maps to G_MININT32.) */
|
|
if (descriptor == H265_SE_V) {
|
|
if (value != 1) {
|
|
overflow = TRUE;
|
|
}
|
|
if (value % 2) {
|
|
se_value = G_MININT32;
|
|
} else {
|
|
se_value = G_MAXINT32;
|
|
}
|
|
} 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<leading_zero_bits; i++) {
|
|
if (bit && (!(bit % 4))) {
|
|
(void) g_strlcat(str, " ", 256);
|
|
}
|
|
if (bit && (!(bit % 8))) {
|
|
(void) g_strlcat(str, " ", 256);
|
|
}
|
|
bit++;
|
|
tmp = value & mask;
|
|
if (tmp != 0) {
|
|
(void) g_strlcat(str, "1", 256);
|
|
}
|
|
else {
|
|
(void) g_strlcat(str, "0", 256);
|
|
}
|
|
mask = mask >> 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 gboolean
|
|
more_rbsp_data(proto_tree *tree _U_, tvbuff_t *tvb, packet_info *pinfo _U_, gint bit_offset)
|
|
{
|
|
int offset;
|
|
int remaining_length;
|
|
int last_one_bit;
|
|
guint8 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_, gint bit_offset)
|
|
{
|
|
gint 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, gint offset)
|
|
{
|
|
//proto_item *level_item;
|
|
gint 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;
|
|
|
|
guint8 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;
|
|
|
|
guint8 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);
|
|
}
|
|
|
|
guint8 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;
|
|
|
|
guint32 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;
|
|
}
|
|
|
|
guint8 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;
|
|
guint8 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);
|
|
}
|
|
guint32 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) {
|
|
gboolean cprms_present_flag/*[i]*/ = 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/*[i]*/, vps_max_sub_layers_minus1);
|
|
}
|
|
}
|
|
}
|
|
|
|
guint8 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, gint offset)
|
|
{
|
|
gint bit_offset;
|
|
guint8 i, sps_max_sub_layers_minus1, sps_extension_4bits = 0;
|
|
guint32 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;
|
|
gboolean 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;
|
|
gint32 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);
|
|
guint 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);
|
|
|
|
gboolean 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/*[i]*/, tvb, pinfo, &bit_offset, H265_UE_V);
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_num_reorder_pics/*[i]*/, tvb, pinfo, &bit_offset, H265_UE_V);
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_latency_increase_plus1/*[i]*/, 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/*[i]*/, 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/*[i]*/, 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, gint offset)
|
|
{
|
|
gint bit_offset;
|
|
guint num_tile_columns_minus1, num_tile_rows_minus1, i;
|
|
gboolean cu_qp_delta_enabled_flag, tiles_enabled_flag, uniform_spacing_flag;
|
|
gboolean deblocking_filter_control_present_flag, pps_deblocking_filter_disabled_flag;
|
|
gboolean pps_scaling_list_data_present_flag, pps_extension_present_flag;
|
|
gboolean 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/*[i]*/, 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/*[i]*/, 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, gint offset, guint8 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");
|
|
|
|
gint 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, gint offset)
|
|
{
|
|
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");
|
|
proto_tree_add_expert(access_unit_delimiter_rbsp_tree, pinfo, &ei_h265_undecoded, tvb, offset, -1);
|
|
}
|
|
|
|
/* 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, gint 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, gint 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, gint 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_, gint offset, gboolean profilePresentFlag, gint vps_max_sub_layers_minus1)
|
|
{
|
|
proto_item *general_level_idc_item;
|
|
guint32 general_profile_idc, general_level_idc;
|
|
guint32 sub_layer_profile_idc[32] = { 0 };
|
|
gboolean general_tier_flag = 0;
|
|
gboolean general_profile_compatibility_flag[32] = { 0 };
|
|
gboolean sub_layer_profile_present_flag[32] = { 0 };
|
|
gboolean sub_layer_level_present_flag[32] = { 0 };
|
|
gboolean 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);
|
|
|
|
gint 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/*[i]*/, 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 hedaer , do more parsing */
|
|
static int
|
|
dissect_h265_slice_segment_header(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, gint bit_offset, guint8 nal_unit_type)
|
|
{
|
|
gboolean first_slice_segment_in_pic_flag = 0, /*no_output_of_prior_pics_flag = 0,*/ dependent_slice_segment_flag = 0;
|
|
|
|
guint MinCbLog2SizeY = log2_min_luma_coding_block_size_minus3 + 3;
|
|
guint CtbLog2SizeY = MinCbLog2SizeY + log2_diff_max_min_luma_coding_block_size;
|
|
guint 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;
|
|
guint nBits = (guint)(ceil(log2(PicSizeInCtbsY)));
|
|
guint 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, gint offset, guint8 nal_unit_type)
|
|
{
|
|
gint 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_, gint bit_offset)
|
|
{
|
|
gboolean scaling_list_pred_mode_flag[4][6] = { { 0 } };
|
|
/*gint32 ScalingList[4][6][64] = { 0 };*/
|
|
gint sizeId, matrixId, nextCoef, coefNum, i;
|
|
gint32 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/*[sizeId][matrixId]*/, 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/*[sizeId][matrixId]*/, 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/*[sizeId - 2][matrixId]*/, 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_, gint bit_offset, guint payloadType _U_, guint payloadSize, guint8 nal_unit_type _U_)
|
|
{
|
|
//gint 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) */
|
|
guint nEarlierBits = bit_offset - bit_start;
|
|
guint 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, gint bit_offset, guint8 nal_unit_type)
|
|
{
|
|
guint payloadType = 0, last_payload_type_byte, payloadSize, last_payload_size_byte;
|
|
gint 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_, gint bit_offset, gint stRpsIdx, gint num_short_term_ref_pic_sets, gint32 NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS])
|
|
{
|
|
gint j;
|
|
guint i;
|
|
guint32 num_negative_pics, num_positive_pics;
|
|
gboolean inter_ref_pic_set_prediction_flag = 0;
|
|
gboolean used_by_curr_pic_flag;
|
|
gint RefRpsIdx;
|
|
gint 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/*[j]*/, tvb, bit_offset, 1, ENC_BIG_ENDIAN);
|
|
bit_offset++;
|
|
if (!used_by_curr_pic_flag/*[j]*/) {
|
|
proto_tree_add_bits_item(tree, hf_h265_use_delta_flag/*[j]*/, 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/*[i]*/, tvb, pinfo, &bit_offset, H265_UE_V);
|
|
proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_s0_flag/*[i]*/, 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/*[i]*/, tvb, pinfo, &bit_offset, H265_UE_V);
|
|
proto_tree_add_bits_item(tree, hf_h265_used_by_curr_pic_s1_flag/*[i]*/, 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_, gint bit_offset, guint subLayerId _U_, guint32 CpbCnt, gboolean sub_pic_hrd_params_present_flag)
|
|
{
|
|
/*The variable CpbCnt is set equal to cpb_cnt_minus1[ subLayerId ] + 1.*/
|
|
guint 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_, gint bit_offset, gboolean commonInfPresentFlag, guint maxNumSubLayersMinus1)
|
|
{
|
|
guint subLayerId;
|
|
gboolean nal_hrd_parameters_present_flag = 0, vcl_hrd_parameters_present_flag = 0, sub_pic_hrd_params_present_flag = 0;
|
|
gboolean fixed_pic_rate_general_flag[32] = { 0 };
|
|
gboolean fixed_pic_rate_within_cvs_flag[32] = { 0 };
|
|
gboolean low_delay_hrd_flag[32] = { 0 };
|
|
guint32 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, gint bit_offset, guint8 sps_max_sub_layers_minus1)
|
|
{
|
|
guint8 aspect_ratio_info_present_flag, aspect_ratio_idc, overscan_info_present_flag;
|
|
guint8 video_signal_type_present_flag, colour_description_present_flag, chroma_loc_info_present_flag;
|
|
guint8 bitstream_restriction_flag, default_display_window_flag, vui_timing_info_present_flag;
|
|
guint8 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_, gint 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, gint 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, gint 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_, gint bit_offset, guint chroma_format_idc, guint bit_depth_luma_minus8, guint bit_depth_chroma_minus8)
|
|
{
|
|
guint BitDepthY = 8 + bit_depth_luma_minus8, BitDepthC = 8 + bit_depth_chroma_minus8;
|
|
gboolean palette_mode_enabled_flag, sps_palette_predictor_initializers_present_flag;
|
|
guint32 sps_num_palette_predictor_initializers_minus1;
|
|
guint32 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/*[comp][i]*/, 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/*[comp][i]*/, 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_, gint bit_offset, guint transform_skip_enabled_flag)
|
|
{
|
|
gboolean chroma_qp_offset_list_enabled_flag;
|
|
gint offset;
|
|
guint 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/*[i]*/, tvb, pinfo, &offset, H265_SE_V);
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_cr_qp_offset_list/*[i]*/, 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_, gint bit_offset)
|
|
{
|
|
gint offset;
|
|
guint pps_num_palette_predictor_initializers, numComps, comp, i;
|
|
gboolean residual_adaptive_colour_transform_enabled_flag, pps_palette_predictor_initializers_present_flag,
|
|
monochrome_palette_flag;
|
|
guint32 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/*[comp][i]*/, 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/*[comp][i]*/, 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, gint 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, gint 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;
|
|
guint8 *buff;
|
|
|
|
buff = (gchar *)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_guint8(tvb, offset);
|
|
buff[NumBytesInRBSP++] = tvb_get_guint8(tvb, offset + 1);
|
|
i += 2;
|
|
offset += 3;
|
|
}
|
|
else {
|
|
buff[NumBytesInRBSP++] = tvb_get_guint8(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;
|
|
guint8 type;
|
|
tvbuff_t *rbsp_tvb;
|
|
|
|
type = tvb_get_guint16(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;
|
|
guint8 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");
|
|
|
|
guint16 h265_nalu_hextet = tvb_get_guint16(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, 1, ett_h265_nal, NULL, "FU identifier");
|
|
else
|
|
h265_nal_tree = proto_tree_add_subtree(h265_tree, tvb, offset, 1, ett_h265_nal, NULL, "NAL unit header or first byte 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_guint8(tvb, offset) & 0x80) == 0x80) {
|
|
type = tvb_get_guint8(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_guint8(tvb, offset) & 0x40) == 0x40) {
|
|
col_append_fstr(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);
|
|
}
|
|
|
|
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_DEC, 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_DEC, 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_DEC, 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_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_general_interlaced_source_flag,
|
|
{ "general_interlaced_source_flag", "h265.general_interlaced_source_flag",
|
|
FT_BOOLEAN, BASE_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_general_intra_constraint_flag,
|
|
{ "general_intra_constraint_flag", "h265.general_intra_constraint_flag",
|
|
FT_BOOLEAN, BASE_DEC, 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_DEC, 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_DEC, 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_DEC, 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_DEC, 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, 0xFF,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_profile_present_flag/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "sub_layer_level_present_flag", "h265.sub_layer_level_present_flag",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_reserved_zero_2bits/*[i]*/,
|
|
{ "reserved_zero_2bits", "h265.reserved_zero_2bits",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_profile_space/*[i]*/,
|
|
{ "sub_layer_profile_space", "h265.sub_layer_profile_space",
|
|
FT_UINT8, BASE_DEC, NULL, 0x03,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_tier_flag/*[i]*/,
|
|
{ "sub_layer_tier_flag", "h265.sub_layer_tier_flag",
|
|
FT_UINT8, BASE_DEC, NULL, 0x04,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_profile_idc/*[i]*/,
|
|
{ "sub_layer_profile_idc", "h265.sub_layer_profile_idc",
|
|
FT_UINT8, BASE_DEC, NULL, 0xF8,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_profile_compatibility_flag/*[i][j]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "sub_layer_inbld_flag", "h265.sub_layer_inbld_flag",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_sub_layer_reserved_zero_bit/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "sub_layer_level_idc", "h265.sub_layer_level_idc",
|
|
FT_UINT8, BASE_DEC, NULL, 0xFF,
|
|
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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i][j]*/,
|
|
{ "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/*[i]*/,
|
|
{ "hrd_layer_set_idx", "h265.hrd_layer_set_idx",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cprms_present_flag/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "low_delay_hrd_flag", "h265.low_delay_hrd_flag",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cpb_cnt_minus1/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "bit_rate_value_minus1", "h265.bit_rate_value_minus1",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cpb_size_value_minus1/*[i]*/,
|
|
{ "cpb_size_value_minus1", "h265.cpb_size_value_minus1",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cpb_size_du_value_minus1/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "bit_rate_du_value_minus1", "h265.bit_rate_du_value_minus1",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cbr_flag/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[sizeId][matrixId]*/,
|
|
{ "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/*[sizeId][matrixId]*/,
|
|
{ "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/*[sizeId - 2][matrixId]*/,
|
|
{ "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/*[j]*/,
|
|
{ "used_by_curr_pic_flag", "h265.used_by_curr_pic_flag",
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_use_delta_flag/*[j]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "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/*[comp][i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "column_width_minus1", "h265.column_width_minus1",
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_row_height_minus1/*[i]*/,
|
|
{ "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/*[i]*/,
|
|
{ "cb_qp_offset_list", "h265.cb_qp_offset_list",
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_h265_cr_qp_offset_list/*[i]*/,
|
|
{ "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/*[comp][i]*/,
|
|
{ "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 }
|
|
},
|
|
/* 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 gint *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 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:
|
|
*/
|