URL
https://opencores.org/ocsvn/bluespec-h264/bluespec-h264/trunk
Subversion Repositories bluespec-h264
[/] [bluespec-h264/] [trunk/] [test/] [decoder/] [ldecod/] [inc/] [global.h] - Rev 14
Go to most recent revision | Compare with Previous | Blame | View Log
/*! ************************************************************************ * \file * global.h * \brief * global definitions for H.264 decoder. * \author * Copyright (C) 1999 Telenor Satellite Services,Norway * Ericsson Radio Systems, Sweden * * Inge Lille-Langoy <inge.lille-langoy@telenor.com> * * Telenor Satellite Services * Keysers gt.13 tel.: +47 23 13 86 98 * N-0130 Oslo,Norway fax.: +47 22 77 79 80 * * Rickard Sjoberg <rickard.sjoberg@era.ericsson.se> * * Ericsson Radio Systems * KI/ERA/T/VV * 164 80 Stockholm, Sweden * ************************************************************************ */ #ifndef _GLOBAL_H_ #define _GLOBAL_H_ #include <stdio.h> #include <stdarg.h> #include <time.h> #include <sys/timeb.h> #include "win32.h" #include "defines.h" #include "ifunctions.h" #include "parsetcommon.h" typedef unsigned char byte; //!< 8 bit unsigned typedef unsigned short imgpel; //!< Pixel type definition (16 bit for FRExt) //typedef unsigned char imgpel; //!< Pixel type definition (8 bit without FRExt) pic_parameter_set_rbsp_t *active_pps; seq_parameter_set_rbsp_t *active_sps; // global picture format dependent buffers, memory allocation in decod.c imgpel **imgY_ref; //!< reference frame find snr imgpel ***imgUV_ref; int **PicPos; int ReMapRef[20]; // B pictures int Bframe_ctr; int frame_no; int g_nFrame; // For MB level frame/field coding int TopFieldForSkip_Y[16][16]; int TopFieldForSkip_UV[2][16][16]; int InvLevelScale4x4Luma_Intra[6][4][4]; int InvLevelScale4x4Chroma_Intra[2][6][4][4]; int InvLevelScale4x4Luma_Inter[6][4][4]; int InvLevelScale4x4Chroma_Inter[2][6][4][4]; int InvLevelScale8x8Luma_Intra[6][8][8]; int InvLevelScale8x8Luma_Inter[6][8][8]; int *qmatrix[8]; #define ET_SIZE 300 //!< size of error text buffer char errortext[ET_SIZE]; //!< buffer for error message for exit with error() /*********************************************************************** * T y p e d e f i n i t i o n s f o r T M L *********************************************************************** */ //! Data Partitioning Modes typedef enum { PAR_DP_1, //!< no data partitioning is supported PAR_DP_3, //!< data partitioning with 3 partitions } PAR_DP_TYPE; //! Output File Types typedef enum { PAR_OF_ANNEXB, //!< Current TML description PAR_OF_RTP //!< RTP Packet Output format } PAR_OF_TYPE; //! definition of H.264 syntax elements typedef enum { SE_HEADER, SE_PTYPE, SE_MBTYPE, SE_REFFRAME, SE_INTRAPREDMODE, SE_MVD, SE_CBP_INTRA, SE_LUM_DC_INTRA, SE_CHR_DC_INTRA, SE_LUM_AC_INTRA, SE_CHR_AC_INTRA, SE_CBP_INTER, SE_LUM_DC_INTER, SE_CHR_DC_INTER, SE_LUM_AC_INTER, SE_CHR_AC_INTER, SE_DELTA_QUANT_INTER, SE_DELTA_QUANT_INTRA, SE_BFRAME, SE_EOS, SE_MAX_ELEMENTS //!< number of maximum syntax elements, this MUST be the last one! } SE_type; // substituting the definitions in element.h typedef enum { INTER_MB, INTRA_MB_4x4, INTRA_MB_16x16 } IntraInterDecision; typedef enum { BITS_TOTAL_MB, BITS_HEADER_MB, BITS_INTER_MB, BITS_CBP_MB, BITS_COEFF_Y_MB, BITS_COEFF_UV_MB, MAX_BITCOUNTER_MB } BitCountType; typedef enum { NO_SLICES, FIXED_MB, FIXED_RATE, CALLBACK, FMO } SliceMode; typedef enum { UVLC, CABAC } SymbolMode; typedef enum { LIST_0=0, LIST_1=1 } Lists; typedef enum { FRAME, TOP_FIELD, BOTTOM_FIELD } PictureStructure; //!< New enum for field processing typedef enum { P_SLICE = 0, B_SLICE, I_SLICE, SP_SLICE, SI_SLICE } SliceType; typedef enum { IS_LUMA = 0, IS_CHROMA = 1 } Component_Type; /*********************************************************************** * D a t a t y p e s f o r C A B A C *********************************************************************** */ //! struct to characterize the state of the arithmetic coding engine typedef struct { unsigned int Dlow, Drange; unsigned int Dvalue; unsigned int Dbuffer; int Dbits_to_go; byte *Dcodestrm; int *Dcodestrm_len; } DecodingEnvironment; typedef DecodingEnvironment *DecodingEnvironmentPtr; //! struct for context management typedef struct { unsigned short state; // index into state-table CP unsigned char MPS; // Least Probable Symbol 0/1 CP } BiContextType; typedef BiContextType *BiContextTypePtr; /********************************************************************** * C O N T E X T S F O R T M L S Y N T A X E L E M E N T S ********************************************************************** */ #define NUM_MB_TYPE_CTX 11 #define NUM_B8_TYPE_CTX 9 #define NUM_MV_RES_CTX 10 #define NUM_REF_NO_CTX 6 #define NUM_DELTA_QP_CTX 4 #define NUM_MB_AFF_CTX 4 #define NUM_TRANSFORM_SIZE_CTX 3 typedef struct { BiContextType mb_type_contexts [4][NUM_MB_TYPE_CTX]; BiContextType b8_type_contexts [2][NUM_B8_TYPE_CTX]; BiContextType mv_res_contexts [2][NUM_MV_RES_CTX]; BiContextType ref_no_contexts [2][NUM_REF_NO_CTX]; BiContextType delta_qp_contexts[NUM_DELTA_QP_CTX]; BiContextType mb_aff_contexts [NUM_MB_AFF_CTX]; BiContextType transform_size_contexts [NUM_TRANSFORM_SIZE_CTX]; } MotionInfoContexts; #define NUM_IPR_CTX 2 #define NUM_CIPR_CTX 4 #define NUM_CBP_CTX 4 #define NUM_BCBP_CTX 4 #define NUM_MAP_CTX 15 #define NUM_LAST_CTX 15 #define NUM_ONE_CTX 5 #define NUM_ABS_CTX 5 typedef struct { BiContextType ipr_contexts [NUM_IPR_CTX]; BiContextType cipr_contexts[NUM_CIPR_CTX]; BiContextType cbp_contexts [3][NUM_CBP_CTX]; BiContextType bcbp_contexts[NUM_BLOCK_TYPES][NUM_BCBP_CTX]; BiContextType map_contexts [NUM_BLOCK_TYPES][NUM_MAP_CTX]; BiContextType last_contexts[NUM_BLOCK_TYPES][NUM_LAST_CTX]; BiContextType one_contexts [NUM_BLOCK_TYPES][NUM_ONE_CTX]; BiContextType abs_contexts [NUM_BLOCK_TYPES][NUM_ABS_CTX]; BiContextType fld_map_contexts [NUM_BLOCK_TYPES][NUM_MAP_CTX]; BiContextType fld_last_contexts[NUM_BLOCK_TYPES][NUM_LAST_CTX]; } TextureInfoContexts; //*********************** end of data type definition for CABAC ******************* /*********************************************************************** * N e w D a t a t y p e s f o r T M L *********************************************************************** */ struct img_par; struct inp_par; struct stat_par; /*! Buffer structure for decoded referenc picture marking commands */ typedef struct DecRefPicMarking_s { 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; struct DecRefPicMarking_s *Next; } DecRefPicMarking_t; //! Syntaxelement typedef struct syntaxelement { int type; //!< type of syntax element for data part. int value1; //!< numerical value of syntax element int value2; //!< for blocked symbols, e.g. run/level int len; //!< length of code int inf; //!< info part of UVLC code unsigned int bitpattern; //!< UVLC bitpattern int context; //!< CABAC context int k; //!< CABAC context for coeff_count,uv #if TRACE #define TRACESTRING_SIZE 100 //!< size of trace string char tracestring[TRACESTRING_SIZE]; //!< trace string #endif //! for mapping of UVLC to syntaxElement void (*mapping)(int len, int info, int *value1, int *value2); //! used for CABAC: refers to actual coding method of each individual syntax element type void (*reading)(struct syntaxelement *, struct img_par *, DecodingEnvironmentPtr); } SyntaxElement; //! Macroblock typedef struct macroblock { int qp; //!< QP luma int qpc[2]; //!< QP chroma int slice_nr; int delta_quant; //!< for rate control struct macroblock *mb_available_up; //!< pointer to neighboring MB (CABAC) struct macroblock *mb_available_left; //!< pointer to neighboring MB (CABAC) // some storage of macroblock syntax elements for global access int mb_type; int mvd[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE][2]; //!< indices correspond to [forw,backw][block_y][block_x][x,y] int cbp; int64 cbp_blk ; int64 cbp_bits; int is_skip; int i16mode; char b8mode[4]; char b8pdir[4]; int ei_flag; int LFDisableIdc; int LFAlphaC0Offset; int LFBetaOffset; int c_ipred_mode; //!< chroma intra prediction mode int mb_field; int skip_flag; int mbAddrA, mbAddrB, mbAddrC, mbAddrD; int mbAvailA, mbAvailB, mbAvailC, mbAvailD; int luma_transform_size_8x8_flag; int NoMbPartLessThan8x8Flag; } Macroblock; //! Bitstream typedef struct { // CABAC Decoding int read_len; //!< actual position in the codebuffer, CABAC only int code_len; //!< overall codebuffer length, CABAC only // UVLC Decoding int frame_bitoffset; //!< actual position in the codebuffer, bit-oriented, UVLC only int bitstream_length; //!< over codebuffer lnegth, byte oriented, UVLC only // ErrorConcealment byte *streamBuffer; //!< actual codebuffer for read bytes int ei_flag; //!< error indication, 0: no error, else unspecified error } Bitstream; //! DataPartition typedef struct datapartition { Bitstream *bitstream; DecodingEnvironment de_cabac; int (*readSyntaxElement)(SyntaxElement *, struct img_par *, struct datapartition *); /*!< virtual function; actual method depends on chosen data partition and entropy coding method */ } DataPartition; //! Slice typedef struct { int ei_flag; //!< 0 if the partArr[0] contains valid information int qp; int slice_qp_delta; int picture_type; //!< picture type PictureStructure structure; //!< Identify picture structure type int start_mb_nr; //!< MUST be set by NAL even in case of ei_flag == 1 int max_part_nr; int dp_mode; //!< data partioning mode int next_header; // int last_mb_nr; //!< only valid when entropy coding == CABAC DataPartition *partArr; //!< array of partitions MotionInfoContexts *mot_ctx; //!< pointer to struct of context models for use in CABAC TextureInfoContexts *tex_ctx; //!< pointer to struct of context models for use in CABAC int ref_pic_list_reordering_flag_l0; int *reordering_of_pic_nums_idc_l0; int *abs_diff_pic_num_minus1_l0; int *long_term_pic_idx_l0; int ref_pic_list_reordering_flag_l1; int *reordering_of_pic_nums_idc_l1; int *abs_diff_pic_num_minus1_l1; int *long_term_pic_idx_l1; int (*readSlice)(struct img_par *, struct inp_par *); int LFDisableIdc; //!< Disable loop filter on slice int LFAlphaC0Offset; //!< Alpha and C0 offset for filtering slice int LFBetaOffset; //!< Beta offset for filtering slice int pic_parameter_set_id; //!<the ID of the picture parameter set the slice is reffering to } Slice; //****************************** ~DM *********************************** // image parameters typedef struct img_par { int number; //!< frame number unsigned int current_mb_nr; // bitstream order unsigned int num_dec_mb; int current_slice_nr; int *intra_block; int tr; //!< temporal reference, 8 bit, wrapps at 255 int qp; //!< quant for the current frame int qpsp; //!< quant for SP-picture predicted frame int sp_switch; //!< 1 for switching sp, 0 for normal sp int direct_spatial_mv_pred_flag; //!< 1 for Spatial Direct, 0 for Temporal int type; //!< image type INTER/INTRA int width; int height; int width_cr; //!< width chroma int width_cr_m1; //!< width chroma int height_cr; //!< height chroma int mb_y; int mb_x; int block_y; int pix_y; int pix_x; int pix_c_y; int block_x; int pix_c_x; int allrefzero; imgpel mpr[16][16]; //!< predicted block int mvscale[6][MAX_REFERENCE_PICTURES]; int m7[16][16]; //!< final 4x4 block. Extended to 16x16 for ABT int cof[4][12][4][4]; //!< correction coefficients from predicted int cofu[16]; byte **ipredmode; //!< prediction type [90][74] int *quad; int ***nz_coeff; int **siblock; int cod_counter; //!< Current count of number of skipped macroblocks in a row int newframe; int structure; //!< Identify picture structure type int pstruct_next_P; // B pictures Slice *currentSlice; //!< pointer to current Slice data struct Macroblock *mb_data; //!< array containing all MBs of a whole frame int subblock_x; int subblock_y; int is_intra_block; int is_v_block; // For MB level frame/field coding int MbaffFrameFlag; // for signalling to the neighbour logic that this is a deblocker call int DeblockCall; DecRefPicMarking_t *dec_ref_pic_marking_buffer; //!< stores the memory management control operations int num_ref_idx_l0_active; //!< number of forward reference int num_ref_idx_l1_active; //!< number of backward reference int slice_group_change_cycle; int redundant_pic_cnt; int explicit_B_prediction; unsigned int pre_frame_num; //!< store the frame_num in the last decoded slice. For detecting gap in frame_num. // End JVT-D101 // POC200301: from unsigned int to int int toppoc; //poc for this top field // POC200301 int bottompoc; //poc of bottom field of frame int framepoc; //poc of this frame // POC200301 unsigned int frame_num; //frame_num for this frame unsigned int field_pic_flag; unsigned int bottom_field_flag; //the following is for slice header syntax elements of poc // for poc mode 0. unsigned int pic_order_cnt_lsb; int delta_pic_order_cnt_bottom; // for poc mode 1. int delta_pic_order_cnt[3]; // //////////////////////// // for POC mode 0: signed int PrevPicOrderCntMsb; unsigned int PrevPicOrderCntLsb; signed int PicOrderCntMsb; // for POC mode 1: unsigned int AbsFrameNum; signed int ExpectedPicOrderCnt, PicOrderCntCycleCnt, FrameNumInPicOrderCntCycle; unsigned int PreviousFrameNum, FrameNumOffset; int ExpectedDeltaPerPicOrderCntCycle; int PreviousPOC, ThisPOC; int PreviousFrameNumOffset; // ///////////////////////// //weighted prediction unsigned int luma_log2_weight_denom; unsigned int chroma_log2_weight_denom; int ***wp_weight; // weight in [list][index][component] order int ***wp_offset; // offset in [list][index][component] order int ****wbp_weight; //weight in [list][fw_index][bw_index][component] order int wp_round_luma; int wp_round_chroma; unsigned int apply_weights; int idr_flag; int nal_reference_idc; //!< nal_reference_idc from NAL unit int idr_pic_id; int MaxFrameNum; unsigned int PicWidthInMbs; unsigned int PicHeightInMapUnits; unsigned int FrameHeightInMbs; unsigned int PicHeightInMbs; unsigned int PicSizeInMbs; unsigned int FrameSizeInMbs; unsigned int oldFrameSizeInMbs; int no_output_of_prior_pics_flag; int long_term_reference_flag; int adaptive_ref_pic_buffering_flag; int last_has_mmco_5; int last_pic_bottom_field; int model_number; // Fidelity Range Extensions Stuff int pic_unit_bitsize_on_disk; int bitdepth_luma; int bitdepth_chroma; int bitdepth_luma_qp_scale; int bitdepth_chroma_qp_scale; unsigned int dc_pred_value_luma; //!< luma value for DC prediction (depends on luma pel bit depth) unsigned int dc_pred_value_chroma; //!< chroma value for DC prediction (depends on chroma pel bit depth) int max_imgpel_value; //!< max value that one luma picture element (pixel) can take (depends on pic_unit_bitdepth) int max_imgpel_value_uv; //!< max value that one chroma picture element (pixel) can take (depends on pic_unit_bitdepth) int Transform8x8Mode; int profile_idc; int yuv_format; int lossless_qpprime_flag; int num_blk8x8_uv; int num_cdc_coeff; int mb_cr_size_x; int mb_cr_size_y; int mb_cr_size_x_blk; int mb_cr_size_y_blk; int mb_size[3][2]; //!< component macroblock dimensions int mb_size_blk[3][2]; //!< component macroblock dimensions int idr_psnr_number; int psnr_number; time_t ltime_start; // for time measurement time_t ltime_end; // for time measurement #ifdef WIN32 struct _timeb tstruct_start; struct _timeb tstruct_end; #else struct timeb tstruct_start; struct timeb tstruct_end; #endif // picture error concealment int last_ref_pic_poc; int ref_poc_gap; int poc_gap; int conceal_mode; int earlier_missing_poc; unsigned int frame_to_conceal; int IDR_concealment_flag; int conceal_slice_type; // random access point decoding int recovery_point; int recovery_point_found; int recovery_frame_cnt; int recovery_frame_num; int recovery_poc; } ImageParameters; extern ImageParameters *img; extern struct snr_par *snr; // signal to noise ratio parameters struct snr_par { int frame_ctr; float snr_y; //!< current Y SNR float snr_u; //!< current U SNR float snr_v; //!< current V SNR float snr_y1; //!< SNR Y(dB) first frame float snr_u1; //!< SNR U(dB) first frame float snr_v1; //!< SNR V(dB) first frame float snr_ya; //!< Average SNR Y(dB) remaining frames float snr_ua; //!< Average SNR U(dB) remaining frames float snr_va; //!< Average SNR V(dB) remaining frames float sse_y; //!< SSE Y float sse_u; //!< SSE U float sse_v; //!< SSE V float msse_y; //!< Average SSE Y float msse_u; //!< Average SSE U float msse_v; //!< Average SSE V }; time_t tot_time; // input parameters from configuration file struct inp_par { char infile[100]; //!< H.264 inputfile char outfile[100]; //!< Decoded YUV 4:2:0 output char reffile[100]; //!< Optional YUV 4:2:0 reference file for SNR measurement int FileFormat; //!< File format of the Input file, PAR_OF_ANNEXB or PAR_OF_RTP int ref_offset; int poc_scale; int write_uv; int silent; #ifdef _LEAKYBUCKET_ unsigned long R_decoder; //!< Decoder Rate in HRD Model unsigned long B_decoder; //!< Decoder Buffer size in HRD model unsigned long F_decoder; //!< Decoder Initial buffer fullness in HRD model char LeakyBucketParamFile[100]; //!< LeakyBucketParamFile #endif // picture error concealment int conceal_mode; int ref_poc_gap; int poc_gap; }; extern struct inp_par *input; typedef struct pix_pos { int available; int mb_addr; int x; int y; int pos_x; int pos_y; } PixelPos; typedef struct old_slice_par { unsigned field_pic_flag; unsigned bottom_field_flag; unsigned frame_num; int nal_ref_idc; unsigned pic_oder_cnt_lsb; int delta_pic_oder_cnt_bottom; int delta_pic_order_cnt[2]; int idr_flag; int idr_pic_id; int pps_id; } OldSliceParams; extern OldSliceParams old_slice; // files int p_out; //!< file descriptor to output YUV file //FILE *p_out2; //!< pointer to debug output YUV file int p_ref; //!< pointer to input original reference YUV file file FILE *p_log; //!< SNR file #if TRACE FILE *p_trace; #endif // Redundant slices unsigned int previous_frame_num; //!< frame number of previous slice int ref_flag[17]; //!< 0: i-th previous frame is incorrect //!< non-zero: i-th previous frame is correct int Is_primary_correct; //!< if primary frame is correct, 0: incorrect int Is_redundant_correct; //!< if redundant frame is correct, 0:incorrect int redundant_slice_ref_idx; //!< reference index of redundant slice void Error_tracking(void); // prototypes void init_conf(struct inp_par *inp, char *config_filename); void report(struct inp_par *inp, struct img_par *img, struct snr_par *snr); void init(struct img_par *img); void malloc_slice(struct inp_par *inp, struct img_par *img); void free_slice(struct inp_par *inp, struct img_par *img); int decode_one_frame(struct img_par *img,struct inp_par *inp, struct snr_par *snr); void init_picture(struct img_par *img, struct inp_par *inp); void exit_picture(); int read_new_slice(); void decode_one_slice(struct img_par *img,struct inp_par *inp); void start_macroblock(struct img_par *img,int CurrentMBInScanOrder); int read_one_macroblock(struct img_par *img,struct inp_par *inp); void read_ipred_modes(struct img_par *img,struct inp_par *inp); int decode_one_macroblock(struct img_par *img,struct inp_par *inp); Boolean exit_macroblock(struct img_par *img,struct inp_par *inp, int eos_bit); void decode_ipcm_mb(struct img_par *img); void readMotionInfoFromNAL (struct img_par *img,struct inp_par *inp); void readCBPandCoeffsFromNAL(struct img_par *img,struct inp_par *inp); void readIPCMcoeffsFromNAL(struct img_par *img, struct inp_par *inp, struct datapartition *dP); void readLumaCoeff8x8_CABAC (struct img_par *img,struct inp_par *inp, int b8); void itrans8x8(struct img_par *img, int ioff, int joff); void copyblock_sp(struct img_par *img,int block_x,int block_y); void itrans_sp_chroma(struct img_par *img,int ll); void itrans(struct img_par *img,int ioff,int joff,int i0,int j0, int chroma); void itrans_sp(struct img_par *img,int ioff,int joff,int i0,int j0); int intrapred(struct img_par *img,int ioff,int joff,int i4,int j4); void itrans_2(struct img_par *img); int intrapred_luma_16x16(struct img_par *img,int predmode); void intrapred_chroma(struct img_par *img, int uv); // SLICE function pointers int (*nal_startcode_follows) (struct img_par*, int ); // NAL functions TML/CABAC bitstream int uvlc_startcode_follows(struct img_par *img, int dummy); int cabac_startcode_follows(struct img_par *img, int eos_bit); void free_Partition(Bitstream *currStream); // ErrorConcealment void reset_ec_flags(); void error(char *text, int code); int is_new_picture(); void init_old_slice(); // dynamic mem allocation int init_global_buffers(); void free_global_buffers(); void frame_postprocessing(struct img_par *img, struct inp_par *inp); void field_postprocessing(struct img_par *img, struct inp_par *inp); int bottom_field_picture(struct img_par *img,struct inp_par *inp); void decode_slice(struct img_par *img,struct inp_par *inp, int current_header); int RBSPtoSODB(byte *streamBuffer, int last_byte_pos); int EBSPtoRBSP(byte *streamBuffer, int end_bytepos, int begin_bytepos); // For MB level frame/field coding void init_super_macroblock(struct img_par *img,struct inp_par *inp); void exit_super_macroblock(struct img_par *img,struct inp_par *inp); int decode_super_macroblock(struct img_par *img,struct inp_par *inp); void decode_one_Copy_topMB(struct img_par *img,struct inp_par *inp); void SetOneRefMV(struct img_par* img); int peekSyntaxElement_UVLC(SyntaxElement *sym, struct img_par *img, struct datapartition *dP); void fill_wp_params(struct img_par *img); void reset_wp_params(struct img_par *img); void FreePartition (DataPartition *dp, int n); DataPartition *AllocPartition(); void tracebits2(const char *trace_str, int len, int info); void init_decoding_engine_IPCM(struct img_par *img); void readIPCMBytes_CABAC(SyntaxElement *sym, Bitstream *currStream); unsigned CeilLog2( unsigned uiVal); // For Q-matrix void AssignQuantParam(pic_parameter_set_rbsp_t* pps, seq_parameter_set_rbsp_t* sps); void CalculateQuantParam(void); void CalculateQuant8Param(void); #endif
Go to most recent revision | Compare with Previous | Blame | View Log