2018-05-29 14:37:58 +00:00
|
|
|
/* 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>
|
2018-07-16 11:23:50 +00:00
|
|
|
#include "packet-h265.h"
|
2018-05-29 14:37:58 +00:00
|
|
|
#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;
|
|
|
|
|
2018-07-16 11:23:50 +00:00
|
|
|
/* 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;
|
|
|
|
|
2018-05-29 14:37:58 +00:00
|
|
|
/*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;
|
2019-03-03 09:18:25 +00:00
|
|
|
static int hf_h265_general_profile_compatibility_flags/*[j]*/ = -1;
|
2018-05-29 14:37:58 +00:00
|
|
|
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_vui_parameters = -1;
|
|
|
|
static int ett_h265_hrd_parameters = -1;
|
2018-07-16 11:23:50 +00:00
|
|
|
static int ett_h265_sprop_parameters = -1;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
static expert_field ei_h265_undecoded = EI_INIT;
|
2018-07-16 11:23:50 +00:00
|
|
|
static expert_field ei_h265_format_specific_parameter = EI_INIT;
|
2019-02-25 15:28:20 +00:00
|
|
|
static expert_field ei_h265_value_to_large = EI_INIT;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
/* The dynamic payload type range which will be dissected as H.265 */
|
|
|
|
|
|
|
|
static range_t *temp_dynamic_payload_type_range = NULL;
|
|
|
|
|
|
|
|
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" },
|
2018-07-05 14:16:24 +00:00
|
|
|
{ 2, "Main 10 and Main 10 Still Picture profiles" },
|
2018-05-29 14:37:58 +00:00
|
|
|
{ 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 */
|
2018-07-03 04:43:34 +00:00
|
|
|
/* XXX - this looks as if the values are 10 times the level value
|
|
|
|
* in Table A.7. */
|
2018-07-05 14:16:24 +00:00
|
|
|
static const value_string h265_level_main_tier_bitrate_values[] = {
|
2018-05-29 14:37:58 +00:00
|
|
|
{ 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 }
|
|
|
|
};
|
2018-07-05 14:16:24 +00:00
|
|
|
/*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 }
|
|
|
|
};
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
/* 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 }
|
|
|
|
};
|
|
|
|
|
|
|
|
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);
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
#define cVALS(x) (const value_string*)(x)
|
|
|
|
|
|
|
|
static guint32
|
|
|
|
dissect_h265_exp_golomb_code(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint *start_bit_offset, h265_golomb_descriptors descriptor)
|
|
|
|
/*(tvbuff_t *tvb, gint *start_bit_offset) */
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
header_field_info *hf_field = NULL;
|
|
|
|
|
|
|
|
start_offset = *start_bit_offset >> 3;
|
|
|
|
|
|
|
|
if (hf_index > -1)
|
|
|
|
hf_field = proto_registrar_get_nth(hf_index);
|
|
|
|
|
|
|
|
bit_offset = *start_bit_offset;
|
|
|
|
|
|
|
|
/* prepare the string */
|
|
|
|
str = (char *)wmem_alloc(wmem_packet_scope(), 256);
|
|
|
|
str[0] = '\0';
|
|
|
|
for (bit = 0; bit<((int)(bit_offset & 0x07)); bit++) {
|
|
|
|
if (bit && (!(bit % 4))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
g_strlcat(str, ".", 256);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
leading_zero_bits = -1;
|
|
|
|
for (b = 0; !b; leading_zero_bits++) {
|
|
|
|
if (bit && (!(bit % 4))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
if (bit && (!(bit % 8))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
b = tvb_get_bits8(tvb, bit_offset, 1);
|
|
|
|
if (b != 0) {
|
|
|
|
g_strlcat(str, "1", 256);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_strlcat(str, "0", 256);
|
|
|
|
}
|
|
|
|
bit++;
|
|
|
|
bit_offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (leading_zero_bits == 0) {
|
|
|
|
codenum = 0;
|
|
|
|
*start_bit_offset = bit_offset;
|
|
|
|
for (; bit % 8; bit++) {
|
|
|
|
if (bit && (!(bit % 4))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
g_strlcat(str, ".", 256);
|
|
|
|
}
|
|
|
|
if (hf_field) {
|
|
|
|
g_strlcat(str, " = ", 256);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
codenum = 1;
|
|
|
|
codenum = codenum << leading_zero_bits;
|
|
|
|
mask = codenum >> 1;
|
|
|
|
if (leading_zero_bits > 32)
|
|
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
|
|
|
else 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 = (codenum - 1) + value;
|
|
|
|
bit_offset = bit_offset + leading_zero_bits;
|
|
|
|
|
|
|
|
/* read the bits for the int */
|
|
|
|
for (i = 0; i<leading_zero_bits; i++) {
|
|
|
|
if (bit && (!(bit % 4))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
if (bit && (!(bit % 8))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
bit++;
|
|
|
|
tmp = value & mask;
|
|
|
|
if (tmp != 0) {
|
|
|
|
g_strlcat(str, "1", 256);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_strlcat(str, "0", 256);
|
|
|
|
}
|
|
|
|
mask = mask >> 1;
|
|
|
|
}
|
|
|
|
for (; bit % 8; bit++) {
|
|
|
|
if (bit && (!(bit % 4))) {
|
|
|
|
g_strlcat(str, " ", 256);
|
|
|
|
}
|
|
|
|
g_strlcat(str, ".", 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.
|
|
|
|
* k+1
|
|
|
|
* (-1) Ceil( k/2 )
|
|
|
|
*/
|
|
|
|
se_value = (codenum + 1) >> 1;
|
|
|
|
if (!(se_value & 1)) {
|
|
|
|
se_value = -se_value;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hf_field) {
|
|
|
|
g_strlcat(str, " = ", 256);
|
|
|
|
g_strlcat(str, hf_field->name, 256);
|
|
|
|
switch (descriptor) {
|
|
|
|
case H265_SE_V:
|
|
|
|
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) && (descriptor == H265_UE_V)) {
|
|
|
|
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) && (descriptor == H265_SE_V)) {
|
|
|
|
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 {
|
|
|
|
/* Only allow guint32 */
|
|
|
|
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;
|
|
|
|
|
2019-03-03 09:18:25 +00:00
|
|
|
proto_tree_add_bits_item(tree, hf_h265_vps_reserved_0xffff_16bits, tvb, bit_offset, 16, ENC_BIG_ENDIAN);
|
2018-05-29 14:37:58 +00:00
|
|
|
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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_vps_max_num_reorder_pics, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_vps_max_latency_increase_plus1, tvb, &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, &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, &bit_offset, H265_UE_V);
|
|
|
|
}
|
|
|
|
guint32 vps_num_hrd_parameters = dissect_h265_exp_golomb_code(tree, hf_h265_vps_num_hrd_parameters, tvb, &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, &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);
|
|
|
|
}
|
|
|
|
|
2019-02-25 15:28:20 +00:00
|
|
|
/* 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
|
2018-05-29 14:37:58 +00:00
|
|
|
static void
|
|
|
|
dissect_h265_seq_parameter_set_rbsp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, gint offset)
|
|
|
|
{
|
2019-07-10 12:48:40 +00:00
|
|
|
gint bit_offset;
|
|
|
|
guint8 i, sps_max_sub_layers_minus1, sps_extension_4bits = 0;
|
2018-05-29 14:37:58 +00:00
|
|
|
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;
|
|
|
|
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, &bit_offset, H265_UE_V);
|
|
|
|
guint chroma_format_idc = dissect_h265_exp_golomb_code(tree, hf_h265_chroma_format_idc, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
pic_height_in_luma_samples = dissect_h265_exp_golomb_code(tree, hf_h265_pic_height_in_luma_samples, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_right_offset, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_top_offset, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_conf_win_bottom_offset, tvb, &bit_offset, H265_UE_V);
|
|
|
|
}
|
|
|
|
bit_depth_luma_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_bit_depth_luma_minus8, tvb, &bit_offset, H265_UE_V);
|
|
|
|
bit_depth_chroma_minus8 = dissect_h265_exp_golomb_code(tree, hf_h265_bit_depth_chroma_minus8, tvb, &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, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_num_reorder_pics/*[i]*/, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_sps_max_latency_increase_plus1/*[i]*/, tvb, &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, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_log2_min_luma_transform_block_size_minus2, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_log2_diff_max_min_luma_transform_block_size, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_max_transform_hierarchy_depth_inter, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_max_transform_hierarchy_depth_intra, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_log2_diff_max_min_pcm_luma_coding_block_size, tvb, &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, &bit_offset, H265_UE_V);
|
2019-02-25 15:28:20 +00:00
|
|
|
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;
|
|
|
|
}
|
2018-05-29 14:37:58 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
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, &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++;
|
|
|
|
|
2018-07-05 14:16:24 +00:00
|
|
|
sps_extension_4bits = tvb_get_bits8(tvb, bit_offset, 4);
|
2018-05-29 14:37:58 +00:00
|
|
|
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)
|
|
|
|
{
|
2019-07-10 12:48:40 +00:00
|
|
|
gint bit_offset;
|
|
|
|
guint num_tile_columns_minus1, num_tile_rows_minus1, i;
|
2018-05-29 14:37:58 +00:00
|
|
|
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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_seq_parameter_set_id, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_num_ref_idx_l1_default_active_minus1, tvb, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_init_qp_minus26, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
}
|
|
|
|
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_cb_qp_offset, tvb, &bit_offset, H265_SE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_cr_qp_offset, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
num_tile_rows_minus1 = dissect_h265_exp_golomb_code(tree, hf_h265_num_tile_rows_minus1, tvb, &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, &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, &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, &bit_offset, H265_SE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_tc_offset_div2, tvb, &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, &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");
|
|
|
|
|
2019-07-10 12:48:40 +00:00
|
|
|
gint bit_offset;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2018-07-05 14:16:24 +00:00
|
|
|
proto_item *general_level_idc_item;
|
|
|
|
guint32 general_profile_idc, general_level_idc;
|
2018-05-29 14:37:58 +00:00
|
|
|
guint32 sub_layer_profile_idc[32] = { 0 };
|
2018-07-05 14:16:24 +00:00
|
|
|
gboolean general_tier_flag = 0;
|
2018-05-29 14:37:58 +00:00
|
|
|
gboolean general_profile_compatibility_flag[32] = { 0 };
|
|
|
|
gboolean sub_layer_profile_present_flag[32] = { 0 };
|
|
|
|
gboolean sub_layer_level_present_flag[32] = { 0 };
|
2018-07-03 04:43:34 +00:00
|
|
|
gboolean sub_layer_profile_compatibility_flag[32][32] = { { 0 } };
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
if (profilePresentFlag) {
|
|
|
|
proto_tree_add_item(tree, hf_h265_general_profile_space, tvb, offset, 1, ENC_BIG_ENDIAN);
|
2018-07-05 14:16:24 +00:00
|
|
|
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);
|
2018-05-29 14:37:58 +00:00
|
|
|
offset++;
|
|
|
|
|
2019-03-03 09:18:25 +00:00
|
|
|
proto_tree_add_item(tree, hf_h265_general_profile_compatibility_flags, tvb, offset, 4, ENC_BIG_ENDIAN);
|
2018-05-29 14:37:58 +00:00
|
|
|
|
2019-07-10 12:48:40 +00:00
|
|
|
gint bit_offset = offset << 3;
|
2019-03-03 09:18:25 +00:00
|
|
|
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;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
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++;
|
|
|
|
|
2018-07-05 14:16:24 +00:00
|
|
|
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"));
|
|
|
|
}
|
2018-05-29 14:37:58 +00:00
|
|
|
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 ||
|
2019-12-14 22:02:44 +00:00
|
|
|
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]) {
|
2018-05-29 14:37:58 +00:00
|
|
|
/* 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;
|
2019-07-10 12:48:40 +00:00
|
|
|
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)));
|
2018-05-29 14:37:58 +00:00
|
|
|
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, &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, &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( ) */
|
2018-07-05 14:16:24 +00:00
|
|
|
dissect_h265_slice_segment_header(tree, tvb, pinfo, bit_offset, nal_unit_type);
|
2018-05-29 14:37:58 +00:00
|
|
|
/* 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)
|
|
|
|
{
|
2018-07-03 04:43:34 +00:00
|
|
|
gboolean scaling_list_pred_mode_flag[4][6] = { { 0 } };
|
2018-05-29 14:37:58 +00:00
|
|
|
/*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, &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, &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, &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)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
gint32 NumDeltaPocs[64] = { 0 }; //TODO: need to initlize
|
|
|
|
|
|
|
|
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) {
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_delta_idx_minus1, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
for (j = 0; j <= NumDeltaPocs[stRpsIdx]; 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++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
num_negative_pics = dissect_h265_exp_golomb_code(tree, hf_h265_num_negative_pics, tvb, &bit_offset, H265_UE_V);
|
|
|
|
num_positive_pics = dissect_h265_exp_golomb_code(tree, hf_h265_num_positive_pics, tvb, &bit_offset, H265_UE_V);
|
|
|
|
for (i = 0; i < num_negative_pics; i++) {
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_delta_poc_s0_minus1/*[i]*/, tvb, &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, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_cpb_size_value_minus1, tvb, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_bit_rate_du_value_minus1, tvb, &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, &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, &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, &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, &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, &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, &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, &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, &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) */
|
2018-07-05 14:16:24 +00:00
|
|
|
proto_tree_add_bits_item(tree, hf_h265_vui_num_units_in_tick, tvb, bit_offset, 32, ENC_BIG_ENDIAN);
|
2018-05-29 14:37:58 +00:00
|
|
|
bit_offset = bit_offset + 32;
|
|
|
|
|
|
|
|
/* vui_time_scale u(32) */
|
2018-07-05 14:16:24 +00:00
|
|
|
proto_tree_add_bits_item(tree, hf_h265_vui_time_scale, tvb, bit_offset, 32, ENC_BIG_ENDIAN);
|
2018-05-29 14:37:58 +00:00
|
|
|
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, &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, &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, &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, &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, &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, &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, &bit_offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_delta_palette_max_predictor_size, tvb, &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, &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;
|
2019-07-10 12:48:40 +00:00
|
|
|
gint offset;
|
|
|
|
guint i, chroma_qp_offset_list_len_minus1;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
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, &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, &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, &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, &offset, H265_SE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_cr_qp_offset_list/*[i]*/, tvb, &offset, H265_SE_V);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_log2_sao_offset_scale_luma, tvb, &offset, H265_UE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_log2_sao_offset_scale_chroma, tvb, &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)
|
|
|
|
{
|
2019-07-10 12:48:40 +00:00
|
|
|
gint offset;
|
|
|
|
guint pps_num_palette_predictor_initializers, numComps, comp, i;
|
2018-05-29 14:37:58 +00:00
|
|
|
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, &offset, H265_SE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_act_cb_qp_offset_plus5, tvb, &offset, H265_SE_V);
|
|
|
|
dissect_h265_exp_golomb_code(tree, hf_h265_pps_act_cr_qp_offset_plus3, tvb, &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, &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, &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, &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;
|
2019-07-10 12:48:40 +00:00
|
|
|
guint8 *buff;
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-07-16 11:23:50 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
/* 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, "H265");
|
|
|
|
|
|
|
|
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",
|
2019-03-03 09:18:25 +00:00
|
|
|
FT_UINT16, BASE_HEX, NULL, 0x0,
|
2018-05-29 14:37:58 +00:00
|
|
|
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",
|
2018-07-03 04:43:34 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(h265_profile_idc_values), 0x1F,
|
2018-05-29 14:37:58 +00:00
|
|
|
NULL, HFILL }
|
|
|
|
},
|
2019-03-03 09:18:25 +00:00
|
|
|
{ &hf_h265_general_profile_compatibility_flags,
|
|
|
|
{ "general_profile_compatibility_flags", "h265.general_profile_compatibility_flags",
|
|
|
|
FT_UINT32, BASE_HEX, NULL, 0xFFFFFFFF,
|
|
|
|
NULL, HFILL }
|
|
|
|
},
|
2018-05-29 14:37:58 +00:00
|
|
|
{ &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",
|
2018-08-14 14:00:25 +00:00
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
2018-05-29 14:37:58 +00:00
|
|
|
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",
|
2018-07-05 14:16:24 +00:00
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
2018-05-29 14:37:58 +00:00
|
|
|
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",
|
2018-07-05 14:16:24 +00:00
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
2018-05-29 14:37:58 +00:00
|
|
|
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 }
|
|
|
|
},
|
2018-07-16 11:23:50 +00:00
|
|
|
/* 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 }
|
|
|
|
},
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 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_vui_parameters,
|
2018-07-16 11:23:50 +00:00
|
|
|
&ett_h265_hrd_parameters,
|
|
|
|
&ett_h265_sprop_parameters
|
2018-05-29 14:37:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static ei_register_info ei[] = {
|
|
|
|
{ &ei_h265_undecoded,{ "h265.undecoded", PI_UNDECODED, PI_WARN, "[Not decoded yet]", EXPFILL } },
|
2019-02-25 15:28:20 +00:00
|
|
|
{ &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 } },
|
2018-05-29 14:37:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Register the protocol name and description */
|
RTP: Make Decode As handling consistent across subdissectors
RTP has two dissector tables, one directly associated with payload types, and
one which is associated with strings that appear in SDP commands. This makes
all dissectors that are registered as a dynamic payload type that can be
configured by SDP appear as a Decode As option for the RTP PT table.
Some protocols were registered in the table for configuration by SDP but
had no way to register with the rtp.pt table. These include EVRC, H.223,
and v150fw.
Other protocols had a long standing preference to set a dynamic payload type,
but they still did not appear in the Decode As menu unless that preference
was changed from the default, largely because of the way that the preference
was not actually registered with the rtp.pt table unless it had a value in
the dynamic payload type range. These include EVS, H.263P, H.264, H.265,
ISMACryp, IuUP, LAPD, MP4V-ES, RTP-MIDI, and VP8.
RFC 3551 says that not just the dynamic payload types, but also the unassigned
and even the statically assigned payload types MAY be dynamically reassigned as
necessary, so this patch also allows these preferences to be set for payload
types less than 96. The only payload type not allowed is 0 (which RFCs 3551 and
7007 say must be μ-law PCM), which is handy anyone for backwards compatibility
with preferences that used to be uints (where 0 meant disabled.)
All protcols which formerly used a uint preference are all converted to a
range preference, and the text is changed to be similar for each. This works
in a backwards compatible fashion, and any defaults are maintained.
The patch also adds some of the dissector variants as PINOs so that they will
show up with distinct names in the Decode As menus, and changes some of the
protocol short names so that the entry in Decode As is clearer and matches
what is used for other similar protocols.
Change-Id: I68627b5c3e495d9fc813d88208f3b62e47e0c4de
Reviewed-on: https://code.wireshark.org/review/37396
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>
2020-06-07 20:15:49 +00:00
|
|
|
proto_h265 = proto_register_protocol("H.265", "H.265", "h265");
|
2018-05-29 14:37:58 +00:00
|
|
|
|
|
|
|
/* 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, proto_reg_handoff_h265);
|
|
|
|
|
|
|
|
|
|
|
|
prefs_register_range_preference(h265_module, "dynamic.payload.type",
|
RTP: Make Decode As handling consistent across subdissectors
RTP has two dissector tables, one directly associated with payload types, and
one which is associated with strings that appear in SDP commands. This makes
all dissectors that are registered as a dynamic payload type that can be
configured by SDP appear as a Decode As option for the RTP PT table.
Some protocols were registered in the table for configuration by SDP but
had no way to register with the rtp.pt table. These include EVRC, H.223,
and v150fw.
Other protocols had a long standing preference to set a dynamic payload type,
but they still did not appear in the Decode As menu unless that preference
was changed from the default, largely because of the way that the preference
was not actually registered with the rtp.pt table unless it had a value in
the dynamic payload type range. These include EVS, H.263P, H.264, H.265,
ISMACryp, IuUP, LAPD, MP4V-ES, RTP-MIDI, and VP8.
RFC 3551 says that not just the dynamic payload types, but also the unassigned
and even the statically assigned payload types MAY be dynamically reassigned as
necessary, so this patch also allows these preferences to be set for payload
types less than 96. The only payload type not allowed is 0 (which RFCs 3551 and
7007 say must be μ-law PCM), which is handy anyone for backwards compatibility
with preferences that used to be uints (where 0 meant disabled.)
All protcols which formerly used a uint preference are all converted to a
range preference, and the text is changed to be similar for each. This works
in a backwards compatible fashion, and any defaults are maintained.
The patch also adds some of the dissector variants as PINOs so that they will
show up with distinct names in the Decode As menus, and changes some of the
protocol short names so that the entry in Decode As is clearer and matches
what is used for other similar protocols.
Change-Id: I68627b5c3e495d9fc813d88208f3b62e47e0c4de
Reviewed-on: https://code.wireshark.org/review/37396
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>
2020-06-07 20:15:49 +00:00
|
|
|
"H.265 dynamic payload types",
|
|
|
|
"Dynamic payload types which will be interpreted as H.265"
|
|
|
|
"; values must be in the range 1 - 127",
|
2018-05-29 14:37:58 +00:00
|
|
|
&temp_dynamic_payload_type_range, 127);
|
|
|
|
|
|
|
|
h265_handle = register_dissector("h265", dissect_h265, proto_h265);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register the protocol with Wireshark */
|
|
|
|
void
|
|
|
|
proto_reg_handoff_h265(void)
|
|
|
|
{
|
|
|
|
static range_t *dynamic_payload_type_range = NULL;
|
|
|
|
static gboolean h265_prefs_initialized = FALSE;
|
|
|
|
|
|
|
|
if (!h265_prefs_initialized) {
|
|
|
|
dissector_add_string("rtp_dyn_payload_type", "H265", h265_handle);
|
|
|
|
|
|
|
|
h265_prefs_initialized = TRUE;
|
|
|
|
}
|
|
|
|
else {
|
RTP: Make Decode As handling consistent across subdissectors
RTP has two dissector tables, one directly associated with payload types, and
one which is associated with strings that appear in SDP commands. This makes
all dissectors that are registered as a dynamic payload type that can be
configured by SDP appear as a Decode As option for the RTP PT table.
Some protocols were registered in the table for configuration by SDP but
had no way to register with the rtp.pt table. These include EVRC, H.223,
and v150fw.
Other protocols had a long standing preference to set a dynamic payload type,
but they still did not appear in the Decode As menu unless that preference
was changed from the default, largely because of the way that the preference
was not actually registered with the rtp.pt table unless it had a value in
the dynamic payload type range. These include EVS, H.263P, H.264, H.265,
ISMACryp, IuUP, LAPD, MP4V-ES, RTP-MIDI, and VP8.
RFC 3551 says that not just the dynamic payload types, but also the unassigned
and even the statically assigned payload types MAY be dynamically reassigned as
necessary, so this patch also allows these preferences to be set for payload
types less than 96. The only payload type not allowed is 0 (which RFCs 3551 and
7007 say must be μ-law PCM), which is handy anyone for backwards compatibility
with preferences that used to be uints (where 0 meant disabled.)
All protcols which formerly used a uint preference are all converted to a
range preference, and the text is changed to be similar for each. This works
in a backwards compatible fashion, and any defaults are maintained.
The patch also adds some of the dissector variants as PINOs so that they will
show up with distinct names in the Decode As menus, and changes some of the
protocol short names so that the entry in Decode As is clearer and matches
what is used for other similar protocols.
Change-Id: I68627b5c3e495d9fc813d88208f3b62e47e0c4de
Reviewed-on: https://code.wireshark.org/review/37396
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>
2020-06-07 20:15:49 +00:00
|
|
|
dissector_delete_uint_range("rtp.pt", dynamic_payload_type_range, h265_handle);
|
2018-05-29 14:37:58 +00:00
|
|
|
wmem_free(wmem_epan_scope(), dynamic_payload_type_range);
|
|
|
|
}
|
|
|
|
|
|
|
|
dynamic_payload_type_range = range_copy(wmem_epan_scope(), temp_dynamic_payload_type_range);
|
RTP: Make Decode As handling consistent across subdissectors
RTP has two dissector tables, one directly associated with payload types, and
one which is associated with strings that appear in SDP commands. This makes
all dissectors that are registered as a dynamic payload type that can be
configured by SDP appear as a Decode As option for the RTP PT table.
Some protocols were registered in the table for configuration by SDP but
had no way to register with the rtp.pt table. These include EVRC, H.223,
and v150fw.
Other protocols had a long standing preference to set a dynamic payload type,
but they still did not appear in the Decode As menu unless that preference
was changed from the default, largely because of the way that the preference
was not actually registered with the rtp.pt table unless it had a value in
the dynamic payload type range. These include EVS, H.263P, H.264, H.265,
ISMACryp, IuUP, LAPD, MP4V-ES, RTP-MIDI, and VP8.
RFC 3551 says that not just the dynamic payload types, but also the unassigned
and even the statically assigned payload types MAY be dynamically reassigned as
necessary, so this patch also allows these preferences to be set for payload
types less than 96. The only payload type not allowed is 0 (which RFCs 3551 and
7007 say must be μ-law PCM), which is handy anyone for backwards compatibility
with preferences that used to be uints (where 0 meant disabled.)
All protcols which formerly used a uint preference are all converted to a
range preference, and the text is changed to be similar for each. This works
in a backwards compatible fashion, and any defaults are maintained.
The patch also adds some of the dissector variants as PINOs so that they will
show up with distinct names in the Decode As menus, and changes some of the
protocol short names so that the entry in Decode As is clearer and matches
what is used for other similar protocols.
Change-Id: I68627b5c3e495d9fc813d88208f3b62e47e0c4de
Reviewed-on: https://code.wireshark.org/review/37396
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>
2020-06-07 20:15:49 +00:00
|
|
|
range_remove_value(wmem_epan_scope(), &dynamic_payload_type_range, 0);
|
|
|
|
dissector_add_uint_range("rtp.pt", dynamic_payload_type_range, h265_handle);
|
2018-05-29 14:37:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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:
|
2018-08-19 11:03:17 +00:00
|
|
|
*/
|