h261func.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:15k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _INC_H261FUNC
  36. #define _INC_H261FUNC   1 
  37. //  dct.c
  38. extern void Dct2( PIXEL x[], int xdim, S16 y[8][8] );
  39. extern void Dct2Diff( PIXEL x[], int xdim, PIXEL pred[], S16 y[64] );
  40. extern void InitDctTables ( void );
  41. extern void Dct8x8ssDiff( PIXEL x[], int xdim, PIXEL pred[], S16 y[8*8],
  42.                           int hSize,    // 16: normal DCT; otherwise: mirror input horizontally
  43.                           int vSize     // 16: normal DCT; otherwise: mirror input vertically
  44.                           );
  45. //  dct4x4.c
  46. extern void Dct4x4( PIXEL x[], int xdim, S16 y[4][4]);
  47. extern void Dct4x4Diff( PIXEL x[], int xdim, PIXEL pred[], S16 y[4][4]);
  48. //  h261dec.c
  49. extern int  H261Decode( H261Decoder * s );
  50. extern int  BsDiff( BS_PTR bs1, BS_PTR bs2 );   // Compute # bits in segment bs1 - bs2
  51. extern void InitFindSC( void );
  52. extern int  checksym( SYMBOL sym, int type, char routine[] );
  53. //  h261enc.c
  54. extern int H261Encode( H261Encoder * s, H261PicDescriptor d, TIME32 time0[], S32 DCTStats[] );
  55. extern int H261Recon( H261Encoder * s, H261PicDescriptor d );
  56. //  h261err.c
  57. extern void H261ErrMsg( char s[] );
  58. //  h263dec.c
  59. extern int  DecPicLayer263( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  60.                             GOB_DESCR * gob, int * decPtype );
  61. extern void InitMvTabs( int trD, int trB,
  62.                         int tabMvF[], int tabMvB[]  // [UMV_MIN:UMV_MAX]
  63.                         );
  64. extern int  DecGobLayer263( BS_PTR * bs, int nbits, GOB_DESCR * gob, int * gfid );
  65. extern int  DecMbLayer263(  BS_PTR * bs,    // Bitstream pointer
  66.                             int nbits,      // Bits to decode (incl. trailing startcode)
  67.                             GOB_DESCR * gob,        // GOB descriptor
  68.                             MACROBLOCK_DESCR mb[],  // Packed array of "gob->num_mb" MB descr.
  69.                             int interFrame, // 0: ptype=INTRA, otherwise ptype=INTER
  70.                             int PBframe,    // 0: not PB frame, otherwise PB frame
  71.                             int unrestrictedMv, // 0: -16/+15.5 motion, otherwise +/- 31.5
  72.                             int advancedIntraMode, // 0 off else on
  73.                             SYMBOL sym[],   // symbol array
  74.                             int maxsym      // size of symbol array
  75.                             );
  76. extern void GetMvBframe( MACROBLOCK_DESCR *mb, int unrestrictedMv,
  77.                          int tabMvF[], int tabMvB[]  // [UMV_MIN:UMV_MAX]
  78.                          );
  79. //  idct.c
  80. extern void InitReconTables( void );
  81. extern void Idct2( SYMBOL sym[], int nsym, PIXEL x[], int xdim, S16 recon[], int clean );
  82. extern void Idct2Sum( SYMBOL sym[], int nsym, PIXEL x[], int xdim, S16 recon[], int clean );
  83. extern void Idct2_s16( int intra, SYMBOL sym[], int nsym, S16 x[], int xdim, S16 recon[] );
  84. //  intercod.c
  85. extern U8  ReconStep[];
  86. extern int InterCode( PICTURE *pic, PICTURE *pred, MACROBLOCK_DESCR * mb, int masking,
  87.                         SYMBOL sym[] );
  88. extern int IntraCode( PICTURE *pic, MACROBLOCK_DESCR * mb, SYMBOL sym[], long mbDiff, int codingMethod );
  89. extern void InitQuantTables( void );
  90. extern int Code32x32( PICTURE *pic, PICTURE *pred, MACROBLOCK_DESCR * mb, int masking,
  91.                         SYMBOL sym[], int intraFlag );
  92. //  predsel.c
  93. extern void InitPred( void );
  94. extern int PredSelect( H261PicDescriptor *d, PICTURE *oldOut, PICTURE *newIn,
  95.                        int mbhor, int mbvert, MACROBLOCK_DESCR mb[], GOB_DESCR gob[],
  96.                        PICTURE *pred, int dct_thresh, H261Stats *stats,
  97.                        S32 weight_1, S32 weight_2, S32 sendGobHeaders );
  98. extern int var16( PIXEL pic[], int xdim, int phase, long var[4] );
  99. extern int err16( PIXEL new[], PIXEL old[], int xdim, int phase, int err[4] );
  100. extern int  LoopFilter( MACROBLOCK_DESCR *mb, PICTURE *prev_pic, PICTURE *pic );
  101. // mcomp.c
  102. extern int  MotionComp( MACROBLOCK_DESCR *mb, PICTURE *prev_pic, PICTURE *pic );
  103. extern void MotionComp263( MACROBLOCK_DESCR * mb, // Describes block to be motion-compensated
  104.                             PICTURE * prevPic,  // Describes previous picture used to form MC
  105.                             PICTURE * pic       // Output picture where MC block is placed
  106.                             );
  107. extern void OverlapMC( MACROBLOCK_DESCR * mb,   // Describes block to be motion-compensated
  108.                         int     PBframe,    // Non-zero if PB frame
  109.                         PICTURE * prevPic,  // Describes previous picture used to form MC
  110.                         PICTURE * pic,      // Output picture where MC block is placed
  111.                         int     mbWidth,    // Macroblocks per row
  112.                         int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
  113.                         int     overlap[4]  // Returns YES or NO to indicate whether overlap
  114.                                             // was done in each 8x8 subblock
  115.                         );
  116. extern int PointingOutside( int col1, int col2, // First and last column of block
  117.                             int row1, int row2, // First and last row of block
  118.                             int mvX, int mvY,   // Motion vector; one fractional bit
  119.                             int nCols, int nRows    // Picture size
  120.                             );
  121. extern void PredBframe( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  122.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  123.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  124.                         PICTURE * Bpic          // Output picture where pred is placed
  125.                         );
  126. extern void PredBdist( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  127.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  128.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  129.                         PICTURE * Bpic          // Output picture where pred is placed
  130.                         );
  131. //  mest.c
  132. extern int  MotionEst( PICTURE *new_in, PICTURE *old_in, int mbhor, int mbvert,
  133.    MACROBLOCK_DESCR Mb[], int unrestrictedMv, int advancedPred, S32 *mvSum );
  134. extern int  RefineMotionVector( MACROBLOCK_DESCR *mb,   // MB descriptor; contains initial MV
  135.                                 PIXEL new[],    // Upper left pixel of new 16x16 block
  136.                                 PIXEL old[],    // Old block (no motion comp)
  137.                                 int xdim,       // Line offset for "new" and "old"
  138.                                 int phase,      // Phase used for computing "mc_err"
  139.                                 int mc_err,     // Error for initial motion vector
  140.                                 int err[4],     // Error for each 8x8 block; submit values for
  141.                                                 // initial mv; returns values for chosen mv
  142.                                 int horPredOnly );   // 1-D prediction for mv?
  143. extern int  TryInter4V( MACROBLOCK_DESCR mb[],  // MB descriptor array; mb[0] is current mb;
  144.                                                 // use surrounding mb's to get mv candidates
  145.                                                 // Note: "past" mv's have a fractional bit
  146.                         PIXEL new[],    // Upper left pixel of new 16x16 block
  147.                         PIXEL old[],    // Old block (no motion comp)
  148.                         int xdim,       // Line offset for "new" and "old"
  149.                         int phase,      // Phase used for computing "mc_err"
  150.                         int mc_err,     // Error for initial motion vector
  151.                         int errMc[4],   // Error for each 8x8 block with INTER mv (undefined
  152.                                         //  if mv=0); returns values for chosen mv/mv's
  153.                         int err[4],     // Error for each 8x8 block with mv=0
  154.                                         //  We are assuming that sum(err) > sum(errMc)
  155.                         int sqQuant     // QUANT^2; needed for INTER4V decision
  156.                         );
  157. extern int UmvErr( PIXEL new[], PIXEL old[], int xdim, int phase, int errvec[4],
  158.                    int size, int col, int row, int mvX, int mvY );
  159. extern int RefineMvReducedResMode( MACROBLOCK_DESCR *mb,// MB descriptor; contains initial MV
  160.                                    int blk,     // Subblock (0,1,2,or 3)
  161.                                    PIXEL new[], // Upper left pixel of new 16x16 or 8x8 block
  162.                                    PIXEL old[], // Old block (no motion comp)
  163.                                    int xdim,    // Line offset for "new" and "old"
  164.                                    int phase,   // Phase used for computing "mc_err"
  165.                                    int col, int row // (x,y) position for upper left corner
  166.                                    );
  167. //  enc
  168. extern void MvPred( MACROBLOCK_DESCR mb[],
  169.                     int blk,        // specify block: UL, UR, LL, LR, or WHOLE 
  170.                     int mbhor,      // offset from previous row of MBs
  171.                     int horPredOnly, 
  172.                     int *mvX, int *mvY );
  173. //  vld.c
  174. extern U8 Get8Bits( BS_PTR bs );
  175. extern void IncBsPtr( BS_PTR * bs, int incr );
  176. extern int FLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
  177.                         int bits,           // Symbol length
  178.                         int * numBits,      // Max # bits to decode; decremented by this routine
  179.                         int * value         // Returns decoded symbol
  180.                         );
  181. extern int VLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
  182.                         int tabNum,         // Use dectable[tabNum] for decoding
  183.                         int * numBits,      // Max # bits to decode; decremented by this routine
  184.                         SYMBOL * sym        // Returns decoded symbol
  185.                         );
  186. extern void InitDecodeTable( void );
  187. //  quant2.c
  188. extern int QuantSelect ( S32 codedBlkCnt, H261CodingControl * cntrl, int num_mb,
  189.                          MACROBLOCK_DESCR mb[], MbInfo mbStats[], long *logSum, S32 color,
  190.                          int reducedResUpdate );
  191. extern void InitLogTab ( void );
  192.                       
  193. // getImgParms().
  194. extern S16 getImgParms( short format, short *numGOBS, short *numMBs, long *imgSize,
  195.             long *lumaSize, long *chromaLineLength, long *chromaRows, long *maxsym);
  196. // vdecopcl.c
  197. extern int AllocVarStructsDecoder( H261Decoder *dec, short formatCap_or_numMBs );
  198. extern void FreeVarStructsDecoder( H261Decoder *dec );
  199. // recongob.c
  200. extern int ReconGob( GOB_DESCR * gob, MACROBLOCK_DESCR mb[],
  201.                      PICTURE * prev_pic, PICTURE * pic, PICTURE * Bpic, 
  202.                      int advancedPred, int PBframe, int PBframeCap, int reducedResUpdate,
  203.                      int advancedIntraMode, H261DecState *state, int maxComp );
  204. extern int ConcealGob( GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int reducedResUpdate,
  205.                        PICTURE * prev_pic, PICTURE * pic );
  206. extern void ReconIntra( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean);
  207. extern void ReconAdvancedIntra( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean);
  208. extern void ReconInter( MACROBLOCK_DESCR * mb, PICTURE * pic, int clean );
  209. extern S8 ReducedResMvComponent( S8 x );
  210. extern void MotionComp32x32( MACROBLOCK_DESCR * mb, // Describes block to be motion-compensated
  211.                             PICTURE * prevPic,  // Describes previous picture used to form MC
  212.                             PICTURE * pic       // Output picture where MC block is placed
  213.                             );
  214. extern void Overlap32x32( MACROBLOCK_DESCR * mb,   // Describes block to be motion-compensated
  215.                         PICTURE * prevPic,  // Describes previous picture used to form MC
  216.                         PICTURE * pic,      // Output picture where MC block is placed
  217.                         int     mbWidth,    // Macroblocks per row
  218.                         int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
  219.                         int     overlap[4]  // Returns YES or NO to indicate whether overlap
  220.                                             // was done in each 8x8 subblock
  221.                         );
  222. extern void Fill32x32( MACROBLOCK_DESCR * mb, PICTURE * pic, PIXEL value );
  223. extern void ReconReducedResMb( MACROBLOCK_DESCR * mb,   // Macroblock to be reconstructed
  224.                                PICTURE * pic,   // Input: motioncomp. prediction;
  225.                                                 // output: reconstr. picture
  226.                                int intra,       // INTER block if zero, otherwise INTRA
  227.                                PICTURE * tempPic// Use for temporary storage
  228.                                );
  229. //  Routines used for debugging
  230. extern void printsym( SYMBOL sym );
  231. extern void sprintsym( SYMBOL sym, char s[], int sBufLen );
  232. extern void sprinttype( int symtype, char s[] , int sBufLen);
  233. extern void printstate( int state );
  234. #endif