Subversion Repositories bluespec-h264

/*!

 ************************************************************************

 *  \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);