swdec_motiontexture.c

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

            {
                status = SwDec_DecodeMv(pDecContainer, mbNumber);
                if (status != HANTRO_OK) return(status);
            }
        }
        /* not coded -> increment first coded if necessary */
        else
        {
            if (mbNumber == pDecContainer->StrmStorage.vpFirstCodedMb)
            {
                pDecContainer->StrmStorage.vpFirstCodedMb++;
            }
            pDecContainer->MbDesc[mbNumber].codedBits = MB_NOT_CODED;
            pDecContainer->MbDesc[mbNumber].typeOfMb = MB_INTER;
            pDecContainer->MbDesc[mbNumber].flags = INTER_MB_MASK;
            pDecContainer->MbDesc[mbNumber].data[0] = 0;
            pDecContainer->MbDesc[mbNumber].data[1] = 0;
            pDecContainer->MbDesc[mbNumber].data[2] = 0;
            pDecContainer->MbDesc[mbNumber].data[3] = 0;
            pDecContainer->MbDesc[mbNumber].data[4] = 0;
            pDecContainer->MbDesc[mbNumber].data[5] = 0;
            pDecContainer->MbDesc[mbNumber].data[6] = 0;
            pDecContainer->MbDesc[mbNumber].data[7] = 0;

            pDecContainer->MbDesc[mbNumber].QP = pDecContainer->StrmStorage.QP;
        }

        mbCounter++;
        mbNumber++;

        /* last macro block of vop -> check stuffing macro blocks */
        if (mbNumber == pDecContainer->VopDesc.totalMbInVop)
        {
            while (SwDec_ShowBits(pDecContainer,10) == 0x1)
            {
                tmp = SwDec_FlushBits(pDecContainer,10);
            }
            if (SwDec_ShowBits(pDecContainer,17) == MOTION_MARKER)
            {
                break;
            }
            else
            {
                return(HANTRO_NOK);
            }
        }

    } while (SwDec_ShowBits(pDecContainer,17) != MOTION_MARKER);
    
    status = SwDec_FlushBits(pDecContainer,17);

    pDecContainer->StrmStorage.vpNumMbs = mbCounter;

    mbNumber = pDecContainer->StrmStorage.vpMbNumber;

    for (i = mbNumber; i < (mbNumber + mbCounter); i++)
    {
        if (pDecContainer->MbDesc[i].codedBits != MB_NOT_CODED)
        {
            /* ac prediction flag */
            if (MB_IS_INTRA(i))
            {
                tmp = SwDec_GetOneBit(pDecContainer);
                CHECK_END_OF_STREAM(tmp);
                if (tmp)
                {
                    pDecContainer->MbDesc[i].flags |= AC_PRED_FLAG_MASK;
                }
            }

            status = SwDec_DecodeCbpy(pDecContainer,i);
            if (status != HANTRO_OK) return(status);

            pDecContainer->StrmStorage.prevQP =
                pDecContainer->StrmStorage.QP;
            if (MB_HAS_DQUANT(i))
            {
                tmp = SwDec_GetBits(pDecContainer,2); /* dquant */
                CHECK_END_OF_STREAM(tmp);

                QP = (i32)(pDecContainer->StrmStorage.QP) +
                    dQuantTable[tmp];
                SATURATE(1,QP,31);
                pDecContainer->StrmStorage.QP = (u32)QP;
            }

            pDecContainer->MbDesc[i].QP =
                pDecContainer->StrmStorage.QP;

            /* determine whether intra_dc_vlc used */
            tmp = MB_IS_INTRA(i) && SwDec_UseIntraDcVlc(pDecContainer,i);

            if (tmp)
            {
                pDecContainer->MbDesc[i].flags |= USE_INTRA_DC_VLC_MASK;
                for (j = 0; j < 6; j++)
                {
                    status = SwDec_DecodeDcCoeff(pDecContainer,i,j);
                    if (status != HANTRO_OK) return(status);
                }
            }

        }
    }

    for (i = mbNumber; i < (mbNumber + mbCounter); i++)
    {
        if (pDecContainer->MbDesc[i].codedBits != MB_NOT_CODED)
        {
            /* initialize mask for block number 0 */
            tmpMask = 0x20;
            for (j = 0; j < 6; j++)
            {
                i32 scanOut[64] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

                scanDir = SwDec_ScanDir(pDecContainer, i, j);

                pDecContainer->StrmStorage.numIdctRows = 0;

                /* decode block i if coded block */
                if (pDecContainer->MbDesc[i].codedBits & tmpMask)
                {
                    if (pDecContainer->Hdrs.reversibleVlc)
                    {
                        status = SwDec_DecodeRvlcBlock(pDecContainer,scanOut,
                            i, pDecContainer->MbDesc[i].QP,scanDir);
                    }
                    else
                    {
                        if (MB_IS_INTER(i))
                        {
                            status = SwDec_DecodeInterVlcBlock(pDecContainer,
                                scanOut, pDecContainer->MbDesc[i].QP,0);
                        }
                        else
                        {
                            status = SwDec_DecodeIntraVlcBlock(pDecContainer,
                                scanOut, pDecContainer->MbDesc[i].QP,
                                pDecContainer->MbDesc[i].flags &
                                    USE_INTRA_DC_VLC_MASK,
                                scanDir);
                        }
                    }
                    if (status != HANTRO_OK) return(status);
                }

                if (MB_IS_INTER(i))
                {
                    SwDec_ProcessInterBlock(pDecContainer,scanOut,i,j);
                }
                else
                {
                    SwDec_ProcessIntraBlock(pDecContainer,scanOut,i,j,
                        scanDir);
                }
                tmpMask >>= 1;
            }
        }
        else
        {
            SwDec_CopyOutput(pDecContainer, i);
        }
    }

    return(status);

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

   5.5  Function name: SwDec_DecodeMb

        Purpose: Decodes one macro block from stream
                 
        Input: 
            pDecContainer   pointer to decContainer_t
            mbNumber

        Output:
                    HANTRO_OK/HANTRO_NOK/END_OF_STREAM

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

u32 SwDec_DecodeMb(decContainer_t *pDecContainer, u32 mbNumber)
{
    u32 i,tmp;
    u32 status;
    u32 dQuant;
    i32 QP;
    u32 tmpMask;
#ifndef MP4DEC_H263_ONLY
    u32 scanDir;
    u32 useIntraDcVlc;
#endif
    
    ASSERT(pDecContainer);
    ASSERT(mbNumber < pDecContainer->VopDesc.totalMbInVop);

    tmp = 0;

    if ( pDecContainer->VopDesc.vopCodingType==PVOP )
    {
        /* not coded? */
        tmp = SwDec_GetOneBit(pDecContainer);
        CHECK_END_OF_STREAM(tmp);
        if (tmp)
        {
            if ( pDecContainer->StrmStorage.vpFirstCodedMb==mbNumber)
                pDecContainer->StrmStorage.vpFirstCodedMb++;

            pDecContainer->MbDesc[mbNumber].codedBits = MB_NOT_CODED;
            pDecContainer->MbDesc[mbNumber].typeOfMb = MB_INTER;
            pDecContainer->MbDesc[mbNumber].flags = INTER_MB_MASK;

            pDecContainer->MbDesc[mbNumber].data[0] = 0;
            pDecContainer->MbDesc[mbNumber].data[1] = 0;
            pDecContainer->MbDesc[mbNumber].data[2] = 0;
            pDecContainer->MbDesc[mbNumber].data[3] = 0;
            pDecContainer->MbDesc[mbNumber].data[4] = 0;
            pDecContainer->MbDesc[mbNumber].data[5] = 0;
            pDecContainer->MbDesc[mbNumber].data[6] = 0;
            pDecContainer->MbDesc[mbNumber].data[7] = 0;

            pDecContainer->MbDesc[mbNumber].QP = pDecContainer->StrmStorage.QP;

            SwDec_CopyOutput(pDecContainer, mbNumber);

            return(HANTRO_OK);
        }
    }

    pDecContainer->MbDesc[mbNumber].codedBits = 0;
    pDecContainer->MbDesc[mbNumber].errorStatus = 0;

    status = SwDec_DecodeMcbpc(pDecContainer,mbNumber);
    if( status!=HANTRO_OK ) return(status);
    if (MB_IS_STUFFING(mbNumber))
    {
        return(HANTRO_OK);
    }
#ifdef MP4DEC_H263_ONLY
    if (pDecContainer->MbDesc[mbNumber].typeOfMb==MB_INTER4V)
        return(HANTRO_NOK);
#else
    /* svh and mbType MB_INTER4V */
    if ( pDecContainer->StrmStorage.shortVideo && 
        (pDecContainer->MbDesc[mbNumber].typeOfMb==MB_INTER4V))
        return(HANTRO_NOK);
    
    /* ac prediction flag */
    if ( MB_IS_INTRA(mbNumber) && 
         !pDecContainer->StrmStorage.shortVideo )
    {
        tmp = SwDec_GetOneBit(pDecContainer);
        CHECK_END_OF_STREAM(tmp);
        pDecContainer->MbDesc[mbNumber].flags = (u8)(tmp*AC_PRED_FLAG_MASK);
    }
#endif
    status = SwDec_DecodeCbpy(pDecContainer,mbNumber);
    if ( status!=HANTRO_OK )
        return(status);
    
    pDecContainer->StrmStorage.prevQP = pDecContainer->StrmStorage.QP;
    if ( MB_HAS_DQUANT(mbNumber) )
    {
        dQuant = SwDec_GetBits(pDecContainer,2);
        CHECK_END_OF_STREAM(dQuant);
        QP = (i32) pDecContainer->StrmStorage.QP +
            dQuantTable[dQuant];
        SATURATE(1,QP,31);
        pDecContainer->StrmStorage.QP = (u32)QP;
    }

    pDecContainer->MbDesc[mbNumber].QP =
        pDecContainer->StrmStorage.QP;

    if ( MB_IS_INTER(mbNumber) )
    {
        status = SwDec_DecodeMv(pDecContainer,mbNumber);
        if ( status!=HANTRO_OK )
            return(status);
        tmpMask = 0x20;
        for ( i=0;i<6;i++ )
        {
            pDecContainer->StrmStorage.numIdctRows = 0;

            if (pDecContainer->MbDesc[mbNumber].codedBits & tmpMask)
            {
                i32 scanOut[64] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                status = SwDec_DecodeInterVlcBlock(pDecContainer,scanOut,
                    pDecContainer->MbDesc[mbNumber].QP, 0);
                if ( status!=HANTRO_OK )
                    return(status);
                SwDec_ProcessInterBlock(pDecContainer,scanOut,mbNumber,i);
            }
            else
            {
                SwDec_ProcessInterBlock(pDecContainer,NULL,mbNumber,i);
            }

            tmpMask >>= 1;
        }
    }
    /* intra macro block */
    else {
#ifndef MP4DEC_H263_ONLY
        useIntraDcVlc = SwDec_UseIntraDcVlc(pDecContainer,mbNumber);
#endif
        tmpMask = 0x20;
        for ( i=0;i<6;i++ )
        {
            i32 scanOut[64] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                               0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                               0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                               0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

#ifdef MP4DEC_H263_ONLY
            status = SwDec_DecodeDcCoeff(pDecContainer,mbNumber,i);
            if ( status!=HANTRO_OK )
                return(status);
#else
            if ( useIntraDcVlc ){
                status = SwDec_DecodeDcCoeff(pDecContainer,mbNumber,i);
                if ( status!=HANTRO_OK )
                    return(status);
            }
            scanDir = SwDec_ScanDir(pDecContainer, mbNumber, i);
#endif
            pDecContainer->StrmStorage.numIdctRows = 0;

            if (pDecContainer->MbDesc[mbNumber].codedBits & tmpMask)
            {
#ifndef MP4DEC_H263_ONLY
                if (!pDecContainer->StrmStorage.shortVideo)
                {
                    status = SwDec_DecodeIntraVlcBlock(pDecContainer, scanOut,
                        pDecContainer->MbDesc[mbNumber].QP,
                        useIntraDcVlc, scanDir);
                }
                else
#endif
                {
                    /* inter vlc tables used for short video. Last param
                     * indicates that dc coeffs are separately decoded */
                    status = SwDec_DecodeInterVlcBlock(pDecContainer,scanOut,
                        pDecContainer->MbDesc[mbNumber].QP, 1);
                }
                if ( status!=HANTRO_OK )
                    return(status);
            }
#ifdef MP4DEC_H263_ONLY
            SwDec_ProcessIntraBlock(pDecContainer,scanOut,mbNumber,i, 0);
#else
            SwDec_ProcessIntraBlock(pDecContainer,scanOut,mbNumber,i,
                scanDir);
#endif
            tmpMask >>= 1;
        }
    }

    return(HANTRO_OK);

}