umc_h264_deblock.cpp

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

            if (!bOnTopEdge)
            {
                cbp_above = pMB->uCBP4x4;
                cbp_above = D_CBP_LUMA_TO_RASTERSCAN_ORDER(cbp_above);
                // If MB above is INTRA, set the intra bits for the top edge blocks
                mbtype_adj = pMB->uMBType;
                QP_above = pMB->uMBQP;
                QPChromaIndex = QP_above + m_pFilterSliceData[AdjSliceNum].chroma_qp_index_offset;
                QPChromaIndex = MIN(QPChromaIndex, (Ipp32s)QP_MAX);
                QPChromaIndex = MAX(0, QPChromaIndex);
                QP_aboveChroma = QPtoChromaQP[QPChromaIndex];
                if (IS_INTRA_MBTYPE(mbtype_adj))
                    bhintra |= uTopBlocksMask;
            }
            else
            {
                // no filter top edge of MB
                cbp_above = 0;
                QP_above = uQP;
                QP_aboveChroma = uQP;
            }
        }   // init filter edge vars

        QPavgLeft = (uQP + QP_left + 1)>>1;
        QPavgAbove = (uQP + QP_above + 1)>>1;
        QPavgLeftChroma = (uQPChroma + QP_leftChroma + 1)>>1;
        QPavgAboveChroma = (uQPChroma + QP_aboveChroma + 1)>>1;

        iAlphaClipIndex = uQP;
        iBetaIndex = uQP;
        iAlphaClipIndexChroma = uQPChroma;
        iBetaIndexChroma = uQPChroma;

        iAlphaClipIndexAbove = QPavgAbove;
        iBetaIndexAbove = QPavgAbove;
        iAlphaClipIndexAboveChroma = QPavgAboveChroma;
        iBetaIndexAboveChroma = QPavgAboveChroma;

        iAlphaClipIndexLeft = QPavgLeft;
        iBetaIndexLeft = QPavgLeft;
        iAlphaClipIndexLeftChroma = QPavgLeftChroma;
        iBetaIndexLeftChroma = QPavgLeftChroma;

        // Adjust table indices if filter offsets (from slice header) are non-zero
        if (iFilterOffsetAlpha)
        {
            iAlphaClipIndex += iFilterOffsetAlpha;
            iAlphaClipIndexChroma += iFilterOffsetAlpha;
            iAlphaClipIndex = MIN(iAlphaClipIndex, (Ipp32s)QP_MAX);
            iAlphaClipIndexChroma = MIN(iAlphaClipIndexChroma, (Ipp32s)QP_MAX);
            iAlphaClipIndex = MAX(iAlphaClipIndex, 0);
            iAlphaClipIndexChroma = MAX(iAlphaClipIndexChroma, 0);

            iAlphaClipIndexAbove += iFilterOffsetAlpha;
            iAlphaClipIndexAboveChroma += iFilterOffsetAlpha;
            iAlphaClipIndexAbove = MIN(iAlphaClipIndexAbove, (Ipp32s)QP_MAX);
            iAlphaClipIndexAboveChroma = MIN(iAlphaClipIndexAboveChroma, (Ipp32s)QP_MAX);
            iAlphaClipIndexAbove = MAX(iAlphaClipIndexAbove, 0);
            iAlphaClipIndexAboveChroma = MAX(iAlphaClipIndexAboveChroma, 0);

            iAlphaClipIndexLeft += iFilterOffsetAlpha;
            iAlphaClipIndexLeftChroma += iFilterOffsetAlpha;
            iAlphaClipIndexLeft = MIN(iAlphaClipIndexLeft, (Ipp32s)QP_MAX);
            iAlphaClipIndexLeftChroma = MIN(iAlphaClipIndexLeftChroma, (Ipp32s)QP_MAX);
            iAlphaClipIndexLeft = MAX(iAlphaClipIndexLeft, 0);
            iAlphaClipIndexLeftChroma = MAX(iAlphaClipIndexLeftChroma, 0);
        }
        if (iFilterOffsetBeta)
        {
            iBetaIndex += iFilterOffsetBeta;
            iBetaIndexChroma += iFilterOffsetBeta;
            iBetaIndex = MIN(iBetaIndex, (Ipp32s)QP_MAX);
            iBetaIndexChroma = MIN(iBetaIndexChroma, (Ipp32s)QP_MAX);
            iBetaIndex = MAX(iBetaIndex, 0);
            iBetaIndexChroma = MAX(iBetaIndexChroma, 0);

            iBetaIndexAbove += iFilterOffsetBeta;
            iBetaIndexAboveChroma += iFilterOffsetBeta;
            iBetaIndexAbove = MIN(iBetaIndexAbove, (Ipp32s)QP_MAX);
            iBetaIndexAboveChroma = MIN(iBetaIndexAboveChroma, (Ipp32s)QP_MAX);
            iBetaIndexAbove = MAX(iBetaIndexAbove, 0);
            iBetaIndexAboveChroma = MAX(iBetaIndexAboveChroma, 0);

            iBetaIndexLeft += iFilterOffsetBeta;
            iBetaIndexLeftChroma += iFilterOffsetBeta;
            iBetaIndexLeft = MIN(iBetaIndexLeft, (Ipp32s)QP_MAX);
            iBetaIndexLeftChroma = MIN(iBetaIndexLeftChroma, (Ipp32s)QP_MAX);
            iBetaIndexLeft = MAX(iBetaIndexLeft, 0);
            iBetaIndexLeftChroma = MAX(iBetaIndexLeftChroma, 0);
        }


        // If table indices are all <= level below which
        // alpha and beta are 0, thus effectively turning off the filter, continue
        // to the next MB.
        if (iAlphaClipIndex <= MAX_NOFILTER_INDEX &&
            iAlphaClipIndexAbove <= MAX_NOFILTER_INDEX &&
            iAlphaClipIndexLeft <= MAX_NOFILTER_INDEX &&
            iBetaIndex <= MAX_NOFILTER_INDEX &&
            iBetaIndexAbove <= MAX_NOFILTER_INDEX &&
            iBetaIndexLeft <= MAX_NOFILTER_INDEX)
            goto NextMB;

        // Initialize filter edge bools dependent upon cbp and mvd (block and adjacent)
        cbp_above &= uBottomBlocksMask;     // only want bottom edge blocks
        cbp_left &= uRightBlocksMask;       // only want right edge blocks

        // Form cbp bit vars for adjacent blocks vertically (to left) by shifting the
        // cbp bits for this MB left 1 bit and replacing the adjacent bits
        // for blocks 0,4,8,12 with the cbp bits from the MB to the left,
        // bits 3,7,11,15:
        //  adj V: 14 13 12 15L 10 9 8 11L 6 5 4 7L 2 1 0 3L
        cbpv_adj = ((cbp<<1) & 0xffff) & (~uLeftBlocksMask);
        cbpv_adj |= (cbp_left>>3);
        bvcbp = cbp | cbpv_adj; // combine into V edge bool

        // Form the cbp bit vars for adjacent blocks horizontally (above) by shifting
        // the cbp bits left 4 bits and replacing the adjacent bits for blocks
        // 0-3 with the cbp bits from the MB above, bits 12-15.
        //  adj H: 11 10 9 8 7 6 5 4 3 2 1 0 15A 14A 13A 12A
        cbph_adj = ((cbp<<4) & 0xffff) & (~uTopBlocksMask);
        cbph_adj |= (cbp_above>>12);
        bhcbp = cbp | cbph_adj; // combine into H edge bool

        // filter an edge if the block or adjacent block is intra, or if
        // cbp for the block or the adjacent block is set, or
        // if mvd for the block is set
        bhfilter = bhintra | bhcbp | (mvd & 0xffff);
        bvfilter = bvintra | bvcbp | (mvd >> 16);

        // but don't filter picture edges
        if (bOnLeftEdge)
        {
            bvfilter &= (~uLeftBlocksMask);
        }
        if (bOnTopEdge)
        {
            bhfilter &= (~uTopBlocksMask);
        }

        // Here all variables have been set up to enable filtering of the edges
        // of the MB.
        Ipp32u uEdgeBit;        // edge bit mask


        Ipp32u uClipIndex;      // index into DeblockClipTable array of 3
        Ipp32u uMBEdge;
        Ipp32u uBlockEdge;
        bool bOuterIsStrong;

        // same for vertical and horizontal edges
        alpha[1] = DeblockAlphaBetaTable[iAlphaClipIndex].alpha;
        beta[1] = DeblockAlphaBetaTable[iBetaIndex].beta;
        alpha[3] = DeblockAlphaBetaTable[iAlphaClipIndexChroma].alpha;
        beta[3] = DeblockAlphaBetaTable[iBetaIndexChroma].beta;

        // Set clip levels for 16 luma V or H edges and 4
        // chroma V or H edges (2 levels per chroma edge).
        // For weak filter set to 0xff to signal do not
        // filter the edge.

        if (bvfilter)
        {
            // Vertical edges
            pBlockClip = &DeblockClipTable[iAlphaClipIndexLeft][0];
            pBlockClipChroma = &DeblockClipTable[iAlphaClipIndexLeftChroma][0];
            alpha[0] = DeblockAlphaBetaTable[iAlphaClipIndexLeft].alpha;
            beta[0] = DeblockAlphaBetaTable[iBetaIndexLeft].beta;
            alpha[2] = DeblockAlphaBetaTable[iAlphaClipIndexLeftChroma].alpha;
            beta[2] = DeblockAlphaBetaTable[iBetaIndexLeftChroma].beta;
            bOuterIsStrong = false;
            uMBEdge = 0;

            // Strong filter is used if the macroblock on either side is intra,
            // and is applied to entire MB edge (except picture edge).
            if ((bvintra & 1) && (!bOnLeftEdge))
            {
                // use strong for left MB edge, clip level not needed but must
                // be initialized as filter may use for do not filter test
                uMBEdge++;
                bOuterIsStrong = true;
                m_pBlockClipVal[0] = 0; // filter all left edges
                m_pBlockClipVal[1] = 0;
                m_pBlockClipVal[2] = 0;
                m_pBlockClipVal[3] = 0;
                m_pBlockClipVal[16] = 0;    // chroma left edge
                m_pBlockClipVal[17] = 0;    // chroma left edge
                m_pBlockClipVal[18] = 0;    // chroma left edge
                m_pBlockClipVal[19] = 0;    // chroma left edge
                *((int*)Bsl) = 0x04040404;
            }

            for (; uMBEdge<4; uMBEdge++)
            {
                int index = uMBEdge*4;
                Bs    = Bsl + index;
                if (uMBEdge == 1)
                {
                    // inner vertical edges
                    pBlockClip = &DeblockClipTable[iAlphaClipIndex][0];
                    pBlockClipChroma = &DeblockClipTable[iAlphaClipIndexChroma][0];
                }
                uEdgeBit = (1<<uMBEdge);
                *((int*)Bs) = 0x03030303;
                // initialize clip values for the 4 4-pixel edges
                for (uBlockEdge=0; uBlockEdge<4; uBlockEdge++)
                {
                    if (bvfilter & uEdgeBit)
                    {
                        // Clip Index (Bs - 1 using JVT terms) is 1 of 3 values
                        uClipIndex = 0;
                        if (bvcbp & uEdgeBit)
                            uClipIndex = 1;
                        if (bvintra & uEdgeBit)
                            uClipIndex = 2;
                        m_pBlockClipVal[uBlockEdge + uMBEdge*4] = pBlockClip[uClipIndex];
                        if ((uMBEdge & 1) == 0)
                            // chroma
                            m_pBlockClipVal[uBlockEdge + uMBEdge*2 + 16] =
                                pBlockClipChroma[uClipIndex];
                    }
                    else
                    {
                        m_pBlockClipVal[uBlockEdge + uMBEdge*4] = 0xff; // do not filter
                        Bsl[uBlockEdge + uMBEdge*4]=0;
                        if ((uMBEdge & 1) == 0)
                        {
                            // chroma
                            m_pBlockClipVal[uBlockEdge + uMBEdge*2 + 16] = 0xff;
                        }
                    }

                    uEdgeBit <<= 4;
                }   // uBlockEdge
            }   // uMBEdge, vertical

            // actual V edge filter
            ippiFilterDeblockingLuma_VerEdge_H264_8u_C1IR(pY,uPitch,alpha,beta,m_pBlockClipVal,Bsl);
            ippiFilterDeblockingChroma_VerEdge_H264_8u_C1IR(pV,uPitch,alpha+2,beta+2,m_pBlockClipVal+16,Bsl);
            ippiFilterDeblockingChroma_VerEdge_H264_8u_C1IR(pU,uPitch,alpha+2,beta+2,m_pBlockClipVal+16,Bsl);

        }   // vertical edges

        if (bhfilter)
        {
            pBlockClip = &DeblockClipTable[iAlphaClipIndexAbove][0];
            pBlockClipChroma = &DeblockClipTable[iAlphaClipIndexAboveChroma][0];
            alpha[0] = DeblockAlphaBetaTable[iAlphaClipIndexAbove].alpha;
            beta[0] = DeblockAlphaBetaTable[iBetaIndexAbove].beta;
            alpha[2] = DeblockAlphaBetaTable[iAlphaClipIndexAboveChroma].alpha;
            beta[2] = DeblockAlphaBetaTable[iBetaIndexAboveChroma].beta;
            bOuterIsStrong = false;
            uMBEdge = 0;
            // Strong filter is used if the macroblock on either side is intra,
            // and is applied to entire MB edge (except picture edge).
            if ((bhintra & 1) && (!bOnTopEdge))
            {
                // use strong for left MB edge, clip level not needed but must
                // be initialized as filter uses for do not filter test
                bOuterIsStrong = true;
                uMBEdge++;
                m_pBlockClipVal[0] = 0; // filter all top edges
                m_pBlockClipVal[1] = 0;
                m_pBlockClipVal[2] = 0;
                m_pBlockClipVal[3] = 0;
                m_pBlockClipVal[16] = 0;    // chroma left edge
                m_pBlockClipVal[17] = 0;    // chroma left edge
                m_pBlockClipVal[18] = 0;    // chroma left edge
                m_pBlockClipVal[19] = 0;    // chroma left edge
                *((int*)Bsl) = 0x04040404;
            }   // strong horizontal

            // weak horizontal
            for (; uMBEdge<4; uMBEdge++)
            {
                if (uMBEdge == 1)
                {
                    // Inner horizontal edges, outer loop top to bottom, inner loop left to right
                    pBlockClip = &DeblockClipTable[iAlphaClipIndex][0];
                    pBlockClipChroma = &DeblockClipTable[iAlphaClipIndexChroma][0];
                }
                uEdgeBit = (1<<(uMBEdge*4));
                int index = uMBEdge*4;
                Bs    = Bsl + index;
                *((int*)Bs) = 0x03030303;

                // initialize clip values for the 4 4-pixel edges
                for (uBlockEdge=0; uBlockEdge<4; uBlockEdge++)
                {
                    if (bhfilter & uEdgeBit)
                    {
                        // Clip Index (Bs - 1 using JVT terms) is 1 of 3 values
                        uClipIndex = 0;
                        if (bhcbp & uEdgeBit)
                            uClipIndex = 1;
                        if (bhintra & uEdgeBit)
                            uClipIndex = 2;

                        m_pBlockClipVal[uBlockEdge + uMBEdge*4] = pBlockClip[uClipIndex];
                        if ((uMBEdge & 1) == 0)
                            // chroma
                            m_pBlockClipVal[uBlockEdge + uMBEdge*2 + 16] =
                                pBlockClipChroma[uClipIndex];
                    }
                    else
                    {
                        m_pBlockClipVal[uBlockEdge + uMBEdge*4] = 0xff; // do not filter
                        Bsl[uBlockEdge + uMBEdge*4] = 0;    // do not filter
                        if ((uMBEdge & 1) == 0)
                            // chroma
                            m_pBlockClipVal[uBlockEdge + uMBEdge*2 + 16] = 0xff;
                    }

                    // next edge right
                    uEdgeBit <<= 1;
                }   // uBlockEdge
            }   // uMBEdge, horizontal

            // actual H edge filter
            ippiFilterDeblockingLuma_HorEdge_H264_8u_C1IR(pY,uPitch,alpha,beta,m_pBlockClipVal,Bsl);
            ippiFilterDeblockingChroma_HorEdge_H264_8u_C1IR(pU,uPitch,alpha,beta,m_pBlockClipVal+16,Bsl);
            ippiFilterDeblockingChroma_HorEdge_H264_8u_C1IR(pV,uPitch,alpha,beta,m_pBlockClipVal+16,Bsl);
        }   // bhfilter

NextMB:
        // next MB
        pMBInfo ++;
        uSliceNum = pMBInfo->uSlice;
        pY += 16;
        pU += 8;
        pV += 8;
        uMBCol++;
        if (uMBCol == uNumMBPerRow)
        {
            // next row of MB
            uMBCol = 0;
            pY -= uWidth;
            pY += (uPitch<<4);
            pU -= uWidth/2;
            pU += (uPitch<<3);
            pV -= uWidth/2;
            pV += (uPitch<<3);
        }
    }   // for uMB

    return status;

} // DeblockSegment


} //namespace UMC