/* 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/expert.h>

#include <epan/prefs.h>

#include <epan/tfs.h>

#include "packet-h265.h"

#include "math.h"

void proto_register_h265(void);

void proto_reg_handoff_h265(void);

/* Initialize the protocol and registered fields */

static int proto_h265;

static int hf_h265_type;

static int hf_h265_nal_unit_type;

static int hf_h265_nuh_layer_id;

static int hf_h265_nuh_temporal_id_plus1;

static int hf_h265_nal_f_bit;

static int hf_h265_start_bit;

static int hf_h265_end_bit;

static int hf_h265_rbsp_stop_bit;

static int hf_h265_rbsp_trailing_bits;

/* SDP */

static int hf_h265_sdp_parameter_sprop_vps;

static int hf_h265_sdp_parameter_sprop_sps;

static int hf_h265_sdp_parameter_sprop_pps;

/*vps*/

static int hf_h265_vps_video_parameter_set_id;

static int hf_h265_vps_base_layer_internal_flag;

static int hf_h265_vps_base_layer_available_flag;

static int hf_h265_vps_max_layers_minus1;

static int hf_h265_vps_max_sub_layers_minus1;

static int hf_h265_vps_temporal_id_nesting_flag;

static int hf_h265_vps_reserved_0xffff_16bits;

static int hf_h265_vps_sub_layer_ordering_info_present_flag;

static int hf_h265_vps_max_dec_pic_buffering_minus1;

static int hf_h265_vps_max_num_reorder_pics;

static int hf_h265_vps_max_latency_increase_plus1;

static int hf_h265_vps_max_layer_id;

static int hf_h265_vps_num_layer_sets_minus1;

static int hf_h265_layer_id_included_flag;

static int hf_h265_vps_timing_info_present_flag;

static int hf_h265_vps_num_units_in_tick;

static int hf_h265_vps_time_scale;

static int hf_h265_vps_poc_proportional_to_timing_flag;

static int hf_h265_vps_num_ticks_poc_diff_one_minus1;

static int hf_h265_vps_num_hrd_parameters;

static int hf_h265_hrd_layer_set_idx;

static int hf_h265_cprms_present_flag;

static int hf_h265_vps_extension_flag;

static int hf_h265_vps_extension_data_flag;

/* profile_tier_level  */

static int hf_h265_general_profile_space;

static int hf_h265_general_tier_flag;

static int hf_h265_general_profile_idc;

static int hf_h265_general_profile_compatibility_flags;

static int hf_h265_general_progressive_source_flag;

static int hf_h265_general_interlaced_source_flag;

static int hf_h265_general_non_packed_constraint_flag;

static int hf_h265_general_frame_only_constraint_flag;

static int hf_h265_general_max_12bit_constraint_flag;

static int hf_h265_general_max_10bit_constraint_flag;

static int hf_h265_general_max_8bit_constraint_flag;

static int hf_h265_general_max_422chroma_constraint_flag;

static int hf_h265_general_max_420chroma_constraint_flag;

static int hf_h265_general_max_monochrome_constraint_flag;

static int hf_h265_general_intra_constraint_flag;

static int hf_h265_general_one_picture_only_constraint_flag;

static int hf_h265_general_lower_bit_rate_constraint_flag;

static int hf_h265_general_max_14bit_constraint_flag;

static int hf_h265_general_reserved_zero_33bits;

static int hf_h265_general_reserved_zero_34bits;

static int hf_h265_general_reserved_zero_7bits;

static int hf_h265_general_reserved_zero_35bits;

static int hf_h265_general_reserved_zero_43bits;

static int hf_h265_general_inbld_flag;

static int hf_h265_general_reserved_zero_bit;

static int hf_h265_general_level_idc;

static int hf_h265_sub_layer_profile_present_flag;

static int hf_h265_sub_layer_level_present_flag;

static int hf_h265_reserved_zero_2bits;

static int hf_h265_sub_layer_profile_space;

static int hf_h265_sub_layer_tier_flag;

static int hf_h265_sub_layer_profile_idc;

static int hf_h265_sub_layer_profile_compatibility_flag;

static int hf_h265_sub_layer_progressive_source_flag;

static int hf_h265_sub_layer_interlaced_source_flag;

static int hf_h265_sub_layer_non_packed_constraint_flag;

static int hf_h265_sub_layer_frame_only_constraint_flag;

static int hf_h265_sub_layer_max_12bit_constraint_flag;

static int hf_h265_sub_layer_max_10bit_constraint_flag;

static int hf_h265_sub_layer_max_8bit_constraint_flag;

static int hf_h265_sub_layer_max_422chroma_constraint_flag;

static int hf_h265_sub_layer_max_420chroma_constraint_flag;

static int hf_h265_sub_layer_max_monochrome_constraint_flag;

static int hf_h265_sub_layer_intra_constraint_flag;

static int hf_h265_sub_layer_one_picture_only_constraint_flag;

static int hf_h265_sub_layer_lower_bit_rate_constraint_flag;

static int hf_h265_sub_layer_max_14bit_constraint_flag;

static int hf_h265_sub_layer_reserved_zero_33bits;

static int hf_h265_sub_layer_reserved_zero_34bits;

static int hf_h265_sub_layer_reserved_zero_7bits;

static int hf_h265_sub_layer_reserved_zero_35bits;

static int hf_h265_sub_layer_reserved_zero_43bits;

static int hf_h265_sub_layer_inbld_flag;

static int hf_h265_sub_layer_reserved_zero_bit;

static int hf_h265_sub_layer_level_idc;

/* hrd_parameters */

static int hf_h265_nal_hrd_parameters_present_flag;

static int hf_h265_vcl_hrd_parameters_present_flag;

static int hf_h265_sub_pic_hrd_params_present_flag;

static int hf_h265_tick_divisor_minus2;

static int hf_h265_du_cpb_removal_delay_increment_length_minus1;

static int hf_h265_sub_pic_cpb_params_in_pic_timing_sei_flag;

static int hf_h265_dpb_output_delay_du_length_minus1;

static int hf_h265_bit_rate_scale;

static int hf_h265_cpb_size_scale;

static int hf_h265_cpb_size_du_scale;

static int hf_h265_initial_cpb_removal_delay_length_minus1;

static int hf_h265_au_cpb_removal_delay_length_minus1;

static int hf_h265_dpb_output_delay_length_minus1;

static int hf_h265_fixed_pic_rate_general_flag;

static int hf_h265_fixed_pic_rate_within_cvs_flag;

static int hf_h265_elemental_duration_in_tc_minus1;

static int hf_h265_low_delay_hrd_flag;

static int hf_h265_cpb_cnt_minus1;

/* sub-layer hrd_parameters */

static int hf_h265_bit_rate_value_minus1;

static int hf_h265_cpb_size_value_minus1;

static int hf_h265_cpb_size_du_value_minus1;

static int hf_h265_bit_rate_du_value_minus1;

static int hf_h265_cbr_flag;

/*sps*/

static int hf_h265_sps_video_parameter_set_id;

static int hf_h265_sps_max_sub_layers_minus1;

static int hf_h265_sps_temporal_id_nesting_flag;

static int hf_h265_sps_seq_parameter_set_id;

static int hf_h265_chroma_format_idc;

static int hf_h265_separate_colour_plane_flag;

static int hf_h265_pic_width_in_luma_samples;

static int hf_h265_pic_height_in_luma_samples;

static int hf_h265_conformance_window_flag;

static int hf_h265_conf_win_left_offset;

static int hf_h265_conf_win_right_offset;

static int hf_h265_conf_win_top_offset;

static int hf_h265_conf_win_bottom_offset;

static int hf_h265_bit_depth_luma_minus8;

static int hf_h265_bit_depth_chroma_minus8;

static int hf_h265_log2_max_pic_order_cnt_lsb_minus4;

static int hf_h265_sps_sub_layer_ordering_info_present_flag;

static int hf_h265_sps_max_dec_pic_buffering_minus1;

static int hf_h265_sps_max_num_reorder_pics;

static int hf_h265_sps_max_latency_increase_plus1;

static int hf_h265_log2_min_luma_coding_block_size_minus3;

static int hf_h265_log2_diff_max_min_luma_coding_block_size;

static int hf_h265_log2_min_luma_transform_block_size_minus2;

static int hf_h265_log2_diff_max_min_luma_transform_block_size;

static int hf_h265_max_transform_hierarchy_depth_inter;

static int hf_h265_max_transform_hierarchy_depth_intra;

static int hf_h265_scaling_list_enabled_flag;

static int hf_h265_sps_scaling_list_data_present_flag;

static int hf_h265_amp_enabled_flag;

static int hf_h265_sample_adaptive_offset_enabled_flag;

static int hf_h265_pcm_enabled_flag;

static int hf_h265_pcm_sample_bit_depth_luma_minus1;

static int hf_h265_pcm_sample_bit_depth_chroma_minus1;

static int hf_h265_log2_min_pcm_luma_coding_block_size_minus3;

static int hf_h265_log2_diff_max_min_pcm_luma_coding_block_size;

static int hf_h265_pcm_loop_filter_disabled_flag;

static int hf_h265_num_short_term_ref_pic_sets;

static int hf_h265_long_term_ref_pics_present_flag;

static int hf_h265_num_long_term_ref_pics_sps;

static int hf_h265_lt_ref_pic_poc_lsb_sps;

static int hf_h265_used_by_curr_pic_lt_sps_flag;

static int hf_h265_sps_temporal_mvp_enabled_flag;

static int hf_h265_strong_intra_smoothing_enabled_flag;

static int hf_h265_vui_parameters_present_flag;

static int hf_h265_sps_extension_present_flag;

static int hf_h265_sps_range_extension_flag;

static int hf_h265_sps_multilayer_extension_flag;

static int hf_h265_sps_3d_extension_flag;

static int hf_h265_sps_scc_extension_flag;

static int hf_h265_sps_extension_4bits;

static int hf_h265_sps_extension_data_flag;

/* scaling_list_data */

static int hf_h265_scaling_list_pred_mode_flag;

static int hf_h265_scaling_list_pred_matrix_id_delta;

static int hf_h265_scaling_list_dc_coef_minus8;

static int hf_h265_scaling_list_delta_coef;

/* st_ref_pic_set */

static int hf_h265_inter_ref_pic_set_prediction_flag;

static int hf_h265_delta_idx_minus1;

static int hf_h265_delta_rps_sign;

static int hf_h265_abs_delta_rps_minus1;

static int hf_h265_used_by_curr_pic_flag;

static int hf_h265_use_delta_flag;

static int hf_h265_num_negative_pics;

static int hf_h265_num_positive_pics;

static int hf_h265_delta_poc_s0_minus1;

static int hf_h265_used_by_curr_pic_s0_flag;

static int hf_h265_delta_poc_s1_minus1;

static int hf_h265_used_by_curr_pic_s1_flag;

/* sps_range_extension */

static int hf_h265_transform_skip_rotation_enabled_flag;

static int hf_h265_transform_skip_context_enabled_flag;

static int hf_h265_implicit_rdpcm_enabled_flag;

static int hf_h265_explicit_rdpcm_enabled_flag;

static int hf_h265_extended_precision_processing_flag;

static int hf_h265_intra_smoothing_disabled_flag;

static int hf_h265_high_precision_offsets_enabled_flag;

static int hf_h265_persistent_rice_adaptation_enabled_flag;

static int hf_h265_cabac_bypass_alignment_enabled_flag;

/* sps_scc_extension */

static int hf_h265_sps_curr_pic_ref_enabled_flag;

static int hf_h265_palette_mode_enabled_flag;

static int hf_h265_palette_max_size;

static int hf_h265_delta_palette_max_predictor_size;

static int hf_h265_sps_palette_predictor_initializers_present_flag;

static int hf_h265_sps_num_palette_predictor_initializers_minus1;

static int hf_h265_sps_palette_predictor_initializer;

static int hf_h265_motion_vector_resolution_control_idc;

static int hf_h265_intra_boundary_filtering_disabled_flag;

/* PPS */

static int hf_h265_pps_pic_parameter_set_id;

static int hf_h265_pps_seq_parameter_set_id;

static int hf_h265_dependent_slice_segments_enabled_flag;

static int hf_h265_output_flag_present_flag;

static int hf_h265_num_extra_slice_header_bits;

static int hf_h265_sign_data_hiding_enabled_flag;

static int hf_h265_cabac_init_present_flag;

static int hf_h265_num_ref_idx_l0_default_active_minus1;

static int hf_h265_num_ref_idx_l1_default_active_minus1;

static int hf_h265_init_qp_minus26;

static int hf_h265_constrained_intra_pred_flag;

static int hf_h265_transform_skip_enabled_flag;

static int hf_h265_cu_qp_delta_enabled_flag;

static int hf_h265_diff_cu_qp_delta_depth;

static int hf_h265_pps_cb_qp_offset;

static int hf_h265_pps_cr_qp_offset;

static int hf_h265_pps_slice_chroma_qp_offsets_present_flag;

static int hf_h265_weighted_pred_flag;

static int hf_h265_weighted_bipred_flag;

static int hf_h265_transquant_bypass_enabled_flag;

static int hf_h265_tiles_enabled_flag;

static int hf_h265_entropy_coding_sync_enabled_flag;

static int hf_h265_num_tile_columns_minus1;

static int hf_h265_num_tile_rows_minus1;

static int hf_h265_uniform_spacing_flag;

static int hf_h265_column_width_minus1;

static int hf_h265_row_height_minus1;

static int hf_h265_loop_filter_across_tiles_enabled_flag;

static int hf_h265_pps_loop_filter_across_slices_enabled_flag;

static int hf_h265_deblocking_filter_control_present_flag;

static int hf_h265_deblocking_filter_override_enabled_flag;

static int hf_h265_pps_deblocking_filter_disabled_flag;

static int hf_h265_pps_beta_offset_div2;

static int hf_h265_pps_tc_offset_div2;

static int hf_h265_pps_scaling_list_data_present_flag;

static int hf_h265_lists_modification_present_flag;

static int hf_h265_log2_parallel_merge_level_minus2;

static int hf_h265_slice_segment_header_extension_present_flag;

static int hf_h265_pps_extension_present_flag;

static int hf_h265_pps_range_extension_flag;

static int hf_h265_pps_multilayer_extension_flag;

static int hf_h265_pps_3d_extension_flag;

static int hf_h265_pps_scc_extension_flag;

static int hf_h265_pps_extension_4bits;

static int hf_h265_pps_extension_data_flag;

/*pps_range_extension*/

static int hf_h265_log2_max_transform_skip_block_size_minus2;

static int hf_h265_cross_component_prediction_enabled_flag;

static int hf_h265_chroma_qp_offset_list_enabled_flag;

static int hf_h265_diff_cu_chroma_qp_offset_depth;

static int hf_h265_chroma_qp_offset_list_len_minus1;

static int hf_h265_cb_qp_offset_list;

static int hf_h265_cr_qp_offset_list;

static int hf_h265_log2_sao_offset_scale_luma;

static int hf_h265_log2_sao_offset_scale_chroma;

/*pps_scc_extension*/

static int hf_h265_pps_curr_pic_ref_enabled_flag;

static int hf_h265_residual_adaptive_colour_transform_enabled_flag;

static int hf_h265_pps_slice_act_qp_offsets_present_flag;

static int hf_h265_pps_act_y_qp_offset_plus5;

static int hf_h265_pps_act_cb_qp_offset_plus5;

static int hf_h265_pps_act_cr_qp_offset_plus3;

static int hf_h265_pps_palette_predictor_initializers_present_flag;

static int hf_h265_pps_num_palette_predictor_initializers;

static int hf_h265_monochrome_palette_flag;

static int hf_h265_luma_bit_depth_entry_minus8;

static int hf_h265_chroma_bit_depth_entry_minus8;

static int hf_h265_pps_palette_predictor_initializer;

/* VUI parameters */

static int hf_h265_aspect_ratio_info_present_flag;

static int hf_h265_aspect_ratio_idc;

static int hf_h265_sar_width;

static int hf_h265_sar_height;

static int hf_h265_overscan_info_present_flag;

static int hf_h265_overscan_appropriate_flag;

static int hf_h265_video_signal_type_present_flag;

static int hf_h265_video_format;

static int hf_h265_video_full_range_flag;

static int hf_h265_colour_description_present_flag;

static int hf_h265_colour_primaries;

static int hf_h265_transfer_characteristics;

static int hf_h265_matrix_coeffs;

static int hf_h265_chroma_loc_info_present_flag;

static int hf_h265_chroma_sample_loc_type_top_field;

static int hf_h265_chroma_sample_loc_type_bottom_field;

static int hf_h265_neutral_chroma_indication_flag;

static int hf_h265_field_seq_flag;

static int hf_h265_frame_field_info_present_flag;

static int hf_h265_default_display_window_flag;

static int hf_h265_def_disp_win_left_offset;

static int hf_h265_def_disp_win_right_offset;

static int hf_h265_def_disp_win_top_offset;

static int hf_h265_def_disp_win_bottom_offset;

static int hf_h265_vui_timing_info_present_flag;

static int hf_h265_vui_num_units_in_tick;

static int hf_h265_vui_time_scale;

static int hf_h265_vui_poc_proportional_to_timing_flag;

static int hf_h265_vui_num_ticks_poc_diff_one_minus1;

static int hf_h265_vui_hrd_parameters_present_flag;

static int hf_h265_bitstream_restriction_flag;

static int hf_h265_tiles_fixed_structure_flag;

static int hf_h265_motion_vectors_over_pic_boundaries_flag;

static int hf_h265_restricted_ref_pic_lists_flag;

static int hf_h265_min_spatial_segmentation_idc;

static int hf_h265_max_bytes_per_pic_denom;

static int hf_h265_max_bits_per_min_cu_denom;

static int hf_h265_log2_max_mv_length_horizontal;

static int hf_h265_log2_max_mv_length_vertical;

/* slice_segment_header */

static int hf_h265_slice_pic_parameter_set_id;

static int hf_h265_slice_segment_address;

static int hf_h265_slice_type;

/* SEI */

static int hf_h265_payloadsize;

static int hf_h265_payloadtype;

/* access unit delimiter */

static int hf_h265_pic_type;

/* Initialize the subtree pointers */

static int ett_h265;

static int ett_h265_profile;

static int ett_h265_nal;

static int ett_h265_fu;

static int ett_h265_stream;

static int ett_h265_sps_multilayer_extension;

static int ett_h265_sps_3d_extension;

static int ett_h265_pps_multilayer_extension;

static int ett_h265_pps_3d_extension;

static int ett_h265_access_unit_delimiter_rbsp;

static int ett_h265_sei_rbsp;

static int ett_h265_filler_data_rbsp;

static int ett_h265_end_of_seq_rbsp;

static int ett_h265_end_of_bitstream_rbsp;

static int ett_h265_profile_tier_level;

static int ett_h265_ref_pic_set;

static int ett_h265_vui_parameters;

static int ett_h265_hrd_parameters;

static int ett_h265_sprop_parameters;

static expert_field ei_h265_undecoded;

static expert_field ei_h265_format_specific_parameter;

static expert_field ei_h265_oversized_exp_golomb_code;

static expert_field ei_h265_value_to_large;

static dissector_handle_t h265_handle;

static bool dependent_slice_segments_enabled_flag;

static unsigned num_extra_slice_header_bits;

static unsigned log2_min_luma_coding_block_size_minus3;

static unsigned log2_diff_max_min_luma_coding_block_size;

static unsigned pic_width_in_luma_samples;

static unsigned pic_height_in_luma_samples;

/* syntax tables in subclause 7.3 is equal to

* ue(v), me(v), se(v), or te(v).

*/

typedef enum {

  H265_UE_V = 0,

  H265_ME_V = 1,

  H265_SE_V = 2,

  H265_TE_V = 3

} h265_golomb_descriptors;

static const true_false_string h265_f_bit_vals = {

  "Bit errors or other syntax violations",

  "No bit errors or other syntax violations"

};

static const true_false_string h265_start_bit_vals = {

  "the first packet of FU-A picture",

  "Not the first packet of FU-A picture"

};

static const true_false_string h265_end_bit_vals = {

  "the last packet of FU-A picture",

  "Not the last packet of FU-A picture"

};

static const value_string h265_type_values[] = {

  { 0,   "TRAIL_N - Coded slice segment of a non-TSA, non-STSA trailing picture" },

  { 1,   "TRAIL_R - Coded slice segment of a non-TSA, non-STSA trailing picture" },

  { 2,   "TSA_N - Coded slice segment of a TSA picture" },

  { 3,   "TSA_R - Coded slice segment of a TSA picture" },

  { 4,   "STSA_N - Coded slice segment of an STSA picture" },

  { 5,   "STSA_R - Coded slice segment of an STSA picture" },

  { 6,   "RADL_N - Coded slice segment of a RADL picture" },

  { 7,   "RADL_R - Coded slice segment of a RADL picture" },

  { 8,   "RASL_N - Coded slice segment of a RASL picture" },

  { 9,   "RASL_R - Coded slice segment of a RASL picture" },

  { 10,  "RSV_VCL_N10 - Reserved non-IRAP SLNR VCL NAL unit types" },

  { 11,  "RSV_VCL_R11 - Reserved non-IRAP sub-layer reference VCL NAL unit types" },

  { 12,  "RSV_VCL_N12 - Reserved non-IRAP SLNR VCL NAL unit types" },

  { 13,  "RSV_VCL_R13 - Reserved non-IRAP sub-layer reference VCL NAL unit types" },

  { 14,  "RSV_VCL_N14 - Reserved non-IRAP SLNR VCL NAL unit types" },

  { 15,  "RSV_VCL_R15 - Reserved non-IRAP sub-layer reference VCL NAL unit types" },

  { 16,  "BLA_W_LP - Coded slice segment of a BLA picture" },

  { 17,  "BLA_W_RADL - Coded slice segment of a BLA picture" },

  { 18,  "BLA_N_LP - Coded slice segment of a BLA picture" },

  { 19,  "IDR_W_RADL - Coded slice segment of an IDR picture" },

  { 20,  "IDR_N_LP - Coded slice segment of an IDR picture" },

  { 21,  "CRA_NUT - Coded slice segment of a CRA picture" },

  { 22,  "RSV_IRAP_VCL22 - Reserved IRAP VCL NAL unit types" },

  { 23,  "RSV_IRAP_VCL23 - Reserved IRAP VCL NAL unit types" },

  { 24,  "RSV_VCL24 - Reserved non-IRAP VCL NAL unit types" },

  { 25,  "RSV_VCL25 - Reserved non-IRAP VCL NAL unit types" },

  { 26,  "RSV_VCL26 - Reserved non-IRAP VCL NAL unit types" },

  { 27,  "RSV_VCL27 - Reserved non-IRAP VCL NAL unit types" },

  { 28,  "RSV_VCL28 - Reserved non-IRAP VCL NAL unit types" },

  { 29,  "RSV_VCL29 - Reserved non-IRAP VCL NAL unit types" },

  { 30,  "RSV_VCL30 - Reserved non-IRAP VCL NAL unit types" },

  { 31,  "RSV_VCL31 - Reserved non-IRAP VCL NAL unit types" },

  { 32,  "VPS_NUT - Video parameter set" },

  { 33,  "SPS_NUT - Sequence parameter set" },

  { 34,  "PPS_NUT - Picture parameter set" },

  { 35,  "AUD_NUT - Access unit delimiter" },

  { 36,  "EOS_NUT - End of sequence" },

  { 37,  "EOB_NUT - End of bitstream" },

  { 38,  "FD_NUT - Filler data" },

  { 39,  "PREFIX_SEI_NUT - Supplemental enhancement information" },

  { 40,  "SUFFIX_SEI_NUT - Supplemental enhancement information" },

  { 41,  "RSV_NVCL41 - Reserved" },

  { 42,  "RSV_NVCL42 - Reserved" },

  { 43,  "RSV_NVCL43 - Reserved" },

  { 44,  "RSV_NVCL44 - Reserved" },

  { 45,  "RSV_NVCL45 - Reserved" },

  { 46,  "RSV_NVCL46 - Reserved" },

  { 47,  "RSV_NVCL47 - Reserved" },

  { 48,  "APS -  Aggregation Packets" },

  { 49,  "FU - Fragmentation Units" },

  { 50,  "PACI - PACI Packets" },

  { 51,  "UNSPEC51 - Unspecified" },

  { 52,  "UNSPEC52 - Unspecified" },

  { 53,  "UNSPEC53 - Unspecified" },

  { 54,  "UNSPEC54 - Unspecified" },

  { 55,  "UNSPEC55 - Unspecified" },

  { 56,  "UNSPEC56 - Unspecified" },

  { 57,  "UNSPEC57 - Unspecified" },

  { 58,  "UNSPEC58 - Unspecified" },

  { 59,  "UNSPEC59 - Unspecified" },

  { 60,  "UNSPEC60 - Unspecified" },

  { 61,  "UNSPEC61 - Unspecified" },

  { 62,  "UNSPEC62 - Unspecified" },

  { 63,  "UNSPEC63 - Unspecified" },

  { 0, NULL }

};

static const value_string h265_type_summary_values[] = {

  { 0,   "TRAIL_N" },

  { 1,   "TRAIL_R" },

  { 2,   "TSA_N" },

  { 3,   "TSA_R" },

  { 4,   "STSA_N" },

  { 5,   "STSA_R" },

  { 6,   "RADL_N" },

  { 7,   "RADL_R" },

  { 8,   "RASL_N" },

  { 9,   "RASL_R" },

  { 10,  "RSV_VCL_N10" },

  { 11,  "RSV_VCL_R11" },

  { 12,  "RSV_VCL_N12" },

  { 13,  "RSV_VCL_R13" },

  { 14,  "RSV_VCL_N14" },

  { 15,  "RSV_VCL_R15" },

  { 16,  "BLA_W_LP" },

  { 17,  "BLA_W_RADL" },

  { 18,  "BLA_N_LP" },

  { 19,  "IDR_W_RADL" },

  { 20,  "IDR_N_LP" },

  { 21,  "CRA_NUT" },

  { 22,  "RSV_IRAP_VCL22" },

  { 23,  "RSV_IRAP_VCL23" },

  { 24,  "RSV_VCL24" },

  { 25,  "RSV_VCL25" },

  { 26,  "RSV_VCL26" },

  { 27,  "RSV_VCL27" },

  { 28,  "RSV_VCL28" },

  { 29,  "RSV_VCL29" },

  { 30,  "RSV_VCL30" },

  { 31,  "RSV_VCL31" },

  { 32,  "VPS_NUT" },

  { 33,  "SPS_NUT" },

  { 34,  "PPS_NUT" },

  { 35,  "AUD_NUT" },

  { 36,  "EOS_NUT" },

  { 37,  "EOB_NUT" },

  { 38,  "FD_NUT" },

  { 39,  "PREFIX_SEI_NUT" },

  { 40,  "SUFFIX_SEI_NUT" },

  { 41,  "RSV_NVCL41" },

  { 42,  "RSV_NVCL42" },

  { 43,  "RSV_NVCL43" },

  { 44,  "RSV_NVCL44" },

  { 45,  "RSV_NVCL45" },

  { 46,  "RSV_NVCL46" },

  { 47,  "RSV_NVCL47" },

  { 48,  "APS" },

  { 49,  "FU" },

  { 50,  "PACI" },

  { 51,  "UNSPEC51" },

  { 52,  "UNSPEC52" },

  { 53,  "UNSPEC53" },

  { 54,  "UNSPEC54" },

  { 55,  "UNSPEC55" },

  { 56,  "UNSPEC56" },

  { 57,  "UNSPEC57" },

  { 58,  "UNSPEC58" },

  { 59,  "UNSPEC59" },

  { 60,  "UNSPEC60" },

  { 61,  "UNSPEC61" },

  { 62,  "UNSPEC62" },

  { 63,  "UNSPEC63" },

  { 0, NULL }

};

/* A.3 Profiles */

static const value_string h265_profile_idc_values[] = {

  { 1,  "Main profile" },

  { 2,  "Main 10 and Main 10 Still Picture profiles" },

  { 3,  "Main Still Picture profile" },

  { 4,  "Format range extensions profiles" },

  { 5,  "High throughput profiles" },

  { 9,  "Screen content coding extensions profiles" },

  { 0, NULL }

};

/* Table A.7-Tier and level limits for the video profiles */

/* XXX - this looks as if the values are 10 times the level value

 * in Table A.7. */

static const value_string h265_level_main_tier_bitrate_values[] = {

  { 10,   "128 kb/s" },

  { 20,   "1.5 Mb/s" },

  { 21,   "3 Mb/s" },

  { 30,   "6 Mb/s" },

  { 31,   "10 Mb/s" },

  { 40,   "12 Mb/s" },

  { 41,   "20 Mb/s" },

  { 50,   "25 Mb/s" },

  { 51,   "40 Mb/s" },

  { 52,   "60 Mb/s" },

  { 60,   "60 Mb/s" },

  { 61,   "120 Mb/s" },

  { 62,   "240 Mb/s" },

  { 0, NULL }

};

/*High tier*/

static const value_string h265_level_high_tier_bitrate_values[] = {

  { 40,   "30 Mb/s" },

  { 41,   "50 Mb/s" },

  { 50,   "100 Mb/s" },

  { 51,   "160 Mb/s" },

  { 52,   "240 Mb/s" },

  { 60,   "240 Mb/s" },

  { 61,   "480 Mb/s" },

  { 62,   "800 Mb/s" },

  { 0, NULL }

};

/* Table 7-7 - Name association to slice_type */

static const value_string h265_slice_type_vals[] = {

  { 0,    "B (B slice)" },

  { 1,    "P (P slice)" },

  { 2,    "I (I slice)" },

  { 0, NULL }

};

/* D.2 SEI payload syntax */

static const value_string h265_sei_payload_vals[] = {

  { 0,   "buffering_period" },

  { 1,   "pic_timing" },

  { 2,   "pan_scan_rect" },

  { 3,   "filler_payload" },

  { 4,   "user_data_registered_itu_t_t35" },

  { 5,   "user_data_unregistered" },

  { 6,   "recovery_point" },

  { 9,   "scene_info" },

  { 15,   "picture_snapshot" },

  { 16,   "progressive_refinement_segment_start" },

  { 17,   "progressive_refinement_segment_end" },

  { 19,   "film_grain_characteristics" },

  { 23,   "tone_mapping_info" },

  { 45,   "frame_packing_arrangement" },

  { 47,   "display_orientation" },

  { 56,   "green_metadata" }, /* specified in ISO/IEC 23001-11 */

  { 128,   "structure_of_pictures_info" },

  { 129,   "active_parameter_sets" },

  { 130,   "decoding_unit_info" },

  { 131,   "temporal_sub_layer_zero_idx" },

  { 133,   "scalable_nesting" },

  { 134,   "region_refresh_info" },

  { 135,   "no_display" },

  { 136,   "time_code" },

  { 137,   "mastering_display_colour_volume" },

  { 138,   "segmented_rect_frame_packing_arrangement" },

  { 139,   "temporal_motion_constrained_tile_sets" },

  { 140,   "chroma_resampling_filter_hint" },

  { 141,   "knee_function_info" },

  { 142,   "colour_remapping_info" },

  { 143,   "deinterlaced_field_identification" },

  { 144,   "content_light_level_info" },

  { 145,   "dependent_rap_indication" },

  { 146,   "coded_region_completion" },

  { 147,   "alternative_transfer_characteristics" },

  { 148,   "ambient_viewing_environment" },

  { 149,   "content_colour_volume" },

  { 150,   "equirectangular_projection" },

  { 151,   "cubemap_projection" },

  { 154,   "sphere_rotation" },

  { 155,   "regionwise_packing" },

  { 156,   "omni_viewport" },

  { 157,   "regional_nesting" },

  { 158,   "mcts_extraction_info_sets" },

  { 159,   "mcts_extraction_info_nesting" },

  { 160,   "layers_not_present" }, /* specified in Annex F */

  { 161,   "inter_layer_constrained_tile_sets" }, /* specified in Annex F */

  { 162,   "bsp_nesting" }, /* specified in Annex F */

  { 163,   "bsp_initial_arrival_time" }, /* specified in Annex F */

  { 164,   "sub_bitstream_property" }, /* specified in Annex F */

  { 165,   "alpha_channel_info" }, /* specified in Annex F */

  { 166,   "overlay_info" }, /* specified in Annex F */

  { 167,   "temporal_mv_prediction_constraints" }, /* specified in Annex F */

  { 168,   "frame_field_info" }, /* specified in Annex F */

  { 176,   "three_dimensional_reference_displays_info" }, /* specified in Annex G */

  { 177,   "depth_representation_info" }, /* specified in Annex G */

  { 178,   "multiview_scene_info" }, /* specified in Annex G */

  { 179,   "multiview_acquisition_info" }, /* specified in Annex G */

  { 180,   "multiview_view_position" }, /* specified in Annex G */

  { 181,   "alternative_depth_info" }, /* specified in Annex I */

  { 0, NULL }

};

/* Table 7-2 - Interpretation of pic_type */

static const value_string h265_pic_type_vals[] = {

  { 0,    "I" },

  { 1,    "P, I" },

  { 2,    "B, P, I" },

  { 0, NULL }

};

/* Ref 7.3.2.2 Sequence parameter set RBSP syntax

 * num_short_term_ref_pic_sets specifies the number of st_ref_pic_set( ) syntax structures included in the SPS. The value

 * of num_short_term_ref_pic_sets shall be in the range of 0 to 64, inclusive

 */

#define H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS 64

static int

dissect_h265(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_);

static int

dissect_h265_profile_tier_level(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int offset, bool profilePresentFlag, int vps_max_sub_layers_minus1);

static int

dissect_h265_hrd_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset, bool commonInfPresentFlag, unsigned maxNumSubLayersMinus1);

static int

dissect_h265_scaling_list_data(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_st_ref_pic_set(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, int stRpsIdx, int num_short_term_ref_pic_sets, int32_t NumDeltaPocs[H265_MAX_NUM_SHORT_TERM_REF_PIC_SETS]);

static int

dissect_h265_vui_parameters(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int bit_offset, uint8_t sps_max_sub_layers_minus1);

static int

dissect_h265_sps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_sps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_sps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_sps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, unsigned chroma_format_idc, unsigned bit_depth_luma_minus8, unsigned bit_depth_chroma_minus8);

static int

dissect_h265_pps_range_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, unsigned transform_skip_enabled_flag);

static int

dissect_h265_pps_scc_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_pps_multilayer_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_pps_3d_extension(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset);

static int

dissect_h265_sei_message(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, int bit_offset, uint8_t nal_unit_type);

#if 0

/* byte_aligned( ) is specified as follows.

* - If the current position in the bitstream is on a byte boundary, i.e.,

*   the next bit in the bitstream is the first bit in a byte,

*   the return value of byte_aligned( ) is equal to true.

* - Otherwise, the return value of byte_aligned( ) is equal to false.

*/

static bool

h265_byte_aligned(int bit_offset)

{

  if (bit_offset & 0x3)

    return false;

  return true;

}

/* more_data_in_payload( ) is specified as follows:

* - If byte_aligned( ) is equal to true and the current position in the sei_payload( ) syntax structure is

* 8 * payloadSize bits from the beginning of the sei_payload( ) syntax structure, the return value of

* more_data_in_payload( ) is equal to false.

* - Otherwise, the return value of more_data_in_payload( ) is equal to true.

*/

static bool

h265_more_data_in_payload(int bit_start, int bit_offset, int payloadSize)

{

  if (h265_byte_aligned(bit_offset) && bit_start + 8 * payloadSize == bit_offset)

    return false;

  return true;

}

/* payload_extension_present( ) is specified as follows:

* - If the current position in the sei_payload( ) syntax structure is not the position of the last (least significant, right-

* most) bit that is equal to 1 that is less than 8 * payloadSize bits from the beginning of the syntax structure (i.e.,

* the position of the payload_bit_equal_to_one syntax element), the return value of payload_extension_present( ) is equal to true.

* - Otherwise, the return value of payload_extension_present( )

* is equal to false.

*/

static bool

h265_payload_extension_present(tvbuff_t* tvb, int bit_start, int bit_offset, int payloadSize)

{

  if (bit_start + 8 * payloadSize > bit_offset && tvb_get_bits8(tvb, bit_offset, 1))

    return true;

  return false;

}

#endif

/* Expect a tvb and a bit offset into the tvb

* returns the value and bit_offset

*

* This supports 32 bit output values. If the exp-Golomb coded value overflows

* the 32 bit type, it will return the actual bit offset but clamp the value

* and add an expert info.

*/

#define cVALS(x) (const value_string*)(x)

static uint32_t

dissect_h265_exp_golomb_code(proto_tree *tree, int hf_index, tvbuff_t *tvb, packet_info *pinfo, int *start_bit_offset, h265_golomb_descriptors descriptor)

/*(tvbuff_t *tvb, int *start_bit_offset) */

{

  proto_item *ti;

  int      leading_zero_bits, bit_offset, start_offset;

  uint32_t codenum, mask, value, tmp;

  int32_t  se_value = 0;

  int      b;

  char    *str;

  int      bit;

  int      i;

  bool overflow = false;

  header_field_info *hf_field = NULL;

  start_offset = *start_bit_offset >> 3;

  if (hf_index > 0) {

    hf_field = proto_registrar_get_nth(hf_index);

  }

  if (hf_field) {

    /* Allow only int32_t for se(v), uint32_t for others. */

    switch (descriptor) {

    case H265_SE_V:

      DISSECTOR_ASSERT_FIELD_TYPE(hf_field, FT_INT32);

      break;

    default:

      DISSECTOR_ASSERT_FIELD_TYPE(hf_field, FT_UINT32);

      break;

    }

  }

  bit_offset = *start_bit_offset;

  /* prepare the string */

  str = (char *)wmem_alloc(pinfo->pool, 256);

  str[0] = '\0';

  for (bit = 0; bit<((int)(bit_offset & 0x07)); bit++) {

    if (bit && (!(bit % 4))) {

      (void) g_strlcat(str, " ", 256);

    }

    (void) g_strlcat(str, ".", 256);

  }

  leading_zero_bits = -1;

  for (b = 0; !b; leading_zero_bits++) {

    if (bit && (!(bit % 4))) {

      (void) g_strlcat(str, " ", 256);

    }

    if (bit && (!(bit % 8))) {

      (void) g_strlcat(str, " ", 256);

    }

    b = tvb_get_bits8(tvb, bit_offset, 1);

    if (b != 0) {

      (void) g_strlcat(str, "1", 256);

    }

    else {

      (void) g_strlcat(str, "0", 256);

    }

    bit++;

    bit_offset++;

  }

  /* XXX: This could be handled in the general case and reduce code

   * duplication.  */

  if (leading_zero_bits == 0) {

    codenum = 0;

    *start_bit_offset = bit_offset;

    for (; bit % 8; bit++) {

      if (bit && (!(bit % 4))) {

        (void) g_strlcat(str, " ", 256);

      }

      (void) g_strlcat(str, ".", 256);

    }

    if (hf_field) {

      (void) g_strlcat(str, " = ", 256);

      (void) g_strlcat(str, hf_field->name, 256);

      switch (descriptor) {

      case H265_SE_V:

        /* if the syntax element is coded as se(v),

        * the value of the syntax element is derived by invoking the

        * mapping process for signed Exp-Golomb codes as specified in

        * subclause 9.1.1 with codeNum as the input.

        */

        if (hf_field->type == FT_INT32) {

          if (hf_field->strings) {

            proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum,

              "%s: %s (%d)",

              str,

              val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "),

              codenum);

          }

          else {

            switch (hf_field->display) {

            case BASE_DEC:

              proto_tree_add_int_format(tree, hf_index, tvb, start_offset, 1, codenum,

                "%s: %d",

                str,

                codenum);

              break;

            default:

              DISSECTOR_ASSERT_NOT_REACHED();

              break;

            }

          }

        }

        return codenum;

      default:

        break;

      }

      if (hf_field->type == FT_UINT32) {

        if (hf_field->strings) {

          proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum,

            "%s: %s (%u)",

            str,

            val_to_str_const(codenum, cVALS(hf_field->strings), "Unknown "),

            codenum);

        }

        else {

          switch (hf_field->display) {

          case BASE_DEC:

            proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum,

              "%s: %u",

              str,

              codenum);

            break;

          case BASE_HEX:

            proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, 1, codenum,

              "%s: 0x%x",

              str,

              codenum);

            break;

          default:

            DISSECTOR_ASSERT_NOT_REACHED();

            break;

          }

        }

      }

      else {

        /* Only allow uint32_t */

        DISSECTOR_ASSERT_NOT_REACHED();

      }

    }

    return codenum;

  }

  /*

  Syntax elements coded as ue(v), me(v), or se(v) are Exp-Golomb-coded. Syntax elements coded as te(v) are truncated

  Exp-Golomb-coded. The parsing process for these syntax elements begins with reading the bits starting at the current

  location in the bitstream up to and including the first non-zero bit, and counting the number of leading bits that are

  equal to 0. This process is specified as follows:

  leadingZeroBits = -1;

  for (b = 0; !b; leadingZeroBits++)

  b = read_bits( 1 )

  The variable codeNum is then assigned as follows:

  codeNum = 2leadingZeroBits - 1 + read_bits( leadingZeroBits )

  where the value returned from read_bits( leadingZeroBits ) is interpreted as a binary representation of an unsigned

  integer with most significant bit written first.

  */

  if (leading_zero_bits > 32) {

    overflow = true;

    codenum = UINT32_MAX;

    if (descriptor == H265_SE_V) {

      /* For signed, must read the last bit to get the sign. */

      value = tvb_get_bits32(tvb, bit_offset + 32*(leading_zero_bits / 32), leading_zero_bits % 32, ENC_BIG_ENDIAN);

      if (value % 2) {

        se_value = INT32_MIN;

      } else {

        se_value = INT32_MAX;

      }

    }

  } else if (leading_zero_bits == 32) {

    value = tvb_get_bits32(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN);

    codenum = UINT32_MAX;

    /* One one value doesn't overflow a 32 bit integer, but they're

     * different for unsigned and signed (because codenum UINT32_MAX maps

     * to INT32_MAX + 1 and UINT32_MAX + 1 maps to INT32_MIN.) */

    if (descriptor == H265_SE_V) {

      if (value != 1) {

        overflow = true;

      }

      if (value % 2) {

        se_value = INT32_MIN;

      } else {

        se_value = INT32_MAX;

      }

    } else {

      if (value != 0) {

        overflow = true;

      }

    }

    mask = 1U << 31;

  } else { /* Non-overflow general case */

    if (leading_zero_bits > 16)

      value = tvb_get_bits32(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN);

    else if (leading_zero_bits > 8)

      value = tvb_get_bits16(tvb, bit_offset, leading_zero_bits, ENC_BIG_ENDIAN);

    else

      value = tvb_get_bits8(tvb, bit_offset, leading_zero_bits);

    codenum = 1;

    codenum = codenum << leading_zero_bits;

    mask = codenum >> 1;

    codenum = (codenum - 1) + value;

    if (descriptor == H265_SE_V) {

      /* if the syntax element is coded as se(v),

      * the value of the syntax element is derived by invoking the

      * mapping process for signed Exp-Golomb codes as specified in

      * subclause 9.1.1 with codeNum as the input.

      *      k+1

      * (-1)    Ceil( k/2 )

      */

      se_value = (codenum + 1) >> 1;

      if (!(codenum & 1)) {

        se_value = -se_value;

      }

    }

  }

  bit_offset = bit_offset + leading_zero_bits;

  if (overflow) {

    *start_bit_offset = bit_offset;

    /* We will probably get a BoundsError later in the packet. */

    if (descriptor == H265_SE_V) {

      ti = proto_tree_add_int_format_value(tree, hf_index, tvb, start_offset, (bit_offset >> 3) - start_offset + 1, codenum, "Invalid value (%d leading zero bits), clamped to %" PRId32, leading_zero_bits, se_value);

      expert_add_info(NULL, ti, &ei_h265_oversized_exp_golomb_code);

      return se_value;

    } else {

      ti = proto_tree_add_uint_format_value(tree, hf_index, tvb, start_offset, (bit_offset >> 3) - start_offset + 1, codenum, "Invalid value (%d leading zero bits), clamped to %" PRIu32, leading_zero_bits, codenum);

      expert_add_info(NULL, ti, &ei_h265_oversized_exp_golomb_code);

      return codenum;

    }

  }

  /* read the bits for the int */

  for (i = 0; i<leading_zero_bits; i++) {

    if (bit && (!(bit % 4))) {

      (void) g_strlcat(str, " ", 256);

    }

    if (bit && (!(bit % 8))) {

      (void) g_strlcat(str, " ", 256);

    }

    bit++;

    tmp = value & mask;

    if (tmp != 0) {

      (void) g_strlcat(str, "1", 256);

    }

    else {

      (void) g_strlcat(str, "0", 256);

    }

    mask = mask >> 1;

  }

  for (; bit % 8; bit++) {

    if (bit && (!(bit % 4))) {

      (void) g_strlcat(str, " ", 256);

    }

    (void) g_strlcat(str, ".", 256);