h264_stream.h

Go to the documentation of this file.

/* 
 * h264bitstream - a library for reading and writing H.264 video
 * Copyright (C) 2005-2006 Auroras Entertainment, LLC
 * 
 * Written by Alex Izvorski <aizvorski@gmail.com>
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdint.h>

#ifndef _H264_STREAM_H
#define _H264_STREAM_H        1

#include "bs.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct
{
        int profile_idc;
        int constraint_set0_flag;
        int constraint_set1_flag;
        int constraint_set2_flag;
        int constraint_set3_flag;
        int reserved_zero_4bits;
        int level_idc;
        int seq_parameter_set_id;
        int chroma_format_idc;
        int residual_colour_transform_flag;
        int bit_depth_luma_minus8;
        int bit_depth_chroma_minus8;
        int qpprime_y_zero_transform_bypass_flag;
        int seq_scaling_matrix_present_flag;
          int seq_scaling_list_present_flag[8];
          int* ScalingList4x4[6];
          int UseDefaultScalingMatrix4x4Flag[6];
          int* ScalingList8x8[2];
          int UseDefaultScalingMatrix8x8Flag[2];
        int log2_max_frame_num_minus4;
        int pic_order_cnt_type;
          int log2_max_pic_order_cnt_lsb_minus4;
          int delta_pic_order_always_zero_flag;
          int offset_for_non_ref_pic;
          int offset_for_top_to_bottom_field;
          int num_ref_frames_in_pic_order_cnt_cycle;
          int offset_for_ref_frame[256];
        int num_ref_frames;
        int gaps_in_frame_num_value_allowed_flag;
        int pic_width_in_mbs_minus1;
        int pic_height_in_map_units_minus1;
        int frame_mbs_only_flag;
        int mb_adaptive_frame_field_flag;
        int direct_8x8_inference_flag;
        int frame_cropping_flag;
          int frame_crop_left_offset;
          int frame_crop_right_offset;
          int frame_crop_top_offset;
          int frame_crop_bottom_offset;
        int vui_parameters_present_flag;
        
        struct
        {
                int aspect_ratio_info_present_flag;
                  int aspect_ratio_idc;
                    int sar_width;
                    int sar_height;
                int overscan_info_present_flag;
                  int overscan_appropriate_flag;
                int video_signal_type_present_flag;
                  int video_format;
                  int video_full_range_flag;
                  int colour_description_present_flag;
                    int colour_primaries;
                        int transfer_characteristics;
                        int matrix_coefficients;
                int chroma_loc_info_present_flag;
                  int chroma_sample_loc_type_top_field;
                  int chroma_sample_loc_type_bottom_field;
                int timing_info_present_flag;
                  int num_units_in_tick;
                  int time_scale;
                  int fixed_frame_rate_flag;
                int nal_hrd_parameters_present_flag;
                int vcl_hrd_parameters_present_flag;
                  int low_delay_hrd_flag;
                int pic_struct_present_flag;
                int bitstream_restriction_flag;
                  int motion_vectors_over_pic_boundaries_flag;
                  int max_bytes_per_pic_denom;
                  int max_bits_per_mb_denom;
                  int log2_max_mv_length_horizontal;
                  int log2_max_mv_length_vertical;
                  int num_reorder_frames;
                  int max_dec_frame_buffering;
        } vui;

        struct
        {
                int cpb_cnt_minus1;
                int bit_rate_scale;
                int cpb_size_scale;
                  int bit_rate_value_minus1[32]; // up to cpb_cnt_minus1, which is <= 31
                  int cpb_size_value_minus1[32];
                  int cbr_flag[32];
                int initial_cpb_removal_delay_length_minus1;
                int cpb_removal_delay_length_minus1;
                int dpb_output_delay_length_minus1;
                int time_offset_length;
        } hrd;

} sps_t;


typedef struct 
{
        int pic_parameter_set_id;
        int seq_parameter_set_id;
        int entropy_coding_mode_flag;
        int pic_order_present_flag;
        int num_slice_groups_minus1;
        int slice_group_map_type;
          int run_length_minus1[8]; // up to num_slice_groups_minus1, which is <= 7 in Baseline and Extended, 0 otheriwse
          int top_left[8];
          int bottom_right[8];
          int slice_group_change_direction_flag;
          int slice_group_change_rate_minus1;
          int pic_size_in_map_units_minus1;
          int slice_group_id[256]; // FIXME what size?
        int num_ref_idx_l0_active_minus1;
        int num_ref_idx_l1_active_minus1;
        int weighted_pred_flag;
        int weighted_bipred_idc;
        int pic_init_qp_minus26;
        int pic_init_qs_minus26;
        int chroma_qp_index_offset;
        int deblocking_filter_control_present_flag;
        int constrained_intra_pred_flag;
        int redundant_pic_cnt_present_flag;
        int transform_8x8_mode_flag;
        int pic_scaling_matrix_present_flag;
          int pic_scaling_list_present_flag[8];
          int* ScalingList4x4[6];
          int UseDefaultScalingMatrix4x4Flag[6];
          int* ScalingList8x8[2];
          int UseDefaultScalingMatrix8x8Flag[2];
        int second_chroma_qp_index_offset;
} pps_t;


typedef struct
{
        int first_mb_in_slice;
        int slice_type;
        int pic_parameter_set_id;
        int frame_num;
        int field_pic_flag;
          int bottom_field_flag;
        int idr_pic_id;
        int pic_order_cnt_lsb;
        int delta_pic_order_cnt_bottom;
        int delta_pic_order_cnt[ 2 ];
        int redundant_pic_cnt;
        int direct_spatial_mv_pred_flag;
        int num_ref_idx_active_override_flag;
        int num_ref_idx_l0_active_minus1;
        int num_ref_idx_l1_active_minus1;
        int cabac_init_idc;
        int slice_qp_delta;
        int sp_for_switch_flag;
        int slice_qs_delta;
        int disable_deblocking_filter_idc;
        int slice_alpha_c0_offset_div2;
        int slice_beta_offset_div2;
        int slice_group_change_cycle;


        struct
        {
                int luma_log2_weight_denom;
                int chroma_log2_weight_denom;
                int luma_weight_l0_flag;
                int luma_weight_l0[64];
                int luma_offset_l0[64];
                int chroma_weight_l0_flag;
                int chroma_weight_l0[64][2];
                int chroma_offset_l0[64][2];
                int luma_weight_l1_flag;
                int luma_weight_l1[64];
                int luma_offset_l1[64];
                int chroma_weight_l1_flag;
                int chroma_weight_l1[64][2];
                int chroma_offset_l1[64][2];
        } pwt; // predictive weight table

        struct // FIXME stack or array
        {
                int ref_pic_list_reordering_flag_l0;
                int ref_pic_list_reordering_flag_l1;
                int reordering_of_pic_nums_idc;
                int abs_diff_pic_num_minus1;
                int long_term_pic_num;
        } rplr; // ref pic list reorder

        struct // FIXME stack or array
        {
                int no_output_of_prior_pics_flag;
                int long_term_reference_flag;
                int adaptive_ref_pic_marking_mode_flag;
                int memory_management_control_operation;
                int difference_of_pic_nums_minus1;
                int long_term_pic_num;
                int long_term_frame_idx;
                int max_long_term_frame_idx_plus1;
        } drpm; // decoded ref pic marking

} slice_header_t;


typedef struct
{
        int forbidden_zero_bit;
        int nal_ref_idc;
        int nal_unit_type;
        //uint8_t* rbsp_buf;
        //int rbsp_size;
} nal_t;


typedef struct
{
        nal_t* nal;
        sps_t* sps;
        pps_t* pps;
        slice_header_t* sh;
} h264_stream_t;


int find_nal_unit(uint8_t* buf, int size, int* nal_start, int* nal_end);

int read_nal_unit(h264_stream_t* h, uint8_t* buf, int size);

void read_pic_parameter_set_rbsp(h264_stream_t* h, bs_t* b);

void read_access_unit_delimiter_rbsp(h264_stream_t* h, bs_t* b);
void read_end_of_seq_rbsp(h264_stream_t* h, bs_t* b);
void read_end_of_stream_rbsp(h264_stream_t* h, bs_t* b);
void read_filler_data_rbsp(h264_stream_t* h, bs_t* b);
void read_slice_layer_rbsp(h264_stream_t* h, bs_t* b);
void read_rbsp_slice_trailing_bits(h264_stream_t* h, bs_t* b);

void read_rbsp_trailing_bits(h264_stream_t* h, bs_t* b);

void read_slice_header(h264_stream_t* h, bs_t* b);
void read_ref_pic_list_reordering(h264_stream_t* h, bs_t* b);
void read_pred_weight_table(h264_stream_t* h, bs_t* b);
void read_dec_ref_pic_marking(h264_stream_t* h, bs_t* b);

void read_seq_parameter_set_rbsp(h264_stream_t* h, bs_t* b);
void read_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int useDefaultScalingMatrixFlag );
void read_vui_parameters(h264_stream_t* h, bs_t* b);
void read_hrd_parameters(h264_stream_t* h, bs_t* b);

int more_rbsp_trailing_data(h264_stream_t* h, bs_t* b);


int write_nal_unit(h264_stream_t* h, uint8_t* buf, int size);
void write_seq_parameter_set_rbsp(h264_stream_t* h, bs_t* b);
void write_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int useDefaultScalingMatrixFlag );
void write_vui_parameters(h264_stream_t* h, bs_t* b);
void write_hrd_parameters(h264_stream_t* h, bs_t* b);
void write_pic_parameter_set_rbsp(h264_stream_t* h, bs_t* b);
void write_access_unit_delimiter_rbsp(h264_stream_t* h, bs_t* b);
void write_end_of_seq_rbsp(h264_stream_t* h, bs_t* b);
void write_end_of_stream_rbsp(h264_stream_t* h, bs_t* b);
void write_filler_data_rbsp(h264_stream_t* h, bs_t* b);
void write_slice_layer_rbsp(h264_stream_t* h, bs_t* b);
void write_rbsp_slice_trailing_bits(h264_stream_t* h, bs_t* b);
void write_rbsp_trailing_bits(h264_stream_t* h, bs_t* b);
void write_slice_header(h264_stream_t* h, bs_t* b);
void write_ref_pic_list_reordering(h264_stream_t* h, bs_t* b);
void write_pred_weight_table(h264_stream_t* h, bs_t* b);
void write_dec_ref_pic_marking(h264_stream_t* h, bs_t* b);


void debug_sps(sps_t* sps);
void debug_pps(pps_t* pps);
void debug_slice_header(slice_header_t* sh);
void debug_nal(h264_stream_t* h, nal_t* nal);

void debug_bytes(uint8_t* buf, int len);
void debug_bs(bs_t* b);

//Table 7-1 NAL unit type codes
#define NAL_UNIT_TYPE_UNSPECIFIED                    0    // Unspecified
#define NAL_UNIT_TYPE_CODED_SLICE_NON_IDR            1    // Coded slice of a non-IDR picture
#define NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_A   2    // Coded slice data partition A
#define NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_B   3    // Coded slice data partition B
#define NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_C   4    // Coded slice data partition C
#define NAL_UNIT_TYPE_CODED_SLICE_IDR                5    // Coded slice of an IDR picture
#define NAL_UNIT_TYPE_SEI                            6    // Supplemental enhancement information (SEI)
#define NAL_UNIT_TYPE_SPS                            7    // Sequence parameter set
#define NAL_UNIT_TYPE_PPS                            8    // Picture parameter set
#define NAL_UNIT_TYPE_AUD                            9    // Access unit delimiter
#define NAL_UNIT_TYPE_END_OF_SEQUENCE               10    // End of sequence
#define NAL_UNIT_TYPE_END_OF_STREAM                 11    // End of stream
#define NAL_UNIT_TYPE_FILLER                        12    // Filler data
#define NAL_UNIT_TYPE_SPS_EXT                       13    // Sequence parameter set extension
                                             // 14..18    // Reserved
#define NAL_UNIT_TYPE_CODED_SLICE_AUX               19    // Coded slice of an auxiliary coded picture without partitioning
                                             // 20..23    // Reserved
                                             // 24..31    // Unspecified

//7.4.3 Table 7-6. Name association to slice_type
#define SH_SLICE_TYPE_P        0        // P (P slice)
#define SH_SLICE_TYPE_B        1        // B (B slice)
#define SH_SLICE_TYPE_I        2        // I (I slice)
#define SH_SLICE_TYPE_SP       3        // SP (SP slice)
#define SH_SLICE_TYPE_SI       4        // SI (SI slice)
#define SH_SLICE_TYPE_P_ALT    5        // P (P slice)
#define SH_SLICE_TYPE_B_ALT    6        // B (B slice)
#define SH_SLICE_TYPE_I_ALT    7        // I (I slice)
#define SH_SLICE_TYPE_SP_ALT   8        // SP (SP slice)
#define SH_SLICE_TYPE_SI_ALT   9        // SI (SI slice)

//Appendix E. Table E-1  Meaning of sample aspect ratio indicator
#define SAR_Unspecified  0           // Unspecified
#define SAR_1_1        1             //  1:1
#define SAR_12_11      2             // 12:11
#define SAR_10_11      3             // 10:11
#define SAR_16_11      4             // 16:11
#define SAR_40_33      5             // 40:33
#define SAR_24_11      6             // 24:11
#define SAR_20_11      7             // 20:11
#define SAR_32_11      8             // 32:11
#define SAR_80_33      9             // 80:33
#define SAR_18_11     10             // 18:11
#define SAR_15_11     11             // 15:11
#define SAR_64_33     12             // 64:33
#define SAR_160_99    13             // 160:99
                                     // 14..254           Reserved
#define SAR_Extended      255        // Extended_SAR




#ifdef __cplusplus
}
#endif

#endif

---