/* packet-h264.c

 * Routines for H.264 dissection

 * Copyright 2007 - 2009, Anders Broman <anders.broman[at]ericsson.com>

 *

 * 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/rfc3984      Obsolete

 * https://tools.ietf.org/html/rfc6184

 * https://tools.ietf.org/html/rfc6190

 * https://www.itu.int/rec/T-REC-H.264/en

 * MS-H264PF https://docs.microsoft.com/en-us/openspecs/office_protocols/ms-h264pf

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/asn1.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include <epan/tfs.h>

#include "packet-h264.h"

void proto_register_h264(void);

void proto_reg_handoff_h264(void);

/* Initialize the protocol and registered fields */

static int proto_h264;

static int hf_h264_type;

static int hf_h264_nal_f_bit;

static int hf_h264_nal_nri;

static int hf_h264_start_bit;

static int hf_h264_forbidden_bit;

static int hf_h264_end_bit;

static int hf_h264_profile;

static int hf_h264_profile_idc;

static int hf_h264_rbsp_stop_bit;

static int hf_h264_rbsp_trailing_bits;

static int hf_h264_constraint_set0_flag;

static int hf_h264_constraint_set1_flag;

static int hf_h264_constraint_set2_flag;

static int hf_h264_constraint_set3_flag;

static int hf_h264_constraint_set4_flag;

static int hf_h264_constraint_set5_flag;

static int hf_h264_reserved_zero_2bits;

static int hf_h264_level_idc;

static int hf_h264_nal_unit;

static int hf_h264_forbidden_zero_bit;

static int hf_h264_nal_ref_idc;

static int hf_h264_nal_unit_type;

static int hf_h264_seq_parameter_set_id;

static int hf_h264_chroma_format_idc;

static int hf_h264_residual_colour_transform_flag;

static int hf_h264_bit_depth_luma_minus8;

static int hf_h264_bit_depth_chroma_minus8;

static int hf_h264_qpprime_y_zero_transform_bypass_flag;

static int hf_h264_seq_scaling_matrix_present_flag;

static int hf_h264_seq_scaling_list_present_flag;

static int hf_h264_delta_scale;

static int hf_h264_log2_max_frame_num_minus4;

static int hf_h264_pic_order_cnt_type;

static int hf_h264_log2_max_pic_order_cnt_lsb_minus4;

static int hf_h264_delta_pic_order_always_zero_flag;

static int hf_h264_offset_for_non_ref_pic;

static int hf_h264_offset_for_top_to_bottom_field;

static int hf_h264_num_ref_frames_in_pic_order_cnt_cycle;

static int hf_h264_offset_for_ref_frame;

static int hf_h264_num_ref_frames;

static int hf_h264_gaps_in_frame_num_value_allowed_flag;

static int hf_h264_pic_width_in_mbs_minus1;

static int hf_h264_pic_height_in_map_units_minus1;

static int hf_h264_frame_mbs_only_flag;

static int hf_h264_mb_adaptive_frame_field_flag;

static int hf_h264_direct_8x8_inference_flag;

static int hf_h264_frame_cropping_flag;

static int hf_h264_frame_crop_left_offset;

static int hf_h264_frame_crop_right_offset;

static int hf_h264_frame_crop_top_offset;

static int hf_h264_frame_crop_bottom_offset;

static int hf_h264_vui_parameters_present_flag;

static int hf_h264_pic_parameter_set_id;

static int hf_h264_entropy_coding_mode_flag;

static int hf_h264_pic_order_present_flag;

static int hf_h264_num_slice_groups_minus1;

static int hf_h264_slice_group_map_type;

static int hf_h264_num_ref_idx_l0_active_minus1;

static int hf_h264_num_ref_idx_l1_active_minus1;

static int hf_h264_weighted_pred_flag;

static int hf_h264_weighted_bipred_idc;

static int hf_h264_pic_init_qp_minus26;

static int hf_h264_pic_init_qs_minus26;

static int hf_h264_chroma_qp_index_offset;

static int hf_h264_deblocking_filter_control_present_flag;

static int hf_h264_constrained_intra_pred_flag;

static int hf_h264_redundant_pic_cnt_present_flag;

static int hf_h264_transform_8x8_mode_flag;

static int hf_h264_pic_scaling_matrix_present_flag;

static int hf_h264_second_chroma_qp_index_offset;

static int hf_h264_primary_pic_type;

static int hf_h264_par_profile;

static int hf_h264_par_profile_b;

static int hf_h264_par_profile_m;

static int hf_h264_par_profile_e;

static int hf_h264_par_profile_h;

static int hf_h264_par_profile_h10;

static int hf_h264_par_profile_h4_2_2;

static int hf_h264_par_profile_h4_4_4;

/* static int hf_h264_par_add_mode_sup; */

static int hf_h264_par_AdditionalModesSupported;

static int hf_h264_par_add_mode_sup_rcdo;

static int hf_h264_par_ProfileIOP;

static int hf_h264_par_constraint_set0_flag;

static int hf_h264_par_constraint_set1_flag;

static int hf_h264_par_constraint_set2_flag;

/* Packetization Values */

static int hf_h264_nalu_size;

static int hf_h264_don;

static int hf_h264_dond;

static int hf_h264_ts_offset16;

static int hf_h264_ts_offset24;

/* Extension Header */

static int hf_h264_nal_extension_subtype;

static int hf_h264_nal_extension_j;

static int hf_h264_nal_extension_k;

static int hf_h264_nal_extension_l;

/* SEI Decoding Information */

static int hf_h264_sei_uuid;

/* Microsoft Layout SEI */

static int hf_h264_sei_ms_lpb;

static int hf_h264_sei_ms_layout_p;

static int hf_h264_sei_ms_layout_ldsize;

static int hf_h264_sei_ms_layer_desc_coded_width;

static int hf_h264_sei_ms_layer_desc_coded_height;

static int hf_h264_sei_ms_layer_desc_display_width;

static int hf_h264_sei_ms_layer_desc_display_height;

static int hf_h264_sei_ms_layer_desc_bitrate;

static int hf_h264_sei_ms_layer_desc_frame_rate;

static int hf_h264_sei_ms_layer_desc_layer_type;

static int hf_h264_sei_ms_layer_desc_prid;

static int hf_h264_sei_ms_layer_desc_cb;

/* Microsoft Bitstream SEI */

static int hf_h264_sei_ms_bitstream_ref_frame_cnt;

static int hf_h264_sei_ms_bitstream_num_nalus;

static int hf_h264_sei_iso_sec_info;

/* Microsoft Crop SEI */

static int hf_h264_sei_ms_crop_num_data;

static int hf_h264_sei_ms_crop_info_type;

static int hf_h264_sei_ms_crop_confidence_level;

static int hf_h264_sei_ms_crop_frame_left_offset;

static int hf_h264_sei_ms_crop_frame_right_offset;

static int hf_h264_sei_ms_crop_frame_top_offset;

static int hf_h264_sei_ms_crop_frame_bottom_offset;

/* SVC NAL Header Extension Values Annex G.7.3.1.1 */

static int hf_h264_nal_hdr_ext_svc;

static int hf_h264_nal_hdr_ext_i;

static int hf_h264_nal_hdr_ext_prid;

static int hf_h264_nal_hdr_ext_n;

static int hf_h264_nal_hdr_ext_did;

static int hf_h264_nal_hdr_ext_qid;

static int hf_h264_nal_hdr_ext_tid;

static int hf_h264_nal_hdr_ext_u;

static int hf_h264_nal_hdr_ext_d;

static int hf_h264_nal_hdr_ext_o;

static int hf_h264_nal_hdr_ext_rr;

/* PACSI Values */

static int hf_h264_pacsi_x;

static int hf_h264_pacsi_y;

static int hf_h264_pacsi_t;

static int hf_h264_pacsi_a;

static int hf_h264_pacsi_p;

static int hf_h264_pacsi_c;

static int hf_h264_pacsi_s;

static int hf_h264_pacsi_e;

static int hf_h264_pacsi_tl0picidx;

static int hf_h264_pacsi_idrpicid;

static int hf_h264_pacsi_donc;

/* VUI parameters */

static int hf_h264_aspect_ratio_info_present_flag;

static int hf_h264_aspect_ratio_idc;

static int hf_h264_sar_width;

static int hf_h264_sar_height;

static int hf_h264_overscan_info_present_flag;

static int hf_h264_overscan_appropriate_flag;

static int hf_h264_video_signal_type_present_flag;

static int hf_h264_video_format;

static int hf_h264_video_full_range_flag;

static int hf_h264_colour_description_present_flag;

static int hf_h264_colour_primaries;

static int hf_h264_transfer_characteristics;

static int hf_h264_matrix_coefficients;

static int hf_h264_chroma_loc_info_present_flag;

static int hf_h264_chroma_sample_loc_type_top_field;

static int hf_h264_chroma_sample_loc_type_bottom_field;

static int hf_h264_timing_info_present_flag;

static int hf_h264_num_units_in_tick;

static int hf_h264_time_scale;

static int hf_h264_fixed_frame_rate_flag;

static int hf_h264_nal_hrd_parameters_present_flag;

static int hf_h264_vcl_hrd_parameters_present_flag;

static int hf_h264_low_delay_hrd_flag;

static int hf_h264_pic_struct_present_flag;

static int hf_h264_bitstream_restriction_flag;

static int hf_h264_motion_vectors_over_pic_boundaries_flag;

static int hf_h264_max_bytes_per_pic_denom;

static int hf_h264_max_bits_per_mb_denom;

static int hf_h264_log2_max_mv_length_horizontal;

static int hf_h264_log2_max_mv_length_vertical;

static int hf_h264_num_reorder_frames;

static int hf_h264_max_dec_frame_buffering;

static int hf_h264_cpb_cnt_minus1;

static int hf_h264_bit_rate_scale;

static int hf_h264_cpb_size_scale;

static int hf_h264_bit_rate_value_minus1;

static int hf_h264_cpb_size_value_minus1;

static int hf_h264_cbr_flag;

static int hf_h264_initial_cpb_removal_delay_length_minus1;

static int hf_h264_cpb_removal_delay_length_minus1;

static int hf_h264_dpb_output_delay_length_minus11;

static int hf_h264_time_offset_length;

static int hf_h264_first_mb_in_slice;

static int hf_h264_slice_type;

static int hf_h264_slice_id;

static int hf_h264_payloadsize;

static int hf_h264_payloadtype;

/* static int hf_h264_frame_num; */

/* Initialize the subtree pointers */

static int ett_h264;

static int ett_h264_profile;

static int ett_h264_nal;

static int ett_h264_fua;

static int ett_h264_stream;

static int ett_h264_nal_unit;

static int ett_h264_par_profile;

static int ett_h264_par_AdditionalModesSupported;

static int ett_h264_par_ProfileIOP;

static int ett_h264_ms_layer_description;

static int ett_h264_ms_crop_data;

static int ett_h264_ni_mtap;

static expert_field ei_h264_undecoded;

static expert_field ei_h264_ms_layout_wrong_length;

static expert_field ei_h264_oversized_exp_golomb_code;

static expert_field ei_h264_bad_nal_length;

static expert_field ei_h264_nal_unit_type_reserved;

static expert_field ei_h264_nal_unit_type_unspecified;

static dissector_handle_t h264_name_handle;

static dissector_handle_t h264_handle;

/* syntax tables in subclause 7.3 is equal to

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

 */

typedef enum {

    H264_UE_V = 0,

    H264_ME_V = 1,

    H264_SE_V = 2,

    H264_TE_V = 3

} h264_golomb_descriptors;

static const true_false_string h264_f_bit_vals = {

  "Bit errors or other syntax violations",

  "No bit errors or other syntax violations"

};

static const true_false_string h264_start_bit_vals = {

  "the first packet of FU-A picture",

  "Not the first packet of FU-A picture"

};

static const true_false_string h264_end_bit_vals = {

  "the last packet of FU-A picture",

  "Not the last packet of FU-A picture"

};

#if 0

static const true_false_string h264_forbidden_bit_vals = {

  "Forbidden Bit of FU-A",

  "Not Forbidden Bit of FU-A"

};

#endif

#define H264_SEQ_PAR_SET        7

#define H264_PIC_PAR_SET        8

#define H264_PREFIX             14

#define H264_STAP_A             24

#define H264_STAP_B             25

#define H264_MTAP16             26

#define H264_MTAP24             27

#define H264_PACSI              30

#define H264_EXTENSION          31

static const value_string h264_type_values[] = {

    {  0,   "Undefined" },

    {  1,   "NAL unit - Coded slice of a non-IDR picture" },    /* Single NAL unit packet per H.264 */

    {  2,   "NAL unit - Coded slice data partition A" },

    {  3,   "NAL unit - Coded slice data partition B" },

    {  4,   "NAL unit - Coded slice data partition C" },

    {  5,   "NAL unit - Coded slice of an IDR picture" },

    {  6,   "NAL unit - Supplemental enhancement information (SEI)" },

    { H264_SEQ_PAR_SET, "NAL unit - Sequence parameter set" },              /* 7 */

    { H264_PIC_PAR_SET, "NAL unit - Picture parameter set" },               /* 8 */

    {  9,   "NAL unit - Access unit delimiter" },

    { 10,   "NAL unit - End of sequence" },

    { 11,   "NAL unit - End of stream" },

    { 12,   "NAL unit - Filler data" },

    { 13,   "NAL unit - Sequence parameter set extension" },

    { H264_PREFIX,   "NAL unit - Prefix" },

    { 15,   "NAL unit - Subset sequence parameter set" },

    { 16,   "NAL unit - Reserved" },

    { 17,   "NAL unit - Reserved" },

    { 18,   "NAL unit - Reserved" },

    { 19,   "NAL unit - Coded slice of an auxiliary coded picture without partitioning" },

    { 20,   "NAL unit - Coded slice extension" },

    { 21,   "NAL unit - Coded slice extension for depth view components" },

    { 22,   "NAL unit - Reserved" },

    { 23,   "NAL unit - Reserved" },

    { 24,   "Single-time aggregation packet A (STAP-A)" },

    { 25,   "Single-time aggregation packet B (STAP-B)" },

    { 26,   "Multi-time aggregation packet 16 (MTAP16)" },

    { 27,   "Multi-time aggregation packet 24 (MTAP24)" },

    { 28,   "Fragmentation unit A (FU-A)" },

    { 29,   "Fragmentation unit B (FU-B)" },

    { 30,   "NAL unit - Payload Content Scalability Information (PACSI)" },

    { 31,   "NAL unit - Extended NAL Header" },

    { 0,    NULL }

};

static const value_string h264_type_summary_values[] = {

    {  0,   "Undefined" },

    {  1,   "non-IDR-Slice" },    /* Single NAL unit packet per H.264 */

    {  2,   "Slice-A" },

    {  3,   "Slice-B" },

    {  4,   "Slice-C" },

    {  5,   "IDR-Slice" },

    {  6,   "SEI" },

    { H264_SEQ_PAR_SET, "SPS" },              /* 7 */

    { H264_PIC_PAR_SET, "PPS" },               /* 8 */

    {  9,   "Access-Delimiter" },

    { 10,   "End-of-Seq" },

    { 11,   "End-of-Stream" },

    { 12,   "Filler" },

    { 13,   "SPS-Ext" },

    { H264_PREFIX,   "Prefix" },

    { 15,   "Reserved" },

    { 16,   "Reserved" },

    { 17,   "Reserved" },

    { 18,   "Reserved" },

    { 19,   "Slice-Aux" },

    { 20,   "Slice-Ext" },

    { 21,   "Slice-Ext-Depth" },

    { 22,   "Reserved" },

    { 23,   "Reserved" },

    { 24,   "STAP-A" },

    { 25,   "STAP-B" },

    { 26,   "MTAP16" },

    { 27,   "MTAP24" },

    { 28,   "FU-A" },

    { 29,   "FU-B" },

    { 30,   "PACSI" },

    { 31,   "EXT" },

    { 0,    NULL }

};

/* Extension Subtype Strings RFC 6190 4.3 */

static const value_string h264_subtype_values[] = {

    {  0,   "Reserved" },

    {  1,   "NAL Unit - Empty" },

    {  2,   "Non-interleaved Multi-Time Aggregation Packet (NI-MTAP)" },

    { 0,    NULL }

};

static const value_string h264_subtype_summary_values[] = {

    {  0,   "Reserved" },

    {  1,   "Empty" },

    {  2,   "NI-MTAP" },

    { 0,    NULL }

};

/* A.2 Profiles */

static const value_string h264_profile_idc_values[] = {

    {  66,  "Baseline profile" },

    {  77,  "Main profile" },

    {  83,  "Scalable Baseline" },

    {  86,  "Scalable High" },

    {  88,  "Extended profile" },

    { 100,  "High profile" },

    { 110,  "High 10 profile" },

    { 118,  "Multi-view High" },

    { 122,  "High 4:2:2 profile" },

    { 128,  "Stereo High" },

    { 144,  "High 4:4:4 profile" },

    { 0,    NULL }

};

/* Table A-1 - Level limits */

static const value_string h264_level_bitrate_values[] = {

    { 10,   "64 kb/s" },

    { 11,   "192 kb/s" },

    { 12,   "384 kb/s" },

    { 13,   "768 kb/s" },

    { 20,   "2 Mb/s" },

    { 21,   "4 Mb/s" },

    { 22,   "4 Mb/s" },

    { 30,   "10 Mb/s" },

    { 31,   "14 Mb/s" },

    { 32,   "20 Mb/s" },

    { 40,   "20 Mb/s" },

    { 41,   "50 Mb/s" },

    { 42,   "50 Mb/s" },

    { 50,   "135 Mb/s" },

    { 51,   "240 Mb/s" },

    { 52,   "240 Mb/s" },

    { 0,    NULL }

};

static const value_string h264_nal_unit_type_vals[] = {

    {  0,   "Unspecified" },

    {  1,   "Coded slice of a non-IDR picture" },

    {  2,   "Coded slice data partition A" },

    {  3,   "Coded slice data partition B" },

    {  4,   "Coded slice data partition C" },

    {  5,   "Coded slice of an IDR picture" },

    {  6,   "Supplemental enhancement information (SEI)" },

    {  7,   "Sequence parameter set" },

    {  8,   "Picture parameter set" },

    {  9,   "Access unit delimiter" },

    { 10,   "End of sequence" },

    { 11,   "End of stream" },

    { 12,   "Filler data" },

    { 13,   "Sequence parameter set extension" },

    { 14,   "Prefix" },

    { 15,   "Subset sequence parameter set" },

    { 16,   "Reserved" },

    { 17,   "Reserved" },

    { 18,   "Reserved" },

    { 19,   "Coded slice of an auxiliary coded picture without partitioning" },

    { 20,   "Coded slice extension" },

    { 21,   "Coded slice extension for depth view components" },

    { 22,   "Reserved" },

    { 23,   "Reserved" },

    { 24,   "Unspecified" },

    { 25,   "Unspecified" },

    { 26,   "Unspecified" },

    { 27,   "Unspecified" },

    { 28,   "FU-A" },

    { 29,   "Unspecified" },

    { 30,   "Unspecified" },

    { 31,   "Unspecified" },

    { 0,    NULL }

};

static const value_string h264_slice_group_map_type_vals[] = {

    { 0,    "Interleaved slice groups" },

    { 1,    "Dispersed slice group mapping" },

    { 2,    "One or more foreground slice groups and a leftover slice group" },

    { 3,    "Changing slice groups" },

    { 4,    "Changing slice groups" },

    { 5,    "Changing slice groups" },

    { 6,    "Explicit assignment of a slice group to each slice group map unit" },

    { 0,    NULL }

};

/* Table 7-5 Meaning of primary_pic_type */

static const value_string h264_primary_pic_type_vals[] = {

    { 0,    "2, 7" },

    { 1,    "0, 2, 5, 7" },

    { 2,    "0, 1, 2, 5, 6, 7" },

    { 3,    "4, 9" },

    { 4,    "3, 4, 8, 9" },

    { 5,    "2, 4, 7, 9" },

    { 6,    "0, 2, 3, 4, 5, 7, 8, 9" },

    { 7,    "0, 1, 2, 3, 4, 5, 6, 7, 8, 9" },

    { 0,    NULL }

};

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

static const value_string h264_slice_type_vals[] = {

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

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

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

    { 3,    "SP (SP slice)" },

    { 4,    "SI (SI slice)" },

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

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

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

    { 8,    "SP (SP slice)" },

    { 9,    "SI (SI slice)" },

    { 0,    NULL }

};

/* Microsoft Frame per second index */

static const value_string h264_sei_ms_frame_values[] = {

    { 0,   "7.5 fps" },

    { 1,   "12.5 fps" },

    { 2,   "15 fps" },

    { 3,   "25 fps" },

    { 4,   "30 fps" },

    { 5,   "50 fps" },

    { 6,   "60 fps" },

    { 0,    NULL }

};

/* Microsoft UUIDs from MS-H264-PF */

#define MS_LAYOUT       0

#define MS_CROPPING     1

#define MS_BITSTREAM    2

static const e_guid_t ms_guids[3] = {

    { 0x139FB1A9, 0x446A, 0x4DEC, {0x8C, 0xBF, 0x65, 0xB1, 0xE1, 0x2D, 0x2C, 0xFD}},    /* Stream Layout */

    { 0xBB7FC1A0, 0x6986, 0x4052, {0x90, 0xF0, 0x09, 0x29, 0x21, 0x75, 0x39, 0xCF}},    /* Cropping Information*/

    { 0x05FBC6B9, 0x5A80, 0x40E5, {0xA2, 0x2A, 0xAB, 0x40, 0x20, 0x26, 0x7E, 0x26}}     /* Bitstream Information */

};

static int

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

/* 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

h264_byte_aligned(int bit_offset)

{

    if (bit_offset&0x3)

        return false;

    return true;

}

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

 * returns the value and bit_offset

 */

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

static uint32_t

dissect_h264_exp_golomb_code(proto_tree *tree, packet_info *pinfo, int hf_index, tvbuff_t *tvb, int *start_bit_offset, h264_golomb_descriptors descriptor)

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

{

    proto_item *ti;

    int      leading_zero_bits, bit_offset, start_offset, length;

    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) {

        switch (descriptor) {

        case H264_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++;

    }

    /*

    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 == H264_SE_V) {

            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;

        /* Only 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 == H264_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 if (leading_zero_bits == 0) {

        codenum = 0;

        if (descriptor == H264_SE_V) {

            se_value = 0;

        }

    } 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 = 1;

        codenum = codenum << leading_zero_bits;

        mask = codenum>>1;

        codenum = (codenum-1) + value;

        if (descriptor == H264_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 )

             */

            if (codenum & 1) {

                se_value = (codenum + 1) >> 1;

            } else {

                se_value = 0 - (codenum >> 1);

            }

        }

    }

    bit_offset = bit_offset + leading_zero_bits;

    length = ((bit_offset + 7) >> 3) - start_offset;

    if (overflow) {

        *start_bit_offset = bit_offset;

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

        if (descriptor == H264_SE_V) {

            ti = proto_tree_add_int_format_value(tree, hf_index, tvb, start_offset, length, codenum, "Invalid value (%d leading zero bits), clamped to %" PRId32, leading_zero_bits, se_value);

            expert_add_info(NULL, ti, &ei_h264_oversized_exp_golomb_code);

            return se_value;

        } else {

            ti = proto_tree_add_uint_format_value(tree, hf_index, tvb, start_offset, length, codenum, "Invalid value (%d leading zero bits), clamped to %" PRIu32, leading_zero_bits, codenum);

            expert_add_info(NULL, ti, &ei_h264_oversized_exp_golomb_code);

            return codenum;

        }

    }

    /* read the bits for the int */

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

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

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

        }

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

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

        }

        bit++;

        tmp = value & mask;

        if (tmp != 0) {

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

        } else {

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

        }

        mask = mask>>1;

    }

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

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

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

        }

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

    }

    if (hf_field) {

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

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

        switch (descriptor) {

        case H264_SE_V:

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

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

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

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

             * subclause 9.1.1 with codeNum as the input.

             */

            break;

        default:

        break;

        }

        if (descriptor == H264_UE_V) {

            if (hf_field->strings) {

                proto_tree_add_uint_format(tree, hf_index, tvb, start_offset, length, 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, length, codenum,

                             "%s: %u",

                              str,

                              codenum);

                        break;

                    case BASE_HEX:

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

                             "%s: 0x%x",

                              str,

                              codenum);

                        break;

                    default:

                        DISSECTOR_ASSERT_NOT_REACHED();

                        break;

                }

            }

        } else if (descriptor == H264_SE_V) {

            if (hf_field->strings) {

                proto_tree_add_int_format(tree, hf_index, tvb, start_offset, length, 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, length, codenum,

                             "%s: %d",

                              str,

                              se_value);

                        break;

                    default:

                        DISSECTOR_ASSERT_NOT_REACHED();

                        break;

                }

            }

            *start_bit_offset = bit_offset;

            return se_value;

        } else {

            DISSECTOR_ASSERT_NOT_REACHED();

        }

    }

    *start_bit_offset = bit_offset;

    return codenum;

}

/* This function is adapted to parsing NAL units from SDP data where the

 * base64 coding may add extra padding

 * Returns true if there is a non-zero bit in remaining of tvb (skipping the current bit)

 *         false if the rest of the tvb is zeros

 */

static bool

more_rbsp_data(proto_tree *tree _U_, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset)

{

    int    current_bit_offset;

    int    byte_offset;

    int    tvb_length;

    int    significant_bits_mask;

    int    i;

    uint8_t current_byte;

    /* XXX might not be the best way of doing things but:

     * Search in the tvb for the first '1' bit

     * assuming that it's the RTBSP stop bit or

     * some data representation

     */

    /*Skip current treating bit*/

    current_bit_offset = bit_offset + 1;

    /*Mask for non processed bits of the current byte*/

    significant_bits_mask = (1 << (8 - (current_bit_offset & 0x07))) - 1;

    /* Set offset to the byte we are treating */

    byte_offset = current_bit_offset >> 3;

    tvb_length = tvb_reported_length(tvb);

    for (i = byte_offset; i < tvb_length; i++) {

        current_byte = tvb_get_uint8(tvb, i);

        if ((current_byte & significant_bits_mask) != 0) {

            return true;

        }

        /* For the rest of bytes every bits are significant*/

        significant_bits_mask = 0xFF;

    }

    return false;

}

static int

dissect_h264_rbsp_trailing_bits(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, int bit_offset)

{

    int remaining_bits=0;

    proto_tree_add_bits_item(tree, hf_h264_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_h264_rbsp_trailing_bits, tvb, bit_offset, remaining_bits, ENC_BIG_ENDIAN);

    }

    return bit_offset+remaining_bits;

}

/*

 * 7.3.3 Slice header syntax

 * slice_header( )

 * XXX Just parse a few bytes

 */

static int

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

{

    /* first_mb_in_slice 2 ue(v) */

    dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_first_mb_in_slice, tvb, &bit_offset, H264_UE_V);

    /* slice_type 2 ue(v) */

    dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_slice_type, tvb, &bit_offset, H264_UE_V);

    /* pic_parameter_set_id 2 ue(v) */

    dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_pic_parameter_set_id, tvb, &bit_offset, H264_UE_V);

    /* frame_num 2 u(v) */

    /*

     * represented by log2_max_frame_num_minus4 + 4 bits in

     * the bitstream

     * proto_tree_add_bits_item(tree, hf_h264_frame_num, tvb, bit_offset, 4, ENC_BIG_ENDIAN);

     */

    return bit_offset;

}

/* 7.3.2.1.1 Scaling list syntax

 *

 * scaling_list( scalingList, sizeOfScalingList, useDefaultScalingMatrixFlag )

 */

static int

dissect_h264_scaling_list(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, int bit_offset, int* hf_index_scalinglist,

                          uint8_t sizeOfScalingList)

{

    uint8_t j;

    int32_t lastScale = 8;

    int32_t nextScale = 8;

    int32_t delta_scale;

    for (j = 0; j < sizeOfScalingList; j++) {

        if (nextScale != 0) {

            /* delta_scale 0 | 1 se(v) */

            delta_scale = dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_delta_scale, tvb, &bit_offset, H264_SE_V);

            /* 7.4.2.1.1.1 Scaling list semantics "The value of delta_scale

             * shall be in the range of −128 to +127, inclusive."

             */

            if (delta_scale > 127 || delta_scale < -128) {

                expert_add_info_format(pinfo, proto_tree_get_parent(tree), &ei_h264_oversized_exp_golomb_code, "The value of delta_scale shall be in the range -128 to +127, inclusive");

                delta_scale %= 256;

            }

            nextScale = ( lastScale + delta_scale + 256 ) % 256;

            /* hf_index_usedefaultscalingmatrixflag = ( j == 0 && nextScale == 0 ); */

        }

        hf_index_scalinglist[ j ] = ( nextScale == 0 ) ? lastScale : nextScale;

        lastScale = hf_index_scalinglist[ j ];

    }

    return bit_offset;

}

/* E.1.2 HRD parameters syntax */

static int

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

{

    uint8_t cpb_cnt_minus1;

    int    SchedSelIdx;

    /* cpb_cnt_minus1 0 ue(v) */

    cpb_cnt_minus1 = dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_cpb_cnt_minus1, tvb, &bit_offset, H264_UE_V);

    /* bit_rate_scale 0 u(4) */

    proto_tree_add_bits_item(tree, hf_h264_bit_rate_scale, tvb, bit_offset, 4, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 4;

    /* cpb_size_scale 0 u(4) */

    proto_tree_add_bits_item(tree, hf_h264_cpb_size_scale, tvb, bit_offset, 4, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 4;

    /* for (SchedSelIdx = 0; SchedSelIdx <= cpb_cnt_minus1; SchedSelIdx++) { */

    for (SchedSelIdx = 0; SchedSelIdx <= cpb_cnt_minus1; SchedSelIdx++) {

        /* bit_rate_value_minus1[ SchedSelIdx ] 0 ue(v) */

        dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_bit_rate_value_minus1, tvb, &bit_offset, H264_UE_V);

        /* cpb_size_value_minus1[ SchedSelIdx ] 0 ue(v)*/

        dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_cpb_size_value_minus1, tvb, &bit_offset, H264_UE_V);

        /* cbr_flag[ SchedSelIdx ] 0 u(1) */

        proto_tree_add_bits_item(tree, hf_h264_cbr_flag, tvb, bit_offset, 1, ENC_BIG_ENDIAN);

        bit_offset++;

    }

    /* initial_cpb_removal_delay_length_minus1 0 u(5) */

    proto_tree_add_bits_item(tree, hf_h264_initial_cpb_removal_delay_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 5;

    /* cpb_removal_delay_length_minus1 0 u(5) */

    proto_tree_add_bits_item(tree, hf_h264_cpb_removal_delay_length_minus1, tvb, bit_offset, 5, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 5;

    /* dpb_output_delay_length_minus1 0 u(5) */

    proto_tree_add_bits_item(tree, hf_h264_dpb_output_delay_length_minus11, tvb, bit_offset, 5, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 5;

    /* time_offset_length 0 u(5) */

    proto_tree_add_bits_item(tree, hf_h264_time_offset_length, tvb, bit_offset, 5, ENC_BIG_ENDIAN);

    bit_offset = bit_offset + 5;

    return bit_offset;

}

#define EXTENDED_SAR 255

/* E.1.1 VUI parameters syntax */

/* Table E-2 - Meaning of video_format */

static const value_string h264_video_format_vals[] = {

    { 22,   "reserved_sei_message)" },

    {  0,   "Component" },

    {  1,   "PAL" },

    {  2,   "NTSC" },

    {  3,   "SECAM" },

    {  4,   "MAC" },

    {  5,   "Unspecified video format" },

    {  6,   "Reserved" },

    {  7,   "Reserved" },

    { 0,    NULL }

};

static int

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

{

    uint8_t aspect_ratio_info_present_flag, aspect_ratio_idc, overscan_info_present_flag;

    uint8_t video_signal_type_present_flag, colour_description_present_flag, chroma_loc_info_present_flag;

    uint8_t timing_info_present_flag, nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;

    uint8_t bitstream_restriction_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_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_h264_matrix_coefficients, 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_h264_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_h264_exp_golomb_code(tree, pinfo, hf_h264_chroma_sample_loc_type_top_field, tvb, &bit_offset, H264_UE_V);

        /* chroma_sample_loc_type_bottom_field 0 ue(v) */

        dissect_h264_exp_golomb_code(tree, pinfo, hf_h264_chroma_sample_loc_type_bottom_field, tvb, &bit_offset, H264_UE_V);