loopfilter.cpp

avs decoder sources, added a command line sample

 *
 * Check if BsV10 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV10_Chroma(
		AVS_INT Bs, MBINFO * pMbInfo, 
		AVS_DWORD dwMbIndex, 
		AVS_DWORD dwMbWidth, 
		AVS_INT iImgType, 
		AVS_INT iAlphaOffset, AVS_INT iBetaOffset, 
		AVS_BYTE * pImgData, AVS_INT iStride)
{
	MBINFO* pMbP = &(pMbInfo[dwMbIndex - 1]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav = (pMbP->dwMbQp + pMbQ->dwMbQp + 1) / 2;
	AVS_INT IndexA = Clip3(0, 63, QPav + iAlphaOffset);
	AVS_INT IndexB = Clip3(0, 63, QPav + iBetaOffset);
	AVS_INT Alpha = ALPHA_TABLE[IndexA];
	AVS_INT Beta = BETA_TABLE[IndexB];

	AVS_INT imgX = (dwMbIndex % dwMbWidth) << 3;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 3;

	AVS_BYTE * p = pImgData + (imgY + 4) * iStride + imgX;

	AVS_INT C = CLIP_TABLE[IndexA];

	if (Bs == 2)
		DeblockVBs2_Chroma(p, Alpha, Beta, iStride);
	else if (Bs == 1)
		DeblockVBs1_Chroma(p, Alpha, Beta, C, iStride);
}

/**
 * Function: Filtering for chroma BsH00.
 *
 * Check if BsH00 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH00_Chroma(
		AVS_INT Bs, 
		MBINFO * pMbInfo, 
		AVS_DWORD dwMbIndex, 
		AVS_DWORD dwMbWidth, 
		AVS_INT iImgType, 
		AVS_INT iAlphaOffset, AVS_INT iBetaOffset, 
		AVS_BYTE * pImgData, AVS_INT iStride)
{
	MBINFO* pMbP = &(pMbInfo[dwMbIndex - dwMbWidth]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav = (pMbP->dwMbQp + pMbQ->dwMbQp + 1) / 2;
	AVS_INT IndexA = Clip3(0, 63, QPav + iAlphaOffset);
	AVS_INT IndexB = Clip3(0, 63, QPav + iBetaOffset);
	AVS_INT Alpha = ALPHA_TABLE[IndexA];
	AVS_INT Beta = BETA_TABLE[IndexB];

	AVS_INT imgX = (dwMbIndex % dwMbWidth) << 3;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 3;

	AVS_BYTE * p = pImgData + imgY * iStride + imgX;
	AVS_INT C = CLIP_TABLE[IndexA];
	if (Bs == 2)
		DeblockHBs2_Chroma(p, Alpha, Beta,iStride);
	else if (Bs == 1)
		DeblockHBs1_Chroma(p, Alpha, Beta, C, iStride);
}

/**
 * Function: Filtering for chroma BsH01.
 *
 * Check if BsH01 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH01_Chroma(
		AVS_INT Bs, 
		MBINFO * pMbInfo, 
		AVS_DWORD dwMbIndex, 
		AVS_DWORD dwMbWidth, 
		AVS_INT iImgType, 
		AVS_INT iAlphaOffset, AVS_INT iBetaOffset, 
		AVS_BYTE * pImgData, 
		AVS_INT iStride)
{

	MBINFO* pMbP = &(pMbInfo[dwMbIndex - dwMbWidth]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);


	AVS_INT QPav = (pMbInfo[dwMbIndex - dwMbWidth].dwMbQp + 
	                pMbInfo[dwMbIndex].dwMbQp + 1) / 2;
	AVS_INT IndexA = Clip3(0, 63, QPav + iAlphaOffset);
	AVS_INT IndexB = Clip3(0, 63, QPav + iBetaOffset);
	AVS_INT Alpha = ALPHA_TABLE[IndexA];
	AVS_INT Beta = BETA_TABLE[IndexB];

	AVS_INT imgX = (dwMbIndex % dwMbWidth) << 3;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 3;

	AVS_BYTE * p = pImgData + imgY * iStride + (imgX + 4);

	AVS_INT C = CLIP_TABLE[IndexA];
	if (Bs == 2)
		DeblockHBs2_Chroma(p, Alpha, Beta, iStride);
	else if (Bs == 1)
		DeblockHBs1_Chroma(p, Alpha, Beta, C, iStride);
}

static AVS_INT GetBsH00(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;

	if (pMbP->dwMbType == I_8x8 || pMbQ->dwMbType == I_8x8)
		Bs = 2;
	else  {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[2], 
			                  pMbQ->dwMbReferenceIndex[0], 
			                  &(pMbP->mv[2]), &(pMbQ->mv[0]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[2]), &(pMbQ->mv[0]), 
			                  &(pMbP->mvBw[2]), &(pMbQ->mvBw[0]));
	}
	return Bs;
}

static AVS_INT GetBsH01(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	int Bs = 0;
	if (pMbP->dwMbType == I_8x8 || pMbQ->dwMbType == I_8x8)
		Bs = 2;
	else  {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[3], 
			                  pMbQ->dwMbReferenceIndex[1], 
			                  &(pMbP->mv[3]), &(pMbQ->mv[1]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[3]), &(pMbQ->mv[1]), 
			                  &(pMbP->mvBw[3]), &(pMbQ->mvBw[1]));
	}
	return Bs;
}

static AVS_INT GetBsH10(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;
	if (pMbP->dwMbType == I_8x8)
		Bs = 2;
	else {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[0], 
			                  pMbQ->dwMbReferenceIndex[2], 
			                  &(pMbP->mv[0]), &(pMbQ->mv[2]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[0]), &(pMbQ->mv[2]), 
			                  &(pMbP->mvBw[0]), &(pMbQ->mvBw[2]));
	}
	return Bs;
}

static AVS_INT GetBsH11(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;
	if (pMbP->dwMbType == I_8x8)
		Bs = 2;
	else {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[1], 
			                  pMbQ->dwMbReferenceIndex[3], 
			                  &(pMbP->mv[1]), &(pMbQ->mv[3]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[1]), &(pMbQ->mv[3]), 
			                  &(pMbP->mvBw[1]), &(pMbQ->mvBw[3]));
	}
	return Bs;

}

static AVS_INT GetBsV00(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;

	if (pMbP->dwMbType == I_8x8 || pMbQ->dwMbType == I_8x8)
		Bs = 2;
	else {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[1], 
			                  pMbQ->dwMbReferenceIndex[0], 
			                  &(pMbP->mv[1]), &(pMbQ->mv[0]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[1]), &(pMbQ->mv[0]), 
			                  &(pMbP->mvBw[1]), &(pMbQ->mvBw[0]));
	}
	return Bs;
}

static AVS_INT GetBsV01(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;
	if (pMbP->dwMbType == I_8x8)
		Bs = 2;
	else  {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[0], 
			                  pMbQ->dwMbReferenceIndex[1], 
			                  &(pMbP->mv[0]), &(pMbQ->mv[1]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[0]), &(pMbP->mv[1]), 
			                  &(pMbQ->mvBw[0]), &(pMbQ->mvBw[1]));
	}
	return Bs;
}

static AVS_INT GetBsV10(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;

	if (pMbP->dwMbType == I_8x8 || pMbQ->dwMbType == I_8x8)
		Bs = 2;
	else {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[3], 
			                  pMbQ->dwMbReferenceIndex[2], 
			                  &(pMbP->mv[3]), &(pMbQ->mv[2]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[1]), &(pMbQ->mv[2]), 
			                  &(pMbP->mvBw[1]), &(pMbQ->mvBw[2]));
	}
	return Bs;
}

static AVS_INT GetBsV11(MBINFO* pMbP, MBINFO* pMbQ, AVS_INT iImgType)
{
	AVS_INT Bs;
	if (pMbP->dwMbType == I_8x8)
		Bs = 2;
	else {
		if (iImgType == P_IMG)
			Bs = GetStrengthP(pMbP->dwMbReferenceIndex[2], 
			                  pMbQ->dwMbReferenceIndex[3], 
			                  &(pMbP->mv[2]), &(pMbQ->mv[3]));
		else /* B frame */
			Bs = GetStrengthB(&(pMbP->mv[2]), &(pMbQ->mv[3]), 
			                  &(pMbP->mvBw[2]), &(pMbQ->mvBw[3]));
	}
	return Bs;
}

void DeblockOneMacroBlock(
		MBINFO * pMbInfo, 
		AVS_DWORD dwMbIndex, 
		AVS_DWORD dwMbWidth, 
		STREAMINFO * pStrmInfo, 
		VIDEODATA * pCurrVD)
{
	AVS_BOOL bUpMbAvailable = FALSE;
	AVS_BOOL bLeftMbAvailable = FALSE;
	AVS_INT iLumaStride = pStrmInfo->SeqInfo.dwWidth;
	AVS_INT iChromaStride = pStrmInfo->SeqInfo.dwWidth / 2;
	AVS_DWORD dwImgType = pStrmInfo->ImgInfo.dwImageType;
	AVS_INT iAlphaOffset = pStrmInfo->ImgInfo.iAlphaCOffset;
	AVS_INT iBetaOffset = pStrmInfo->ImgInfo.iBetaOffset;

	if (dwMbIndex/dwMbWidth != 0)
		bUpMbAvailable = TRUE;
	if (dwMbIndex%dwMbWidth != 0)
		bLeftMbAvailable = TRUE;

	if (bLeftMbAvailable) {
		AVS_INT Bs00 = GetBsV00(&(pMbInfo[dwMbIndex - 1]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs01 = GetBsV01(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs10 = GetBsV10(&(pMbInfo[dwMbIndex - 1]), 
		                        &(pMbInfo[dwMbIndex]), dwImgType);
		AVS_INT Bs11 = GetBsV11(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);

		DeblockMb_BsV00_Luma(Bs00, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsV01_Luma(Bs01, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsV10_Luma(Bs10, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsV11_Luma(Bs11, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);

		DeblockMb_BsV00_Chroma(Bs00, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->u, iChromaStride);
		DeblockMb_BsV10_Chroma(Bs01, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->u, iChromaStride);

		DeblockMb_BsV00_Chroma(Bs10, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->v, iChromaStride);
		DeblockMb_BsV10_Chroma(Bs11, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->v, iChromaStride);
	}
	else {
		AVS_INT Bs01 = GetBsV01(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs11 = GetBsV11(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);

		DeblockMb_BsV01_Luma(Bs01, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsV11_Luma(Bs11, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);    
	}
	if (bUpMbAvailable) {
		AVS_INT Bs00 = GetBsH00(&(pMbInfo[dwMbIndex - dwMbWidth]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs01 = GetBsH01(&(pMbInfo[dwMbIndex - dwMbWidth]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs10 = GetBsH10(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), dwImgType);
		AVS_INT Bs11 = GetBsH11(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		DeblockMb_BsH00_Luma(Bs00, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsH01_Luma(Bs01, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsH10_Luma(Bs10, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsH11_Luma(Bs11, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);

		DeblockMb_BsH00_Chroma(Bs00, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->u, iChromaStride);
		DeblockMb_BsH01_Chroma(Bs01, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->u, iChromaStride);

		DeblockMb_BsH00_Chroma(Bs00, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->v, iChromaStride);
		DeblockMb_BsH01_Chroma(Bs01, pMbInfo, dwMbIndex, 
		                       dwMbWidth, dwImgType, 
		                       iAlphaOffset, iBetaOffset, 
		                       pCurrVD->v, iChromaStride);

	}
	else {
		AVS_INT Bs10 = GetBsH10(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);
		AVS_INT Bs11 = GetBsH11(&(pMbInfo[dwMbIndex]), 
		                        &(pMbInfo[dwMbIndex]), 
		                        dwImgType);

		DeblockMb_BsH10_Luma(Bs10, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);
		DeblockMb_BsH11_Luma(Bs11, pMbInfo, dwMbIndex, 
		                     dwMbWidth, dwImgType, 
		                     iAlphaOffset, iBetaOffset, 
		                     pCurrVD->y, iLumaStride);    
	}
}