swdec_vlc.c

freescale i.mx31 BSP CE5.0全部源码

            quantization parameter
            use intra dc vlc flag
            scanning direction

        Output: HANTRO_OK/HANTRO_NOK/END_OF_STREAM

------------------------------------------------------------------------------*/

u32 SwDec_DecodeIntraVlcBlock(decContainer_t *pDecContainer,i32 *pOut, u32 QP,
    u32 useIntraDcVlc, u32 scanDir)
{

    const vlcTable_t *tab;
    u32 sign;
    u32 inputBuffer;
    u32 CodeCount;
    u32 escape_code,escape_type;
    u32 tmp;
    i32 level = 0;
    u32 run = 0;
    u32 last = 0;
    u32 rlc = 0;
    tmpBuffer_t buffer = {0,0};

    ASSERT(pDecContainer);
    ASSERT(pOut);
    ASSERT(QP);
    ASSERT(QP < 32);
    ASSERT(scanDir < 3);

    if (useIntraDcVlc)
        CodeCount = 1;
    else
        CodeCount = 0;

    /* read 32 bits into buffer */
    BUFFER_INIT(buffer);

    do {
        BUFFER_SHOW(buffer, inputBuffer, 13);

        if(inputBuffer>=1024)
        {
            tab = &vlcIntraTable1[(inputBuffer>>6) -16];
        }
        else if(inputBuffer>=256)
        {
            tab = &vlcIntraTable2[(inputBuffer>>3) -32];
        }
        else if(inputBuffer>=16)
        {
            tab = &vlcIntraTable3[(inputBuffer>>1) - 8];
        }
        else
        {
            return(HANTRO_NOK);
        }

        BUFFER_FLUSH(buffer,tab->len+1);

        /* value 65535 used in tables to indicate escape code */
        if(tab->lrl == 65535)
        {
            /* escape type can be found in inputBuffer at bit positions
             * 7-8 */
            escape_type = (inputBuffer>>4)&0x3;
            if ( !(escape_type & 0x2) ){
                BUFFER_FLUSH(buffer, 1);
                escape_type = 1;
            } else {
                BUFFER_FLUSH(buffer, 2);
            }
            /* Type 1 & 2 Escape */
            if ( (escape_type==1) || (escape_type==2) )     
            {
                BUFFER_SHOW(buffer, escape_code, 13);
                
                if(escape_code>=1024)
                {
                    tab = &vlcIntraTable1[(escape_code>>6) -16];
                }
                else if(escape_code>=256)
                {
                    tab = &vlcIntraTable2[(escape_code>>3) - 32];
                }
                else if(escape_code>=16)
                {
                    tab = &vlcIntraTable3[(escape_code>>1) - 8];
                }
                else
                {
                    return(HANTRO_NOK);
                }

                /* can not be escape code at this point */
                if ( tab->lrl == 65535 ){
                    return(HANTRO_NOK);
                }
                
                /* sign, rlc & last */
                sign = escape_code & (0x1000>>tab->len);
                rlc = tab->lrl;
                last = rlc>>15;
                
                if (escape_type==1)
                {
                    /* type 1 escape intra mb */
                    run = ( (rlc & 0x7E00)>>9);
                    if ( last==1 )
                    {
                        if (run == 0)
                            tmp = 8;
                        else if (run == 1)
                            tmp = 3;
                        else if (run < 7)
                            tmp = 2;
                        else
                            tmp = 1;
                    }

                    else 
                    {
                        tmp = lmaxIntraTable[run];
                    }
                    level = (i32)((rlc & 0x1FF) + tmp);
                    if ( sign ) level = -level;
                    run = (rlc&0x7E00)>>9;
                }
                else
                {
                    /* intra mb and escape type 2 */
                    level = (rlc & 0x1FF);
                    if ( last==1 ) /* last == 1 */
                    {
                        tmp = rmaxIntraTableLast[level-1];
                    }
                    else    /* Last == 0 */
                    {
                        tmp= rmaxIntraTable[level-1];
                    }
                    level = (rlc & 0x1FF);
                    if ( sign ) level = -level;
                    run = ((rlc&0x7E00)>>9) + tmp + 1;
                }
                
                BUFFER_FLUSH(buffer, tab->len+1);

            }
            /* Type 3 Escape: After escape_code 11*/
            else
            {
                BUFFER_GET(buffer, escape_code, 21);

                last = (escape_code & 0x100000) >> 20;
                run  = (escape_code & 0x0FC000) >> 14;
                level= (escape_code & 0x000FFE) >> 1;
                sign = (escape_code & 0x001000);
                
                    
                /*Check Marker Bits*/
                if ( !(escape_code & 0x000001) || !(escape_code & 0x002000))
                    return(HANTRO_NOK);
                if (level == 0) return(HANTRO_NOK);
                if(sign) level = level - 2048;
            }
        }
        /* no escape code */
        else
        {
            /* sign */
            sign = inputBuffer & (0x1000>>tab->len);

            rlc = tab->lrl;
            level = rlc&0x1FF;
            if ( sign ) level = -level;
            run = (rlc>>9)&0x3F;
            last = rlc>>15;
        }
        
        CodeCount += run + 1;

        if (CodeCount > 64)
        {
            return(HANTRO_NOK);
        }

        /* quantize all but first row and column */
        if (scanDir == 0)
	        tmp = zigZagScan[CodeCount-1];
        else if (scanDir == 1)
	        tmp = horScan[CodeCount-1];
        else
    	    tmp = verScan[CodeCount-1];
        
        pOut[tmp] = level;
        if ((tmp > 8) && (tmp & 0x7))
        {
            DEQUANTIZE(pOut[tmp],QP);
        }

        if ( ((tmp>>3)+1) >
             pDecContainer->StrmStorage.numIdctRows )
        {
            pDecContainer->StrmStorage.numIdctRows =
                (tmp>>3) + 1;
        }

    } while(!last);

    tmp = SwDec_FlushBits(pDecContainer,32-buffer.bits);
    return(tmp);

}
#endif
/*------------------------------------------------------------------------------

   5.2  Function name: SwDec_DecodeInterVlcBlock

        Purpose: The decode vlc encoded rlc words
                 This function is called for each block

        Input:
            pointer to decContainer_t
            pointer to output data block
            quantization parameter
            short video intra flag

        Output: HANTRO_OK/HANTRO_NOK/END_OF_STREAM

------------------------------------------------------------------------------*/

u32 SwDec_DecodeInterVlcBlock(decContainer_t *pDecContainer, i32 *pOut, u32 QP,
    u32 shortVideoIntra)
{

    const vlcTable_t *tab;
    u32 sign;
    u32 inputBuffer;
    u32 CodeCount;
    u32 escape_code;
    u32 tmp;
    i32 level = 0;
    u32 run = 0;
    u32 last = 0;
    u32 rlc = 0;
    tmpBuffer_t buffer = {0,0};
#ifndef MP4DEC_H263_ONLY    
    u32 escape_type;
#endif
    
    if (shortVideoIntra)
        CodeCount = 1;
    else
        CodeCount = 0;

    /* read 32 bits into buffer */
    BUFFER_INIT(buffer);

    do {
        BUFFER_SHOW(buffer, inputBuffer, 13);
        if(inputBuffer>=1024)
        {
            tab = &vlcInterTable1[(inputBuffer>>6) -16];
        }
        else if(inputBuffer>=256)
        {
            tab = &vlcInterTable2[(inputBuffer>>3) -32];
        }
        else if(inputBuffer>=16)
        {
            tab = &vlcInterTable3[(inputBuffer>>1) - 8];
        }
        else
        {
            return(HANTRO_NOK);
        }

        BUFFER_FLUSH(buffer,tab->len+1);
        
        /* value 65535 used in tables to indicate escape code */
#ifdef MP4DEC_H263_ONLY
        if(tab->lrl == 65535)
        {
            BUFFER_GET(buffer, escape_code, 15);
            last = (escape_code & 0x4000) >> 14;
            run  = (escape_code & 0x3F00) >> 8;
            level= (escape_code & 0x00FF);
            if ( level == 0 || level == 128 )
            {
                return(HANTRO_NOK);
            }
            else if (level > 128)
            {
                level -= 256;
            }
        }
#else
        if(tab->lrl == 65535)
        {
            /* Type 4 escape for short video */
            if(pDecContainer->StrmStorage.shortVideo)
            {
                BUFFER_GET(buffer, escape_code, 15);
                last = (escape_code & 0x4000) >> 14;
                run  = (escape_code & 0x3F00) >> 8;
                level= (escape_code & 0x00FF);
                if ( level == 0 || level == 128 )
                {
                    return(HANTRO_NOK);
                }
                else if (level > 128)
                {
                    level -= 256;
                }
            }
            else 
            {
                /* escape type can be found in inputBuffer at bit positions
                 * 7-8 */
                escape_type = (inputBuffer>>4)&0x3;
                if ( !(escape_type & 0x2) ){
                    escape_type = 1;
                    BUFFER_FLUSH(buffer, 1);
                } else {
                    BUFFER_FLUSH(buffer, 2);
                }
                /* Type 1 & 2 Escape */
                if ( (escape_type==1) || (escape_type==2) )     
                {
                    BUFFER_SHOW(buffer, escape_code, 13);
                    
                    if(escape_code>=1024)
                    {
                        tab = &vlcInterTable1[(escape_code>>6) -16];
                    }
                    else if(escape_code>=256)
                    {
                        tab = &vlcInterTable2[(escape_code>>3) - 32];
                    }
                    else if(escape_code>=16)
                    {
                        tab = &vlcInterTable3[(escape_code>>1) - 8];
                    }
                    else
                    {
                        return(HANTRO_NOK);
                    }

                    /* can not be escape code at this point */
                    if ( tab->lrl == 65535 ){
                        return(HANTRO_NOK);
                    }