/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#ifndef _MP4LIB_INT_H_
#define _MP4LIB_INT_H_

#include "mp4def.h"
#include "mp4dec_api.h"	// extra structure

#undef ENABLE_LOG
#define BITRATE_AVERAGE_WINDOW 4
#define FRAMERATE_SCALE ((BITRATE_AVERAGE_WINDOW-1)*10000L)
#define FAST_IDCT			 /* , for fast Variable complexity IDCT */
//#define PV_DEC_EXTERNAL_IDCT  /*  for separate IDCT (i.e. no direct access to output frame) */
#define PV_ANNEX_IJKT_SUPPORT
#define mid_gray 1024

typedef struct tagBitstream
{
    /* function that reteive data from outside the library.   04/11/2000 */
    /*    In frame-based decoding mode, this shall be NULL.   08/29/2000 */
    uint32 curr_word;
    uint32 next_word;
    uint8 *bitstreamBuffer;	/* pointer to buffer memory */
    int32  read_point;			/* starting point in the buffer to be read to cache */
    int  incnt;				/* bit left in cached */
    int	 incnt_next;
    uint32 bitcnt;			/* total bit read so-far (from inbfr)*/
    int32  data_end_pos;		/*should be added ,  06/07/2000 */
    int searched_frame_boundary;
} BitstreamDecVideo, *LPBitstreamDecVideo;

/* complexity estimation parameters */
typedef struct tagComplexity_Est
{
    uint8	text_1;				/* texture_complexity_estimation_set_1	*/
    uint8	text_2;				/* texture_complexity_estimation_set_2	*/
    uint8	mc;					/* motion_compensation_complexity		*/
} Complexity_Est;


typedef struct tagVop
{
    PIXEL	*yChan;				/* The Y component */
    PIXEL	*uChan;				/* The U component */
    PIXEL	*vChan;				/* The V component */

    uint32	timeStamp;			/* Vop TimeStamp in msec */

    /* Actual syntax elements for VOP (standard) */
    int		predictionType;		/* VOP prediction type */
    uint	timeInc;			/* VOP time increment (relative to last mtb) */
    int		vopCoded;
    int		roundingType;
    int		intraDCVlcThr;
    int16		quantizer;			/* VOP quantizer */
    int		fcodeForward;		/* VOP dynamic range of motion vectors */
    int		fcodeBackward;		/* VOP dynamic range of motion vectors */
    int		refSelectCode;		/* enhancement layer reference select code */

    /* H.263 parameters */
    int		gobNumber;
    int		gobFrameID;
    int	    temporalRef;		/* temporal reference, roll over at 256 */
    int		ETR;
} Vop;

typedef struct tagVol
{
    int		volID;					/* VOL identifier (for tracking) */
    uint	timeIncrementResolution;/* VOL time increment */
    int		nbitsTimeIncRes;		/* number of bits for time increment  */
    uint		timeInc_offset;			/* timeInc offset for multiple VOP in a packet  */
    uint32	moduloTimeBase;			/* internal decoder clock */
    int		fixedVopRate;
    BitstreamDecVideo	*bitstream;	/* library bitstream buffer (input buffer) */

    int		complexity_estDisable;	/* VOL disable complexity estimation */
    int		complexity_estMethod;	/* VOL complexity estimation method	*/
    Complexity_Est complexity;		/* complexity estimation flags		*/

    /* Error Resilience Flags */
    int		errorResDisable;		/* VOL disable error resilence mode */
    /*            (Use Resynch markers) */
    int		useReverseVLC;			/* VOL reversible VLCs */
    int		dataPartitioning;		/* VOL data partitioning */

    /* Bit depth  */
    uint	bitsPerPixel;
//	int		mid_gray;				/* 2^(bits_per_pixel+2) */

    /* Quantization related parameters */
    int		quantPrecision;			/* Quantizer precision */
    uint	quantType;				/* MPEG-4 or H.263 Quantization Type */
    /* Added loaded quant mat,  05/22/2000 */
    int		loadIntraQuantMat;		/* Load intra quantization matrix */
    int		loadNonIntraQuantMat;	/* Load nonintra quantization matrix */
    int		iqmat[64];				/* Intra quant.matrix */
    int		niqmat[64];				/* Non-intra quant.matrix */

    /* Parameters used for scalability */
    int		scalability;			/* VOL scalability (flag) */
    int		scalType;				/* temporal = 0, spatial = 1, both = 2 */

    int		refVolID;				/* VOL id of reference VOL */
    int		refSampDir;				/* VOL resol. of ref. VOL */
    int		horSamp_n;				/* VOL hor. resampling of ref. VOL given by */
    int		horSamp_m;				/*     sampfac = hor_samp_n/hor_samp_m      */
    int		verSamp_n;				/* VOL ver. resampling of ref. VOL given by */
    int		verSamp_m;				/*     sampfac = ver_samp_n/ver_samp_m      */
    int		enhancementType;		/* VOL type of enhancement layer */
    /* profile and level */
    int32   profile_level_id;		/* 8-bit profile and level */ //  6/17/04

} Vol;


typedef int16 typeMBStore[6][NCOEFF_BLOCK];

typedef struct tagMacroBlock
{
    typeMBStore 		block;				/* blocks */         /*  ACDC */
    uint8 	pred_block[384];		/* prediction block,  Aug 3,2005 */
    uint8	bitmapcol[6][8];
    uint8	bitmaprow[6];
    int		no_coeff[6];
    int		DCScalarLum;						/* Luminance DC Scalar */
    int		DCScalarChr;						/* Chrominance DC Scalar */
#ifdef PV_ANNEX_IJKT_SUPPORT
    int direction;
#endif
} MacroBlock;

typedef struct tagHeaderInfoDecVideo
{
    uint8		*Mode;				/* Modes INTRA/INTER/etc. */
    uint8		*CBP;				/* MCBPC/CBPY stuff */
} HeaderInfoDecVideo;


/************************************************************/
/*					VLC structures							*/
/************************************************************/
typedef struct tagTcoef
{
    uint last;
    uint run;
    int level;
    uint sign;
} Tcoef, *LPTcoef;


typedef struct tagVLCtab
{
    int32 val;
    int32 len;
} VLCtab, *LPVLCtab;

typedef struct tagVLCshorttab
{
    int16 val;
    int16 len;
} VLCshorttab, *LPVLCshorttab ; /* for space saving, Antoine Nguyen*/

typedef struct tagVLCtab2
{
    uint8 run;
    uint8 level;
    uint8 last;
    uint8 len;
} VLCtab2, *LPVLCtab2;	/* 10/24/2000 */

/* This type is designed for fast access of DC/AC */
/*    prediction data.  If the compiler is smart  */
/*    enough, it will use shifting for indexing.  */
/*     04/14/2000.                              */

typedef int16 typeDCStore[6];   /*  ACDC */
typedef int16 typeDCACStore[4][8];


/* Global structure that can be passed around */
typedef struct tagVideoDecData
{
    BitstreamDecVideo	*bitstream;	/* library bitstream buffer (input buffer) */
    /* Data For Layers (Scalability) */
    Vol				**vol;					/* Data stored for each VOL */

    /* Data used for reconstructing frames */
    Vop 			*currVop;  				/* Current VOP (frame)  */
    Vop 			*prevVop;				/* Previous VOP (frame) */
    /* Data used to facilitate multiple layer decoding.   05/04/2000 */
    Vop				*prevEnhcVop;			/* New change to rid of memcpy().  04/24/2001 */
    Vop				**vopHeader;			/* one for each layer.   08/29/2000 */

    /* I/O structures */
    MacroBlock		*mblock;					/* Macroblock data structure */
    uint8			*acPredFlag;				/*  */

    /* scratch memory used in data partitioned mode */
    typeDCStore		*predDC;		/*  The DC coeffs for each MB */
    typeDCACStore   *predDCAC_row;
    typeDCACStore   *predDCAC_col;

    int				usePrevQP;				/* running QP decision switch */
    uint8			*sliceNo;				/* Slice indicator for each MB  */
    /*     changed this to a 1D   */
    /*    array for optimization    */
    MOT				*motX;					/* Motion vector in X direction */
    MOT				*motY;					/* Motion vector in Y direction */
    HeaderInfoDecVideo	headerInfo;			/* MB Header information */
    int16 			*QPMB;					/* Quantizer value for each MB */

    uint8			*pstprcTypCur;			/* Postprocessing type for current frame */
    uint8			*pstprcTypPrv;			/* Postprocessing type for previous frame */
    /* scratch memory used in all modes */
    int				mbnum;						/*  Macroblock number */
    uint			mbnum_row;
    int				mbnum_col;
    /* I added these variables since they are used a lot.   04/13/2000 */
    int		nMBPerRow, nMBPerCol;	/* number of MBs in each row & column    */
    int		nTotalMB;
    /* for short video header */
    int		nMBinGOB;				/* number of MBs in GOB,  05/22/00 */
    int		nGOBinVop;				/* number of GOB in Vop   05/22/00 */
    /* VOL Dimensions */
    int		width;					/* Width */
    int		height;					/* Height */
    int		displayWidth;				/* Handle image whose size is not a multiple of 16. */
    int		displayHeight;				/*   This is the actual size.   08/09/2000        */
    int32	size;
    /* Miscellaneous data points to be passed */
    int				frame_idx;				/* Current frame ID */
    int				frameRate;				/* Output frame Rate (over 10 seconds) */
    int32			duration;
    uint32			currTimestamp;
    int				currLayer;				/* Current frame layer  */
    int     shortVideoHeader;       /* shortVideoHeader mode */
    int		intra_acdcPredDisable;	/* VOL disable INTRA DC prediction */
    int				numberOfLayers;			/* Number of Layers */
    /* Frame to be used for concealment     07/07/2001 */
    uint8			*concealFrame;
    int				vop_coding_type;
    /* framerate and bitrate statistics counters.   08/23/2000 */
    int32			nBitsPerVop[BITRATE_AVERAGE_WINDOW];
    uint32			prevTimestamp[BITRATE_AVERAGE_WINDOW];
    int		nBitsForMBID;			/* how many bits required for MB number? */
    /* total data memory used by the docder library.   08/23/2000 */
    int32			memoryUsage;

    /* flag to turn on/off error concealment or soft decoding */
    int errorConcealment;

    /* Application controls */
    VideoDecControls	*videoDecControls;
    int					postFilterType;		/* Postfilter mode  04/25/00 */


    PV_STATUS(*vlcDecCoeffIntra)(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra_luma*/);
    PV_STATUS(*vlcDecCoeffInter)(BitstreamDecVideo *stream, Tcoef *pTcoef);
#if 0
    int (*vlcDequantIntraBlock)(void *video, int comp, int switched,
                                uint8 *bitmaprow, uint8 *bitmapcol);
    int (*vlcDequantInterBlock)(void *video, int comp,
                                uint8 *bitmaprow, uint8 *bitmapcol);
#endif
    int					initialized;

    /* Annex IJKT */
    int		deblocking;
    int		slice_structure;
    int		modified_quant;
    int		advanced_INTRA;
    int16 QP_CHR;  /* ANNEX_T */
} VideoDecData;

/* for fast VLC+Dequant  10/12/2000*/
typedef int (*VlcDequantBlockFuncP)(void *video, int comp, int switched,
                                    uint8 *bitmaprow, uint8 *bitmapcol);

//////////////////////////////////////////////////////////////
//					Decoder structures						//
//////////////////////////////////////////////////////////////
#endif /* _MP4LIB_INT_H_ */