umc_vc1_deblock_adv.cpp

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

    }
    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, flag_ver);
}

static void HorizontalDeblockingBlkB(Ipp8u* pUUpBlock,
                                     Ipp32u Pquant,
                                     Ipp32s Pitch,
                                     VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s flag_ver = IPPVC_EDGE_ALL;
    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV_BBL,VM_STRING("Edge = %d\n"),Edge);

    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,Pitch, 0);
    if ((_pBlk->blkType==VC1_BLK_INTER8X4) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 2))
        {
            flag_ver ^= IPPVC_EDGE_HALF_1;
        }
        if ((SBP & 4) || (SBP & 1))
        {
            flag_ver ^= IPPVC_EDGE_HALF_2;
        }
    }
    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, flag_ver);

}
static void VerticalDeblockingBlkB_No_DBlock(Ipp8u* pUUpLBlock,
                                             Ipp32u Pquant,
                                             Ipp32s Pitch,
                                             VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s flag_ver = IPPVC_EDGE_ALL;
    if ((_pBlk->blkType==VC1_BLK_INTER4X8) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 4))
        {
            flag_ver ^= IPPVC_EDGE_HALF_1;


        }
        if ((SBP & 2) || (SBP & 1))
        {
            flag_ver ^= IPPVC_EDGE_HALF_2;
        }
    }
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch,flag_ver);
}

static void VerticalDeblockingBlkB(Ipp8u* pUUpLBlock,
                                   Ipp32u Pquant,
                                   Ipp32s Pitch,
                                   VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s flag_ver = IPPVC_EDGE_ALL;
    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV_BBL,VM_STRING("Edge = %d\n"),Edge);
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 8, Pquant,Pitch,0);
    if ((_pBlk->blkType==VC1_BLK_INTER4X8) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 4))
        {
            /* Deblock first 4 pixels of subblock edge */
            flag_ver ^= IPPVC_EDGE_HALF_1;
        }
        if ((SBP & 2) || (SBP & 1))
        {
            /* Deblock second 4 pixels of subblock edge */
            flag_ver ^= IPPVC_EDGE_HALF_2;
        }
    }
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch,flag_ver);
}



static void HorizontalDeblockingBlkInterlaceP_No_DBlock(Ipp8u* pUUpBlock,
                                                        Ipp32u Pquant,
                                                        Ipp32s Pitch,
                                                        VC1Block* _pBlk,
                                                        Ipp32u field)
{
    Ipp32s flag_ver=0;
    if (field)
    {
        if ((_pBlk->blkType == VC1_BLK_INTER8X4) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,2*Pitch, flag_ver);
        }

    }
}
static void HorizontalDeblockingBlkInterlaceP(Ipp8u* pUUpBlock,
                                              Ipp32u Pquant,
                                              Ipp32s Pitch,
                                              VC1Block* _pBlk,
                                              Ipp32u field,
                                              Ipp32u is_intern_deblock)
{
    if (field)
    {
        if ((_pBlk->blkType == VC1_BLK_INTER8X4) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,2*Pitch, 0);

        }
        _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 16*Pitch, Pquant,2*Pitch, 0);
    }
    else
    {
        if (is_intern_deblock&&((_pBlk->blkType == VC1_BLK_INTER8X4) ||
            (_pBlk->blkType == VC1_BLK_INTER4X4)))
        {
            _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,2*Pitch, 0);
            _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 5*Pitch, Pquant,2*Pitch, 0);
        }
        _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,2*Pitch, 0);
        _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 9*Pitch, Pquant,2*Pitch, 0);
    }

}
static void VerticalDeblockingBlkInterlaceP_No_DBlock(Ipp8u* pUUpBlock,
                                                      Ipp32u Pquant,
                                                      Ipp32s Pitch,
                                                      VC1Block* _pBlk,
                                                      Ipp32u field)
{
    Ipp32s flag_ver = IPPVC_EDGE_HALF_2;
    if (field)
    {
        if ((_pBlk->blkType == VC1_BLK_INTER4X8) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4, Pquant,2*Pitch,flag_ver);
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4 +8*Pitch, Pquant,2*Pitch,flag_ver);

        }
    }
    else
    {
        if ((_pBlk->blkType == VC1_BLK_INTER4X8) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4, Pquant,2*Pitch,flag_ver);
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4 + Pitch, Pquant,2*Pitch,flag_ver);
        }
    }
}
static void VerticalDeblockingBlkInterlaceP(Ipp8u* pUUpBlock,
                                            Ipp32u Pquant,
                                            Ipp32s Pitch,
                                            VC1Block* _pBlk,
                                            Ipp32u field)
{
    Ipp32s flag_ver = IPPVC_EDGE_HALF_2;
    if (field)
    {
        if ((_pBlk->blkType == VC1_BLK_INTER4X8) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock+ 4, Pquant,2*Pitch,flag_ver);
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4 +8*Pitch, Pquant,2*Pitch,flag_ver);

        }
        _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 8, Pquant,2*Pitch,flag_ver);
        _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 8 +8*Pitch, Pquant,2*Pitch,flag_ver);

    }

    else
    {
        if ((_pBlk->blkType == VC1_BLK_INTER4X8) || (_pBlk->blkType == VC1_BLK_INTER4X4))
        {
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4, Pquant,2*Pitch,flag_ver);
            _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 4 + Pitch, Pquant,2*Pitch,flag_ver);
        }
        _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 8, Pquant,2*Pitch,flag_ver);
        _own_FilterDeblockingChroma_VerEdge_VC1(pUUpBlock + 8 + Pitch, Pquant,2*Pitch,flag_ver);
    }

}


void Deblocking_ProgressiveIpicture_Adv(VC1Context* pContext)
{
    Ipp32s WidthMB =  pContext->m_seqLayerHeader->widthMB;
    Ipp32s curX, curY;
    Ipp32u PQuant = pContext->m_picLayerHeader->PQUANT;

    Ipp32s HeightMB   = pContext->DeblockInfo.HeightMB;
    VC1MB* m_CurrMB = pContext->m_pCurrMB;

    Ipp32s YPitch = m_CurrMB->currYPitch;
    Ipp32s UPitch = m_CurrMB->currUPitch;
    Ipp32s VPitch = m_CurrMB->currVPitch;

    Ipp32s flag_ver = 0;

    /* Deblock horizontal edges */
    for (curY=0; curY<HeightMB-1; curY++)
    {
        for (curX=0; curX<WidthMB; curX++)
        {
            flag_ver = 0;
            /* Top luma blocks */
            _own_FilterDeblockingLuma_HorEdge_VC1((m_CurrMB->currYPlane+8*YPitch), PQuant, YPitch,flag_ver);

            /* Bottom Luma blocks */
            _own_FilterDeblockingLuma_HorEdge_VC1((m_CurrMB->currYPlane+YPitch*16),
                                      PQuant,YPitch,flag_ver);
            //flag_ver = IPPVC_EDGE_HALF_2;
            /* Horizontal deblock Cb */
            _own_FilterDeblockingChroma_HorEdge_VC1((m_CurrMB->currUPlane+8*UPitch),
                                              PQuant,UPitch,flag_ver);
            /* Horizontal deblock Cr */
            _own_FilterDeblockingChroma_HorEdge_VC1((m_CurrMB->currVPlane+8*VPitch),
                                              PQuant,VPitch,flag_ver);
            ++m_CurrMB;
        }
    }
    if (pContext->DeblockInfo.is_last_deblock)
    {
        flag_ver =0;
        for (curX=0; curX<WidthMB; curX++)
        {
            /* Top luma blocks */
            _own_FilterDeblockingLuma_HorEdge_VC1((m_CurrMB->currYPlane+8*YPitch), PQuant, YPitch,flag_ver);
            ++m_CurrMB;
        }
    } else
        HeightMB -=1;


    m_CurrMB   -= WidthMB*HeightMB;
    /* Deblock vertical edges */
    for (curY=0; curY<HeightMB; curY++)
    {
        for (curX=0; curX<WidthMB-1; curX++)
        {
            flag_ver = 0;
            _own_FilterDeblockingLuma_VerEdge_VC1((m_CurrMB->currYPlane+8), PQuant,YPitch,flag_ver);

            /* Bottom Luma blocks */
            _own_FilterDeblockingLuma_VerEdge_VC1((m_CurrMB->currYPlane+16),PQuant,YPitch,flag_ver);

            //flag_ver = IPPVC_EDGE_HALF_2;
            /* Vertical deblock Cb */
            _own_FilterDeblockingChroma_VerEdge_VC1(m_CurrMB->currUPlane+8,PQuant,UPitch,flag_ver);
            /* Vertical deblock Cr */
            _own_FilterDeblockingChroma_VerEdge_VC1(m_CurrMB->currVPlane+8,PQuant,VPitch,flag_ver);
            ++m_CurrMB;
        }
        flag_ver =0;
        _own_FilterDeblockingLuma_VerEdge_VC1((m_CurrMB->currYPlane+8), PQuant,YPitch,flag_ver);
        ++m_CurrMB;

    }
}
void Deblocking_ProgressivePpicture_Adv(VC1Context* pContext)
{
    Ipp32s WidthMB =  pContext->m_seqLayerHeader->widthMB;
    Ipp32s curX, curY;
    Ipp32s PQuant = pContext->m_picLayerHeader->PQUANT;

    Ipp32s HeightMB   = pContext->DeblockInfo.HeightMB;
    //VC1MB* m_CurrMB = pContext->m_pCurrMB - WidthMB*(HeightMB);
    VC1MB* m_CurrMB = pContext->m_pCurrMB;
    Ipp32s YPitch = m_CurrMB->currYPitch;
    Ipp32s UPitch = m_CurrMB->currUPitch;
    Ipp32s VPitch = m_CurrMB->currVPitch;

    /* Deblock horizontal edges */
    for (curY=0; curY<HeightMB-1; curY++)
    {
        for (curX=0; curX<WidthMB; curX++)
        {
            //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV_BBL, VM_STRING("MB number is %d MB type %d\n"), WidthMB*curY+curX, m_CurrMB->mbType);
            /* Top luma blocks */
            HorizontalDeblockingLumaP(m_CurrMB->currYPlane,
                                        PQuant,YPitch,
                                        m_CurrMB,
                                        m_CurrMB);

            /* Bottom Luma blocks */
            HorizontalDeblockingLumaP((m_CurrMB->currYPlane+YPitch*8),
                                         PQuant,
                                         YPitch,
                                         m_CurrMB,
                                         m_CurrMB+WidthMB);
            /* Horizontal deblock Cb */
            HorizontalDeblockingChromaP((m_CurrMB->currUPlane),
                                         PQuant,
                                         UPitch,
                                         &m_CurrMB->m_pBlocks[4],
                                         &(m_CurrMB+WidthMB)->m_pBlocks[4]);
            /* Horizontal deblock Cr */
            HorizontalDeblockingChromaP((m_CurrMB->currVPlane),
                                         PQuant,
                                         VPitch,
                                         &m_CurrMB->m_pBlocks[5],
                                         &(m_CurrMB+WidthMB)->m_pBlocks[5]);
            /*  VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV_BBL,VM_STRING("Number of NZC coeffs in Macroblock =%d\n Block[0].NZC[0]=%d\n Block[0].NZC[1]=%d\n Block[0].NZC[2]=%d\n Block[0].NZC[3]=%d\n"),
            WidthMB*curY+curX,m_CurrMB->m_pBlocks[0].numCoeffs[0],m_CurrMB->m_pBlocks[0].numCoeffs[1], m_CurrMB->m_pBlocks[0].numCoeffs[2],m_CurrMB->m_pBlocks[0].numCoeffs[3]);*/
            ++m_CurrMB;
        }
    }
    if (pContext->DeblockInfo.is_last_deblock)
    {
    for (curX=0; curX<WidthMB; curX++)
    {

        /* Top luma blocks */
        HorizontalDeblockingLumaP((m_CurrMB->currYPlane),
                                   PQuant,
                                   YPitch,
                                   m_CurrMB,
                                   m_CurrMB);

        HorizontalDeblockingLumaPNoBotBlock((m_CurrMB->currYPlane+YPitch*8),
                                             PQuant,
                                             YPitch,
                                             m_CurrMB);
        /* Horizontal deblock Cb */
        HorizontalDeblockingChromaPNoBotBlock((m_CurrMB->currUPlane),
                                               PQuant,
                                               UPitch,
                                               &m_CurrMB->m_pBlocks[4]);
        /* Horizontal deblock Cr */
        HorizontalDeblockingChromaPNoBotBlock((m_CurrMB->currVPlane),
                                               PQuant,
                                               VPitch,
                                               &m_CurrMB->m_pBlocks[5]);
        ++m_CurrMB;
    }
    } else
        HeightMB -=1;

    m_CurrMB   -= WidthMB*(HeightMB);

    //printf("Vertical Deblocking \n");

    /* Deblock vertical edges */
    for (curY=0; curY<HeightMB; curY++)
    {
        for (curX=0; curX<WidthMB-1; curX++)
        {
            //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV_BBL, VM_STRING("MB number is %d MB type %d\n"), WidthMB*curY+curX, m_CurrMB->mbType);

            /* Left luma blocks */
            VerticalDeblockingLumaP(m_CurrMB->currYPlane,
                                    PQuant,
                                    YPitch,
                                    m_CurrMB,
                                    m_CurrMB);
            /* Right Luma blocks */
             VerticalDeblockingLumaP(m_CurrMB->currYPlane+8,
                                    PQuant,
                                    YPitch,
                                    m_CurrMB,
                                    m_CurrMB+1);
            /* Vertical deblock Cb */
            VerticalDeblockingChromaP((m_CurrMB->currUPlane),
                PQuant,
                UPitch,
                &m_CurrMB->m_pBlocks[4],