swdec_utils.c

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

    ASSERT(pDecContainer->StrmDesc.bitPosInWord < 8);

#ifdef MP4DEC_H263_ONLY
    tmp = SwDec_ShowBits(pDecContainer, 22);

    if (!pDecContainer->StrmStorage.strmDecReady)
    {
        if (tmp == SC_SV_START)
        {
            codeLength = 22;
            startCode = tmp;
        }
    }
    else if ( (tmp == SC_SV_START) || (tmp == SC_SV_END) )
    {
        codeLength = 22;
        startCode = tmp;
    }
    else if ( (tmp >> 5) == SC_RESYNC )
    {
        codeLength = 17;
        startCode = SC_RESYNC;
    }    
#else
    markerLength =
        pDecContainer->StrmStorage.resyncMarkerLength;

    tmp = SwDec_ShowBits(pDecContainer, 32);

    /* only check VisualObjectSequence, VisualObject, VisualObjectLayer and
     * short video start codes if decoder is not ready yet */
    if (!pDecContainer->StrmStorage.strmDecReady)
    {
        if ( ((tmp&0xFFFFFFE0) == SC_VO_START) ||
             ((tmp&0xFFFFFFF0) == SC_VOL_START) ||
             (tmp == SC_VOS_START) ||
             (tmp == SC_VOS_END) ||
             (tmp == SC_VISO_START) )
        {
            codeLength = 32;
            startCode = startCodeTable[tmp&0xFF];
        }
        else if ((tmp >> 10) == SC_SV_START)
        {
            codeLength = 22;
            startCode = tmp >> 10;
        }
    }

    else if ( !pDecContainer->StrmStorage.shortVideo &&
              ((tmp>>8) == 0x01) && startCodeTable[tmp&0xFF] )
    {
        codeLength = 32;
        startCode = startCodeTable[tmp&0xFF];
    }
    else if ( pDecContainer->StrmStorage.shortVideo &&
        (((tmp&0xFFFFFFE0) == SC_VO_START) || (tmp == SC_VOS_START) ||
         (tmp == SC_VOS_END) || (tmp == SC_VISO_START)) )
    {
        codeLength = 32;
        startCode = startCodeTable[tmp&0xFF];
    }
    else if ( pDecContainer->StrmStorage.shortVideo &&
        ( ((tmp>>10) == SC_SV_START) || ((tmp>>10) == SC_SV_END)) )
    {
        codeLength = 22;
        startCode = tmp>>10;
    }
    else if ( (tmp >> (32-markerLength)) == SC_RESYNC )
    {
        codeLength = markerLength;
        startCode = SC_RESYNC;
    }
    else if ( (tmp & 0xFFFFFE00) == 0 )
    {
        codeLength = 32;
        startCode = SC_ERROR;
        /* consider VOP start code lost */
        pDecContainer->StrmStorage.startCodeLoss = 1;
    }
#endif
    if (startCode != SC_NOT_FOUND)
    {
        tmp = SwDec_FlushBits(pDecContainer,codeLength);
        CHECK_END_OF_STREAM(tmp);
        pDecContainer->StrmStorage.pLastSync =
            pDecContainer->StrmDesc.pStrmCurrPos;
    }

    return(startCode);

}

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

   5.8  Function name: SwDec_NumBits

        Purpose: computes number of bits needed to represent value given as
        argument
                 
        Input: 
            u32 value [0,2^32)

        Output:
            Number of bits needed to represent input value

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

u32 SwDec_NumBits(u32 value)
{

    u32 numBits = 0;

    while (value)
    {
        value >>= 1;
        numBits++;
    }

    if (!numBits)
    {
        numBits = 1;
    }

    return(numBits);

}

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

   5.9  Function name: SwDec_UnFlushBits

        Purpose: unflushes bits from mpeg-4 input stream
                 
        Input: 
            Pointer to decContainer_t structure
            Number of bits to unflush [0,2^32)

        Output:
            HANTRO_OK if operation was successful

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

u32 SwDec_UnFlushBits(decContainer_t *pDecContainer, u32 numBits)
{

    ASSERT(pDecContainer);
    ASSERT(pDecContainer->StrmDesc.pStrmBuffStart);
    ASSERT(pDecContainer->StrmDesc.pStrmCurrPos);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord < 8);

    if ( pDecContainer->StrmDesc.strmBuffReadBits < numBits)
    {
        pDecContainer->StrmDesc.strmBuffReadBits = 0;
        pDecContainer->StrmDesc.bitPosInWord = 0;
        pDecContainer->StrmDesc.pStrmCurrPos = 
            pDecContainer->StrmDesc.pStrmBuffStart;
    }
    else
    {
        pDecContainer->StrmDesc.strmBuffReadBits -= numBits;
        pDecContainer->StrmDesc.bitPosInWord = 
            pDecContainer->StrmDesc.strmBuffReadBits & 0x7;
        pDecContainer->StrmDesc.pStrmCurrPos = 
            pDecContainer->StrmDesc.pStrmBuffStart + 
            (pDecContainer->StrmDesc.strmBuffReadBits >> 3);
    }

    return(HANTRO_OK);
}

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

   5.10  Function name: SwDec_CheckStuffing

        Purpose: checks mpeg-4 stuffing from input stream
                 
        Input: 
            Pointer to decContainer_t structure
                -uses and updates StrmDesc

        Output:
            HANTRO_OK if there is stuffing at current stream position
            HANTRO_NOK otherwise

------------------------------------------------------------------------------*/
#ifndef MP4DEC_H263_ONLY
u32 SwDec_CheckStuffing(decContainer_t *pDecContainer)
{

    u32 length;

    ASSERT(pDecContainer);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord < 8);

    length = 8 - pDecContainer->StrmDesc.bitPosInWord;

    if (SwDec_ShowBits(pDecContainer, length) == stuffingTable[length-1])
        return(HANTRO_OK);
    else
        return(HANTRO_NOK);

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

   5.11  Function name: SwDec_ShowBits32

        Purpose: read 32 bits from mpeg-4 input stream. In case stream ends,
        function fills the word with zeros.
                 
        Input: 
            Pointer to decContainer_t structure

        Output:
            u32 containing bits read from stream

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

u32 SwDec_ShowBits32(decContainer_t *pDecContainer)
{
    
    i32 bits, shift;
    u32 out;
    u8 *pStrm;

    ASSERT(pDecContainer);
    ASSERT(pDecContainer->StrmDesc.pStrmCurrPos);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord < 8);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord ==
           (pDecContainer->StrmDesc.strmBuffReadBits & 0x7));
    ASSERT(pDecContainer->StrmDesc.strmBuffSize);

    pStrm = pDecContainer->StrmDesc.pStrmCurrPos;

    /* bits left in the buffer */
    bits = (i32)pDecContainer->StrmDesc.strmBuffSize*8 -
               (i32)pDecContainer->StrmDesc.strmBuffReadBits;
        
    if (!bits)
    {
        return(0);
    }

    /* at least 32-bits in the buffer -> get 32 bits and drop extra bits out */
    if (bits >= 32)
    {
        out = ((u32)pStrm[0] << 24) | ((u32)pStrm[1] << 16) | 
                  ((u32)pStrm[2] <<  8) | ((u32)pStrm[3]);
        if (pDecContainer->StrmDesc.bitPosInWord)
        {
            out <<= pDecContainer->StrmDesc.bitPosInWord;
            out |=
                (u32)pStrm[4]>>(8-pDecContainer->StrmDesc.bitPosInWord);
        }
    }
    else
    {
        shift = 24 + (i32)pDecContainer->StrmDesc.bitPosInWord;
        out = (u32)(*pStrm++) << shift;
        bits -= 8 - (i32)pDecContainer->StrmDesc.bitPosInWord;
        while (bits > 0)
        {
            shift -= 8;
            out |= (u32)(*pStrm++) << shift;
            bits -= 8;
        }
    }

    return(out);

}

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

   5.12  Function name: SwDec_GetOneBit

        Purpose: read and remove one bit from mpeg-4 input stream
                 
        Input: 
            Pointer to decContainer_t structure

        Output:
            u32 containing bits read from stream. Value END_OF_STREAM
            reserved to indicate failure.

------------------------------------------------------------------------------*/
u32 SwDec_GetOneBit(decContainer_t *pDecContainer)
{
    i32 bits;
    u8 *pStrm;
    u8 out;
    
    ASSERT(pDecContainer);
    ASSERT(pDecContainer->StrmDesc.pStrmCurrPos);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord < 8);
    ASSERT(pDecContainer->StrmDesc.bitPosInWord ==
           (pDecContainer->StrmDesc.strmBuffReadBits & 0x7));
    ASSERT(pDecContainer->StrmDesc.strmBuffSize);
    ASSERT(pDecContainer->StrmDesc.pStrmBuffStart);

    pStrm = pDecContainer->StrmDesc.pStrmCurrPos;

    /* bits left in the buffer */
    bits = (i32)pDecContainer->StrmDesc.strmBuffSize*8 -
               (i32)pDecContainer->StrmDesc.strmBuffReadBits;

    /* at least one bit in the buffer -> get 8 bits and drop extra bits out */
    if (bits >= 1)
    {
        out = (u8)(pStrm[0]<<pDecContainer->StrmDesc.bitPosInWord);
        out >>=7;

        pDecContainer->StrmDesc.strmBuffReadBits++;
        pDecContainer->StrmDesc.bitPosInWord++;
        pDecContainer->StrmDesc.pStrmCurrPos +=
            pDecContainer->StrmDesc.bitPosInWord >> 3;
        pDecContainer->StrmDesc.bitPosInWord &= 0x7;
        return(out);
    }
    else
    {   
        pDecContainer->StrmDesc.strmBuffReadBits =
            8 * pDecContainer->StrmDesc.strmBuffSize;
        pDecContainer->StrmDesc.bitPosInWord = 0;
        pDecContainer->StrmDesc.pStrmCurrPos =
            pDecContainer->StrmDesc.pStrmBuffStart + 
            pDecContainer->StrmDesc.strmBuffSize;

        return(END_OF_STREAM);
    }
}