umc_vc1_enc_picture_adv.cpp

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

        pBlocks[4]  = pTopMB->m_pBlock[2];
        pBlocks[12] = pTopMB->m_pBlock[4];
        pBlocks[15] = pTopMB->m_pBlock[5];
    }
    if (pLeftMB)
    {
        pBlocks[2]   = pLeftMB->m_pBlock[1];
        pBlocks[7]   = pLeftMB->m_pBlock[1];
        pBlocks[8]   = pLeftMB->m_pBlock[3];
        pBlocks[14]  = pLeftMB->m_pBlock[4];
        pBlocks[17]  = pLeftMB->m_pBlock[5];

    }

    //  Estimation about AC prediction
    for (i = 0; i<VC1_ENC_NUMBER_OF_BLOCKS; i++)
    {
        if (pBlocks[3*i+0] && pBlocks[3*i+2])
        {
            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]);
            }
        }
        else if (pBlocks[3*i+0])
        {
                direction[i] = VC1_ENC_TOP;
                z += SumSqDiff_7x1_16s(pCurrMB->m_pBlock[i], pBlocks[3*i+0]);
        }
        else if (pBlocks[3*i+2])
        {
               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_LEFT;
               pBlocks[3*i+2]   = temp;
               z += SumSqDiff_1x7_16s(pCurrMB->m_pBlock[i], pCurrMB->m_uiBlockStep[i],pBlocks[3*i+2]);
        }
    }

        //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(VC1EncoderMBDataSM* pCurrMB,
                                   VC1EncoderMBDataSM* pLeftMB,
                                   VC1EncoderMBDataSM* pTopMB,
                                   VC1EncoderMBDataSM* pTopLeftMB,
                                   VC1EncoderMBDataSM* 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]);
    }

    return (z<0);
}
*/

UMC::Status VC1EncoderPictureADV::WriteIFrame(VC1EncoderBitStreamAdv* 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];
    fDeblockingLumaHor          pDeblockingLumaHor[2]  = {DeblockingNOVSTLumaHor,
                                                          DeblockingNOVSTLumaHorLast};

    fDeblockingChromaHor        pDeblockingChromaHor[2] = {DeblockingNOVSTChromaHor,
                                                           DeblockingNOVSTChromaHorLast};
   // fWriteDCAdv                 pWriteDC        =  (m_uiQuant<=2)?
    //                                                pWriteDCAdv[m_uiQuant-1]:pWriteDCAdv[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);
            }
STATISTICS_START_TIME(m_TStat->Intra_StartTime);
            // intra prediction
            dACPrediction = DCACPredictionIFrameAdv( pCurMBData,
                                                    m_pMBs->GetLeftMBData(),
                                                    m_pMBs->GetTopMBData(),
                                                    m_pMBs->GetTopLeftMBData(),
                                                    &TempBlock,
                                                    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);

            pCompressedMB->SetACPrediction(dACPrediction);
            pCompressedMB->SetMBCBPCY(CBPCY);
            /* ---------------------coding------------------------------------------------------------- */
            {
            err = pCompressedMB->WriteMBHeaderI_ADV(pCodedPicture, m_bRawBitplanes, m_uiCondOverlap == VC1_ENC_COND_OVERLAP_SOME);
            if (err != UMC::UMC_OK)
                return err;

            for (blk = 0; blk<6; blk++)
            {
                    err = pCompressedMB->WriteBlock(pCodedPicture,pDCTableVLC[blk],m_uiQuant,pACTablesVLC[blk],&ACEscInfo,blk);
                    VC1_ENC_CHECK (err)
            }//for
            }