/* ======================================================================== *//*  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:                         *//*                                                                          *//*        #ifndef IMG_MPEG2_VLD_STRUCT_                                     *//*        #define IMG_MPEG2_VLD_STRUCT_ 1                                   *//*                                                                          *//*        typedef struct {                                                  *//*            unsigned int  *bsbuf;      // pointer to bitstream buffer     *//*            unsigned int  next_wptr;   // next word to read from buffer   *//*            unsigned int  bptr;        // bit position within word        *//*            unsigned int  word1;       // word aligned buffer             *//*            unsigned int  word2;       // word aligned buffer             *//*            unsigned int  top0;        // top 32 bits of bitstream        *//*            unsigned int  top1;        // next 32 bits of bitstream       *//*            const unsigned char *scan; // inverse zigzag scan matrix      *//*            unsigned int  intravlc;    // intra_vlc_format                *//*            unsigned int  quant_scale; // quant_scale                     *//*            unsigned int  dc_prec;     // intra_dc_precision              *//*            unsigned int  cbp;         // coded_block_pattern             *//*            unsigned int  fault;       // fault condition (returned)      *//*            unsigned int  reserved;    // reserved                        *//*        } IMG_mpeg2_vld;                                                  *//*                                                                          *//*        #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*//*S     The following files contain the required VLD look-up tables:       S*//*S                                                                        S*//*S         b14s_tbl.c    : run-level VLD table (1152 bytes, Table B-14)   S*//*S         b15s_tbl.c    : run-level VLD table (1152 bytes, Table B-15)   S*//*S         b14_len_tbl.c : code word length table (640 bytes, Table B-14) S*//*S         b15_len_tbl.c : code word length table (640 bytes, Table B-15) S*//*                                                                          *//*      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     */