umc_h264_dec_deblocking.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

{
    Ipp8u *pY = pParams->pY;
    Ipp32s pic_pitch = pParams->pitch;
    Ipp32u MBAddr = pParams->nMBAddr;
    Ipp8u Clipping[16];
    Ipp8u Alpha[2];
    Ipp8u Beta[2];
    Ipp32s AlphaC0Offset = pParams->nAlphaC0Offset;
    Ipp32s BetaOffset = pParams->nBetaOffset;
    Ipp32s pmq_QP = m_mbinfo.mbs[MBAddr].QP;

    //
    // luma deblocking
    //

    if (pParams->DeblockingFlag[dir])
    {
        Ipp8u *pClipTab;
        Ipp32s QP;
        Ipp32s index;
        Ipp8u *pStrength = pParams->Strength[dir];

        //
        // correct strengths for high profile
        //
        if (pGetMB8x8TSFlag(m_pCurrentFrame->m_mbinfo.mbs + MBAddr))
        {
            SetEdgeStrength(pStrength + 4, 0);
            SetEdgeStrength(pStrength + 12, 0);
        }

        if (pParams->ExternalEdgeFlag[dir])
        {
            Ipp32s pmp_QP;

            // get neighbour block QP
            pmp_QP = m_mbinfo.mbs[pParams->nNeighbour[dir]].QP;

            // luma variables
            QP = (pmp_QP + pmq_QP + 1) >> 1 ;

            // external edge variables
            index = IClip(0, 51, QP + BetaOffset);
            Beta[0] = BETA_TABLE[index];

            index = IClip(0, 51, QP + AlphaC0Offset);
            Alpha[0] = ALPHA_TABLE[index];
            pClipTab = CLIP_TAB[index];

            // create clipping values
            Clipping[0] = pClipTab[pStrength[0]];
            Clipping[1] = pClipTab[pStrength[1]];
            Clipping[2] = pClipTab[pStrength[2]];
            Clipping[3] = pClipTab[pStrength[3]];

        }

        // internal edge variables
        QP = pmq_QP;

        index = IClip(0, 51, QP + BetaOffset);
        Beta[1] = BETA_TABLE[index];

        index = IClip(0, 51, QP + AlphaC0Offset);
        Alpha[1] = ALPHA_TABLE[index];
        pClipTab = CLIP_TAB[index];

        // create clipping values
        {
            Ipp32u edge;

            for (edge = 1;edge < 4;edge += 1)
            {
                if (*((Ipp32u *) (pStrength + edge * 4)))
                {
                    // create clipping values
                    Clipping[edge * 4 + 0] = pClipTab[pStrength[edge * 4 + 0]];
                    Clipping[edge * 4 + 1] = pClipTab[pStrength[edge * 4 + 1]];
                    Clipping[edge * 4 + 2] = pClipTab[pStrength[edge * 4 + 2]];
                    Clipping[edge * 4 + 3] = pClipTab[pStrength[edge * 4 + 3]];
                }
            }
        }

        // perform deblocking
        IppLumaDeblocking[dir](pY,
                               pic_pitch,
                               Alpha,
                               Beta,
                               Clipping,
                               pStrength);
    }

} // void H264VideoDecoder::DeblockLuma(Ipp32u dir, DeblockingParameters *pParams)

void H264VideoDecoder::DeblockChroma(Ipp32u dir, DeblockingParameters *pParams)
{
    // do not deblocking of 4:0:0 format
    if (1)
    {
        Ipp8u *pU = pParams->pU;
        Ipp8u *pV = pParams->pV;
        Ipp32s pic_pitch = pParams->pitch;
        Ipp32u MBAddr = pParams->nMBAddr;
        Ipp8u Clipping[16];
        Ipp8u Alpha[2];
        Ipp8u Beta[2];
        Ipp32s AlphaC0Offset = pParams->nAlphaC0Offset;
        Ipp32s BetaOffset = pParams->nBetaOffset;
        Ipp32s pmq_QP = m_mbinfo.mbs[MBAddr].QP;

        //
        // chroma deblocking
        //

        if (pParams->DeblockingFlag[dir])

        {
            Ipp8u *pClipTab;
            Ipp32s QP;
            Ipp32s index;
            Ipp8u *pStrength = pParams->Strength[dir];
            Ipp32u nPlane;

            for (nPlane = 0; nPlane < 2; nPlane += 1)
            {
                if (0 == nPlane)
                {
                    Ipp32s chroma_qp_offset = (m_PicParamSet[m_CurrentPicParamSet].chroma_qp_index_offset) ;

                    if (pParams->ExternalEdgeFlag[dir])
                    {
                        Ipp32s pmp_QP;

                        // get left block QP
                        pmp_QP = m_mbinfo.mbs[pParams->nNeighbour[dir]].QP;

                        // external edge variables
                        QP = (QP_SCALE_CR[IClip(0, 51, pmp_QP + chroma_qp_offset)] +
                              QP_SCALE_CR[IClip(0, 51, pmq_QP + chroma_qp_offset)] + 1) >> 1;

                        index = IClip(0, 51, QP + BetaOffset);
                        Beta[0] = BETA_TABLE[index];

                        index = IClip(0, 51, QP + AlphaC0Offset);
                        Alpha[0] = ALPHA_TABLE[index];
                        pClipTab = CLIP_TAB[index];

                        // create clipping values
                        Clipping[0] = pClipTab[pStrength[0]];
                        Clipping[1] = pClipTab[pStrength[1]];
                        Clipping[2] = pClipTab[pStrength[2]];
                        Clipping[3] = pClipTab[pStrength[3]];
                    }

                    // internal edge variables
                    QP = QP_SCALE_CR[IClip(0, 51, pmq_QP + chroma_qp_offset)];

                    index = IClip(0, 51, QP + BetaOffset);
                    Beta[1] = BETA_TABLE[index];

                    index = IClip(0, 51, QP + AlphaC0Offset);
                    Alpha[1] = ALPHA_TABLE[index];
                    pClipTab = CLIP_TAB[index];

                    // create clipping values
                    Clipping[4] = pClipTab[pStrength[8]];
                    Clipping[5] = pClipTab[pStrength[9]];
                    Clipping[6] = pClipTab[pStrength[10]];
                    Clipping[7] = pClipTab[pStrength[11]];
                }

                // perform deblocking chroma component
                IppChromaDeblocking[dir]((0 == nPlane) ? (pU) : (pV),
                                         pic_pitch,
                                         Alpha,
                                         Beta,
                                         Clipping,
                                         pStrength);
            }
        }
    }

} // void H264VideoDecoder::DeblockChroma(Ipp32u dir, DeblockingParameters *pParams)

void H264VideoDecoder::ResetDeblockingVariables(DeblockingParameters *pParams)
{
    Ipp8u *pY, *pU, *pV;
    Ipp32u offset;
    Ipp32s MBYAdjust = 0;
    Ipp32u mbXOffset, mbYOffset;
    Ipp32s pic_pitch = m_pCurrentFrame->pitch();
    Ipp32u MBAddr = pParams->nMBAddr;
    Ipp32u nCurrMB_X, nCurrMB_Y;
    H264LimitedSliceHeader *pHeader = m_pLimitedSliceInfo + m_pCurrentFrame->m_mbinfo.mbs[MBAddr].slice_id;

    // load planes
    pY = m_pCurrentFrame->m_pYPlane;
    pU = m_pCurrentFrame->m_pUPlane;
    pV = m_pCurrentFrame->m_pVPlane;
    if (FRM_STRUCTURE > m_pCurrentFrame->m_PictureStructureForDec)
    {
        if(m_pCurrentFrame->m_bottom_field_flag[m_field_index])
        {
            pY += pic_pitch;
            pU += pic_pitch;
            pV += pic_pitch;
        }
        if (m_field_index)
            MBYAdjust = mb_height / 2;
        pic_pitch *= 2;
    }

    // prepare macroblock variables
    nCurrMB_X = (MBAddr % mb_width);
    nCurrMB_Y = (MBAddr / mb_width)- MBYAdjust;
    mbXOffset = nCurrMB_X * 16;
    mbYOffset = nCurrMB_Y * 16;

    // calc plane's offsets
    offset = mbXOffset + (mbYOffset * pic_pitch);
    pY += offset;
    offset >>= 1;
    pU += offset;
    pV += offset;

    // set external edge variables
    pParams->ExternalEdgeFlag[VERTICAL_DEBLOCKING] = (nCurrMB_X != 0);
    pParams->ExternalEdgeFlag[HORIZONTAL_DEBLOCKING] = (nCurrMB_Y != 0);

    if (DEBLOCK_FILTER_ON_NO_SLICE_EDGES == pHeader->disable_deblocking_filter_idc)
    {
        // don't filter at slice boundaries
        if (nCurrMB_X)
        {
            if (m_pCurrentFrame->m_mbinfo.mbs[MBAddr].slice_id !=
                m_pCurrentFrame->m_mbinfo.mbs[MBAddr - 1].slice_id)
                pParams->ExternalEdgeFlag[VERTICAL_DEBLOCKING] = 0;
        }

        if (nCurrMB_Y)
        {
            if (m_pCurrentFrame->m_mbinfo.mbs[MBAddr].slice_id !=
                m_pCurrentFrame->m_mbinfo.mbs[MBAddr - mb_width].slice_id)
                pParams->ExternalEdgeFlag[HORIZONTAL_DEBLOCKING] = 0;
        }
    }

    // reset external edges strength
    SetEdgeStrength(pParams->Strength[VERTICAL_DEBLOCKING], 0);
    SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING], 0);

    // set neighbour addreses
    pParams->nNeighbour[VERTICAL_DEBLOCKING] = MBAddr - 1;
    pParams->nNeighbour[HORIZONTAL_DEBLOCKING] = MBAddr - mb_width;

    // set deblocking flag(s)
    pParams->DeblockingFlag[VERTICAL_DEBLOCKING] = 0;
    pParams->DeblockingFlag[HORIZONTAL_DEBLOCKING] = 0;

    // save variables
    pParams->pY = pY;
    pParams->pU = pU;
    pParams->pV = pV;
    pParams->pitch = pic_pitch;
    pParams->nMaxMVector = (FRM_STRUCTURE > m_pCurrentFrame->m_PictureStructureForDec) ? (2) : (4);
    pParams->MBFieldCoded = (FRM_STRUCTURE > m_pCurrentFrame->m_PictureStructureForDec);

    // set slice's variables
    pParams->nAlphaC0Offset = pHeader->slice_alpha_c0_offset;
    pParams->nBetaOffset = pHeader->slice_beta_offset;

} // void H264VideoDecoder::ResetDeblockingVariables(DeblockingParameters *pParams)

void H264VideoDecoder::PrepareDeblockingParametersISlice(DeblockingParameters *pParams)
{
    // set deblocking flag(s)
    pParams->DeblockingFlag[VERTICAL_DEBLOCKING] = 1;
    pParams->DeblockingFlag[HORIZONTAL_DEBLOCKING] = 1;

    // calculate strengths
    if (pParams->ExternalEdgeFlag[VERTICAL_DEBLOCKING])
    {
        // deblocking with strong deblocking of external edge
        SetEdgeStrength(pParams->Strength[VERTICAL_DEBLOCKING] + 0, 4);
    }

    SetEdgeStrength(pParams->Strength[VERTICAL_DEBLOCKING] + 4, 3);
    SetEdgeStrength(pParams->Strength[VERTICAL_DEBLOCKING] + 8, 3);
    SetEdgeStrength(pParams->Strength[VERTICAL_DEBLOCKING] + 12, 3);

    if (pParams->ExternalEdgeFlag[HORIZONTAL_DEBLOCKING])
    {
        if (pParams->MBFieldCoded)
        {
            // deblocking field macroblock with external edge
            SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING] + 0, 3);
        }
        else
        {
            // deblocking with strong deblocking of external edge
            SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING] + 0, 4);
        }
    }

    SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING] + 4, 3);
    SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING] + 8, 3);
    SetEdgeStrength(pParams->Strength[HORIZONTAL_DEBLOCKING] + 12, 3);

} // void H264VideoDecoder::PrepareDeblockingParametersISlice(DeblockingParameters *pParams)

void H264VideoDecoder::PrepareDeblockingParametersPSlice(DeblockingParameters *pParams)
{
    Ipp32u MBAddr = pParams->nMBAddr;
    Ipp32u mbtype = (m_pCurrentFrame->m_mbinfo.mbs + MBAddr)->mbtype;

    // when this macroblock is intra coded
    if (IS_INTRA_MBTYPE(mbtype))
    {
        PrepareDeblockingParametersISlice(pParams);
        return;
    }

    // try simplest function to prepare deblocking parameters
    switch (mbtype)
    {
        // when macroblock has type inter 16 on 16
    case MBTYPE_INTER:
    case MBTYPE_FORWARD:
    case MBTYPE_BACKWARD:
    case MBTYPE_BIDIR:
        PrepareDeblockingParametersPSlice16(VERTICAL_DEBLOCKING, pParams);