global.h

davinci avs.......................................................

  /* global loopfilter indicator -- zhan ma */
  int loop_filter_disable_flag;
  int loop_filter_parameter_flag;
  int loop_filter_alpha_ci_offset;
  int loop_filter_cp_offset;
  int loop_filter_qp_offset;

  /* interpolation accuracy in P frames */
  int half_pixel_mv_flag;  
  
  int constrained_intra_pred_flag;
  int skip_mode_flag;
  int delta_time_picture_distance_1;

#ifdef _HRD_
  int picture_distance;
  int picture_distance_gap_minus1;
#endif //! _HRD_

  seq_parameter_set *sps;	    //!<SPS
  pic_parameter_set *pps;    //!<PPS

  /* optinoal switch for non-reference frame selections */
  int skip_img_flag;                /* simulate  a lower-end decoder that can only decode video with low frame rate */

} Image;


/* added for future decoder structure adjustment -- zhan ma */
typedef struct {
  int slice_nr;
  int fisrt_mb_nr;

  int loop_filter_disable_flag;
  int loop_filter_parameter_flag;
  int loop_filter_alpha_ci_offset;
  int loop_filter_cp_offset;
  int loop_filter_qp_offset; 

} Slice;

//! Signal to Noice ratio parameters
struct snr_par
{
  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
#ifdef _PSNR_YUV_
  float snr_yuv;
  float snr_yuva;
#endif // _PSNR_YUV_
} ;//SNR;


//!< input parameters from configuration file
struct inp_par
{
  char infile[100];                       //<! input file
  char outfile[100];                      //<! Decoded YUV 4:2:0 output
  char reffile[100];                      //<! Optional YUV 4:2:0 reference file for SNR measurement
  
#ifdef _HRD_
  unsigned int R_decoder;                //<! Decoder Rate in HRD Model
  unsigned int B_decoder;                //<! Decoder Buffer size in HRD model
  unsigned int F_decoder;                //<! Decoder Inital buffer fullness in HRD model
  char LeakyBucketParamFile[100];         //<! LeakyBucketParamFile
#endif // _HRD_
} ;//Input;




#define SVA_STREAM_BUF_SIZE 1024
typedef struct {
	unsigned char	buf[SVA_STREAM_BUF_SIZE];	//流缓冲区,size must be large than 3 bytes
	unsigned int	uClearBits;					//不含填充位的位缓冲，32位，初始值是0xFFFFFFFF
	unsigned int	uPre3Bytes;					//  含填充位的位缓冲，32位，初始值是0x00000000
	         int	iBytePosition;							//当前字节位置
	         int	iBufBytesNum;							//最近一次读入缓冲区的字节数
	         int	iClearBitsNum;							//不含填充位的位的个数
	         int	iStuffBitsNum;							//已剔除的填充位的个数，遇到开始码时置0
	         int iBitsCount;								//码流总位数
} InputStream;

typedef struct 
{
           int startcodeprefix_len;
	unsigned int len;                 //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)
	         int nal_unit_type;            //! NALU_TYPE_xxxx
	         int nal_reference_idc;        //! NALU_PRIORITY_xxxx
	         int forbidden_bit;            //! should be always FALSE
	unsigned char *buf;        //! conjtains the first byte followed by the EBSP
} NALU_t;


/* stat parameter struct for global bitstream conformance check -- zhan ma*/
typedef struct
{
  /* sequence-level statistics */
  int tot_frame_number;
  int img_height;
  int img_width;
  int delta_time_picture_distance_1;
  int frame_skip;
  int ref_frame_number;
  int frame_cropping_flag;

  /* image-level statistics */
  int picture_reference_flag;
  int skip_mode_flag;
  int loop_filter_disable_flag;
  int loop_filter_parameter_flag;
  int constrained_intra_pred_flag;
  int half_pixel_mv_flag;
  
  int alpha_ci_offset;
  int cp_offset;
  int loop_fiter_qp_offset;

  /* macroblock-level statistics */
  int mb_type[6];
  int intra_luma_pred_mode[9];
  int intra_chroma_pred_mode[3];
  int max_mv[2],min_mv[2];

} StatParameter;
/*
**********************************************************************
* G l o b a l S t r u c t u r e D e f i n i t i o n
**********************************************************************
*/
extern seq_parameter_set *sps,*sps_buf[16];	    //!<SPS
extern pic_parameter_set *pps,*pps_buf[128];    //!<PPS
extern picture_header *picture_header_rbsp; //!Picture Header
extern NALU_t *nalu;

extern struct inp_par   *input;			//!< input parameters from input configuration file
extern struct snr_par   *snr;				//!< statistics
extern struct img_par   *pgImage;         //!< image parameters

extern Bitstream *currStream;
extern Macroblock *mb_data;  
extern Macroblock *pgcurrMB;
extern StatParameter *stat_parameter;

extern int tot_time;  //!< decoding lasting time statistics


// files
extern FILE *p_out;                    //<! pointer to output YUV file
extern FILE *p_ref;                    //<! pointer to input original reference YUV file file
extern FILE *p_log;                    //<! SNR file
extern FILE *reffile;                  //<! Refence YUV

#if ERR_REPORT
extern FILE *p_err;
#endif

/*！
**********************************************************************
*  P r o t o t y p e s  f o r  g lo b a l  f u n c t i o n 
**********************************************************************
*/

void init_decoder(char *config_file);          //!< AVS-M Decoder Initialization
void read_configfile(char *config_filename);  //!< Decoding Parameter readin and mapping
void release_decoder();

void DeblockFrame(byte **imgY , byte ***imgUV );

void report_picture(int time_pic);
void report_seq(struct snr_par *snr);
void find_snr(struct snr_par *snr, FILE *p_ref);
//void init();

int GetAnnexbNALU();
void CloseAnnexbFile();
void OpenAnnexbFile(char *fn);
void DecodeTrailingBits(Bitstream *bitstream);
void DecodeTrailingBits1(Bitstream *bitstream,int bitstream_length);  //!< temporary

int NALUtoRBSP (NALU_t *nalu);
int EBSPtoRBSP(byte *streamBuffer, int end_bytepos, int begin_bytepos);
int  decode_one_picture(struct snr_par *snr);
void init_frame();
void write_frame(FILE *p_out);
void decode_picture_data();
void decode_slice_header();
void decode_slice_data();

void start_macroblock();
int  read_one_macroblock();
int  decode_one_macroblock();
//int  sign(int a , int b);
Bitstream *AllocBitstream();

// Direct interpolation
void get_block(int x_pos, int y_pos, int block[4][4], unsigned char **ref_pic);//,unsigned char **ref_pic);
void CheckAvailabilityOfNeighbors();
// error printout
void error(char *text, int code);

// dynamic mem allocation
int  init_global_buffers();
void free_global_buffers();
void Update_Picture_Buffers();
void FreeBitstream();

#if TRACE
/* trace out bitstream parseting statistics -- zhan ma */
void tracebits(const char *trace_str,  //!< tracing information, char array describing the symbol
							 int len,                //!< length of syntax element in bits
							 int info,               //!< infoword of syntax element
							 int value1);

void tracebits2(const char *trace_str, int len, int info);
void tracebits3(const char *trace_str, int len,	int info,  int value1);
void trace_frame(FILE* p_trace,int img_width,int img_height,byte **img_luma, byte ***img_chroma);
void trace_mb_data(Macroblock *curMb);
void trace_mboverhead(Macroblock *curMb);
#endif

/* Error Handle Function Prototype -- Zhan Ma */
void CheckNALUValid(unsigned char nalu_header,FILE *error_file);
void CheckSPSValid(seq_parameter_set *SeqParaSet);
void CheckPPSValid(pic_parameter_set *PicParaSet);
void CheckHCoeffValid(int MbNr,int b8, int b4, int HCoeff);
void CheckDCTCoeffValid(int MbNr,int b8, int b4, int DCTCoeff);
void CheckQCoeffValid(int MbNr,int b8, int b4, int QCoeff);
void CheckPictureHeaderValid(picture_header *p,NALU_t *nalu);
void CheckMbOverHeadValid(Macroblock *curMb);
void CheckSliceHeaderValid(int first_mb_in_slice,int delta_qp);
void CheckBitstreamStatus(FILE *error_file);
/************************************************/

/* Sequence_header() */
//int aspect_ratio_information;
//int frame_rate_code; 
//int bit_rate_value; 
//int bbv_buffer_size;
//int profile_id;
//int level_id;
extern int horizontal_size;
extern int vertical_size;
//int sample_precision;
//int frame_rate_code;
//int bit_rate;
//int low_delay;
//int bit_rate_lower;
//int bit_rate_upper;


/* I_pictures_header() */ 
//int progressive_frame;

extern int fixed_picture_qp_flag;
extern int fixed_slice_qp_flag;  // zhan ma 0714
extern int previous_qp;  // zhan ma 0714
extern int picture_qp;  // zhan ma 0714
//int slice_qp;
//int p_pic_type;  //zhangnan
extern int picture_reference_flag;
extern int next_slice;
//int time_code_flag;
//int time_code;

//int loop_filter_disable;
//int loop_filter_parameter_flag;
extern int alpha_ci_offset;
extern int cp_offset;
extern int loopfilter_qp_offset;//WJP FOR DEBLOCK

//int bby_delay;
//int hour;
//int minute;
//int sec;
//int frame_offset;
//int bbv_check_times;

/* Pb_picture_header() */
//int picture_coding_type;
//int bbv_delay;


extern byte **reference_frame[3][3];  //[refnum][yuv][height][width]
extern byte ***current_frame;//[yuv][height][width]


#endif