mpeg2_vld_intra_h.asm

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

* ========================================================================= *
*   TEXAS INSTRUMENTS, INC.                                                 *
*                                                                           *
*   NAME                                                                    *
*       mpeg2_vld_intra                                                     *
*                                                                           *
*   PLATFORM                                                                *
*       C6400                                                               *
*                                                                           *
*   DESCRIPTION                                                             * 
*       This routine takes a bitstream of an MPEG-2 intra coded macroblock  * 
*       and returns the decoded IDCT coefficients. The routine is           * 
*       implemented as specified in the MPEG-2 standard text (ISO/IEC       * 
*       13818-2). The routine checks the coded block pattern (cbp),         * 
*       performs DC and AC decoding inlcuding, variable length decode,      * 
*       run-length expansion, inverse zigzag, dequantization, saturation    * 
*       and mismatch control.                                               * 
*                                                                           * 
*   USAGE                                                                   * 
*       This routine is C callable, and has the following C prototype:      * 
*                                                                           * 
*       void mpeg2_vld_intra                                                * 
*       (                                                                   * 
*           const short    *restrict Wptr,                                  * 
*           short          *restrict outi,                                  * 
*           IMG_mpeg2_vld  *restrict Mpeg2v,                                * 
*           int            dc_pred[3],                                      * 
*           int            mode_12Q4,                                       * 
*           int            num_blocks,                                      * 
*           int            bsbuf_words                                      * 
*       );                                                                  * 
*                                                                           * 
*         Wptr:   Pointer to array that contains quantization matrix. The   * 
*                 elements of the quantization matrix in *Wptr must be      * 
*                 ordered according to the scan pattern used (zigzag or     * 
*                 alternate scan). Video format 4:2:0 requires one          * 
*                 quantization matrix (64 array elements).  For formats     * 
*                 4:2:2 and 4:4:4 two quantization matrices (one for luma   * 
*                 and one for chroma) must specified in the array (128      * 
*                 array elements).                                          * 
*                                                                           * 
*         outi:   Pointer to the IDCT coefficients output array             * 
*                 (6*64 elements), elements must be set to zero prior to    * 
*                 function call.                                            * 
*                                                                           * 
*         Mpeg2v: Pointer to the context object containing the coding       * 
*                 parameters of the MB to be decoded and the current state  * 
*                 of the bitstream buffer. The structure is described       * 
*                 below.                                                    * 
*                                                                           * 
*        dc_pred: Intra DC prediction array, the first element of dc_pred   * 
*                 is the DC prediction for Y, the second for Cr and the     * 
*                 third for Cb.                                             * 
*                                                                           * 
*      mode_12Q4: 0: Coefficients are returned in normal 16-bit integer     * 
*                 format.                                                   * 
*                 Otherwise: Coefficients are returned in 12Q4 format       * 
*                 (normal 16-bit integer format left shifted by 4). This    * 
*                 mode is useful for directly passing the coefficients      * 
*                 into the IMG_idct_8x8 routine.                            * 
*                                                                           * 
*     num_blocks: Number of blocks that the MB contains. Valid values are   * 
*                 6 for 4:2:0, 8 for 4:2:2 and 12 for 4:4:4 format.         * 
*                                                                           * 
*    bsbuf_words: Size of bitstream buffer in words. Must be a power of 2.  * 
*                 Bitstream buffer must be aligned at an address boundary   * 
*                 equal to its size in bytes (bitstream buffer is           * 
*                 addressed circularly by this routine.)                    * 
*                                                                           * 
*       The structure Mpeg2v is defined as follows:                         * 
*                                                                           * 
*C        #ifndef IMG_MPEG2_VLD_STRUCT_                                     * 
*C        #define IMG_MPEG2_VLD_STRUCT_ 1                                   * 
*C                                                                          * 
*C        typedef struct {                                                  * 
*C            unsigned int  *bsbuf;      // pointer to bitstream buffer     * 
*C            unsigned int  next_wptr;   // next word to read from buffer   * 
*C            unsigned int  bptr;        // bit position within word        * 
*C            unsigned int  word1;       // word aligned buffer             * 
*C            unsigned int  word2;       // word aligned buffer             * 
*C            unsigned int  top0;        // top 32 bits of bitstream        * 
*C            unsigned int  top1;        // next 32 bits of bitstream       * 
*C            const unsigned char *scan; // inverse zigzag scan matrix      * 
*C            unsigned int  intravlc;    // intra_vlc_format                * 
*C            unsigned int  quant_scale; // quant_scale                     * 
*C            unsigned int  dc_prec;     // intra_dc_precision              * 
*C            unsigned int  cbp;         // coded_block_pattern             * 
*C            unsigned int  fault;       // fault condition (returned)      * 
*C            unsigned int  reserved;    // reserved                        * 
*C        } IMG_mpeg2_vld;                                                  * 
*C                                                                          * 
*C        #endif                                                            * 
*                                                                           * 
*       The Mpeg2v variables should have a fixed layout since they are      * 
*       accessed by this routine.  If the layout is changed, the            * 
*       corresponding changes have to be made in the assembly code too.     * 
*                                                                           * 
*       The routine sets the fault flag Mpeg2v.fault to 1 if an invalid     * 
*       VLC code was encountered or the total run went beyond 63. In        * 
*       theses cases the decoder has to resynchronize.                      * 
*S                                                                          * 
*S      The following files contain the required VLD look-up tables:        * 
*S                                                                          * 
*S          b14s_tbl.c    : run-level VLD table (1152 bytes, Table B-14)    * 
*S          b15s_tbl.c    : run-level VLD table (1152 bytes, Table B-15)    * 
*S          b14_len_tbl.c : code word length table (640 bytes, Table B-14)  * 
*S          b15_len_tbl.c : code word length table (640 bytes, Table B-15)  * 
*                                                                           * 
*       Before calling the routine the bitstream variables in Mpeg2v        * 
*       have to be initialized. If bsbuf is a circular buffer and bsptr     * 
*       contains the number of bits in the buffer that already have         * 
*       been consumed, then next_wptr, bptr, word1, word2, top0 and         * 
*       top1 are initialized as follows:                                    * 
*                                                                           * 
*       1. nextwptr: bsptr may not be a multiple of 32, therefore obtain    * 
*       the next lower multiple of 32.                                      * 
*                                                                           * 
*           next_wptr = (bsptr >> 5);                                       * 
*                                                                           * 
*       2. bptr: bptr is the bit pointer which points to the current        * 
*       bit WITHIN the word pointed to by next_wptr.                        * 
*                                                                           * 
*           bptr = bsptr & 31;                                              * 
*           bptr_cmpl = 32 - bptr;                                          * 
*                                                                           * 
*       3. word1 and word2: read next 3 words from the bitstream buffer     * 
*       (word0 is a temporary variable). bsbuf_words is the size of the     * 
*       bitstream buffer in words.                                          * 
*                                                                           * 
*           word0 = bsbuf[next_wptr];                                       * 
*           next_wptr = (next_wptr + 1) & (bsbuf_words-1);                  * 
*                                                                           * 
*           word1 = bsbuf[next_wptr];                                       * 
*           next_wptr = (next_wptr + 1) & (bsbuf_words-1);                  * 
*                                                                           * 
*           word2 = bsbuf[next_wptr];                                       * 
*           next_wptr = (next_wptr + 1) & (bsbuf_words-1);                  * 
*                                                                           * 
*       4. top0 and top1: Shift words word0, word1, word2 by bptr to the    * 
*       left so that the current bit becomes the MSB in word0. word0 can    * 
*       simply be shifted by bptr; the then empty LSBs of word0 have to be  * 
*       filled with the MSBs of word1. To do that the required MSBs are     * 
*       brought into the position of empty LSBs of word0 by shifting word1  * 
*       to the right by (32-bptr). The result is then copied into word0 by  * 
*       an addition. Rather than overwriting word0, top0 is used to hold    * 
*       the new bit aligned word. The same procedure is used to obtain      * 
*       top1. top0 and top1 contain the next 64 bits of the bitstream.      * 
*                                                                           * 
*           s1 = word0 << bptr;                                             * 
*           s2 = word1 >> bptr_cmpl;  /* unsigned right-shift */            * 
*           top0 = s1 + s2;                                                 * 
*                                                                           * 
*           s3 = word1 << bptr;                                             * 
*           s4 = word2 >> bptr_cmpl;  /* unsigned right-shift */            * 
*           top1 = s3 + s4;                                                 * 
*                                                                           * 
*       Note that the routine returns the updated state of the bitstream    * 
*       buffer variables, top0, top1, word1, word2, bptr and next_wptr. If  * 
*       all other functions which access the bitstream in a decoder system  * 
*       maintain the buffer variables in the same way, then the above       * 
*       initialization procedure has to be performed only once at the       * 
*       beginning.                                                          * 
*                                                                           * 
*   TECHNIQUES                                                              * 
*       The instruction NORM is used to detect the number of leading zeros  * 
*       or ones in a code word. This value together with additional bits    * 
*       extracted from the codeword is then used as an index into look-up   * 
*       tables to determine the length, run, level and sign. Escape code    * 
*       sequences are directly extracted from the code word.                * 
*                                                                           * 
*       DC coefficients are decoded without lookup tables by exploiting     * 
*       the relatively simple relationship between the number of leading    * 
*       zeros and dc_size and the length of the code word.                  * 
*                                                                           * 
*   ASSUMPTIONS                                                             * 
*       The bitstream must be stored in memory in 32-bit words which are    * 
*       in little endian byte order.                                        * 
*                                                                           * 
*       Wptr is allowed to overrun once (to detect total run overrun), so   * 
*       maximum overrun that can occur is 66 (Error mark). Therefore,       * 
*       in memory 66+1 halfwords behind the weighting matrix should be      * 
*       valid (e.g. peripherals). No memory is overwritten,                 * 
*       only loads occurr.                                                  * 
*                                                                           * 
*       Note that the AMR register is set to zero on exit.                  * 
*                                                                           * 
*   NOTES                                                                   * 
*       This code is little ENDIAN.                                         * 
*       This code is interrupt-tolerant but not interruptible.              * 
*                                                                           * 
*   MEMORY NOTES                                                            * 
*       No bank conflicts                                                   * 
*                                                                           * 
*   CYCLES                                                                  * 
*       10 * (S - CB) + 55 * CB + 15 * NCB + 35                             * 
*       where S:   Number of symbols in MB, CB: Number of coded blocks,     * 
*             NCB: Number of not-coded blocks, and CB+NCB=6                 * 
*                                                                           * 
*   CODE SIZE                                                               * 
*       1496 bytes                                                          * 
*                                                                           * 
*   DATA SIZE                                                               * 
*       3584 bytes for the lookup tables                                    * 
* ------------------------------------------------------------------------- *
*             Copyright (c) 2002 Texas Instruments, Incorporated.           *
*                            All Rights Reserved.                           *
* ========================================================================= *

            .sect ".text:hand"
            .global _mpeg2_vld_intra_asm

* ====================== SYMBOLIC REGISTER ASSIGNMENTS ===================== *
        .asg            A0,         A_neg
        .asg            A1,         A_bptr1
        .asg            A1,         A_qw
        .asg            A1,         A_test1
        .asg            A1,         A_test2
        .asg            A14,        A_constSHR      ; 12Q4 MERGE
        .asg            A16,        A_len_c
        .asg            A17,        A_bptr
        .asg            A18,        A_len_tbl_adr
        .asg            A19,        A_const31
        .asg            A2,         A_top0l
        .asg            A20,        A_const32
        .asg            A22,        A_const36
        .asg            A23,        A_qscl
        .asg            A24,        A_level4
        .asg            A24,        A_t2
        .asg            A24,        A_top0_bk
        .asg            A25,        A_empty
        .asg            A25,        A_len
        .asg            A26,        A_nrm
        .asg            A26,        A_t1l