h263_vld_n.h

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

/*         [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,          */
/*         this lookup occurs over the range [64, 91].                      */
/*                                                                          */
/*         The actual code table contains 304 entires to get multiple of 8. */
/*         Each code word is stored in the table in the following format:   */
/*         The code word used in this context refers to the run, level      */
/*         associated with each Huffman code word that is decoded and not   */
/*         to the Huffman code word itself.                                 */
/*                                                                          */
/*         Last(1/0)  RUNVALUE   LEVEL                                      */
/*         14         13....8    7....0                                     */
/*                                                                          */
/*         Each code word thus has a pad of 2 bits and is stored as a half  */
/*         word                                                             */
/*                                                                          */
/*         Example:                                                         */
/*                                                                          */
/*         1) Code: 0000 0000 110s Run: 0   Level: 11                       */
/*                                                                          */
/*         Clearly for this code f5 the first 5 bits from the left are zero.*/
/*         first 12 bits from the left are extracted in idx1. If the upper  */
/*         5 bits are zero then idx1 can have a maximum value of upto 127.  */
/*         In this case this value will be either 13 or 14 depending on the */
/*         sign bit.                                                        */
/*         0         000000 001011  ------------->   0x0b                   */
/*                                                                          */
/*                                                                          */
/*         The length table is a set of values constructed as follows. The  */
/*         code words are taken and divided into two categories for this    */
/*         purpose:                                                         */
/*                  Class 1:  Codes 00000xxxxx...00011xxxxx                 */
/*                  Class 2:  Codes 001xxxxx..   xxxx                       */
/*         Therfore it can be seen that under class 2 there can be a set of */
/*         32 codes and under class 1 there are 60 enties that the given    */
/*         code table maps into. Therfore there are a total of 32 entries.  */
/*         This can be seen by way of example:                              */
/*                                                                          */
/*         Code at Index: 50 of the Table 16 in H  63 spec                  */
/*                                                                          */
/*         Run: 19 Level: 1 Code: 0000 1110 1s and falls under Class 1      */
/*         When the 9 left most bits are examined this gives us 29.  The    */
/*         29th entry in the length table gives us the length of the code   */
/*         word as 10.                                                      */
/*                                                                          */
/*                                                                          */
/*         Similarly a code at Index 40 of the Table 16 in H  63 spec       */
/*                                                                          */
/*         Run: 10 Level: 1 Code: 0010110s. This comes under Class 2 and    */
/*         hence the 5 left most bits are extracted to give an index of 5   */
/*         The code lengths for these class of codes is stored with an      */
/*         implicit offset of 60 and hence this code's length is actually   */
/*         stored at location 65. The 65 th entry from the length table is  */
/*         8 and corresponds to the length of the code.                     */
/*                                                                          */
/*                                                                          */
/*         The entries in the Zig-Zag table are expected to be in the range */
/*         0 .. 63, with no repeated entries.  The VLD starts reading the   */
/*         Zig-Zag table at zz[1], and under normal circumstances will not  */
/*         read past element zz[63].  However, when an invalid bitstream is */
/*         encountered, elements as high as zz[126] may be accessed.  See   */
/*         the MEMORY NOTE below for more information.                      */
/*                                                                          */
/*  ASSUMPTIONS                                                             */
/*     Speculative reads are OK.  See MEMORY NOTE below.                    */
/*                                                                          */
/*     Short (as in, invalid due to truncation) bitstreams are followed     */
/*     by sentinel values to halt VLD with an error condition, to prevent   */
/*     underflow.                                                           */
/*                                                                          */
/*  MEMORY NOTE                                                             */
/*     The VLD routine will read up to two full words beyond the final      */
/*     position of the bitstream word pointer, as part of its lookahead.    */
/*     The user must ensure that two words of valid memory exist there.     */
/*                                                                          */
/*     Speculative reads are performed to each of the following arrays:     */
/*     (Ranges are in bytes, and are inclusive.)                            */
/*                                                                          */
/*         Table/Array            Valid Range   Accessed Range              */
/*                                                                          */
/*         Zig-Zag Table            0..63           0.  27                  */
/*         Length Table             0..91           0..511                  */
/*         Coef/Run Table           0..607          0..607                  */
/*                                                                          */
/*     The user should ensure that valid (eg. CPU readable) memory          */
/*     exists in the required ranges past the end of each table.            */
/*                                                                          */
/*     Alternately, to ensure that these reads do not reduce cache          */
/*     effectiveness (C6211) and do not access invalid memory, the          */
/*     following table layout is recommended, as it causes all              */
/*     speculative reads to land inside other valid table entries:          */
/*                                                                          */
/*         Bytes   0 .. 63    'zz'    Zig-Zag table                         */
/*         Bytes  64 .. 159   'len'   Huffman-code Length table             */
/*         Bytes 160 .. 767   'tab'   Huffman-code Coefficient/Run Table    */
/*                                                                          */
/* NOTES                                                                    */
/*     The input bitstream must be "word order", meaning that it is         */
/*     accessed with word-wide reads.                                       */
/*                                                                          */
/* ======================================================================== */
/*            Copyright (c) 2002 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#ifndef H263_VLD_N_H_
#define H263_VLD_N_H_ 1

int h263_vld_nsa
(
    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
);

#endif
/* ======================================================================== */
/*  End of file:  h263_vld_n.h                                              */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2002 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */