Files

1243 lines
41 KiB
C

/*!
************************************************************************
* \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 <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <sys/timeb.h>
#include "win32.h"
#include "defines.h"
#include "ifunctions.h"
#include "parsetcommon.h"
#include "types.h"
#include "io_image.h"
#include "frame.h"
#include "distortion.h"
#include "io_video.h"
typedef struct bit_stream_dec Bitstream;
#define ET_SIZE 300 //!< size of error text buffer
extern char errortext[ET_SIZE]; //!< buffer for error message for exit with error()
struct pic_motion_params_old;
struct pic_motion_params;
/***********************************************************************
* T y p e d e f i n i t i o n s f o r J M
***********************************************************************
*/
typedef enum
{
DEC_OPENED = 0,
DEC_STOPPED,
}DecoderStatus_e;
typedef enum
{
LumaComp = 0,
CrComp = 1,
CbComp = 2
} Color_Component;
/***********************************************************************
* D a t a t y p e s f o r C A B A C
***********************************************************************
*/
typedef struct pix_pos
{
int available;
int mb_addr;
short x;
short y;
short pos_x;
short pos_y;
} PixelPos;
//! struct to characterize the state of the arithmetic coding engine
typedef struct
{
unsigned int Drange;
unsigned int Dvalue;
int DbitsLeft;
byte *Dcodestrm;
int *Dcodestrm_len;
} DecodingEnvironment;
typedef DecodingEnvironment *DecodingEnvironmentPtr;
// Motion Vector structure
typedef struct
{
short mv_x;
short mv_y;
} MotionVector;
static const MotionVector zero_mv = {0, 0};
typedef struct
{
short x;
short y;
} BlockPos;
//! struct for context management
typedef struct
{
uint16 state; // index into state-table CP
unsigned char MPS; // Least Probable Symbol 0/1 CP
unsigned char dummy; // for alignment
} 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
// structures that will be declared somewhere else
struct storable_picture;
struct datapartition_dec;
struct syntaxelement_dec;
typedef struct
{
BiContextType mb_type_contexts [3][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];
} 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 transform_size_contexts [NUM_TRANSFORM_SIZE_CTX];
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 [2][NUM_BLOCK_TYPES][NUM_MAP_CTX];
BiContextType last_contexts[2][NUM_BLOCK_TYPES][NUM_LAST_CTX];
BiContextType one_contexts [NUM_BLOCK_TYPES][NUM_ONE_CTX];
BiContextType abs_contexts [NUM_BLOCK_TYPES][NUM_ABS_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
***********************************************************************
*/
/*! 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;
//! cbp structure
typedef struct cbp_s
{
int64 blk ;
int64 bits ;
int64 bits_8x8;
} CBPStructure;
//! Macroblock
typedef struct macroblock_dec
{
int is_decoded;
struct slice *p_Slice; //!< pointer to the current slice
struct video_par *p_Vid; //!< pointer to VideoParameters
struct inp_par *p_Inp;
int mbAddrX; //!< current MB address
int mbAddrA, mbAddrB, mbAddrC, mbAddrD;
Boolean mbAvailA, mbAvailB, mbAvailC, mbAvailD;
BlockPos mb;
int block_x;
int block_y;
int block_y_aff;
int pix_x;
int pix_y;
int pix_c_x;
int pix_c_y;
int subblock_x;
int subblock_y;
int qp; //!< QP luma
int qpc[2]; //!< QP chroma
int qp_scaled[MAX_PLANE]; //!< QP scaled for all comps.
Boolean is_lossless;
Boolean is_intra_block;
Boolean is_v_block;
Boolean DeblockCall;
short slice_nr;
char ei_flag; //!< error indicator flag that enables concealment
char dpl_flag; //!< error indicator flag that signals a missing data partition
short delta_quant; //!< for rate control
short list_offset;
struct macroblock_dec *mb_up; //!< pointer to neighboring MB (CABAC)
struct macroblock_dec *mb_left; //!< pointer to neighboring MB (CABAC)
struct macroblock_dec *mbup; // neighbors for loopfilter
struct macroblock_dec *mbleft; // neighbors for loopfilter
// some storage of macroblock syntax elements for global access
short mb_type;
short mvd[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE][2]; //!< indices correspond to [forw,backw][block_y][block_x][x,y]
//short ****mvd; //!< indices correspond to [forw,backw][block_y][block_x][x,y]
int cbp;
CBPStructure s_cbp[3];
int i16mode;
char b8mode[4];
char b8pdir[4];
char ipmode_DPCM;
char c_ipred_mode; //!< chroma intra prediction mode
char skip_flag;
short DFDisableIdc;
short DFAlphaC0Offset;
short DFBetaOffset;
Boolean mb_field;
//Flag for MBAFF deblocking;
byte mixedModeEdgeFlag;
// deblocking strength indices
byte strength_ver[4][4];
byte strength_hor[4][16];
Boolean luma_transform_size_8x8_flag;
Boolean NoMbPartLessThan8x8Flag;
void (*itrans_4x4)(struct macroblock_dec *currMB, ColorPlane pl, int ioff, int joff);
void (*itrans_8x8)(struct macroblock_dec *currMB, ColorPlane pl, int ioff, int joff);
void (*GetMVPredictor) (struct macroblock_dec *currMB, PixelPos *block,
MotionVector *pmv, short ref_frame, struct pic_motion_params **mv_info, int list, int mb_x, int mb_y, int blockshape_x, int blockshape_y);
int (*read_and_store_CBP_block_bit) (struct macroblock_dec *currMB, DecodingEnvironmentPtr dep_dp, int type);
char (*readRefPictureIdx) (struct macroblock_dec *currMB, struct syntaxelement_dec *currSE, struct datapartition_dec *dP, char b8mode, int list);
void (*read_comp_coeff_4x4_CABAC) (struct macroblock_dec *currMB, struct syntaxelement_dec *currSE, ColorPlane pl, int (*InvLevelScale4x4)[4], int qp_per, int cbp);
void (*read_comp_coeff_8x8_CABAC) (struct macroblock_dec *currMB, struct syntaxelement_dec *currSE, ColorPlane pl);
void (*read_comp_coeff_4x4_CAVLC) (struct macroblock_dec *currMB, ColorPlane pl, int (*InvLevelScale4x4)[4], int qp_per, int cbp, byte **nzcoeff);
void (*read_comp_coeff_8x8_CAVLC) (struct macroblock_dec *currMB, ColorPlane pl, int (*InvLevelScale8x8)[8], int qp_per, int cbp, byte **nzcoeff);
} Macroblock;
//! Syntaxelement
typedef struct syntaxelement_dec
{
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 CAVLC code
unsigned int bitpattern; //!< CAVLC 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 CAVLC 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 macroblock_dec *currMB, struct syntaxelement_dec *, DecodingEnvironmentPtr);
} SyntaxElement;
//! Bitstream
struct bit_stream_dec
{
// CABAC Decoding
int read_len; //!< actual position in the codebuffer, CABAC only
int code_len; //!< overall codebuffer length, CABAC only
// CAVLC Decoding
int frame_bitoffset; //!< actual position in the codebuffer, bit-oriented, CAVLC only
int bitstream_length; //!< over codebuffer lnegth, byte oriented, CAVLC only
// ErrorConcealment
byte *streamBuffer; //!< actual codebuffer for read bytes
int ei_flag; //!< error indication, 0: no error, else unspecified error
};
//! DataPartition
typedef struct datapartition_dec
{
Bitstream *bitstream;
DecodingEnvironment de_cabac;
int (*readSyntaxElement)(struct macroblock_dec *currMB, struct syntaxelement_dec *, struct datapartition_dec *);
/*!< virtual function;
actual method depends on chosen data partition and
entropy coding method */
} DataPartition;
typedef struct wp_params
{
short weight[3];
short offset[3];
} WPParams;
#if (MVC_EXTENSION_ENABLE)
typedef struct nalunitheadermvcext_tag
{
unsigned int non_idr_flag;
unsigned int priority_id;
unsigned int view_id;
unsigned int temporal_id;
unsigned int anchor_pic_flag;
unsigned int inter_view_flag;
unsigned int reserved_one_bit;
unsigned int iPrefixNALU;
} NALUnitHeaderMVCExt_t;
#endif
//! Slice
typedef struct slice
{
struct video_par *p_Vid;
struct inp_par *p_Inp;
pic_parameter_set_rbsp_t *active_pps;
seq_parameter_set_rbsp_t *active_sps;
int svc_extension_flag;
// dpb pointer
struct decoded_picture_buffer *p_Dpb;
//slice property;
int idr_flag;
int idr_pic_id;
int nal_reference_idc; //!< nal_reference_idc from NAL unit
int Transform8x8Mode;
Boolean chroma444_not_separate; //!< indicates chroma 4:4:4 coding with separate_colour_plane_flag equal to zero
int toppoc; //poc for this top field
int bottompoc; //poc of bottom field of frame
int framepoc; //poc of this frame
//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[2];
// ////////////////////////
// for POC mode 0:
signed int PicOrderCntMsb;
//signed int PrevPicOrderCntMsb;
//unsigned int PrevPicOrderCntLsb;
// for POC mode 1:
unsigned int AbsFrameNum;
int ThisPOC;
//signed int ExpectedPicOrderCnt, PicOrderCntCycleCnt, FrameNumInPicOrderCntCycle;
//unsigned int PreviousFrameNum, FrameNumOffset;
//int ExpectedDeltaPerPicOrderCntCycle;
//int PreviousFrameNumOffset;
// /////////////////////////
//information need to move to slice;
unsigned int current_mb_nr; // bitstream order
unsigned int num_dec_mb;
short current_slice_nr;
//int mb_x;
//int mb_y;
//int block_x;
//int block_y;
//int pix_c_x;
//int pix_c_y;
int cod_counter; //!< Current count of number of skipped macroblocks in a row
int allrefzero;
//end;
int mb_aff_frame_flag;
int direct_spatial_mv_pred_flag; //!< Indicator for direct mode type (1 for Spatial, 0 for Temporal)
int num_ref_idx_active[2]; //!< number of available list references
//int num_ref_idx_l0_active; //!< number of available list 0 references
//int num_ref_idx_l1_active; //!< number of available list 1 references
int ei_flag; //!< 0 if the partArr[0] contains valid information
int qp;
int slice_qp_delta;
int qs;
int slice_qs_delta;
int slice_type; //!< slice type
int model_number; //!< cabac model number
unsigned int frame_num; //frame_num for this frame
unsigned int field_pic_flag;
byte bottom_field_flag;
PictureStructure structure; //!< Identify picture structure type
int start_mb_nr; //!< MUST be set by NAL even in case of ei_flag == 1
int end_mb_nr_plus1;
int max_part_nr;
int dp_mode; //!< data partitioning mode
int current_header;
int next_header;
int last_dquant;
//slice header information;
int colour_plane_id; //!< colour_plane_id of the current coded slice
int redundant_pic_cnt;
int sp_switch; //!< 1 for switching sp, 0 for normal sp
int slice_group_change_cycle;
int redundant_slice_ref_idx; //!< reference index of redundant slice
int no_output_of_prior_pics_flag;
int long_term_reference_flag;
int adaptive_ref_pic_buffering_flag;
DecRefPicMarking_t *dec_ref_pic_marking_buffer; //!< stores the memory management control operations
char listXsize[6];
struct storable_picture **listX[6];
// 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 mvscale[6][MAX_REFERENCE_PICTURES];
int ref_pic_list_reordering_flag[2];
int *modification_of_pic_nums_idc[2];
int *abs_diff_pic_num_minus1[2];
int *long_term_pic_idx[2];
#if (MVC_EXTENSION_ENABLE)
int *abs_diff_view_idx_minus1[2];
int view_id;
int inter_view_flag;
int anchor_pic_flag;
NALUnitHeaderMVCExt_t NaluHeaderMVCExt;
#endif
int layer_id;
short DFDisableIdc; //!< Disable deblocking filter on slice
short DFAlphaC0Offset; //!< Alpha and C0 offset for filtering slice
short DFBetaOffset; //!< Beta offset for filtering slice
int pic_parameter_set_id; //!<the ID of the picture parameter set the slice is reffering to
int dpB_NotPresent; //!< non-zero, if data partition B is lost
int dpC_NotPresent; //!< non-zero, if data partition C is lost
Boolean is_reset_coeff;
Boolean is_reset_coeff_cr;
imgpel ***mb_pred;
imgpel ***mb_rec;
int ***mb_rres;
int ***cof;
int ***fcf;
int cofu[16];
imgpel **tmp_block_l0;
imgpel **tmp_block_l1;
int **tmp_res;
imgpel **tmp_block_l2;
imgpel **tmp_block_l3;
// Scaling matrix info
int InvLevelScale4x4_Intra[3][6][4][4];
int InvLevelScale4x4_Inter[3][6][4][4];
int InvLevelScale8x8_Intra[3][6][8][8];
int InvLevelScale8x8_Inter[3][6][8][8];
int *qmatrix[12];
// Cabac
int coeff[64]; // one more for EOB
int coeff_ctr;
int pos;
//weighted prediction
unsigned short weighted_pred_flag;
unsigned short weighted_bipred_idc;
unsigned short luma_log2_weight_denom;
unsigned short chroma_log2_weight_denom;
WPParams **wp_params; // wp parameters in [list][index]
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
short wp_round_luma;
short wp_round_chroma;
#if (MVC_EXTENSION_ENABLE)
int listinterviewidx0;
int listinterviewidx1;
struct frame_store **fs_listinterview0;
struct frame_store **fs_listinterview1;
#endif
// for signalling to the neighbour logic that this is a deblocker call
//byte mixedModeEdgeFlag;
int max_mb_vmv_r; //!< maximum vertical motion vector range in luma quarter pixel units for the current level_idc
int ref_flag[17]; //!< 0: i-th previous frame is incorrect
int erc_mvperMB;
Macroblock *mb_data;
struct storable_picture *dec_picture;
int **siblock;
byte **ipredmode;
char *intra_block;
char chroma_vector_adjustment[6][16];
void (*read_CBP_and_coeffs_from_NAL) (Macroblock *currMB);
int (*decode_one_component ) (Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, struct storable_picture *dec_picture);
int (*readSlice ) (struct video_par *, struct inp_par *);
int (*nal_startcode_follows ) (struct slice*, int );
void (*read_motion_info_from_NAL) (Macroblock *currMB);
void (*read_one_macroblock ) (Macroblock *currMB);
void (*interpret_mb_mode ) (Macroblock *currMB);
void (*init_lists ) (struct slice *currSlice);
void (*intra_pred_chroma ) (Macroblock *currMB);
int (*intra_pred_4x4) (Macroblock *currMB, ColorPlane pl, int ioff, int joff,int i4,int j4);
int (*intra_pred_8x8) (Macroblock *currMB, ColorPlane pl, int ioff, int joff);
int (*intra_pred_16x16) (Macroblock *currMB, ColorPlane pl, int predmode);
void (*linfo_cbp_intra ) (int len, int info, int *cbp, int *dummy);
void (*linfo_cbp_inter ) (int len, int info, int *cbp, int *dummy);
void (*update_direct_mv_info ) (Macroblock *currMB);
void (*read_coeff_4x4_CAVLC ) (Macroblock *currMB, int block_type, int i, int j, int levarr[16], int runarr[16], int *number_coefficients);
//! Edited by Joao Carreira
int have_concealed_reference;
} Slice;
typedef struct decodedpic_t
{
int bValid; //0: invalid, 1: valid, 3: valid for 3D output;
int iViewId; //-1: single view, >=0 multiview[VIEW1|VIEW0];
int iPOC;
int iYUVFormat; //0: 4:0:0, 1: 4:2:0, 2: 4:2:2, 3: 4:4:4
int iYUVStorageFormat; //0: YUV seperate; 1: YUV interleaved; 2: 3D output;
int iBitDepth;
byte *pY; //if iPictureFormat is 1, [0]: top; [1] bottom;
byte *pU;
byte *pV;
int iWidth; //frame width;
int iHeight; //frame height;
int iYBufStride; //stride of pY[0/1] buffer in bytes;
int iUVBufStride; //stride of pU[0/1] and pV[0/1] buffer in bytes;
int iSkipPicNum;
int iBufSize;
struct decodedpic_t *pNext;
} DecodedPicList;
//****************************** ~DM ***********************************
typedef struct coding_par
{
int layer_id;
int profile_idc;
int width;
int height;
int width_cr; //!< width chroma
int height_cr; //!< height chroma
int pic_unit_bitsize_on_disk;
short bitdepth_luma;
short bitdepth_chroma;
int bitdepth_scale[2];
int bitdepth_luma_qp_scale;
int bitdepth_chroma_qp_scale;
unsigned int dc_pred_value_comp[MAX_PLANE]; //!< component value for DC prediction (depends on component pel bit depth)
int max_pel_value_comp[MAX_PLANE]; //!< max value that one picture element (pixel) can take (depends on pic_unit_bitdepth)
int yuv_format;
int lossless_qpprime_flag;
int num_blk8x8_uv;
int num_uv_blocks;
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_cr_size;
int mb_size[3][2]; //!< component macroblock dimensions
int mb_size_blk[3][2]; //!< component macroblock dimensions
int mb_size_shift[3][2];
int max_vmv_r; //!< maximum vertical motion vector range in luma quarter frame pixel units for the current level_idc
int separate_colour_plane_flag;
int ChromaArrayType;
int max_frame_num;
unsigned int PicWidthInMbs;
unsigned int PicHeightInMapUnits;
unsigned int FrameHeightInMbs;
unsigned int FrameSizeInMbs;
int iLumaPadX;
int iLumaPadY;
int iChromaPadX;
int iChromaPadY;
int subpel_x;
int subpel_y;
int shiftpel_x;
int shiftpel_y;
int total_scale;
unsigned int oldFrameSizeInMbs;
//padding info;
void (*img2buf) (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int symbol_size_in_bytes, int crop_left, int crop_right, int crop_top, int crop_bottom, int iOutStride);
int rgb_output;
imgpel **imgY_ref; //!< reference frame find snr
imgpel ***imgUV_ref;
Macroblock *mb_data; //!< array containing all MBs of a whole frame
Macroblock *mb_data_JV[MAX_PLANE]; //!< mb_data to be used for 4:4:4 independent mode
char *intra_block;
char *intra_block_JV[MAX_PLANE];
BlockPos *PicPos;
byte **ipredmode; //!< prediction type [90][74]
byte **ipredmode_JV[MAX_PLANE];
byte ****nz_coeff;
int **siblock;
int **siblock_JV[MAX_PLANE];
int *qp_per_matrix;
int *qp_rem_matrix;
}CodingParameters;
typedef struct layer_par
{
int layer_id;
struct video_par *p_Vid;
CodingParameters *p_Cps;
seq_parameter_set_rbsp_t *p_SPS;
struct decoded_picture_buffer *p_Dpb;
}LayerParameters;
//! Edited by Joao Carreira
typedef struct vector_stats_t {
int total_frames;
float burst_average;
float burst_variance;
}VectorStats;
// video parameters
typedef struct video_par
{
struct inp_par *p_Inp;
pic_parameter_set_rbsp_t *active_pps;
seq_parameter_set_rbsp_t *active_sps;
seq_parameter_set_rbsp_t SeqParSet[MAXSPS];
pic_parameter_set_rbsp_t PicParSet[MAXPPS];
struct decoded_picture_buffer *p_Dpb_layer[MAX_NUM_DPB_LAYERS];
CodingParameters *p_EncodePar[MAX_NUM_DPB_LAYERS];
LayerParameters *p_LayerPar[MAX_NUM_DPB_LAYERS];
#if (MVC_EXTENSION_ENABLE)
subset_seq_parameter_set_rbsp_t *active_subset_sps;
//int svc_extension_flag;
subset_seq_parameter_set_rbsp_t SubsetSeqParSet[MAXSPS];
int last_pic_width_in_mbs_minus1;
int last_pic_height_in_map_units_minus1;
int last_max_dec_frame_buffering;
int last_profile_idc;
#endif
struct sei_params *p_SEI;
struct old_slice_par *old_slice;
#if( MVC_EXTENSION_ENABLE )
struct snr_par *snr[MAX_VIEW_NUM];
#else
struct snr_par *snr;
#endif
int number; //!< frame number
//current picture property;
unsigned int num_dec_mb;
int iSliceNumOfCurrPic;
int iNumOfSlicesAllocated;
int iNumOfSlicesDecoded;
Slice **ppSliceList;
char *intra_block;
char *intra_block_JV[MAX_PLANE];
//int qp; //!< quant for the current frame
//int sp_switch; //!< 1 for switching sp, 0 for normal sp
int type; //!< image type INTER/INTRA
byte **ipredmode; //!< prediction type [90][74]
byte **ipredmode_JV[MAX_PLANE];
byte ****nz_coeff;
int **siblock;
int **siblock_JV[MAX_PLANE];
BlockPos *PicPos;
int newframe;
int structure; //!< Identify picture structure type
//Slice *currentSlice; //!< pointer to current Slice data struct
Slice *pNextSlice; //!< pointer to first Slice of next picture;
Macroblock *mb_data; //!< array containing all MBs of a whole frame
Macroblock *mb_data_JV[MAX_PLANE]; //!< mb_data to be used for 4:4:4 independent mode
//int colour_plane_id; //!< colour_plane_id of the current coded slice
int ChromaArrayType;
#if (MVC_EXTENSION_ENABLE)
int pre_frame_num[MAX_VIEW_NUM]; //!< store the frame_num in the last decoded slice. For detecting gap in frame_num.
#else
int pre_frame_num; //!< store the frame_num in the last decoded slice. For detecting gap in frame_num.
#endif
int non_conforming_stream;
// ////////////////////////
// for POC mode 0:
signed int PrevPicOrderCntMsb;
unsigned int PrevPicOrderCntLsb;
// for POC mode 1:
signed int ExpectedPicOrderCnt, PicOrderCntCycleCnt, FrameNumInPicOrderCntCycle;
unsigned int PreviousFrameNum, FrameNumOffset;
int ExpectedDeltaPerPicOrderCntCycle;
int ThisPOC;
int PreviousFrameNumOffset;
// /////////////////////////
unsigned int PicHeightInMbs;
unsigned int PicSizeInMbs;
int no_output_of_prior_pics_flag;
int last_has_mmco_5;
int last_pic_bottom_field;
int idr_psnr_number;
int psnr_number;
// Timing related variables
TIME_T start_time;
TIME_T end_time;
/*
* Edited by Joao Carreira
* Function Related to Frame error concealment
*/
// picture error concealment
#if (MVC_EXTENSION_ENABLE)
int last_ref_pic_poc[MAX_VIEW_NUM];
int last_ref_hier0_poc[MAX_VIEW_NUM];
#else
int last_ref_pic_poc;
int last_ref_hier0_poc;
#endif
struct conceal_params *p_FrameConc;
int ref_poc_gap;
int poc_gap;
int conceal_mode;
int earlier_missing_poc;
unsigned int frame_to_conceal;
double MotionAverage;
unsigned int NoZeroMVsCount;
unsigned int IntraBlocks;
Boolean first_sps;
// random access point decoding
int recovery_point;
int recovery_point_found;
int recovery_frame_cnt;
int recovery_frame_num;
int recovery_poc;
byte *buf;
byte *ibuf;
ImageData imgData; //!< Image data to be encoded (dummy variable for now)
ImageData imgData0; //!< base layer input
ImageData imgData1; //!< temp buffer for left de-muxed view
ImageData imgData2; //!< temp buffer for right de-muxed view
// Data needed for 3:2 pulldown or temporal interleaving
ImageData imgData32; //!< Image data to be encoded
ImageData imgData4;
ImageData imgData5;
ImageData imgData6;
// Redundant slices. Should be moved to another structure and allocated only if extended profile
unsigned int previous_frame_num; //!< frame number of previous slice
//!< 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
// Time
int64 tot_time;
// files
int p_out; //!< file descriptor to output YUV file
#if (MVC_EXTENSION_ENABLE)
int p_out_mvc[MAX_VIEW_NUM]; //!< file descriptor to output YUV file for MVC
int p_ref_mvc[MAX_VIEW_NUM]; //!< pointer to input original reference YUV file file
#else
int p_ref; //!< pointer to input original reference YUV file file
#endif
//FILE *p_log; //!< SNR file
int LastAccessUnitExists;
int NALUCount;
// B pictures
int Bframe_ctr;
int frame_no;
int frame_no_idr;
int IDRframe_ctr;
int g_nFrame;
Boolean global_init_done[MAX_VIEW_NUM];
// global picture format dependent buffers, memory allocation in decod.c
imgpel **imgY_ref; //!< reference frame find snr
imgpel ***imgUV_ref;
int *qp_per_matrix;
int *qp_rem_matrix;
/* Edited by Joao Carreira */
#if ( MVC_EXTENSION_ENABLE )
int last_output_frame_no[MAX_VIEW_NUM];
#else
int last_output_frame_no;
#endif
struct storable_picture *dec_picture;
struct storable_picture *dec_picture_JV[MAX_PLANE]; //!< dec_picture to be used during 4:4:4 independent mode decoding
struct storable_picture *no_reference_picture; //!< dummy storable picture for recovery point
// Error parameters
struct object_buffer *erc_object_list;
struct ercVariables_s *erc_errorVar;
int erc_mvperMB;
struct video_par *erc_img;
int ec_flag[SE_MAX_ELEMENTS]; //!< array to set errorconcealment
struct annex_b_struct *annex_b;
struct frame_store *out_buffer;
struct storable_picture *pending_output;
int pending_output_state;
int recovery_flag;
int BitStreamFile;
// report
char cslice_type[9];
// FMO
int *MbToSliceGroupMap;
int *MapUnitToSliceGroupMap;
int NumberOfSliceGroups; // the number of slice groups -1 (0 == scan order, 7 == maximum)
#if (ENABLE_OUTPUT_TONEMAPPING)
struct tone_mapping_struct_s *seiToneMapping;
#endif
void (*buf2img) (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int o_size_x, int o_size_y, int symbol_size_in_bytes, int bitshift);
void (*getNeighbour) (Macroblock *currMB, int xN, int yN, int mb_size[2], PixelPos *pix);
void (*get_mb_block_pos) (BlockPos *PicPos, int mb_addr, short *x, short *y);
void (*GetStrengthVer) (Macroblock *MbQ, int edge, int mvlimit, struct storable_picture *p);
void (*GetStrengthHor) (Macroblock *MbQ, int edge, int mvlimit, struct storable_picture *p);
void (*EdgeLoopLumaVer) (ColorPlane pl, imgpel** Img, byte *Strength, Macroblock *MbQ, int edge);
void (*EdgeLoopLumaHor) (ColorPlane pl, imgpel** Img, byte *Strength, Macroblock *MbQ, int edge, struct storable_picture *p);
void (*EdgeLoopChromaVer)(imgpel** Img, byte *Strength, Macroblock *MbQ, int edge, int uv, struct storable_picture *p);
void (*EdgeLoopChromaHor)(imgpel** Img, byte *Strength, Macroblock *MbQ, int edge, int uv, struct storable_picture *p);
void (*img2buf) (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int symbol_size_in_bytes, int crop_left, int crop_right, int crop_top, int crop_bottom, int iOutStride);
ImageData tempData3;
DecodedPicList *pDecOuputPic;
int iDeblockMode; //0: deblock in picture, 1: deblock in slice;
struct nalu_t *nalu;
int iLumaPadX;
int iLumaPadY;
int iChromaPadX;
int iChromaPadY;
//control;
int bDeblockEnable;
int iPostProcess;
int bFrameInit;
#if _FLTDBG_
FILE *fpDbg;
#endif
pic_parameter_set_rbsp_t *pNextPPS;
int last_dec_poc;
int last_dec_view_id;
int last_dec_layer_id;
int dpb_layer_id;
/******************* deprecative variables; ***************************************/
int width;
int height;
int width_cr; //!< width chroma
int height_cr; //!< height chroma
// Fidelity Range Extensions Stuff
int pic_unit_bitsize_on_disk;
short bitdepth_luma;
short bitdepth_chroma;
int bitdepth_scale[2];
int bitdepth_luma_qp_scale;
int bitdepth_chroma_qp_scale;
unsigned int dc_pred_value_comp[MAX_PLANE]; //!< component value for DC prediction (depends on component pel bit depth)
int max_pel_value_comp[MAX_PLANE]; //!< max value that one picture element (pixel) can take (depends on pic_unit_bitdepth)
int separate_colour_plane_flag;
int pic_unit_size_on_disk;
int profile_idc;
int yuv_format;
int lossless_qpprime_flag;
int num_blk8x8_uv;
int num_uv_blocks;
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_cr_size;
int mb_size[3][2]; //!< component macroblock dimensions
int mb_size_blk[3][2]; //!< component macroblock dimensions
int mb_size_shift[3][2];
int subpel_x;
int subpel_y;
int shiftpel_x;
int shiftpel_y;
int total_scale;
int max_frame_num;
unsigned int PicWidthInMbs;
unsigned int PicHeightInMapUnits;
unsigned int FrameHeightInMbs;
unsigned int FrameSizeInMbs;
unsigned int oldFrameSizeInMbs;
int max_vmv_r; //!< maximum vertical motion vector range in luma quarter frame pixel units for the current level_idc
//int max_mb_vmv_r; //!< maximum vertical motion vector range in luma quarter pixel units for the current level_idc
/******************* end deprecative variables; ***************************************/
struct dec_stat_parameters *dec_stats;
//! Control the number of views in stream
int n_views;
/*
* Edited by Jo�o Carreira
* NAL Units parser
*/
void *p_ParserNAL;
void *p_PredictionParser;
/*
* Edited by Jo�o Carreira
* Transcode Module Struct pointer
*/
void *p_Transcode;
/*
* Edited by Joao Carreira
* Report Variables
*/
#if ( MVC_EXTENSION_ENABLE )
int nFramesConceal[MAX_VIEW_NUM];
int nFramesDecoded[MAX_VIEW_NUM];
int nFramesOut[MAX_VIEW_NUM];
#else
int nFramesConceal;
int nFramesDecoded;
int nFramesOut;
#endif
/**** Stats ****/
#define INITAL_PFRAMES_LENGTH 10000
int *p_PFrames[MAX_VIEW_NUM];
unsigned int n_PFrames[MAX_VIEW_NUM];
VectorStats LostFrames[MAX_VIEW_NUM];
VectorStats AfectedFrames[MAX_VIEW_NUM];
int n_Loops;
int n_BiPred;
int n_SKIP;
} VideoParameters;
// signal to noise ratio parameters
typedef struct snr_par
{
int frame_ctr;
float snr[3]; //!< current SNR (component)
float snr1[3]; //!< SNR (dB) first frame (component)
float snra[3]; //!< Average component SNR (dB) remaining frames
float sse[3]; //!< component SSE
float msse[3]; //!< Average component SSE
} SNRParameters;
// input parameters from configuration file
typedef struct inp_par
{
char infile[FILE_NAME_SIZE]; //!< H.264 inputfile
char outfile[FILE_NAME_SIZE]; //!< Decoded YUV 4:2:0 output
char reffile[FILE_NAME_SIZE]; //!< Optional YUV 4:2:0 reference file for SNR measurement
//! Edited by Joao Carreira
char statsfile[FILE_NAME_SIZE]; //!< 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;
int intra_profile_deblocking; //!< Loop filter usage determined by flags and parameters in bitstream
// Input/output sequence format related variables
FrameFormat source; //!< source related information
FrameFormat output; //!< output related information
int ProcessInput;
int enable_32_pulldown;
VideoDataFile input_file1; //!< Input video file1
VideoDataFile input_file2; //!< Input video file2
VideoDataFile input_file3; //!< Input video file3
#if (MVC_EXTENSION_ENABLE)
int DecodeAllLayers;
#endif
#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[FILE_NAME_SIZE]; //!< LeakyBucketParamFile
#endif
// picture error concealment
int conceal_mode;
int DisparityMethod;
int DisparityDirection;
int DisparityReference;
int DisparityWindow;
char DispLoadFileName[FILE_NAME_SIZE];
int DisparityProjection;
int Disparity4x4BlockSize;
int MotionVectorCandidates;
int MVConcealmentMode;
int TemporalThreshold;
int SpatialThreshold;
char TranscodeFile[FILE_NAME_SIZE];
int error_prop;
int ref_poc_gap;
int poc_gap;
int IDR_Period;
int GOP_Size;
int FrameSkip;
int search_mode_ref;
int search_mode_nonref;
/* Edited by Jo�o Carreira */
#define MAX_LOST_NALU 200
char drop_nalu[MAX_LOST_NALU];
//! Edited by Joao Carreira
int dump_nalu; //!< if 1 write to a file the nal units found in bitstream
int PredictionParser;
// dummy for encoder
int start_frame;
// Needed to allow compilation for decoder. May be used later for distortion computation operations
int stdRange; //!< 1 - standard range, 0 - full range
int videoCode; //!< 1 - 709, 3 - 601: See VideoCode in io_tiff.
int export_views;
int iDecFrmNum;
int bDisplayDecParams;
int dpb_plus[2];
} InputParameters;
typedef struct old_slice_par
{
unsigned field_pic_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];
byte bottom_field_flag;
byte idr_flag;
int idr_pic_id;
int pps_id;
#if (MVC_EXTENSION_ENABLE)
int view_id;
int inter_view_flag;
int anchor_pic_flag;
#endif
int layer_id;
} OldSliceParams;
typedef struct decoder_params
{
InputParameters *p_Inp; //!< Input Parameters
VideoParameters *p_Vid; //!< Image Parameters
int64 bufferSize; //!< buffersize for tiff reads (not currently supported)
int UsedBits; // for internal statistics, is adjusted by read_se_v, read_ue_v, read_u_1
FILE *p_trace; //!< Trace file
int bitcounter;
} DecoderParams;
extern DecoderParams *p_Dec;
// prototypes
extern void error(char *text, int code);
// dynamic mem allocation
extern int init_global_buffers( VideoParameters *p_Vid, int layer_id );
extern void free_global_buffers( VideoParameters *p_Vid);
extern void free_layer_buffers( VideoParameters *p_Vid, int layer_id );
extern int RBSPtoSODB(byte *streamBuffer, int last_byte_pos);
extern int EBSPtoRBSP(byte *streamBuffer, int end_bytepos, int begin_bytepos);
extern void FreePartition (DataPartition *dp, int n);
extern DataPartition *AllocPartition(int n);
extern void tracebits (const char *trace_str, int len, int info, int value1);
extern void tracebits2(const char *trace_str, int len, int info);
extern unsigned CeilLog2 ( unsigned uiVal);
extern unsigned CeilLog2_sf( unsigned uiVal);
// For 4:4:4 independent mode
extern void change_plane_JV ( VideoParameters *p_Vid, int nplane, Slice *pSlice);
extern void make_frame_picture_JV( VideoParameters *p_Vid );
#if (MVC_EXTENSION_ENABLE)
extern void nal_unit_header_mvc_extension(NALUnitHeaderMVCExt_t *NaluHeaderMVCExt, struct bit_stream_dec *bitstream);
#endif
extern void FreeDecPicList ( DecodedPicList *pDecPicList );
extern void ClearDecPicList( VideoParameters *p_Vid );
extern DecodedPicList *get_one_avail_dec_pic_from_list(DecodedPicList *pDecPicList, int b3D, int view_id);
extern Slice *malloc_slice( InputParameters *p_Inp, VideoParameters *p_Vid );
extern void free_slice (Slice *currSlice);
extern void copy_slice_info ( Slice *currSlice, OldSliceParams *p_old_slice );
extern void OpenOutputFiles(VideoParameters *p_Vid, int view0_id, int view1_id);
extern void OpenRefFiles(VideoParameters *p_Vid, int view0_id, int view1_id);
//! Edit by Joao Carreira
extern void OpenOutputFiles_per_layer(VideoParameters *p_Vid, int view_id);
extern void OpenRefFiles_per_layer(VideoParameters *p_Vid, int view_id);
extern void set_global_coding_par(VideoParameters *p_Vid, CodingParameters *cps);
static inline int is_FREXT_profile(unsigned int profile_idc)
{
return ( profile_idc >= FREXT_HP || profile_idc == FREXT_CAVLC444 );
}
static inline int HI_intra_only_profile(unsigned int profile_idc, Boolean constrained_set3_flag)
{
return ( ((profile_idc >= FREXT_Hi10P) && constrained_set3_flag) || (profile_idc == FREXT_CAVLC444) );
}
static inline int is_BL_profile(unsigned int profile_idc)
{
return ( profile_idc == FREXT_CAVLC444 || profile_idc == BASELINE || profile_idc == MAIN || profile_idc == EXTENDED ||
profile_idc == FREXT_HP || profile_idc == FREXT_Hi10P || profile_idc == FREXT_Hi422 || profile_idc == FREXT_Hi444);
}
static inline int is_EL_profile(unsigned int profile_idc)
{
return ( (profile_idc == MVC_HIGH) || (profile_idc == STEREO_HIGH)
);
}
static inline int is_MVC_profile(unsigned int profile_idc)
{
return ( (0)
#if (MVC_EXTENSION_ENABLE)
|| (profile_idc == MVC_HIGH) || (profile_idc == STEREO_HIGH)
#endif
);
}
//! Report Function
enum{
STATUS = 0,
REPORT = 1,
DEBUG = 2,
};
extern void av_log(int level, const char *fmt, ...);
#endif