umc_vc1_enc_picture_sm.cpp

audio-video-codecs.rar语音编解码器

    TempBlock.InitBlocks(temp);

    TempBlock.m_pBlock[0][0] = TempBlock.m_pBlock[1][0]= TempBlock.m_pBlock[2][0] =
    TempBlock.m_pBlock[3][0] = TempBlock.m_pBlock[4][0]= TempBlock.m_pBlock[5][0] =
                                                                            defPredictor;

    pLeftMB     = (pLeftMB)     ? pLeftMB   :&TempBlock;
    pTopLeftMB  = (pTopLeftMB)  ? pTopLeftMB:&TempBlock;
    pTopMB      = (pTopMB)      ? pTopMB    :&TempBlock;

    Ipp16s*             pBlocks[VC1_ENC_NUMBER_OF_BLOCKS*3]=
    {
        pTopMB->m_pBlock[2],    pTopLeftMB->m_pBlock[3], pLeftMB->m_pBlock[1],
        pTopMB->m_pBlock[3],    pTopMB->m_pBlock[2],     pCurrMB->m_pBlock[0],
        pCurrMB->m_pBlock[0],   pLeftMB->m_pBlock[1],    pLeftMB->m_pBlock[3],
        pCurrMB->m_pBlock[1],   pCurrMB->m_pBlock[0],    pCurrMB->m_pBlock[2],
        pTopMB->m_pBlock[4],    pTopLeftMB->m_pBlock[4], pLeftMB->m_pBlock[4],
        pTopMB->m_pBlock[5],    pTopLeftMB->m_pBlock[5], pLeftMB->m_pBlock[5]
    };
    //  Estimation about AC prediction
    for (i = 0; i<VC1_ENC_NUMBER_OF_BLOCKS; i++)
    {
        if (((Ipp32u)((pBlocks[3*i+0][0] - pBlocks[3*i+1][0])*(pBlocks[3*i+0][0] - pBlocks[3*i+1][0]))<=
             (Ipp32u)((pBlocks[3*i+2][0] - pBlocks[3*i+1][0])*(pBlocks[3*i+2][0] - pBlocks[3*i+1][0]))))
        {
            direction[i] = VC1_ENC_LEFT;
            z += SumSqDiff_1x7_16s(pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],pBlocks[3*i+2]);
        }
        else
        {
            direction[i] = VC1_ENC_TOP;
            z += SumSqDiff_7x1_16s(pCurrMB->m_pBlock[i], pBlocks[3*i+0]);
        }
    }

        //AC, DC prediction
        for (i = 0; i<VC1_ENC_NUMBER_OF_BLOCKS; i++)
        {
            Ipp8u numBlk    = 3*i + 2*(!(direction[i] & VC1_ENC_TOP));
            Ipp8u numTable  = (z<0)*direction[i];
            Diff8x8 (pCurrMB->m_pBlock[i],      pCurrMB->m_uiBlockStep[i],
                    pBlocks[numBlk],           pCurrMB->m_uiBlockStep[i],
                    pTables[numTable],         8,
                    pPredBlock->m_pBlock[i],   pPredBlock->m_uiBlockStep[i]);

#ifdef VC1_ENC_DEBUG_ON
            if(z<0)
            {
                pDebug->SetBlockAsIntra(i);
                pDebug->SetDCACInfo(1, pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],
                    pPredBlock->m_pBlock[i], pPredBlock->m_uiBlockStep[i],
                    direction[i], i);
            }
            else
            {
                pDebug->SetBlockAsIntra(i);
                pDebug->SetDCACInfo(0, pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],
                    pPredBlock->m_pBlock[i], pPredBlock->m_uiBlockStep[i],
                    direction[i], i);
            }
#endif
        }

    return (z<0);
}


static bool DCACPredictionPFrameSM(VC1EncoderMBData* pCurrMB,
                                   VC1EncoderMBData* pLeftMB,
                                   VC1EncoderMBData* pTopMB,
                                   VC1EncoderMBData* pTopLeftMB,
                                   VC1EncoderMBData* pPredBlock,
                                   Ipp16s defPredictor,
                                   eDirection* direction)
{
    Ipp32s              z = 0;
    int                 i;
    const Ipp8u*        pTables[] = {NonPrediction, VerPrediction, HorPrediction};
    VC1EncoderMBData    TempBlock;
    Ipp16s              temp [VC1_ENC_BLOCK_SIZE*VC1_ENC_NUMBER_OF_BLOCKS]={0};
    Ipp8u               leftTop = 0;
    bool                bTop  = true;
    bool                bLeft = true;

    TempBlock.InitBlocks(temp);

    TempBlock.m_pBlock[0][0] = TempBlock.m_pBlock[1][0]= TempBlock.m_pBlock[2][0] =
    TempBlock.m_pBlock[3][0] = TempBlock.m_pBlock[4][0]= TempBlock.m_pBlock[5][0] =
                                                                            defPredictor;
    pTopLeftMB  = (pTopLeftMB)  ? pTopLeftMB:&TempBlock;
    if (!pTopMB)
    {
        bTop   = false;
        pTopMB = &TempBlock;
    }
    if (!pLeftMB)
    {
        bLeft   = false;
        pLeftMB = &TempBlock;
    }

    Ipp16s*             pBlocks[VC1_ENC_NUMBER_OF_BLOCKS*3]=
    {
        pTopMB->m_pBlock[2],    pTopLeftMB->m_pBlock[3], pLeftMB->m_pBlock[1],
        pTopMB->m_pBlock[3],    pTopMB->m_pBlock[2],     pCurrMB->m_pBlock[0],
        pCurrMB->m_pBlock[0],   pLeftMB->m_pBlock[1],    pLeftMB->m_pBlock[3],
        pCurrMB->m_pBlock[1],   pCurrMB->m_pBlock[0],    pCurrMB->m_pBlock[2],
        pTopMB->m_pBlock[4],    pTopLeftMB->m_pBlock[4], pLeftMB->m_pBlock[4],
        pTopMB->m_pBlock[5],    pTopLeftMB->m_pBlock[5], pLeftMB->m_pBlock[5]
    };

    //  Estimation about AC prediction
    for (i = 0; i<VC1_ENC_NUMBER_OF_BLOCKS; i++)
    {

        if (((Ipp32u)((pBlocks[3*i+0][0] - pBlocks[3*i+1][0])*(pBlocks[3*i+0][0] - pBlocks[3*i+1][0]))<=
             (Ipp32u)((pBlocks[3*i+2][0] - pBlocks[3*i+1][0])*(pBlocks[3*i+2][0] - pBlocks[3*i+1][0]))))
        {
            direction[i] = VC1_ENC_LEFT;
            z += SumSqDiff_1x7_16s(pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],pBlocks[3*i+2]);
        }
        else
        {
            direction[i] = VC1_ENC_TOP;
            z += SumSqDiff_7x1_16s(pCurrMB->m_pBlock[i], pBlocks[3*i+0]);
        }
    }
    if (!bLeft)
    {
        direction[0]=direction[2]=direction[4]=direction[5]=VC1_ENC_TOP;
    }
    if (!bTop)
    {
        direction[0]=direction[1]=direction[4]=direction[5]=VC1_ENC_LEFT;
    }

        //AC, DC prediction
    for (i = 0; i<VC1_ENC_NUMBER_OF_BLOCKS; i++)
    {
        Ipp8u numBlk    = 3*i + 2*(!(direction[i] & VC1_ENC_TOP));
        Ipp8u numTable  = (z<0)*direction[i];
        assert(numTable<3);
        Diff8x8 (pCurrMB->m_pBlock[i],      pCurrMB->m_uiBlockStep[i],
                pBlocks[numBlk],           pCurrMB->m_uiBlockStep[i],
                pTables[numTable],         8,
                pPredBlock->m_pBlock[i],   pPredBlock->m_uiBlockStep[i]);

#ifdef VC1_ENC_DEBUG_ON
            if(z<0)
            {
                pDebug->SetBlockAsIntra(i);
                pDebug->SetDCACInfo(1, pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],
                    pPredBlock->m_pBlock[i], pPredBlock->m_uiBlockStep[i],
                    direction[i], i);
            }
            else
            {
                pDebug->SetBlockAsIntra(i);
                pDebug->SetDCACInfo(0, pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],
                    pPredBlock->m_pBlock[i], pPredBlock->m_uiBlockStep[i],
                    direction[i], i);
            }
#endif
    }

    return (z<0);
}

UMC::Status VC1EncoderPictureSM::WriteIFrame(VC1EncoderBitStreamSM* pCodedPicture)
{
    Ipp32u                      i=0, j=0, blk = 0;
    bool                        bRaiseFrame = (m_pRaisedPlane[0])&&(m_pRaisedPlane[1])&&(m_pRaisedPlane[2]);
    UMC::Status                 err = UMC::UMC_OK;
    Ipp8u*                      pCurMBRow[3] =  {m_pPlane[0],m_pPlane[1],m_pPlane[2]};
    Ipp32u                      h = m_pSequenceHeader->GetNumMBInCol();
    Ipp32u                      w = m_pSequenceHeader->GetNumMBInRow();
    IppiSize roiSize = {8, 8};

    //forward transform quantization
    IntraTransformQuantFunction    TransformQuantACFunction = (m_bUniformQuant) ? IntraTransformQuantUniform :
                                                                        IntraTransformQuantNonUniform;
    //inverse transform quantization
    IntraInvTransformQuantFunction InvTransformQuantACFunction = (m_bUniformQuant) ? IntraInvTransformQuantUniform :
                                                                        IntraInvTransformQuantNonUniform;

    Ipp8u                       defDCPredCoeff  = (m_pSequenceHeader->IsLoopFilter()&& m_uiQuant>=9)? 0:1;
    eDirection                  direction[VC1_ENC_NUMBER_OF_BLOCKS];
    bool                        dACPrediction   = true;
    Ipp8u                       RSize3Mode      = 0, LSize3Mode = 0;
    VC1EncoderMBData            TempBlock;
    Ipp16s                      tempBuffer[VC1_ENC_BLOCK_SIZE*VC1_ENC_NUMBER_OF_BLOCKS];
    IppiSize                    blkSize     = {8,8};
    IppiSize                    blkSizeLuma = {16,16};
    eCodingSet                  LumaCodingSet   = LumaCodingSetsIntra[m_uiQuantIndex>8][m_uiDecTypeAC2];
    eCodingSet                  ChromaCodingSet = ChromaCodingSetsIntra[m_uiQuantIndex>8][m_uiDecTypeAC1];


    const sACTablesSet*             pACTablesVLC[6] = {
                                    &ACTablesSet[LumaCodingSet],    &ACTablesSet[LumaCodingSet],
                                    &ACTablesSet[LumaCodingSet],    &ACTablesSet[LumaCodingSet],
                                    &ACTablesSet[ChromaCodingSet],  &ACTablesSet[ChromaCodingSet]};

    const Ipp32u*                 pDCTableVLC[6]  ={
                                    DCTables[m_uiDecTypeDCIntra][0],    DCTables[m_uiDecTypeDCIntra][0],
                                    DCTables[m_uiDecTypeDCIntra][0],    DCTables[m_uiDecTypeDCIntra][0],
                                    DCTables[m_uiDecTypeDCIntra][1],    DCTables[m_uiDecTypeDCIntra][1]};

    sACEscInfo                       ACEscInfo = {(m_uiQuant<= 7 /*&& !VOPQuant*/)?
                                               Mode3SizeConservativeVLC : Mode3SizeEfficientVLC,
                                               0, 0
                                             };


    Ipp8u                       doubleQuant     =  2*m_uiQuant + m_bHalfQuant;
    Ipp8u                       DCQuant         =  DCQuantValues[m_uiQuant];
    Ipp16s                      defPredictor    =  defDCPredCoeff*(1024 + (DCQuant>>1))/DCQuant;

    fDeblockingLumaHor          pDeblockingLumaHor[2]  = {DeblockingNOVSTLumaHor,
                                                          DeblockingNOVSTLumaHorLast};

    fDeblockingChromaHor        pDeblockingChromaHor[2] = {DeblockingNOVSTChromaHor,
                                                           DeblockingNOVSTChromaHorLast};
   // fWriteDCSM                 pWriteDC       =  (m_uiQuant<=2)?
    //                                                pWriteDCSM[m_uiQuant-1]:pWriteDCSM[2];
   TempBlock.InitBlocks(tempBuffer);

    if (m_pSavedMV)
    {
        memset(m_pSavedMV,0,w*h*2*sizeof(Ipp16s));
    }
    err = m_pMBs->Reset();
    if (err != UMC::UMC_OK)
        return err;

    for (i=0; i < h; i++)
    {
        for (j=0; j < w; j++)
        {
            Ipp8u               MBPattern  = 0;
            Ipp8u               CBPCY      = 0;
            VC1EncoderMBInfo*   pCurMBInfo = 0;
            VC1EncoderMBData*   pCurMBData = 0;
            Ipp32s              xLuma      = VC1_ENC_LUMA_SIZE*j;
            Ipp32s              xChroma    = VC1_ENC_CHROMA_SIZE*j;

            VC1EncoderCodedMB*  pCompressedMB = &(m_pCodedMB[w*i+j]);

            pCurMBInfo  =   m_pMBs->GetCurrMBInfo();
            pCurMBData  =   m_pMBs->GetCurrMBData();


            pCompressedMB ->Init(VC1_ENC_I_MB);
            pCurMBInfo->Init(true);

            /*------------------- Compressing  ------------------------------------------------------*/

            pCurMBData->CopyMBProg(pCurMBRow[0]+ xLuma,   m_uiPlaneStep[0],
                                   pCurMBRow[1]+ xChroma, m_uiPlaneStep[1],
                                   pCurMBRow[2]+ xChroma, m_uiPlaneStep[2]);

            for (blk = 0; blk<6; blk++)
            {
                if (m_pSequenceHeader->IsOverlap())
                {
                    roiSize.height = 8;
                    roiSize.width  = 8;
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
                    _own_Diff8x8C_16s(128, pCurMBData->m_pBlock[blk], pCurMBData->m_uiBlockStep[blk], roiSize, 0);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
                }
STATISTICS_START_TIME(m_TStat->FwdQT_StartTime);
                TransformQuantACFunction(pCurMBData->m_pBlock[blk], pCurMBData->m_uiBlockStep[blk],
                                         DCQuant, doubleQuant);
STATISTICS_END_TIME(m_TStat->FwdQT_StartTime, m_TStat->FwdQT_EndTime, m_TStat->FwdQT_TotalTime);
            }

            /* intra prediction
               Result is stored in temp block, becouse
               current block is saved for next prediction*/

STATISTICS_START_TIME(m_TStat->Intra_StartTime);
            dACPrediction = DCACPredictionIFrameSM( pCurMBData,
                                                    m_pMBs->GetLeftMBData(),
                                                    m_pMBs->GetTopMBData(),
                                                    m_pMBs->GetTopLeftMBData(),
                                                    &TempBlock,
                                                    defPredictor,
                                                    direction);
STATISTICS_END_TIME(m_TStat->Intra_StartTime, m_TStat->Intra_EndTime, m_TStat->Intra_TotalTime);


            for (blk=0; blk<6; blk++)
            {
                pCompressedMB->SaveResidual(    TempBlock.m_pBlock[blk],
                                                TempBlock.m_uiBlockStep[blk],
                                                ZagTables_I[direction[blk]* dACPrediction],
                                                blk);
            }


            MBPattern = pCompressedMB->GetMBPattern();

            VC1EncoderMBInfo* t = m_pMBs->GetTopMBInfo();
            VC1EncoderMBInfo* l = m_pMBs->GetLeftMBInfo();
            VC1EncoderMBInfo* tl = m_pMBs->GetTopLeftMBInfo();

            CBPCY = Get_CBPCY(MBPattern, (t)? t->GetPattern():0, (l)? l->GetPattern():0, (tl)? tl->GetPattern():0);

            pCurMBInfo->SetMBPattern(MBPattern);