loopfilter.cpp

avs decoder sources, added a command line sample

		AVS_INT Alpha, AVS_INT Beta, 
		AVS_INT iStride)
{
	AVS_INT i;
	AVS_BYTE * p = pStart;
	for (i = 0; i < 4; i++) {
		AVS_BYTE p2 = *(p - 3 * iStride);
		AVS_BYTE p1 = *(p - 2 * iStride);
		AVS_BYTE p0 = *(p - iStride);

		AVS_BYTE q0 = *p;
		AVS_BYTE q1 = *(p + iStride);
		AVS_BYTE q2 = *(p + 2 * iStride);
		if (abs(p0 - q0) < Alpha && 
		    abs(p1 - p0) < Beta && 
		    abs(q1 - q0) < Beta) {
			AVS_INT ap = abs(p2 - p0);
			AVS_INT aq = abs(q2 - q0);

			if (ap < Beta && abs(p0 - q0) < ((Alpha >> 2) + 2))
				*(p - iStride) = (p1 + 2 * p0 + q0 + 2) >> 2;
			else
				*(p - iStride) = (2 * p1 + p0 + q0 + 2) >> 2;

			if (aq < Beta && abs(p0 - q0) < ((Alpha >> 2) + 2))
				*(p  ) = (q1 + 2*q0 + p0 + 2) >> 2;
			else
				*(p  ) = (2*q1 + q0 + p0 + 2) >> 2;
		}      
		p ++;
	}
}

static void DeblockHBs1_Chroma(
		AVS_BYTE * pStart, 
		AVS_INT Alpha, AVS_INT Beta, 
		AVS_INT C, AVS_INT iStride)
{
	AVS_INT i;
	AVS_BYTE * p = pStart;
	for (i = 0; i < 4; i++) {
		AVS_BYTE p1 = *(p - 2 * iStride);
		AVS_BYTE p0 = *(p - iStride);

		AVS_BYTE q0 = *p;
		AVS_BYTE q1 = *(p + iStride);
		if (abs(p0 - q0) < Alpha && abs(p1 - p0) < Beta && 
		    abs(q1 - q0) < Beta) {   
			AVS_INT delta = Clip3(-C, C, 
			                      (((q0 - p0) * 3 + 
			                        (p1-q1) + 4) >> 3));

			*(p - iStride) = Clip(p0 + delta);
			*(p  ) = Clip(q0 + delta);
		}
		p++;
	}
}

AVS_INT GetStrengthP(
		AVS_DWORD dwRefIdxP, AVS_DWORD dwRefIdxQ, 
		MOTIONVECTOR * pMvP, MOTIONVECTOR * pMvQ)
{
	if (dwRefIdxP != dwRefIdxQ ||
	    abs(pMvP->x - pMvQ->x) >= 4 ||
	    abs(pMvP->y - pMvQ->y) >= 4)
		return 1;
	return 0;
}

AVS_INT GetStrengthB(
		MOTIONVECTOR * pMvP, MOTIONVECTOR * pMvQ, 
		MOTIONVECTOR * pMvBwP, MOTIONVECTOR * pMvBwQ)
{
	if (abs(pMvP->x - pMvQ->x) >= 4 ||
	    abs(pMvP->y - pMvQ->y) >= 4 ||
	    abs(pMvBwP->x - pMvBwQ->x) >= 4 ||
	    abs(pMvBwP->y - pMvBwQ->y) >= 4)
		return 1;
	return 0;
}

/**
 * Function: Filtering for luma BsV00.
 *
 * Check if BsV00 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV00_Luma(
		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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

	AVS_BYTE* p = pImgData + imgY * iStride + imgX;
	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsV10.
 *
 * Check if BsV10 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV10_Luma(
		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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

	AVS_BYTE* p = pImgData + (imgY + 8) * iStride + imgX;
	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsV01.
 *
 * Check if BsV01 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV01_Luma(
		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]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav =  pMbP->dwMbQp;
	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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

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

	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsV11.
 *
 * Check if BsV11 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV11_Luma(
		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]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav = pMbP->dwMbQp;
	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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

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

	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsH00.
 *
 * Check if BsH00 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH00_Luma(
		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) << 4;
	AVS_INT imgY = (dwMbIndex/dwMbWidth) << 4;

	AVS_BYTE * p = pImgData + imgY * iStride + imgX;
	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsH01.
 *
 * Check if BsH01 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH01_Luma(
		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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

	AVS_BYTE* p = pImgData + imgY * iStride + (imgX + 8);
	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsH10.
 *
 * Check if BsH10 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH10_Luma(
		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]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav = pMbP->dwMbQp;
	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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

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

	AVS_INT C = CLIP_TABLE[IndexA];

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

/**
 * Function: Filtering for luma BsH11.
 *
 * Check if BsH11 side is inside the boundary before invoking.
 */
static void DeblockMb_BsH11_Luma(
		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]);
	MBINFO* pMbQ = &(pMbInfo[dwMbIndex]);

	AVS_INT QPav = pMbP->dwMbQp;
	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) << 4;
	AVS_INT imgY = (dwMbIndex / dwMbWidth) << 4;

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

	AVS_INT C = CLIP_TABLE[IndexA];

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


/**
 * Function: Filtering for chroma BsV00.
 *
 * Check if BsV00 side is inside the boundary before invoking.
 */
static void DeblockMb_BsV00_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 * 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 BsV10.