h263_vld_h.h

h263,jpeg,mpeg2编解码核心程序(TI DSP C64xx)

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      h263_vld                                                            */
/*                                                                          */
/*  USAGE                                                                   */
/*          This routine is C-callable and can be called as:                */
/*                                                                          */
/*              int h263_vld                                                */
/*              (                                                           */
/*                  unsigned int         *restrict                          */
/*                                       *restrict bufPtr,                  */
/*                  int                  *restrict bitPtr,                  */
/*                  const unsigned short *restrict tab,                     */
/*                  const unsigned char  *restrict len,                     */
/*                  short q, int  dq,                                       */
/*                  const unsigned char  *restrict zz,                      */
/*                  short                *restrict idct,                    */
/*                  int   inter                                             */
/*              )                                                           */
/*                                                                          */
/*           bufPtr =  pointer to VLD buffer word pointer.                  */
/*           bitPtr =  pointer to the number of valid bits.n VLD_buffer     */
/*           tab    =  pointer to VLC Coeff/Run table.                      */
/*           len    =  pointer to VLC Length table.                         */
/*           Q      =  Quantization value.                                  */
/*           dq     =  Quant/Mismatch control value.                        */
/*           zz     =  Ptr to zig-zag scan table.                           */
/*           idct   =  8x8 IDCT Coeff block. (Output)                       */
/*           inter  =  Flag:  Set to 1 if INTER block, zero if INTRA        */
/*                                                                          */
/*      The function places decoded data in the idct[] array.  Also, it     */
/*      returns a two-bit error code as its return value:  Bit 0 of the     */
/*      return value denotes whether the zig-zag array was overrun, and     */
/*      bit 1 denotes whether an invalid VLC symbol was encountered.  A     */
/*      return value of 0 denotes no error.                                 */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*      This code performs the variable length decode of a H.263            */
/*      bit_stream using  the Table 16 and Table 17 of the H.263            */
/*      standard. The function accepts a packed Variable length encoded     */
/*      buffer and returns the idct array for one block. This function      */
/*      also returns state variables that allow chaining for calling it     */
/*      multiple times to perform VLD for a macro-block.The function        */
/*      returns 0 if a valid VLD decode of a block was performed and a      */
/*      1 if the block had an error.                                        */
/*                                                                          */
/*      This code handles both cases of INTER and INTRA.  For INTER         */
/*      blocks the DC term is encoded as an AC coefficient and it is        */
/*      possible to have up to 64 terms.  The code sets the error flag      */
/*      appropriately for either INTER or INTRA blocks.                     */
/*                                                                          */
/*                                                                          */
/*      The following is the implementation:                                */
/*                                                                          */
/*      This routine performs VLD on the AC terms in a Huffman coded 8x8    */
/*      block for H.263 decode.  Inverse Quantization, Run-Length Decode    */
/*      and Zig-Zag reordering are performed on each coefficient before     */
/*      it is written to the IDCT array.  The IDCT array is presumed to     */
/*      prezeroed by the calling function.                                  */
/*                                                                          */
/*      Error detection is performed by detecting invalid Huffman codes     */
/*      and for run-values which send the run-length decode outside the     */
/*      current 8x8 block.  No test is made, however, to determine if the   */
/*      bitstream input underflows.  The user is advised to place a         */
/*      sentinel bitstream at the end of the VLD buffer to prevent buffer   */
/*      underflow in the case of an error.                                  */
/*                                                                          */
/*      The bitstream is processed in word-sized chunks, using word-wide    */
/*      loads from the bitstream.  Therefore, it is necessary to store the  */
/*      bitstream in "word order".   For example, consider the following    */
/*      bitstream:  (leftmost bits are earliest in time.)                   */
/*                                                                          */
/*        +--------------------------------+----------------------          */
/*        |ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef|ghijklmnopqrstuvwxyz . . .      */
/*        +--------------------------------+----------------------          */
/*                     Word 0                          Word 1               */
/*                                                                          */
/*      The VLD routine will read the bitstream a word at a time, as        */
/*      labeled above.  On a little endian CPU, this implies that the       */
/*      bit-stream will be stored as follows in memory:                     */
/*                                                                          */
/*          +--------+--------+--------+--------+-----                      */
/*          |YZabcdef|QRSTUVWX|IJKLMNOP|ABCDEFGH| . . .                     */
/*          +--------+--------+--------+--------+-----                      */
/*          | Byte 0   Byte 1   Byte 2   Byte 3 |                           */
/*          |<------------ Word 0 ------------->|                           */
/*                                                                          */
/*      The VLC codes fall into several different classes.  The VLD         */
/*      attempts to isolate what VLC code it has by looking at various      */
/*      ranges of bits.  The following diagram illustrates the various      */
/*      regions of the bitstream that are extracted into different          */
/*      variables.                                                          */
/*                                                                          */
/*            3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1                   */
/*            1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0                   */
/*           +-------------------------------------------------             */
/*           |A B C D E F G H I J K L M N O P Q R S T U V W . . .           */
/*           +-------------------------------------------------             */
/*           |<--f5--->|   |   | |   |                                      */
/*           |<----f7----->|   | |   |                                      */
/*           |<------f9------->| |   |                                      */
/*           |<-------idx2------>|   |                                      */
/*           |<---------idx1-------->|                                      */
/*                                                                          */
/*      The Len/Run/Last lookup for VLD then proceeds as follows:           */
/*                                                                          */
/*      == If 'f5' is less than 4, then we have a code in the range         */
/*         00000xxxxx to 00011xxxxx.                                        */
/*                                                                          */
/*         ** For 00000xxxxxxx codes, lookup tab[idx1].  Since f5           */
/*            is zero (and therefore bits A...E are zero), idx1 has         */
/*            7 significant bits.  Therefore, the lookup occurs over        */
/*            over the range [0,127].                                       */
/*                                                                          */
/*         -- For 00001xxxxx thru 00011xxxxx codes, lookup                  */
/*            tab[64 + idx0].  For this range of codes, idx0 >= 64,         */
/*            and has 7 significant bits.  Therefore, the lookup            */
/*            occurs over the range [128,191].                              */
/*                                                                          */
/*       == If 'f5' is not less than 4, then we need to look at the         */
/*          first 7 bits to determine what code we have.                    */
/*                                                                          */
/*          -- For 001xxxx through 1xxxxxx codes, lookup                    */
/*             tab[176 + f7].  We know that f7 >= 32, so therefore,         */
/*             the lookup will occur over the range [198,303].              */
/*                                                                          */
/*       == If 'f7' equals 3, we have an escape code of the form            */
/*          0000011Lrrrrrrllllllll, where 'L' is the LAST flag,             */
/*          'rrrrrr' is the Run, and 'llllllll' is the signed level.        */
/*                                                                          */
/*                                                                          */
/*      The length of the VLC code is determined with one pair of           */
/*      lookups.                                                            */
/*                                                                          */
/*       == If 'f5' is less than 4, then we have a code in the range        */
/*          00000xxxxx to 00011xxxxx.  For this case, we look up the        */
/*          length at len[f9].  This lookup occurs over the range           */
/*          [0,63].                                                         */
/*                                                                          */
/*       == If 'f5' is >= 4, we use the first 5 bits to look in the         */
/*          length table.  We look at len[60 + f5].  Since f5 >= 4,         */