pred.cpp

avs decoder sources, added a command line sample

			{
				mvB.x = mvB.y = 0; 
				BlockDistanceB = 1;
				RefIdxB = -1;
			}
			else
			{
				mvB = pMbInfo[dwMbIndex-dwMbWidth].mv[3];
				BlockDistanceB = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistance[3];
				RefIdxB = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndex[3];
			}

			if(!D_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth].dwMbType == I_8x8 ||
					(pMbInfo[dwMbIndex-dwMbWidth].predDir[2] != pMbInfo[dwMbIndex].predDir[1]&&
					 pMbInfo[dwMbIndex-dwMbWidth].predDir[2] != PREDDIRSYM))
			{
				mvD.x = mvD.y = 0;
				BlockDistanceD = 1;
				RefIdxD = -1;
			}
			else
			{
				mvD = pMbInfo[dwMbIndex-dwMbWidth].mv[2];
				BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistance[2];
				RefIdxD = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndex[2];
			}
			if(!C_BlockAvailable)
			{
				mvC = mvD;
				BlockDistanceC = BlockDistanceD;
				RefIdxC = RefIdxD;
			}
			else if(pMbInfo[dwMbIndex-dwMbWidth+1].dwMbType==I_8x8 ||
					(pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2]!=pMbInfo[dwMbIndex].predDir[1]&&
					 pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2]!= PREDDIRSYM))
			{
				mvC.x = mvC.y = 0;
				BlockDistanceC = 1;
				RefIdxC = -1;
			}
			else
			{
				mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mv[2];
				BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistance[2];
				RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndex[2];
			}
			break;
		case 2:
			B_BlockAvailable = TRUE;
			C_BlockAvailable = TRUE;
			if(MbX>0)
				D_BlockAvailable = TRUE;
			if(MbX>0)
				A_BlockAvailable = TRUE;

			if(!A_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 ||
					(pMbInfo[dwMbIndex-1].predDir[3] != pMbInfo[dwMbIndex].predDir[2] &&
					 pMbInfo[dwMbIndex-1].predDir[3] != PREDDIRSYM))
			{
				mvA.x = mvA.y = 0;
				BlockDistanceA = 1;
				RefIdxA = -1;
			}
			else
			{
				mvA = pMbInfo[dwMbIndex-1].mv[3];
				BlockDistanceA = pMbInfo[dwMbIndex-1].iBlockDistance[3];
				RefIdxA = pMbInfo[dwMbIndex-1].dwMbReferenceIndex[3];
			}

			if((pMbInfo[dwMbIndex].predDir[0] != pMbInfo[dwMbIndex].predDir[2] && 
						pMbInfo[dwMbIndex].predDir[0] != PREDDIRSYM))
			{
				mvB.x = mvB.y = 0;
				BlockDistanceB = 1;
				RefIdxB = -1;
			}
			else
			{
				mvB = pMbInfo[dwMbIndex].mv[0];
				BlockDistanceB = pMbInfo[dwMbIndex].iBlockDistance[0];
				RefIdxB = pMbInfo[dwMbIndex].dwMbReferenceIndex[0];
			}

			if(!D_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 ||
					(pMbInfo[dwMbIndex-1].predDir[1] != pMbInfo[dwMbIndex].predDir[2] &&
					 pMbInfo[dwMbIndex-1].predDir[1] != PREDDIRSYM))
			{
				mvD.x = mvD.y = 0;
				BlockDistanceD = 1;
				RefIdxD = -1;
			}
			else
			{
				mvD = pMbInfo[dwMbIndex-1].mv[1];
				BlockDistanceD = pMbInfo[dwMbIndex-1].iBlockDistance[1];
				RefIdxD = pMbInfo[dwMbIndex-1].dwMbReferenceIndex[1];
			}

			mvC = pMbInfo[dwMbIndex].mv[1];
			BlockDistanceC = pMbInfo[dwMbIndex].iBlockDistance[1];
			RefIdxC = pMbInfo[dwMbIndex].dwMbReferenceIndex[1];

			break;
		case 3:
			A_BlockAvailable = TRUE;
			B_BlockAvailable = TRUE;
			D_BlockAvailable = TRUE;

			if((pMbInfo[dwMbIndex].predDir[2] != pMbInfo[dwMbIndex].predDir[3] &&
						pMbInfo[dwMbIndex].predDir[2] != PREDDIRSYM))
			{
				mvA.x = mvA.y = 0;
				BlockDistanceA = 1;
				RefIdxA = -1;
			}
			else
			{
				mvA = pMbInfo[dwMbIndex].mv[2];
				BlockDistanceA = pMbInfo[dwMbIndex].iBlockDistance[2];
				RefIdxA = pMbInfo[dwMbIndex].dwMbReferenceIndex[2];
			}

			if(pMbInfo[dwMbIndex].predDir[0] != pMbInfo[dwMbIndex].predDir[3] &&
					pMbInfo[dwMbIndex].predDir[0]  != PREDDIRSYM)
			{
				mvD.x = mvD.y = 0;
				BlockDistanceD = 1;
				RefIdxD = -1;
			}
			else
			{
				mvD = pMbInfo[dwMbIndex].mv[0];
				BlockDistanceD = pMbInfo[dwMbIndex].iBlockDistance[0];
				RefIdxD = pMbInfo[dwMbIndex].dwMbReferenceIndex[0];
			}

			if(pMbInfo[dwMbIndex].predDir[1] != pMbInfo[dwMbIndex].predDir[3] &&
					pMbInfo[dwMbIndex].predDir[1] != PREDDIRSYM)
			{
				mvB.x = mvB.y = 0;
				BlockDistanceB = 1;
				RefIdxB = -1;
			}
			else
			{
				mvB = pMbInfo[dwMbIndex].mv[1];
				BlockDistanceB = pMbInfo[dwMbIndex].iBlockDistance[1];
				RefIdxB = pMbInfo[dwMbIndex].dwMbReferenceIndex[1];
			}

			mvC = mvD;
			BlockDistanceC = BlockDistanceD;
			RefIdxC = RefIdxD;

			break;
		default:
			break;
	}

	if(RefIdxA !=-1 && RefIdxB == -1 && RefIdxC == -1)
	{
		MVEPred = mvA;
	}
	else if(RefIdxA == -1 && RefIdxB != -1 && RefIdxC == -1)
	{
		MVEPred = mvB;
	}
	else if(RefIdxA ==-1 && RefIdxB == -1 && RefIdxC != -1)
	{
		MVEPred = mvC;
	}
	else
	{
		MVEPred = ScalePredMv(&mvA, &mvB, &mvC, iBlockDistance, BlockDistanceA, BlockDistanceB, BlockDistanceC);  
	}

	if(pBwRefInfo[dwMbIndex].dwMbType == I_8x8)
	{
		//mvE = MVEPred;
		mvFw = mvBw = MVEPred;
		idxBw = idxFw;
	}
	else
	{
		if(mvRef.x < 0)
		{
			mvFw.x = -(((16384/BlockDistanceRef)*(1-mvRef.x * iBlockDistance)-1)>>14);
			mvBw.x = (((16384/BlockDistanceRef)*(1-mvRef.x * iBlockDistanceBw)-1)>>14);
		}
		else
		{
			mvFw.x = (((16384/BlockDistanceRef)*(1+mvRef.x * iBlockDistance)-1)>>14);
			mvBw.x = -(((16384/BlockDistanceRef)*(1+mvRef.x * iBlockDistanceBw)-1)>>14);
		}
		if(mvRef.y < 0)
		{
			mvFw.y = -(((16384/BlockDistanceRef)*(1-mvRef.y * iBlockDistance)-1)>>14);
			mvBw.y = (((16384/BlockDistanceRef)*(1-mvRef.y * iBlockDistanceBw)-1)>>14);
		}
		else
		{
			mvFw.y = (((16384/BlockDistanceRef)*(1+mvRef.y * iBlockDistance)-1)>>14);
			mvBw.y = -(((16384/BlockDistanceRef)*(1+mvRef.y * iBlockDistanceBw)-1)>>14);
		}
	}

	pMbInfo[dwMbIndex].mv[dwSubMb] = mvFw;
	pMbInfo[dwMbIndex].mvBw[dwSubMb] = mvBw;
	pMbInfo[dwMbIndex].iBlockDistance[dwSubMb] = iBlockDistance; 
	pMbInfo[dwMbIndex].iBlockDistanceBw[dwSubMb] = iBlockDistanceBw; 

	AVS_INT iImgWidth = dwMbWidth*16;
	AVS_INT iImgHeight = dwMbHeight*16;
	AVS_INT iImgX = (dwMbIndex%dwMbWidth)*16 + (dwSubMb%2)*8;
	AVS_INT iImgY = (dwMbIndex/dwMbWidth)*16 + (dwSubMb/2)*8;

	AVS_BYTE PredBw[4][8][8];
	GetBlock(&(pMbInfo[dwMbIndex].mv[dwSubMb]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxFw]->y, pPred+dwSubMb*64);
	GetBlock(&(pMbInfo[dwMbIndex].mvBw[dwSubMb]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxBw]->y, &(PredBw[0][0][0])+dwSubMb*64);

	AVS_BYTE* pDst = pPred+dwSubMb*64;
	AVS_BYTE* pSrc = &(PredBw[0][0][0])+dwSubMb*64;
	AverageB8x(pDst, pSrc, 8, 8);

	return AVS_NOERROR;
}

static AVS_HRESULT InterPredLumaBSkipDirect2(MBINFO* pMbInfo,
		AVS_DWORD dwMbIndex, 
		const VIDEODATA** ppRefFrame, 
		AVS_DWORD dwRefNum, 
		AVS_DWORD dwMbWidth, 
		AVS_DWORD dwMbHeight, 
		AVS_DWORD dwCurrDistanceIndex, 
		AVS_DWORD dwSubMb, 
		AVS_INT   PictureStructure,
		const BWREFINFO* pBwRefInfo, 
		AVS_BYTE* pPred)
{
	AVS_INT idxFw = 1;
	AVS_INT idxBw = 0;

	MOTIONVECTOR mvFw, mvBw;
	MOTIONVECTOR mvRef;
	AVS_INT DistanceIndexRef;

	mvRef = pBwRefInfo[dwMbIndex].mvRef[dwSubMb];
	DistanceIndexRef = pBwRefInfo[dwMbIndex].iDistanceIndexRef[dwSubMb];
	AVS_INT DistanceIndexFw0 = ppRefFrame[2]->dwDistanceIndex; 
	AVS_INT DistanceIndexFw1 = ppRefFrame[3]->dwDistanceIndex;
	AVS_INT DistanceIndexBw0 = ppRefFrame[1]->dwDistanceIndex;
	AVS_INT DistanceIndexBw1 = ppRefFrame[0]->dwDistanceIndex;

	AVS_INT DistanceIndexFw, DistanceIndexBw;
	AVS_INT iBlockDistance;
	AVS_INT iBlockDistanceBw; 

	// step 1:
	if(DistanceIndexRef == DistanceIndexFw0)
	{
		idxFw = 2;
		DistanceIndexFw = DistanceIndexFw0;
	}
	else
	{
		idxFw = 3;
		DistanceIndexFw = DistanceIndexFw1;   
	}

	idxBw = 1;
	DistanceIndexBw = DistanceIndexBw0;

	pMbInfo[dwMbIndex].dwMbReferenceIndex[dwSubMb] = idxFw;
	pMbInfo[dwMbIndex].dwMbReferenceIndexBw[dwSubMb] = idxBw;

	// step 2:
	AVS_INT BlockDistanceRef = (DistanceIndexBw - DistanceIndexRef + 512) % 512;
	iBlockDistance = (dwCurrDistanceIndex - DistanceIndexFw + 512) % 512;
	iBlockDistanceBw = (DistanceIndexBw - dwCurrDistanceIndex + 512) % 512;

	if(PictureStructure == 1 && pBwRefInfo->PictureStructure == 0) 
		mvRef.y <<= 1;
	else if(PictureStructure == 0 && pBwRefInfo->PictureStructure == 1) 
		mvRef.y >>= 1;     

	// step 3:
	if(mvRef.x < 0)
	{
		mvFw.x = -(((16384/BlockDistanceRef)*(1-mvRef.x * iBlockDistance)-1)>>14);
		mvBw.x = (((16384/BlockDistanceRef)*(1-mvRef.x * iBlockDistanceBw)-1)>>14);
	}
	else
	{
		mvFw.x = (((16384/BlockDistanceRef)*(1+mvRef.x * iBlockDistance)-1)>>14);
		mvBw.x = -(((16384/BlockDistanceRef)*(1+mvRef.x * iBlockDistanceBw)-1)>>14);
	}
	if(mvRef.y < 0)
	{
		mvFw.y = -(((16384/BlockDistanceRef)*(1-mvRef.y * iBlockDistance)-1)>>14);
		mvBw.y = (((16384/BlockDistanceRef)*(1-mvRef.y * iBlockDistanceBw)-1)>>14);
	}
	else
	{
		mvFw.y = (((16384/BlockDistanceRef)*(1+mvRef.y * iBlockDistance)-1)>>14);
		mvBw.y = -(((16384/BlockDistanceRef)*(1+mvRef.y * iBlockDistanceBw)-1)>>14);
	}

	pMbInfo[dwMbIndex].mv[dwSubMb] = mvFw;
	pMbInfo[dwMbIndex].mvBw[dwSubMb] = mvBw;
	pMbInfo[dwMbIndex].iBlockDistance[dwSubMb] = iBlockDistance; 
	pMbInfo[dwMbIndex].iBlockDistanceBw[dwSubMb] = iBlockDistanceBw; 
	//  pMbInfo[dwMbIndex].dwMbReferenceIndex[dwSubMb] = idxFw;
	//  pMbInfo[dwMbIndex].dwMbReferenceIndexBw[dwSubMb] = idxBw;


	AVS_INT iImgWidth = dwMbWidth*16;
	AVS_INT iImgHeight = dwMbHeight*16;
	AVS_INT iImgX = (dwMbIndex%dwMbWidth)*16 + (dwSubMb%2)*8;
	AVS_INT iImgY = (dwMbIndex/dwMbWidth)*16 + (dwSubMb/2)*8;

	AVS_BYTE PredBw[4][8][8];
	GetBlock(&(pMbInfo[dwMbIndex].mv[dwSubMb]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxFw]->y, pPred+dwSubMb*64);
	GetBlock(&(pMbInfo[dwMbIndex].mvBw[dwSubMb]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxBw]->y, &(PredBw[0][0][0])+dwSubMb*64);

	AVS_BYTE* pDst = pPred+dwSubMb*64;
	AVS_BYTE* pSrc = &(PredBw[0][0][0])+dwSubMb*64;
	AverageB8x(pDst, pSrc, 8, 8);

	return AVS_NOERROR;
}


static AVS_HRESULT InterPredLumaSym16x16(MBINFO* pMbInfo, AVS_DWORD dwMbIndex, const VIDEODATA** ppRefFrame, AVS_DWORD dwRefNum, AVS_DWORD dwMbWidth, AVS_DWORD dwMbHeight, AVS_DWORD dwCurrDistanceIndex, AVS_BYTE* pPred)
{
	AVS_BOOL A_BlockAvailable = FALSE;
	AVS_BOOL B_BlockAvailable = FALSE;
	AVS_BOOL C_BlockAvailable = FALSE;
	AVS_BOOL D_BlockAvailable = FALSE;

	AVS_INT  BlockDistanceA=1;
	AVS_INT  BlockDistanceB=1;
	AVS_INT  BlockDistanceC=1;
	AVS_INT  BlockDistanceD=1;


	AVS_INT  RefIdxA = -1;
	AVS_INT  RefIdxB = -1;
	AVS_INT  RefIdxC = -1;
	AVS_INT  RefIdxD = -1;

	AVS_INT idxBw = 0;
	AVS_INT idxFw = 1;
	AVS_INT dirBw = 1;

	AVS_INT iBlockDistance = ((dwCurrDistanceIndex - ppRefFrame[idxFw]->dwDistanceIndex)+512)%512;
	AVS_INT iBlockDistanceBw = ((ppRefFrame[idxBw]->dwDistanceIndex - dwCurrDistanceIndex)+512)%512;


	MOTIONVECTOR mvA={0,0}, mvB={0,0}, mvC={0,0}, mvD={0,0}, mvFw={0,0}, mvBw={0,0}, mvE={0,0};
	MOTIONVECTOR MVEPred={0,0};

	AVS_INT MbX = dwMbIndex%dwMbWidth;
	AVS_INT MbY = dwMbIndex/dwMbWidth;

	if(MbX>0)
		A_BlockAvailable = TRUE;
	if(MbY>0)
		B_BlockAvailable = TRUE;
	if(MbX>0 && MbY>0)
		D_BlockAvailable = TRUE;
	if(MbY>0 && MbX<dwMbWidth-1)
		C_BlockAvailable = TRUE;

	if(!A_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 ||
			pMbInfo[dwMbIndex-1].predDir[1] == PREDDIRBWD)
	{
		mvA.x = mvA.y = 0;
		BlockDistanceA = 1;
		RefIdxA = -1;
	}
	else
	{
		mvA = pMbInfo[dwMbIndex-1].mv[1];
		BlockDistanceA = pMbInfo[dwMbIndex-1].iBlockDistance[1];
		RefIdxA = pMbInfo[dwMbIndex-1].dwMbReferenceIndex[1];
	}

	if(!B_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth].dwMbType == I_8x8 ||
			pMbInfo[dwMbIndex-dwMbWidth].predDir[2] == PREDDIRBWD)
	{
		mvB.x = mvB.y = 0;
		BlockDistanceB = 1;
		RefIdxB = -1;
	}
	else
	{
		mvB = pMbInfo[dwMbIndex-dwMbWidth].mv[2];
		BlockDistanceB = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistance[2];
		RefIdxB = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndex[2];
	}

	if(!D_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth-1].dwMbType == I_8x8 ||
			pMbInfo[dwMbIndex-dwMbWidth-1].predDir[3] == PREDDIRBWD)
	{
		mvD.x = mvD.y = 0;
		BlockDistanceD = 1;
		RefIdxD = -1;
	}
	else
	{
		mvD = pMbInfo[dwMbIndex-dwMbWidth-1].mv[3];
		BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth-1].iBlockDistance[3];
		RefIdxD = pMbInfo[dwMbIndex-dwMbWidth-1].dwMbReferenceIndex[3];
	}
	if(!C_BlockAvailable)
	{
		mvC = mvD;
		BlockDistanceC = BlockDistanceD;
		RefIdxC = RefIdxD;
	}
	else if(pMbInfo[dwMbIndex-dwMbWidth+1].dwMbType==I_8x8 ||
			pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2]== PREDDIRBWD)
	{
		mvC.x = mvC.y = 0;
		BlockDistanceC = 1;  
		RefIdxC = -1;
	}
	else
	{
		mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mv[2];
		BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistance[2];
		RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndex[2];
	}

	if(RefIdxA !=-1 && RefIdxB == -1 && RefIdxC == -1)
	{
		MVEPred = mvA;
	}
	else if(RefIdxA == -1 && RefIdxB != -1 && RefIdxC == -1)
	{
		MVEPred = mvB;
	}
	else if(RefIdxA ==-1 && RefIdxB == -1 && RefIdxC != -1)
	{
		MVEPred = mvC;
	}
	else
	{
		MVEPred = ScalePredMv(&mvA, &mvB, &mvC, iBlockDistance, BlockDistanceA, BlockDistanceB, BlockDistanceC);
	}

	mvE.x = MVEPred.x + pMbInfo[dwMbIndex].iMvDiffX[0];
	mvE.y = MVEPred.y + pMbInfo[dwMbIndex].iMvDiffY[0];

	mvBw.x = -((mvE.x * iBlockDistanceBw * (512/iBlockDistance)+256) >> 9);
	mvBw.y = -((mvE.y * iBlockDistanceBw * (512/iBlockDistance)+256) >> 9);

	AVS_BYTE pPredBw[4][8][8];

	for(AVS_INT block=0; block<4; block++)
	{
		pMbInfo[dwMbIndex].mv[block] = mvE;
		pMbInfo[dwMbIndex].iBlockDistance[block] = iBlockDistance;
		pMbInfo[dwMbIndex].mvBw[block] = mvBw;
		pMbInfo[dwMbIndex].iBlockDistanceBw[block] = iBlockDistanceBw;

		AVS_INT iImgWidth = dwMbWidth*16;
		AVS_INT iImgHeight = dwMbHeight*16;
		AVS_INT iImgX = (dwMbIndex%dwMbWidth)*16 + (block%2)*8;
		AVS_INT iImgY = (dwMbIndex/dwMbWidth)*16 + (block/2)*8;

		//插值，得到4个8x8预测块
		GetBlock(&(pMbInfo[dwMbIndex].mv[block]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxFw]->y, pPred+block*64);
		GetBlock(&(pMbInfo[dwMbIndex].mvBw[block]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxBw]->y, &(pPredBw[block][0][0]));
	} 

	// average
	AVS_BYTE* pDst = pPred;
	AVS_BYTE* pSrc = &(pPredBw[0][0][0]);
	AverageB8x(pDst, pSrc, 32, 8);

	return AVS_NOERROR;
}

static AVS_HRESULT InterPredLuma16x8(
		MBINFO* pMbInfo, AVS_INT dwMbIndex, 
		const AVS_BYTE* pbRefY, 
		AVS_INT dwMbWidth, AVS_INT dwMbHeight, 
		AVS_INT iBlockDistance, 
		AVS_INT dwSubMb, AVS_INT dirBw,