Deblock::getBoundaryStrength()

该函数为step2：计算边界强度

/*
	获取边界强度BS，取值[0,2]

	策略：
	BS = 2：	（优先级1）P4x4block和Q4x4block存在Intra类型
	BS = 1：	（优先级2）P4x4block和Q4x4block存在非零系数，即cbf非零
	BS = 0：	（优先级3）
			·P4x4block和Q4x4block都在P类型，且两者的前向MV在x/y方向上的差值都在1个整像素内
			·P4x4block和Q4x4block存在B类型
				·P4x4block和Q4x4block的前后向参考帧相同，且前后向MV在x/y方向上的差值都在1个整像素内
				·P4x4block和Q4x4block的前后向参考帧交叉相同
					·前后向MV在x/y方向上的差值都在1个整像素内
					·前后向MV交叉在x/y方向上的差值都在1个整像素内
	剩下的所有情况均返回BS = 1
*/
uint8_t Deblock::getBoundaryStrength(const CUData* cuQ, int32_t dir, uint32_t partQ, const uint8_t blockStrength[])
{
    // Calculate block index
    uint32_t partP;
    const CUData* cuP = (dir == EDGE_VER ? cuQ->getPULeft(partP, partQ) : cuQ->getPUAbove(partP, partQ));

    /* Set BS for Intra MB : BS = 2 
		若P4x4block和Q4x4block都是帧内，则强度为2 */
    if (cuP->isIntra(partP) || cuQ->isIntra(partQ))
        return 2;

    /* Set BS for not Intra MB : BS = 1 or 0 
		若P4x4block和Q4x4block存在非零系数，则强度为1 */
    if (blockStrength[partQ] > 1 &&
        (cuQ->getCbf(partQ, TEXT_LUMA, cuQ->m_tuDepth[partQ]) ||
         cuP->getCbf(partP, TEXT_LUMA, cuP->m_tuDepth[partP])))
        return 1;

    static const MV zeroMv(0, 0);
    const Slice* const sliceQ = cuQ->m_slice;
    const Slice* const sliceP = cuP->m_slice;
    const Frame* refP0 = (cuP->m_refIdx[0][partP] >= 0) ? sliceP->m_refFrameList[0][cuP->m_refIdx[0][partP]] : NULL;
    const Frame* refQ0 = (cuQ->m_refIdx[0][partQ] >= 0) ? sliceQ->m_refFrameList[0][cuQ->m_refIdx[0][partQ]] : NULL;
    const MV& mvP0 = refP0 ? cuP->m_mv[0][partP] : zeroMv;
    const MV& mvQ0 = refQ0 ? cuQ->m_mv[0][partQ] : zeroMv;
	/* 若P4x4block和Q4x4block都在Pslice
		若ref不同 || x/y方向上的mv差值大于1个像素，则返回1
		否则返回0	*/
    if (sliceQ->isInterP() && sliceP->isInterP())
    {
        return ((refP0 != refQ0) ||
                (abs(mvQ0.x - mvP0.x) >= 4) || (abs(mvQ0.y - mvP0.y) >= 4)) ? 1 : 0;
    }

	/* (sliceQ->isInterB() || sliceP->isInterB())
		到这里P4x4block和Q4x4block存在Bslice	*/
    const Frame* refP1 = (cuP->m_refIdx[1][partP] >= 0) ? sliceP->m_refFrameList[1][cuP->m_refIdx[1][partP]] : NULL;
    const Frame* refQ1 = (cuQ->m_refIdx[1][partQ] >= 0) ? sliceQ->m_refFrameList[1][cuQ->m_refIdx[1][partQ]] : NULL;
    const MV& mvP1 = refP1 ? cuP->m_mv[1][partP] : zeroMv;
    const MV& mvQ1 = refQ1 ? cuQ->m_mv[1][partQ] : zeroMv;

	// 若前后向ref都相同，或交叉相同
    if (((refP0 == refQ0) && (refP1 == refQ1)) || ((refP0 == refQ1) && (refP1 == refQ0)))
    {
		// 前后向ref交叉相同，若前后向的x/y方向上的mv差值存在超过1个整像素，则返回1，否则0
        if (refP0 != refP1) // Different L0 & L1
        {
            if (refP0 == refQ0)
                return ((abs(mvQ0.x - mvP0.x) >= 4) || (abs(mvQ0.y - mvP0.y) >= 4) ||
                        (abs(mvQ1.x - mvP1.x) >= 4) || (abs(mvQ1.y - mvP1.y) >= 4)) ? 1 : 0;
            else
                return ((abs(mvQ1.x - mvP0.x) >= 4) || (abs(mvQ1.y - mvP0.y) >= 4) ||
                        (abs(mvQ0.x - mvP1.x) >= 4) || (abs(mvQ0.y - mvP1.y) >= 4)) ? 1 : 0;
        }
		/* 前后向ref相同，若前后向的x/y方向上的mv差值存在超过1个整像素，
			并且交叉前后向的x/y方向上的mv差值存在超过1个整像素，则返回1，否则0 */
        else // Same L0 & L1
        {
            return (((abs(mvQ0.x - mvP0.x) >= 4) || (abs(mvQ0.y - mvP0.y) >= 4) ||
                     (abs(mvQ1.x - mvP1.x) >= 4) || (abs(mvQ1.y - mvP1.y) >= 4)) &&
                    ((abs(mvQ1.x - mvP0.x) >= 4) || (abs(mvQ1.y - mvP0.y) >= 4) ||
                     (abs(mvQ0.x - mvP1.x) >= 4) || (abs(mvQ0.y - mvP1.y) >= 4))) ? 1 : 0;
        }
    }
        
    // for all different Ref_Idx 其余全部1
    return 1;
}