h261func.h

symbian 下的helix player源代码

                        PICTURE * pic,      // Output picture where MC block is placed
                        int     mbWidth,    // Macroblocks per row
                        int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
                        int     overlap[4]  // Returns YES or NO to indicate whether overlap
                                            // was done in each 8x8 subblock
                        );
extern int PointingOutside( int col1, int col2, // First and last column of block
                            int row1, int row2, // First and last row of block
                            int mvX, int mvY,   // Motion vector; one fractional bit
                            int nCols, int nRows    // Picture size
                            );
extern void PredBframe( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
                        PICTURE * prevPic,      // Prev. picture (forward pred)
                        PICTURE * nextPic,      // Next P-picture (backward pred)
                        PICTURE * Bpic          // Output picture where pred is placed
                        );
extern void PredBdist( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
                        PICTURE * prevPic,      // Prev. picture (forward pred)
                        PICTURE * nextPic,      // Next P-picture (backward pred)
                        PICTURE * Bpic          // Output picture where pred is placed
                        );

//  mest.c
extern int  MotionEst( PICTURE *new_in, PICTURE *old_in, int mbhor, int mbvert,
					   MACROBLOCK_DESCR Mb[], int unrestrictedMv, int advancedPred, S32 *mvSum );
extern int  RefineMotionVector( MACROBLOCK_DESCR *mb,   // MB descriptor; contains initial MV
                                PIXEL new[],    // Upper left pixel of new 16x16 block
                                PIXEL old[],    // Old block (no motion comp)
                                int xdim,       // Line offset for "new" and "old"
                                int phase,      // Phase used for computing "mc_err"
                                int mc_err,     // Error for initial motion vector
                                int err[4],     // Error for each 8x8 block; submit values for
                                                // initial mv; returns values for chosen mv
                                int horPredOnly );   // 1-D prediction for mv?
extern int  TryInter4V( MACROBLOCK_DESCR mb[],  // MB descriptor array; mb[0] is current mb;
                                                // use surrounding mb's to get mv candidates
                                                // Note: "past" mv's have a fractional bit
                        PIXEL new[],    // Upper left pixel of new 16x16 block
                        PIXEL old[],    // Old block (no motion comp)
                        int xdim,       // Line offset for "new" and "old"
                        int phase,      // Phase used for computing "mc_err"
                        int mc_err,     // Error for initial motion vector
                        int errMc[4],   // Error for each 8x8 block with INTER mv (undefined
                                        //  if mv=0); returns values for chosen mv/mv's
                        int err[4],     // Error for each 8x8 block with mv=0
                                        //  We are assuming that sum(err) > sum(errMc)
                        int sqQuant     // QUANT^2; needed for INTER4V decision
                        );
extern int UmvErr( PIXEL new[], PIXEL old[], int xdim, int phase, int errvec[4],
                   int size, int col, int row, int mvX, int mvY );
extern int RefineMvReducedResMode( MACROBLOCK_DESCR *mb,// MB descriptor; contains initial MV
                                   int blk,     // Subblock (0,1,2,or 3)
                                   PIXEL new[], // Upper left pixel of new 16x16 or 8x8 block
                                   PIXEL old[], // Old block (no motion comp)
                                   int xdim,    // Line offset for "new" and "old"
                                   int phase,   // Phase used for computing "mc_err"
                                   int col, int row // (x,y) position for upper left corner
                                   );

//  enc
extern void MvPred( MACROBLOCK_DESCR mb[],
                    int blk,        // specify block: UL, UR, LL, LR, or WHOLE 
                    int mbhor,      // offset from previous row of MBs
                    int horPredOnly, 
                    int *mvX, int *mvY );

//  vld.c
extern U8 Get8Bits( BS_PTR bs );
extern void IncBsPtr( BS_PTR * bs, int incr );
extern int FLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
                        int bits,           // Symbol length
                        int * numBits,      // Max # bits to decode; decremented by this routine
                        int * value         // Returns decoded symbol
                        );
extern int VLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
                        int tabNum,         // Use dectable[tabNum] for decoding
                        int * numBits,      // Max # bits to decode; decremented by this routine
                        SYMBOL * sym        // Returns decoded symbol
                        );
extern void InitDecodeTable( void );
//  quant2.c
extern int QuantSelect ( S32 codedBlkCnt, H261CodingControl * cntrl, int num_mb,
                         MACROBLOCK_DESCR mb[], MbInfo mbStats[], long *logSum, S32 color,
                         int reducedResUpdate );
extern void InitLogTab ( void );

                      
// getImgParms().
extern S16 getImgParms( short format, short *numGOBS, short *numMBs, long *imgSize,
            long *lumaSize, long *chromaLineLength, long *chromaRows, long *maxsym);


// vdecopcl.c
extern int AllocVarStructsDecoder( H261Decoder *dec, short formatCap_or_numMBs );
extern void FreeVarStructsDecoder( H261Decoder *dec );

// recongob.c
extern int ReconGob( GOB_DESCR * gob, MACROBLOCK_DESCR mb[],
                     PICTURE * prev_pic, PICTURE * pic, PICTURE * Bpic, 
                     int advancedPred, int PBframe, int PBframeCap, int reducedResUpdate,
                     int advancedIntraMode, H261DecState *state, int maxComp );
extern int ConcealGob( GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int reducedResUpdate,
                       PICTURE * prev_pic, PICTURE * pic );
extern void ReconIntra( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean);
extern void ReconAdvancedIntra( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean);
extern void ReconInter( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean );
extern S8 ReducedResMvComponent( S8 x );
extern void MotionComp32x32( MACROBLOCK_DESCR * mb, // Describes block to be motion-compensated
                            PICTURE * prevPic,  // Describes previous picture used to form MC
                            PICTURE * pic       // Output picture where MC block is placed
                            );
extern void Overlap32x32( MACROBLOCK_DESCR * mb,   // Describes block to be motion-compensated
                        PICTURE * prevPic,  // Describes previous picture used to form MC
                        PICTURE * pic,      // Output picture where MC block is placed
                        int     mbWidth,    // Macroblocks per row
                        int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
                        int     overlap[4]  // Returns YES or NO to indicate whether overlap
                                            // was done in each 8x8 subblock
                        );
extern void Fill32x32( MACROBLOCK_DESCR * mb, PICTURE * pic, PIXEL value );
extern void ReconReducedResMb( MACROBLOCK_DESCR * mb,   // Macroblock to be reconstructed
                               PICTURE * pic,   // Input: motioncomp. prediction;
                                                // output: reconstr. picture
                               int intra,       // INTER block if zero, otherwise INTRA
                               PICTURE * tempPic// Use for temporary storage
                               );

//  Routines used for debugging
extern void printsym( SYMBOL sym );
extern void sprintsym( SYMBOL sym, char s[], int sBufLen );
extern void sprinttype( int symtype, char s[] , int sBufLen);
extern void printstate( int state );

#endif