/* ************************************************************************* ** INTEL Corporation Proprietary Information ** ** This listing is supplied under the terms of a license ** agreement with INTEL Corporation and may not be copied ** nor disclosed except in accordance with the terms of ** that agreement. ** ** Copyright (c) 1995 Intel Corporation. ** All Rights Reserved. ** ** ************************************************************************* */ //////////////////////////////////////////////////////////////////////////// // // $Author: MDUDA $ // $Date: 19 Mar 1997 14:58:04 $ // $Archive: S:\h26x\src\enc\e3enc.h_v $ // $Header: S:\h26x\src\enc\e3enc.h_v 1.87 19 Mar 1997 14:58:04 MDUDA $ // $Log: S:\h26x\src\enc\e3enc.h_v $ ;// ;// Rev 1.87 19 Mar 1997 14:58:04 MDUDA ;// Increased motion estimation stack space from 16k to 64k bytes. ;// ;// Rev 1.86 17 Mar 1997 20:19:50 MDUDA ;// Moved local storage to encoder catalog and allocated pseudo stack ;// space needed to work around problem with 16-bit apps that allocated ;// insufficient stack space. ;// ;// Rev 1.85 10 Feb 1997 11:43:28 JMCVEIGH ;// ;// Support for new interpretation of blocking filter - ;// allow for motion vectors outside of the reference picture. ;// ;// Rev 1.84 07 Feb 1997 10:58:14 CZHU ;// Added three entry in EC to remove static variable used in e3rtp.cpp ;// ;// Rev 1.83 05 Feb 1997 12:19:18 JMCVEIGH ;// Pass GOBHeaderPresent parameter to MMxEDTQ() for EMV bug fix ;// support latest H.263+ draft bitstream spec, and support for ;// separate improved PB-frame flag. ;// ;// Rev 1.82 30 Dec 1996 19:55:48 MDUDA ;// Added color convertor initializer prototype. ;// ;// Rev 1.81 19 Dec 1996 16:33:38 MDUDA ;// Modified call to colorCnvtFrame to support H263 backward compatibility. ;// ;// Rev 1.80 16 Dec 1996 17:49:48 JMCVEIGH ;// H263Plus flag. ;// ;// Rev 1.79 16 Dec 1996 13:35:30 MDUDA ;// ;// Added ColorConvertor field to Encoder Catalog. ;// ;// Rev 1.78 11 Dec 1996 15:03:58 JMCVEIGH ;// ;// Changed size of padding of encoder catalog to handle H.263+ ;// options. ;// ;// Rev 1.77 10 Dec 1996 09:07:48 JMCVEIGH ;// Fixed bug in padding of T_H263EncoderCatalog to 512 bytes when ;// H263P not defined. ;// ;// Rev 1.76 09 Dec 1996 17:59:28 JMCVEIGH ;// Added support for arbitrary frame size support. ;// 4 <= width <= 352, 4 <= height <= 288, both multiples of 4. ;// Normally, application will pass identical (arbitrary) frame ;// sizes in lParam1 and lParam2 of CompressBegin(). If ;// cropping/stretching desired to convert to standard frame sizes, ;// application should pass the desired output size in lParam2 and ;// the input size in lParam1. ;// ;// Rev 1.75 09 Dec 1996 09:49:44 MDUDA ;// Modified for H263P. ;// ;// Rev 1.74 11 Nov 1996 09:12:28 JMCVEIGH ;// Added bPrevIntra. This is used to re-initialize the ME states ;// when the previous frame was intra coded and the current frame ;// is to be inter coded. ;// ;// Rev 1.73 06 Nov 1996 16:32:12 gmlim ;// Removed H263ModeC preprocessor definitions. ;// ;// Rev 1.72 05 Nov 1996 13:25:08 GMLIM ;// Added mode c support for mmx case. ;// ;// Rev 1.71 03 Nov 1996 19:01:26 gmlim ;// Parameters changed in PB_GOB_Q_RLE_VLC_WriteBS() for mode c. ;// ;// Rev 1.70 22 Oct 1996 14:51:52 KLILLEVO ;// Blocktype initialization in InitMEState() is now only called if ;// the AP mode has changed from the previous picture. ;// ;// Rev 1.69 10 Oct 1996 16:43:02 BNICKERS ;// Initial debugging of Extended Motion Vectors. ;// ;// Rev 1.68 04 Oct 1996 08:47:56 BNICKERS ;// Add EMV. ;// ;// Rev 1.67 12 Sep 1996 10:56:12 BNICKERS ;// Add arguments for thresholds and differentials. ;// ;// Rev 1.66 06 Sep 1996 16:12:28 KLILLEVO ;// fixed the logical problem that the inter code count was always ;// incremented no matter whether coefficients were transmitted or not ;// ;// Rev 1.65 22 Aug 1996 11:31:24 KLILLEVO ;// changed PB switch to work the same for IA as for MMX ;// ;// Rev 1.64 19 Aug 1996 13:49:04 BNICKERS ;// Provide threshold and differential variables for spatial filtering. ;// ;// Rev 1.63 25 Jun 1996 14:24:50 BNICKERS ;// Implement heuristic motion estimation for MMX, AP mode. ;// ;// Rev 1.62 30 May 1996 15:09:08 BNICKERS ;// Fixed minor error in recent IA ME speed improvements. ;// ;// Rev 1.61 29 May 1996 15:38:02 BNICKERS ;// Acceleration of IA version of ME. ;// ;// Rev 1.60 14 May 1996 12:18:44 BNICKERS ;// Initial debugging of MMx B-Frame ME. ;// ;// Rev 1.59 03 May 1996 14:59:32 KLILLEVO ;// added one parameter to MMXEDTQ() : pointer to B-frame stream of ;// run,lengt,sign triplets ;// ;// Rev 1.58 03 May 1996 10:55:00 KLILLEVO ;// ;// started integrating Brian's MMX PB-frames ;// ;// Rev 1.57 02 May 1996 12:01:02 BNICKERS ;// Initial integration of B Frame ME, MMX version. ;// ;// Rev 1.56 28 Apr 1996 19:56:52 BECHOLS ;// Enabled RTP header stuff in calls. ;// ;// Rev 1.55 26 Apr 1996 11:06:36 BECHOLS ;// Added rtp stuff... but still need to get rid of ifdef's ;// ;// Rev 1.54 26 Mar 1996 12:00:16 BNICKERS ;// Did some tuning for MMx encode. ;// ;// Rev 1.53 15 Mar 1996 15:57:32 BECHOLS ;// ;// Added support for monolithic MMx code. ;// ;// Rev 1.52 12 Mar 1996 13:26:52 KLILLEVO ;// new rate control with adaptive bit usage profile ;// ;// Rev 1.51 27 Feb 1996 14:12:56 KLILLEVO ;// ;// PB switch ;// ;// Rev 1.50 22 Feb 1996 18:48:50 BECHOLS ;// ;// Added declarations for MMX functions. ;// ;// Rev 1.49 24 Jan 1996 13:21:26 BNICKERS ;// Implement OBMC ;// ;// Rev 1.48 22 Jan 1996 17:13:22 BNICKERS ;// Add MBEdgeType to MacroBlock Action Descriptor. ;// ;// Rev 1.47 22 Jan 1996 16:29:20 TRGARDOS ;// Started adding bit counting structures and code. ;// ;// Rev 1.46 03 Jan 1996 12:19:02 TRGARDOS ;// Added bUseINISettings member to EC structure. ;// ;// Rev 1.45 02 Jan 1996 17:07:54 TRGARDOS ;// Moved colorCnvtFrame into excolcnv.cpp and made ;// color convertor functions static. ;// ;// Rev 1.44 27 Dec 1995 15:32:56 RMCKENZX ;// Added copyright notice ;// ;// Added uBitUsageProfile for BRC. ;// added a control to activate the chaned BRC ;// Hookup init from Registry instead of ini ;// Add a parameter to QRLE entry point - bRTPHeader flag ;// Add a variable to the encoder catalog to store the netx intra MB ;// Added comments ;// integrate with build 29 // //////////////////////////////////////////////////////////////////////////// #ifndef __H263E_H__ #define __H263E_H__ /* * This file declares structs which catalog the locations of various * tables, structures, and arrays needed by the H263 encoder. */ const U8 def263INTRA_QP = 16; // default QP values const U8 def263INTER_QP = 16; /* * Block description structure. Must be 16-byte aligned. * See e3mbad.inc for more detail on each structure entry. */ typedef struct { U32 BlkOffset; // [0-3] Offset to 8*8 target block from start of Y plane. union { /* * Adress of reference block for P frame motion estimation. */ U8 *PastRef; // [4-7] Address of 8*8 reference block. /* * MVf and MVb vectors for B-frame motion estimation as defined in * H.263 spec. The reference block addresses are generated for * frame differencing. The numbers are biased by 60H. */ struct { U8 HMVf; U8 VMVf; U8 HMVb; U8 VMVb; } CandidateMV; } B4_7; struct { // Scratch variables used by ME. U8 HMVf; U8 VMVf; U8 HMVb; U8 VMVb; } BestMV; char PHMV; // [12] Horizontal motion vector for P block.. char PVMV; // [13] Vertical motion vector for P block.. char BHMV; // [14] Horizontal motion vector (delta?) for B block.. char BVMV; // [15] Vertical motion vector (delta?) for B block.. } T_Blk; const int sizeof_T_Blk = 16; /* * T_MBlockActionStream - Structure to keep side information for a MB * used by encoder. This structure must be 16-byte aligned when allocated. * CodedBlocks must be DWORD aligned. The entire structure must be a multiple * of 16 bytes, and must match the size of the structure in e3mbad.inc. */ #define SIZEOF_PSEUDOSTACKSPACE (1024 * 64) typedef struct { U8 BlockType; // 0 -- See block types below. U8 MBEdgeType; // 1 -- 1 off if left edge | 2 right | 4 top | 8 bottom. U8 Unassigned1; // 2 -- U8 FirstMEState; // 3 -- First State Num for Motion Estimation engine. U8 CodedBlocks; // 4 -- [6] End-of-Stream indicator // [0] indicates Y1 non-empty // [1...5] indicates Y2, Y3, Y4, U, V nonempty. // Other bits zero. U8 CodedBlocksB; // 5 -- [0...5] like CodedBlocks, but for B frame. // Set to 0 for non bi-di prediction. U8 Unassigned2[2]; // 6...7 U32 SWD; // 8...11 Sum of weighted diffs, from motion estimation. U32 SWDB; // 12...15 Sum of weighted diffs, from B frame motion estimation. T_Blk BlkY1; // 16...31 T_Blk BlkY2; // 32...47 T_Blk BlkY3; // 48...63 T_Blk BlkY4; // 64...79 T_Blk BlkU; // 80...95 T_Blk BlkV; // 96...111 U8 COD; // 112 -- Coded macroblock indication. When set to "0" // indicates that macroblock is coded. If set to // "1", it indicates that the macroblock is not coded // and the rest of the macroblock layer is empty. U8 MBType; // 113 -- Macro block type, {INTER, INTER+Q, INTER4V, INTRA, INTRA+Q} U8 CBPC; // 114 -- Coded block pattern for chrominance. U8 MODB; // 115 -- Macroblock mode for B-blocks. U8 CBPB; // 116 -- Coded block pattern for B blocks. U8 CBPY; // 117 -- Coded block pattern for luminance. U8 DQUANT; // 118 -- Quantizer information. A two bit pattern to define // change in QUANT. U8 InterCodeCnt; // 119 -- Count number of times current MB has been intercoded. U8 Unassigned4[8];// 120...127 -- Pad out to a power of two. } T_MBlockActionStream; const int sizeof_T_MBlockActionStream = 128; /* * Block Types */ const U8 INTERBLOCK = 0; const U8 INTRABLOCK = 1; const U8 INTERBIDI = 2; const U8 INTRABIDI = 3; const U8 INTER4MV = 4; const U8 IsINTRA = 1; // Mask to check for INTRA or ITNRABIDI. const U8 IsBIDI = 2; // Mask to check for INTRABIDI or INTERBIDI. /* * MB Types */ const U8 INTER = 0; const U8 INTERQ = 1; const U8 INTER4V= 2; const U8 INTRA = 3; const U8 INTRAQ = 4; /* * MB Edge Types */ const U8 MBEdgeTypeIsLeftEdge = 0xE; const U8 MBEdgeTypeIsRightEdge = 0xD; const U8 MBEdgeTypeIsTopEdge = 0xB; const U8 MBEdgeTypeIsBottomEdge = 0x7; /* * First ME state for ME engine */ const U8 ForceIntra = 0; const U8 UpperLeft = 1; const U8 UpperEdge = 2; const U8 UpperRight = 3; const U8 LeftEdge = 4; const U8 CentralBlock = 5; const U8 RightEdge = 6; const U8 LowerLeft = 7; const U8 LowerEdge = 8; const U8 LowerRight = 9; const U8 NoVertLeftEdge = 10; const U8 NoVertCentralBlock = 11; const U8 NoVertRightEdge = 12; /* * Coded block bit masks. */ const U8 Y1BLOCK = 0x01; const U8 Y2BLOCK = 0x02; const U8 Y3BLOCK = 0x04; const U8 Y4BLOCK = 0x08; const U8 UBLOCK = 0x10; const U8 VBLOCK = 0x20; const I32 GOBs_IN_CIF = 18; const I32 MBs_PER_GOB_CIF = 22; typedef struct { U8 StateNumInc_SelectCentralPt; U8 MVIncIdx_SelectCentralPt; U8 StateNumInc_SelectRef1; U8 MVIncIdx_SelectRef1; U8 StateNumInc_SelectRef2; U8 MVIncIdx_SelectRef2; U16 pad; } T_SADState; /* * Structure to store bit counts. */ typedef struct { U32 PictureHeader; // 0 All of picture header. U32 GOBHeader; // 4 All of GOB Header. U32 MBHeader; // 8 All of MB header. U32 DQUANT; // 12 Bits spent on DQUANT. U32 MV; // 16 Bits spent on MV's. U32 Coefs; // 20 Total bits spent on coefs. U32 Coefs_Y; // 24 Total bits spent on Y coefs. U32 IntraDC_Y; // 28 Bits spent on IntraDC coefs for Y. U32 Coefs_C; // 32 Total bits spent on Chroma Coefs U32 IntraDC_C; // 36 Bits spent on IntraDC coefs for C. U32 CBPY; // 40 Bits spent on CBPY U32 MCBPC; // 44 Bits spent on MCBPC U32 Coded; // 48 Number of coded blocks. U32 num_intra; // 52 Number of intra coded blocks. U32 num_inter; // 56 Number of Inter coded blocks. U32 num_inter4v; // 60 Number of Inter4V coded blocks. } T_BitCounts; typedef struct { U32 MBStartBitOff; // Start of MB Data U8 CBPYBitOff; // from start of MB data U8 MVDBitOff; U8 BlkDataBitOff; // from start of MB data } T_FutrPMBData; #ifdef LOG_ENCODE_TIMINGS_ON // { LOG_ENCODE_TIMINGS_ON /* Encoder Timing Data - per frame */ typedef struct { U32 uEncodeFrame; #ifdef DETAILED_ENCODE_TIMINGS_ON // { DETAILED_ENCODE_TIMINGS_ON U32 uInputCC; U32 uMotionEstimation; U32 uFDCT; U32 uQRLE; U32 uDecodeFrame; U32 uZeroingBuffer; #endif // } DETAILED_ENCODE_TIMINGS_ON } ENC_TIMING_INFO; #define ENC_TIMING_INFO_FRAME_COUNT 105 #endif // } LOG_ENCODE_TIMINGS_ON /* * T_H263EncoderCatalog - Catalog of information needed for an instance. * This structure must be multiple of 16. */ typedef struct { U8 *pU8_CurrFrm; // 0 U8 *pU8_CurrFrm_YPlane; // 4 Pointers to current frame buffers. U8 *pU8_CurrFrm_VPlane; // 8 U8 *pU8_CurrFrm_UPlane; // 12 U8 *pU8_PrevFrm; // 16 U8 *pU8_PrevFrm_YPlane; // 20 Pointers to previous frame buffers U8 *pU8_PrevFrm_VPlane; // 24 U8 *pU8_PrevFrm_UPlane; // 28 U8 *pU8_FutrFrm; // 32 U8 *pU8_FutrFrm_YPlane; // 36 Pointers to previous frame buffers U8 *pU8_FutrFrm_VPlane; // 40 U8 *pU8_FutrFrm_UPlane; // 44 U8 *pU8_BidiFrm; // 48 U8 *pU8_BFrm_YPlane; // 52 Pointers to B frame buffers. U8 *pU8_BFrm_UPlane; // 56 U8 *pU8_BFrm_VPlane; // 60 T_MBlockActionStream *pU8_MBlockActionStream; // 64 Pointer to macro block action stream. I32 *pU8_DCTCoefBuf; // 68 Pointer to GOB DCT coefficient buffer. U8 *pU8_BitStream; // 72 Pointer to bitstream buffer. U8 *pU8_BitStrCopy; // 76 Pointer to bitstream buffer // for the PB-frame T_H263FrameHeaderStruct PictureHeader;// 80..127 (48 bytes) // Picture layer header structure. UN FrameHeight; // 128 UN FrameWidth; // 132 FrameSize FrameSz; // 136 -- Define frame size: SQCIF, QCIF, CIF UN NumMBRows; // 140 -- Number of rows of MB's UN NumMBPerRow; // 144 -- Number of MB's in a row. UN NumMBs; // 148 -- Total number of MBs. U8 *pU8_RGB24Image; // 152 U8 *pU8_MBlockCodeBookStream;// 156 U8 *pU8_BlockCodeBookStream; // 160 U8 *pU8_BlockOfInterCoeffs; // 164 U8 *pU8_BlockOfIntraCoeffs; // 168 U32 AvgIntraSAD; // 172 Average SAD for Intra macroblocks. LPDECINST pDecInstanceInfo; // 176 Private decoder instance info. BRCStateStruct BRCState; // 180 State variables for bitrate control (32 bytes) U8 u8EncodePBFrame; // 212 Should encoder encode PB frames U8 u8SavedBFrame; // 213 Do we have a B-Frame saved for // encoding PB-frame U8 bMakeNextFrameKey; // 214 U8 bUseINISettings; // 215 U32 GOBHeaderPresent; // 216...220 Flag which GOB headers are present. U32 LastSWDBeforeForcedP; // 220...224 The last SWD before B frames were turned off T_BitCounts Bits; // 224 .. 288 U8 *pU8_PredictionScratchArea; // 288...292 Pointer to area for pre-computing predictions. U8 prevAP; // 292 AP mode for previous picture U8 prevUMV; // 293 UMV mode for previous picture (not used) U8 bPrevFrameIntra; // 294 Flag whether previous frame was intra coded (used to set the ME states) U8 Unassigned0[1]; // 295...295 available U32 uBitUsageProfile[19]; // 296...372 Table for storing bit usage profile // 19 is large enough for CIF // element 0...NumGOBs-1 stores cumulative bit usage // element NumGOBs stores the final frame size I8 *pI8_MBRVS_Luma; // 372..376 Pointer to area for Luma Run Value Sign Triplets. I8 *pI8_MBRVS_Chroma; // 376..380 Pointer to area for Chroma Run Value Sign Triplets. HANDLE hBsInfoStream; // 380..384 memory handle for blocks allocate for extended portion of bs void * pBsInfoStream; // 384..388 point to next BITSTREAM_INFO struct for next packet U32 uBase; // 388..392 byte offset of at the beginning of this packet from start // 392..396 of the whole bitstream; U32 uPacketSizeThreshold; // 396..400 the packet size used by the codec void * pBaseBsInfoStream; // 400..404 start of bitstream extension U32 uNumOfPackets; // 404..408 U32 uNextIntraMB; // 408..412 Used to implement rolling intra MBs U32 uNumberForcedIntraMBs; // 412..416 Number of forced intras in each frame I8 *pI8_MBRVS_BLuma; // 416..420 Pointer to area for Luma Run Value Sign Triplets for the B-frame (MMX) I8 *pI8_MBRVS_BChroma; // 420..424 Pointer to area for Chroma Run Value Sign Triplets for the B-frame (MMX) U8 *pU8_Signature; // 424 U8 *pU8_Signature_YPlane; // 428 Pointers to signature buffers #ifdef USE_BILINEAR_MSH26X U32 uActualFrameWidth; // 460+40 Actual (non-padded) frame width U32 uActualFrameHeight; // 464+40 Actual (non-padded) frame height U32 ColorConvertor; // 468+40 Input color convertor. #endif #ifdef H263P //NEWCHANGES U32 uBitOffset_currPacket; // 432+40 bit offset for current packet U8 *pBitStream_currPacket; // 436+40 pointer to current bitstream, last MB U8 *pBitStream_lastPacket; // 440+40 pointer to bitstream at last packet U8 *pPseudoStackSpace; // 444+40 pointer to buffer for motion estimation T_FutrPMBData *pFutrPMBData; // 448+40 pointer to buffer previously on local stack in I8 *pWeightForwMotion; // 452+40 values based on TRb and TRd I8 *pWeightBackMotion; // 456+40 values based on TRb and TRd U32 uActualFrameWidth; // 460+40 Actual (non-padded) frame width U32 uActualFrameHeight; // 464+40 Actual (non-padded) frame height U32 ColorConvertor; // 468+40 Input color convertor. U8 bH263Plus; // 469+40 Flag for using H.263+ U8 prevDF; // 470+40 Deblocking filter mode for previous picture // sizeof_T_H263FrameHeaderStruct = 88 U8 Unassigned2[2]; // Pad size to 512 bytes. #else #ifdef LOG_ENCODE_TIMINGS_ON // { LOG_ENCODE_TIMINGS_ON ENC_TIMING_INFO *pEncTimingInfo; // 432 U32 uStatFrameCount; // 436 int bTimingThisFrame; // 440 U32 uStartLow; // 444 U32 uStartHigh; // 448 #ifdef USE_BILINEAR_MSH26X U8 Unassigned2[62]; // Pad size to 512 bytes. #else U8 Unassigned2[64]; // Pad size to 512 bytes. #endif #else // }{ LOG_ENCODE_TIMINGS_ON #ifdef USE_BILINEAR_MSH26X U8 Unassigned2[72]; // Pad size to 512 bytes. #else U8 Unassigned2[84]; // Pad size to 512 bytes. #endif #endif // } LOG_ENCODE_TIMINGS_ON #endif } T_H263EncoderCatalog; const int sizeof_T_H263EncoderCatalog = 512; /* * T_H263EncoderInstanceMemory * Memory layout for encoder instance. The memory is allocated * dynamically and the beginning of this structure is aligned to a * 32 byte boundary. * All arrays should be start on a DWORD boundary. * MBActionStream should start on a 16 byte boundary. */ // Define bit stream buffer size. const unsigned int sizeof_bitstreambuf = 352*288*3/4; // This structure is allocated on a N-byte boundary, where N is the size of // a MacroBlock Action Descriptor, which must be a power of two. typedef struct { T_H263EncoderCatalog EC; U8 UnAssigned0[2560]; // so that MMX ME (EMV case) can read outside // of legal address range of MBActionStream. T_MBlockActionStream MBActionStream[22*18+3]; U8 UnAssigned1[16]; U8 u8CurrentPlane [ (288+16+8+144)*384 + 8 ]; U8 u8Pad1[ 72 ]; U8 u8PreviousPlane[ (16+288+16+8+144+8)*384 + 64]; // reconstructed past U8 u8FuturePlane [ (16+288+16+8+144+8)*384 + 0]; // reconstructed future U8 u8BPlane [ (288+16+8+144)*384 + 8 ]; // like current plane U8 u8Pad2[1928]; U8 u8Signature[(16+288+16)*384 + 24]; U8 u8Scratch1[4096]; U8 u8BitStream [ sizeof_bitstreambuf ]; U8 u8BitStrCopy[ sizeof_bitstreambuf ]; /* * Allocate space for DCT coefficients for an entire GOB. * Each block of coefficients is stored in 32 DWORDS (2 coefs/DWORD) * and there can be up to 6 blocks in a macroblock (P frame), * and up to 22 macroblocks in a GOB (CIF size). */ U32 UnAssigned2[6]; // insert 6 DWORDS to put DCT on 32 byte boundary. I32 piGOB_DCTCoefs[32*6*22]; // For best performance align to 32 byte boundary /* * Allocate scratch space for storage of prediction blocks. We need * enough space for a whole GOB, luma only. This is used for the * calculation of OBMC predictions only. */ U8 u8PredictionScratchArea[16*384]; // The following arrays are needed for MMX I8 i8MBRVS_Luma[65 * 3 * 22 * 4]; I8 i8MBRVS_Chroma[65 * 3 * 22 * 2]; DECINSTINFO DecInstanceInfo; // Private decoder instance. #if defined(H263P) U8 u8PseudoStackSpace[SIZEOF_PSEUDOSTACKSPACE]; T_FutrPMBData FutrPMBData[GOBs_IN_CIF*MBs_PER_GOB_CIF + 1]; I8 WeightForwMotion[128]; // values based on TRb and TRd I8 WeightBackMotion[128]; // values based on TRb and TRd #endif #ifdef LOG_ENCODE_TIMINGS_ON // { LOG_ENCODE_TIMINGS_ON ENC_TIMING_INFO EncTimingInfo[ENC_TIMING_INFO_FRAME_COUNT]; #endif // { LOG_ENCODE_TIMINGS_ON } T_H263EncoderInstanceMemory; // Define offsets from Y to U planes, and U to V planes. const int YU_OFFSET = (288+16+8)*384; const int UV_OFFSET = 192; const int CurPrev_OFFSET = 181328; // Offset from current to previous frame buffer. /**************************************************************** * Function prototypes ****************************************************************/ #if defined(H263P) || defined(USE_BILINEAR_MSH26X) void colorCnvtFrame ( U32 ColorConvertor, LPCODINST lpCompInst, ICCOMPRESS *lpicComp, U8 *YPlane, U8 *UPlane, U8 *VPlane ); void colorCnvtInitialize(LPBITMAPINFOHEADER lpbiInput, int InputColorConvertor); #else void colorCnvtFrame( T_H263EncoderCatalog * EC, LPCODINST lpCompInst, ICCOMPRESS * lpicComp, U8 * YPlane, U8 * UPlane, U8 * VPlane ); #endif void PutBits( unsigned int fieldval, // Value of field to write to stream. unsigned int fieldlen, // Length of field to be written unsigned char **pbs, // Pointer to current byte in bitstream unsigned char *bitoffset // bit offset in current byte of bitstream. ); extern "C" void FORWARDDCT (T_MBlockActionStream * MBlockActionStream, U8 * TargetFrameBaseAddr, U8 * PreviousFrameBaseAddr, U8 * FutureFrameBaseAddr, I32 * CoeffStream, int IsBFrame, int IsAdvancedPrediction, int IsPOfPBPair, U8 * ScratchBlocks, int NumberOfMBlksInGOB ); extern "C" void MOTIONESTIMATION ( T_MBlockActionStream * MBlockActionStream, U8 * TargetFrameBaseAddr, U8 * PreviousFrameBaseAddr, U8 * FilteredFrameBaseAddr, int DoRadius15Search, int DoHalfPelEstimation, int DoBlockLevelVectors, #if defined(H263P) U8 * pPseudoStackSpace, #endif int DoSpatialFiltering, int ZeroVectorThreshold, int NonZeroMVDifferential, int BlockMVDifferential, int EmptyThreshold, int InterCodingThreshold, int IntraCodingDifferential, int SpatialFilteringThreshold, int SpatialFilteringDifferential, U32 * IntraSWDTotal, U32 * IntraSWDBlocks, U32 * InterSWDTotal, U32 * InterSWDBlocks ); #ifdef USE_MMX // { USE_MMX extern "C" void MMxMESignaturePrep (U8 * PreviousFrameBaseAddr, U8 * SignatureBaseAddr, int FrameWidth, int FrameHeight ); extern "C" void MMxEDTQ ( T_MBlockActionStream * MBlockActionStream, U8 * TargetFrameBaseAddr, U8 * PreviousFrameBaseAddr, U8 * BTargetFrameBaseAddr, U8 * SignatureBaseAddr, I8 * WeightForWardMotion, I8 * WeightBackwardMotion, int FrameWidth, int DoHalfPelEstimation, int DoBlockLevelVectors, #if defined(H263P) U8 * pPseudoStackSpace, #endif int DoSpatialFiltering, int DoAdvancedPrediction, int DoBFrame, #if defined(H263P) int DoDeblockingFilter, // Only H.263+ should use this int DoImprovedPBFrames, // Only H.263+ should use this #endif int DoLumaBlocksInThisPass, int DoExtendedMotionVectors, #if defined(H263P) int GOBHeaderPresent, #endif int QuantizationLevel, int BQuantizationLevel, int BFrmZeroVectorThreshold, int SpatialFiltThreshold, int SpatialFiltDifferential, U32 * SWDTotal, U32 * BSWDTotal, I8 * CodeStreamCursor, I8 * CodeBStreamCursor ); #endif // } USE_MMX extern "C" void BFRAMEMOTIONESTIMATION ( T_MBlockActionStream * MBlockActionStream, U8 * TargetFrameBaseAddr, U8 * PreviousFrameBaseAddr, U8 * FutureFrameBaseAddr, I8 * WeightForWardMotion, I8 * WeightBackwardMotion, U32 ZeroVectorThreshold, #if defined(H263P) U8 * pPseudoStackSpace, #endif U32 NonZeroMVDifferential, U32 EmptyBlockThreshold, U32 * InterSWDTotal, U32 * InterSWDBlocks ); extern "C" I8 * QUANTRLE( I32 *CoeffStr, I8 *CodeStr, I32 QP, I32 BlockType ); extern "C" void MBEncodeVLC( I8 **, I8 **, U32 , U8 **, U8 *, I32, I32 ); /* * Routine to quantize, rle, vlc and write to bitstream * for an entire GOB. */ void GOB_Q_RLE_VLC_WriteBS( T_H263EncoderCatalog *EC, I32 *DCTCoefs, U8 **pBitStream, U8 *pBitOffset, T_FutrPMBData *FutrPMBData, U32 GOB, U32 QP, BOOL bRTPHeader, U32 StartingMB ); void GOB_VLC_WriteBS( T_H263EncoderCatalog *EC, I8 *pMBRVS_Luma, I8 *pMBRVS_Chroma, U8 **pBitStream, U8 *pBitOffset, T_FutrPMBData *FutrPMBData, // Start of GOB U32 GOB, U32 QP, BOOL bRTPHeader, U32 StartingMB ); void PB_GOB_Q_RLE_VLC_WriteBS( T_H263EncoderCatalog * EC, I32 * DCTCoefs, U8 * pP_BitStreamStart, U8 ** pPB_BitStream, U8 * pPB_BitOffset, const T_FutrPMBData * const FutrPMBData, const U32 GOB, const U32 QP, BOOL bRTPHeader ); void PB_GOB_VLC_WriteBS( T_H263EncoderCatalog * EC, I8 * pMBRVS_Luma, I8 * pMBRVS_Chroma, U8 * pP_BitStreamStart, U8 ** pPB_BitStream, U8 * pPB_BitOffset, const T_FutrPMBData * const FutrPMBData, const U32 GOB, const U32 QP, BOOL bRTPHeader ); void CopyBits( U8 **pDestBS, U8 *pDestBSOffset, const U8 *pSrcBS, const U32 uSrcBitOffset, const U32 uBits ); void InitVLC(void); #ifdef DEBUG_ENC void trace(char *str); #endif #ifdef DEBUG_DCT void cnvt_fdct_output(unsigned short *DCTcoeff, int DCTarray[64], int BlockType); #endif struct T_MAXLEVEL_PTABLE { int maxlevel; int * ptable; }; //extern "C" { UN FAR ASM_CALLTYPE H263EOffset_DecoderInstInfo(); } #endif // #ifndef _H263E_H_