You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
830 lines
29 KiB
830 lines
29 KiB
/* *************************************************************************
|
|
** 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_
|