pbdll.h

魔兽2Linux版

	// Macro Block and SuperBlock Information
	INT32	(*BlockMap)[4][4];			// super block + sub macro block + sub frag -> FragIndex

	// Coded flag arrays and counters for them
	UINT8   *SBCodedFlags;
	UINT8   *SBFullyFlags;
	UINT8   *MBCodedFlags;
	UINT8   *MBFullyFlags;
	//****************************************************************************************

	UINT32 EOB_Run;

    COORDINATE *FragCoordinates;
	MOTION_VECTOR MVector;
	INT32    ReconPtr2Offset;        // Offset for second reconstruction in half pixel MC
	Q_LIST_ENTRY * quantized_list;  
	INT16 *ReconDataBuffer;
	INT16 *ReconDataBufferAlloc;
	INT32 IDCT_codes[64];      
	Q_LIST_ENTRY InvLastIntraDC;
	Q_LIST_ENTRY InvLastInterDC;
	Q_LIST_ENTRY LastIntraDC;
	Q_LIST_ENTRY LastInterDC;

	UINT32 BlocksToDecode;				// Blocks to be decoded this frame
	UINT32 DcHuffChoice;				// Huffman table selection variables
	UINT8  ACHuffChoice; 
	UINT32 QuadMBListIndex;

	INT32 ByteCount;

	UINT32  bit_pattern ;
	UINT8   bits_so_far ; 
	UINT8   NextBit;
	INT32   BitsLeft;
	
	INT16 * DequantBuffer;
	INT16 * DequantBufferAlloc;

	INT32 fp_quant_InterUV_coeffs[64];
	INT32 fp_quant_InterUV_round[64];
	INT32 fp_ZeroBinSize_InterUV[64];

	INT16 * TmpReconBuffer;
	INT16 * TmpReconBufferAlloc;
	INT16 * TmpDataBuffer;
	INT16 * TmpDataBufferAlloc;

	// Loop filter bounding values
	INT32 FiltBoundingValue[512];

    // Dequantiser and rounding tables
	UINT32 QThreshTable[Q_TABLE_SIZE];
	Q_LIST_ENTRY * dequant_InterUV_coeffs;
	Q_LIST_ENTRY * dequant_InterUV_coeffsAlloc;
	unsigned quant_index[64];
	INT32 quant_Y_coeffs[64];
	INT32 quant_UV_coeffs[64];
	INT32 fp_quant_Y_coeffs[64];		// used in reiniting quantizers

	HUFF_ENTRY ** HuffRoot_VP3x;
	UINT32 * HuffCodeArray_VP3x[NUM_HUFF_TABLES];
	UINT8  * HuffCodeLengthArray_VP3x[NUM_HUFF_TABLES];

    // Quantiser and rounding tables
    INT32 fp_quant_UV_coeffs[64];
	INT32 fp_quant_Inter_coeffs[64];
	INT32 fp_quant_Y_round[64];
	INT32 fp_quant_UV_round[64];
	INT32 fp_quant_Inter_round[64];
	INT32 fp_ZeroBinSize_Y[64];
	INT32 fp_ZeroBinSize_UV[64];
	INT32 fp_ZeroBinSize_Inter[64];
	INT32 *fquant_coeffs;
	INT32 *fquant_round;
	INT32 *fquant_ZbSize;
	Q_LIST_ENTRY * dequant_Y_coeffs;
	Q_LIST_ENTRY * dequant_Y_coeffsAlloc;
	Q_LIST_ENTRY * dequant_UV_coeffs;
	Q_LIST_ENTRY * dequant_UV_coeffsAlloc;
	Q_LIST_ENTRY * dequant_Inter_coeffs;
	Q_LIST_ENTRY * dequant_Inter_coeffsAlloc;
	Q_LIST_ENTRY * dequant_coeffs;

	// Predictor used in choosing entropy table for decoding block patterns.
	UINT8	BlockPatternPredictor;

	//****************************************************************

	

	//****************************************************************
	// Function Pointers some probably could be library globals!
	void (*ReconIntra)( xPB_INST pbi, UINT8 * ReconPtr, UINT16 * ChangePtr, UINT32 LineStep );

	void (*ReconInter)( xPB_INST pbi, UINT8 * ReconPtr, UINT8 * RefPtr, INT16 * ChangePtr, UINT32 LineStep );

	void (*ReconInterHalfPixel2)( xPB_INST pbi, UINT8  * ReconPtr, UINT8  * RefPtr1, UINT8 * RefPtr2, 
		INT16  * ChangePtr, UINT32 LineStep );

	void (*idct[65])( INT16 *InputData, INT16 *QuantMatrix, INT16 * OutputData );


	void (*YUVtoRGB)( xPB_INST pbi, YUV_BUFFER_ENTRY_PTR yblock, YUV_BUFFER_ENTRY_PTR ublock,	
		YUV_BUFFER_ENTRY_PTR vblock, int uvoffset, BGR_TYPE * RGBPtr, BOOL ReconBuffer );	/* Yuv Conversion Function */		

	void (*ClearDownQFrag)(xPB_INST pbi);

	UINT32 (*ExtractToken)(BITREADER *,HUFF_ENTRY *);

	void (*UnPackVideo)(xPB_INST pbi);
	void (*CopyBlock) (unsigned char *src, unsigned char *dest, unsigned int srcstride);

    void (*FilterHoriz)(xPB_INST pbi, UINT8 * PixelPtr, INT32 LineLength, INT32*);
    void (*FilterVert)(xPB_INST pbi, UINT8 * PixelPtr, INT32 LineLength, INT32*);
    INT32 *(*SetupBoundingValueArray)(xPB_INST pbi, INT32 FLimit);

    void (*BuildQuantIndex)(xPB_INST pbi);

	void (*ClearSysState)(void);


#if defined(POSTPROCESS)	
    void (*DeringBlockWeak)(const xPB_INST, const UINT8 *, const UINT8 *, INT32, UINT32, UINT32 *);
    void (*DeringBlockStrong)(const xPB_INST, const UINT8 *, UINT8 *, const INT32, UINT32, UINT32 *);
    void (*DeblockLoopFilteredBand)(xPB_INST, UINT8 *, UINT8 *, UINT32, UINT32, UINT32, UINT32 *);

    short Modifier[4][512];
    short *ModifierPointer[4];

#endif	
	
	UINT8 *  DataOutputInPtr;		  

	//****************************************************************

} PB_INSTANCE;

/****************************************************************************
*  Functions.
*****************************************************************************
*/  

extern void FilterHoriz_Generic(PB_INSTANCE *pbi, UINT8 * PixelPtr, INT32 LineLength, INT32 *BoundingValuePtr);
extern void FilterVert_Generic(PB_INSTANCE *pbi, UINT8 * PixelPtr, INT32 LineLength, INT32 *BoundingValuePtr);
extern INT32 *SetupBoundingValueArray_Generic(PB_INSTANCE *pbi, INT32 FLimit);

extern void FilterHoriz_MMX(PB_INSTANCE *pbi, UINT8 * PixelPtr, INT32 LineLength, INT32 *BoundingValuePtr);
extern void FilterVert_MMX(PB_INSTANCE *pbi, UINT8 * PixelPtr, INT32 LineLength, INT32 *BoundingValuePtr);
extern INT32 *SetupBoundingValueArray_ForMMX(PB_INSTANCE *pbi, INT32 FLimit);


extern PB_INSTANCE * CreatePBInstance(void);

extern void DeletePBInstance(PB_INSTANCE **);

extern void ReadAndUnPackDFArray( PB_INSTANCE *pbi );

extern int LoadAndDecode(PB_INSTANCE *pbi);


/* Frame header functions. */   
extern BOOL LoadFrame(PB_INSTANCE *pbi);
extern BOOL LoadFrameHeader(PB_INSTANCE *pbi);
extern void SetFrameType(PB_INSTANCE *pbi, UINT8 FrType );
extern UINT8 GetFrameType(PB_INSTANCE *pbi);

extern void DecodeData(PB_INSTANCE *pbi);  
extern void UnpackAndExpandAcToken( PB_INSTANCE *pbi, Q_LIST_ENTRY * ExpandedBlock, UINT8 * CoeffIndex  );
extern void UnpackAndExpandDcToken( PB_INSTANCE *pbi, Q_LIST_ENTRY * ExpandedBlock, UINT8 * CoeffIndex  );

extern BOOL PbBuildBitmapHeader( PB_INSTANCE *pbi/*, UINT32 ImageWidth, UINT32 ImageHeight*/ );

extern __inline UINT8 ExtractBitFromBuffer(PB_INSTANCE *pbi);
extern __inline UINT32 ReadBits( PB_INSTANCE *pbi, UINT32 BitsToRead );
extern void  ExtractInit(PB_INSTANCE *pbi);

extern __inline void FrArrayDeCodeInit(PB_INSTANCE *pbi);
extern CODING_MODE FrArrayUnpackMode(PB_INSTANCE *pbi);
extern void ClearDownQFragData(PB_INSTANCE *pbi);

// Expand quantised viodeo data and reconstruct reference frames.
extern void ExpandToken( PB_INSTANCE *pbi, Q_LIST_ENTRY * ExpandedBlock, UINT8 * CoeffIndex, UINT32 Token, INT32 ExtraBits );
extern void ReconRefFrames (PB_INSTANCE *pbi);
extern void CopyBlock(unsigned char *src, unsigned char *dest, unsigned int srcstride);
extern void ExpandBlock ( PB_INSTANCE *pbi, INT32 FragmentNumber );
extern void ExpandKFBlock ( PB_INSTANCE *pbi, INT32 FragmentNumber );
extern UINT32 ExtractToken(BITREADER *br, HUFF_ENTRY * CurrentRoot);

// Set up Entropy Tables
extern void SelectHuffmanSet( PB_INSTANCE *pbi );
extern void CreateHuffmanTrees();
extern void DestroyHuffmanTrees();
extern void select_InterUV_quantiser ( PB_INSTANCE *pbi );
extern void DestroyHuffTree( HUFF_ENTRY * * root_ptr );
extern void InitPostProcessing(void);

// Indexing into block mapping
extern void CalcPixelIndexTable( PB_INSTANCE *pbi );
extern __inline UINT32 GetFragIndex( UINT32 * pixel_index_table, UINT32 FragmentNo );
extern __inline UINT32 ReconGetFragIndex( UINT32 * recon_pixel_index_table, UINT32 FragmentNo );


// DCT Functions 
//extern void IDctSlow(  Q_LIST_ENTRY * InputData, int16 *QuantMatrix, int16 * OutputData );

// Quantizer Selections 
extern void InitQTables( PB_INSTANCE *pbi );
extern void UpdateQ( PB_INSTANCE *pbi, UINT32 NewQ );
extern void select_Y_dequantiser ( PB_INSTANCE *pbi);
extern void select_UV_dequantiser ( PB_INSTANCE *pbi );
extern void select_Inter_dequantiser ( PB_INSTANCE *pbi );
extern void select_Y_quantiser ( PB_INSTANCE *pbi );
extern void select_Inter_quantiser ( PB_INSTANCE *pbi );
extern void select_UV_quantiser ( PB_INSTANCE *pbi );

extern void BuildQuantIndex_Generic(PB_INSTANCE *pbi);

extern BOOL InitFrameDetails(PB_INSTANCE *pbi); 

// RGB YUV Conversions
extern void ScalarYUVtoRGB ( PB_INSTANCE * pbi,YUV_BUFFER_ENTRY_PTR yblock, YUV_BUFFER_ENTRY_PTR ublock,		
				             YUV_BUFFER_ENTRY_PTR vblock, int uvoffset,					    
                             BGR_TYPE * RGBPtr, BOOL ReconBuffer );

extern void CopyYUVtoBmp( PB_INSTANCE * pbi,YUV_BUFFER_ENTRY_PTR YUVPtr, UINT8 * BmpPtr, BOOL ConvertAll, BOOL ReconBuffer );
//extern void SetupRgbYuvAccelerators(void);
extern void ErrorTrap( PB_INSTANCE *pbi, int ErrorCode );

// Initialization Routines
extern BOOL AllocateFragmentInfo(PB_INSTANCE * pbi);
extern BOOL AllocateFrameInfo(PB_INSTANCE * pbi, unsigned int FrameSize);
extern void DeleteFragmentInfo(PB_INSTANCE * pbi);
extern void DeleteFrameInfo(PB_INSTANCE * pbi);
extern void fillidctconstants(void);
extern void DMachineSpecificConfig(PB_INSTANCE *pbi);

// Tim's bit reading functions
extern __inline UINT32 bitread1(BITREADER *br) ;
extern __inline UINT32 bitread(BITREADER *br, int bits);

extern void ClearSysState(void);
#endif