mcenc.cpp

完整的RTP RTSP代码库

    pmv8++;
    CoordI blkX = x + BLOCK_SIZE;
    CoordI blkY = y + BLOCK_SIZE;
    if (m_volmd.bQuarterSample) // Quarter sample
      motionCompQuarterSample (
                               pppxlcPredMBA[iAuxComp],
                               pvopcRefQ->pixelsA (iAuxComp),
                               BLOCK_SIZE,
                               x * 4 + pmv8->trueMVHalfPel ().x, 
                               y * 4 + pmv8->trueMVHalfPel ().y,
                               iRoundingControl,
                               prctMVLimit
                               );
    else
      motionComp (
                  pppxlcPredMBA[iAuxComp],
                  pvopcRefQ->pixelsA (iAuxComp),
                  BLOCK_SIZE,
                  x * 2 + pmv8->trueMVHalfPel ().x, 
                  y * 2 + pmv8->trueMVHalfPel ().y,
                  iRoundingControl,
                  prctMVLimit
                  );
    pmv8++;
 
    if (m_volmd.bQuarterSample) // Quarter sample
      motionCompQuarterSample (
                               pppxlcPredMBA[iAuxComp] + OFFSET_BLK1,
                               pvopcRefQ->pixelsA (iAuxComp), 				 
                               BLOCK_SIZE,
                               blkX * 4 + pmv8->trueMVHalfPel ().x, 
                               y * 4 + pmv8->trueMVHalfPel ().y,
                               iRoundingControl,
                               prctMVLimit
                               );
    else
      motionComp (
                  pppxlcPredMBA[iAuxComp] + OFFSET_BLK1,
                  pvopcRefQ->pixelsA (iAuxComp), 				 
                  BLOCK_SIZE,
                  blkX * 2 + pmv8->trueMVHalfPel ().x, 
                  y * 2 + pmv8->trueMVHalfPel ().y,
                  iRoundingControl,
                  prctMVLimit
                  );
    pmv8++;
    if (m_volmd.bQuarterSample) // Quarter sample
      motionCompQuarterSample (
                               pppxlcPredMBA[iAuxComp] + OFFSET_BLK2, 
                               pvopcRefQ->pixelsA (iAuxComp), 
                               BLOCK_SIZE,
                               x * 4 + pmv8->trueMVHalfPel ().x, 
                               blkY * 4 + pmv8->trueMVHalfPel ().y,
                               iRoundingControl,
                               prctMVLimit
                               );
    else
      motionComp (
                  pppxlcPredMBA[iAuxComp] + OFFSET_BLK2, 
                  pvopcRefQ->pixelsA (iAuxComp), 
                  BLOCK_SIZE,
                  x * 2 + pmv8->trueMVHalfPel ().x, 
                  blkY * 2 + pmv8->trueMVHalfPel ().y,
                  iRoundingControl,
                  prctMVLimit
                  );
    pmv8++;
    if (m_volmd.bQuarterSample) // Quarter sample
      motionCompQuarterSample (
                               pppxlcPredMBA[iAuxComp] + OFFSET_BLK3,
                               pvopcRefQ->pixelsA (iAuxComp),
                               BLOCK_SIZE,
                               blkX * 4 + pmv8->trueMVHalfPel ().x, 
                               blkY * 4 + pmv8->trueMVHalfPel ().y,
                               iRoundingControl,
                               prctMVLimit
                               );
    else
      motionComp (
                  pppxlcPredMBA[iAuxComp] + OFFSET_BLK3,
                  pvopcRefQ->pixelsA (iAuxComp),
                  BLOCK_SIZE,
                  blkX * 2 + pmv8->trueMVHalfPel ().x, 
                  blkY * 2 + pmv8->trueMVHalfPel ().y,
                  iRoundingControl,
                  prctMVLimit
                  );

}
// ~added for BVOP direct mode , mwi

Void CVideoObjectEncoder::motionCompEncY (
	const PixelC* ppxlcRef, const PixelC* ppxlcRefZoom,
	PixelC* ppxlcPred,
	Int iSize, // either MB or BLOCK size
	const CMotionVector* pmv, // motion vector
	CoordI x, CoordI y, // current coordinate system
	CRct *prctMVLimit
)
{
	Int iUnit = sizeof(PixelC); // NBIT: for memcpy
	CoordI ix, iy;
 	Bool bXSubPxl, bYSubPxl;
    CoordI xHalf = 2*x + pmv->m_vctTrueHalfPel.x;
    CoordI yHalf = 2*y + pmv->m_vctTrueHalfPel.y;
//	CoordI xHalf = 2*(x + pmv->iMVX) + pmv->iHalfX;
//	CoordI yHalf = 2*(y + pmv->iMVY) + pmv->iHalfY;
	limitMVRangeToExtendedBBHalfPel(xHalf,yHalf,prctMVLimit,iSize);

	bXSubPxl = (xHalf&1);
	bYSubPxl = (yHalf&1);
	if (!bYSubPxl && !bXSubPxl) {
		const PixelC* ppxlcRefMB = ppxlcRef + m_rctRefFrameY.offset (xHalf>>1, yHalf>>1);
		for (iy = 0; iy < iSize; iy++) {
			memcpy (ppxlcPred, ppxlcRefMB, iSize*iUnit);
			ppxlcRefMB += m_iFrameWidthY;
			ppxlcPred += MB_SIZE;
		}
	}
	else {
		const PixelC* ppxlcPrevZoomY = ppxlcRefZoom
			+ m_puciRefQZoom0->where ().offset (xHalf, yHalf);
		for (iy = 0; iy < iSize; iy++) {
			for (ix = 0; ix < iSize; ix++)
				ppxlcPred [ix] = ppxlcPrevZoomY [2 * ix]; 
			ppxlcPrevZoomY += m_iFrameWidthZoomY * 2;
			ppxlcPred += MB_SIZE;
		}
	}
}

Void CVideoObjectEncoder::motionCompOverLapEncY (
	const CMotionVector* pmv, // motion vector
	const CMBMode* pmbmd, // macroblk mode	
	Bool bLeftBndry, Bool bRightBndry, Bool bTopBndry,
	CoordI x, // current coordinate system
	CoordI y, // current coordinate system
	CRct *prctMVLimit
)
{
	// Overlap Motion Comp use motion vector of current blk and motion vectors of neighboring blks.
	const CMotionVector *pmvC, *pmvT = NULL, *pmvB=NULL, *pmvR=NULL, *pmvL=NULL; // MVs of Cur, Top, Bot, Right and Left Blocks. 
	const CMotionVector *pmvCurrMb, *pmvTopMb = NULL, *pmvRightMb = NULL, *pmvLeftMb = NULL; // MVs of Cur, Top, Right and Left MacroBlocks.
	const CMBMode *pmbmdTopMb = NULL, *pmbmdRightMb = NULL, *pmbmdLeftMb = NULL; // MVs of Cur, Top, Right and Left MacroBlocks.
	Bool bIntraT = false, bIntraR = false, bIntraL = false; // flags of 4MV for Cur, Top, Right and Left MacroBlocks.
	pmvCurrMb = pmv;
	// assign values to bIntra[TRL] and pmv{TRL}Mb, when they are valid. 
	if (!bTopBndry) {
		pmbmdTopMb = pmbmd - m_iNumMBX; 
		bIntraT = (pmbmdTopMb->m_dctMd == INTRA || pmbmdTopMb->m_dctMd == INTRAQ || pmbmdTopMb->m_bMCSEL==TRUE); // GMC
		pmvTopMb = pmv - m_iNumOfTotalMVPerRow;
	}
	if (!bLeftBndry) {
		pmbmdLeftMb = pmbmd - 1;
		bIntraL = (pmbmdLeftMb->m_dctMd == INTRA || pmbmdLeftMb->m_dctMd == INTRAQ || pmbmdLeftMb->m_bMCSEL == TRUE); // GMC
		pmvLeftMb = pmv - PVOP_MV_PER_REF_PER_MB;
	}
	if (!bRightBndry) {
		pmbmdRightMb = pmbmd + 1;
		bIntraR = (pmbmdRightMb->m_dctMd == INTRA || pmbmdRightMb->m_dctMd == INTRAQ || pmbmdRightMb->m_bMCSEL == TRUE); // GMC
		pmvRightMb = pmv + PVOP_MV_PER_REF_PER_MB;
	}
	UInt i;
	// assign the neighboring blk's MVs to pmv[TBRLC] 
	for (i = 1; i < 5; i++) {
		if (pmbmd->m_rgTranspStatus [i] == ALL)
			continue;
		pmvC = pmvCurrMb + i;
		switch (i) {
			case 1:
				if (pmbmd->m_rgTranspStatus [3] == ALL)
					pmvB = pmvCurrMb + 1;
				else
					pmvB = pmvCurrMb + 3;
				
				if (pmbmd->m_rgTranspStatus [2] == ALL)
					pmvR = pmvCurrMb + 1; 	
				else
					pmvR = pmvCurrMb + 2; 	

				if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [3] == ALL)
					pmvT = pmvCurrMb + 1;
				else
					pmvT = pmvTopMb + 3;

				if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [2] == ALL)
					pmvL = pmvCurrMb + 1;
				else
					pmvL = pmvLeftMb + 2;
				break;
			case 2:
				if (pmbmd->m_rgTranspStatus [4] == ALL)
					pmvB = pmvCurrMb + 2;
				else
					pmvB = pmvCurrMb + 4;

				if (pmbmd->m_rgTranspStatus [1] == ALL)
					pmvL = pmvCurrMb + 2;
				else
					pmvL = pmvCurrMb + 1;

				if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [4] == ALL)
					pmvT = pmvCurrMb + 2;
				else
					pmvT = pmvTopMb + 4;      	

				if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [1] == ALL)
					pmvR = pmvCurrMb + 2;
				else
					pmvR = pmvRightMb + 1;
				break;
			case 3:
				if (pmbmd->m_rgTranspStatus [1] == ALL)
					pmvT = pmvCurrMb + 3;  
				else
					pmvT = pmvCurrMb + 1;
				
				pmvB = pmvCurrMb + 3; // use the current mv

				if (pmbmd->m_rgTranspStatus [4] == ALL)
					pmvR = pmvCurrMb + 3;
				else
					pmvR = pmvCurrMb + 4;

				if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [4] == ALL)
					pmvL = pmvCurrMb + 3;
				else
					pmvL = pmvLeftMb + 4;
				break;
			case 4:
				if (pmbmd->m_rgTranspStatus [2] == ALL)
					pmvT = pmvCurrMb + 4;    	
				else
					pmvT = pmvCurrMb + 2;
				
				pmvB = pmvCurrMb + 4;

				if (pmbmd->m_rgTranspStatus [3] == ALL)
					pmvL = pmvCurrMb + 4;  	
				else
					pmvL = pmvCurrMb + 3;
				
				if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [3] == ALL)
					pmvR = pmvCurrMb + 4;
				else
					pmvR = pmvRightMb + 3;
				break;
			default:
				assert (FALSE);
			}
		// Compute the top left corner's x,y coordinates of current block.
		UInt dxc = (((i - 1) & 1) << 3); 
		UInt dyc = (((i - 1) & 2) << 2);
		UInt nxcY = (x + dxc) << 1; 
		UInt nycY = (y + dyc) << 1; 
		// Compute the corresponding positions on Ref frm, using 5 MVs.
		CoordI xRefC = nxcY + pmvC->m_vctTrueHalfPel.x, yRefC = nycY + pmvC->m_vctTrueHalfPel.y;
		CoordI xRefT = nxcY + pmvT->m_vctTrueHalfPel.x, yRefT = nycY + pmvT->m_vctTrueHalfPel.y;
		CoordI xRefB = nxcY + pmvB->m_vctTrueHalfPel.x, yRefB = nycY + pmvB->m_vctTrueHalfPel.y;
		CoordI xRefR = nxcY + pmvR->m_vctTrueHalfPel.x, yRefR = nycY + pmvR->m_vctTrueHalfPel.y;
		CoordI xRefL = nxcY + pmvL->m_vctTrueHalfPel.x, yRefL = nycY + pmvL->m_vctTrueHalfPel.y;
//		UInt nxcY = x + dxc; 
//  	UInt nycY = y + dyc; 
//		// Compute the corresponding positions on Ref frm, using 5 MVs.
//		CoordI xRefC = ((nxcY + pmvC->iMVX) << 1) + pmvC->iHalfX, yRefC = ((nycY + pmvC->iMVY) << 1) + pmvC->iHalfY;
//		CoordI xRefT = ((nxcY + pmvT->iMVX) << 1) + pmvT->iHalfX, yRefT = ((nycY + pmvT->iMVY) << 1) + pmvT->iHalfY;
//		CoordI xRefB = ((nxcY + pmvB->iMVX) << 1) + pmvB->iHalfX, yRefB = ((nycY + pmvB->iMVY) << 1) + pmvB->iHalfY;
//		CoordI xRefR = ((nxcY + pmvR->iMVX) << 1) + pmvR->iHalfX, yRefR = ((nycY + pmvR->iMVY) << 1) + pmvR->iHalfY;
//		CoordI xRefL = ((nxcY + pmvL->iMVX) << 1) + pmvL->iHalfX, yRefL = ((nycY + pmvL->iMVY) << 1) + pmvL->iHalfY;

		limitMVRangeToExtendedBBHalfPel (xRefC,yRefC,prctMVLimit,BLOCK_SIZE);
		limitMVRangeToExtendedBBHalfPel (xRefT,yRefT,prctMVLimit,BLOCK_SIZE);
		limitMVRangeToExtendedBBHalfPel (xRefB,yRefB,prctMVLimit,BLOCK_SIZE);
		limitMVRangeToExtendedBBHalfPel (xRefR,yRefR,prctMVLimit,BLOCK_SIZE);
		limitMVRangeToExtendedBBHalfPel (xRefL,yRefL,prctMVLimit,BLOCK_SIZE);

		//PixelC* ppxlcPredY = ppxlcYMB + dxc + dyc * m_iWidthY;  // Starting of Pred. Frame
		PixelC* ppxlcPred = m_ppxlcPredMBY + dxc + dyc * MB_SIZE;  // Starting of Pred. Frame
		// 5 starting pos. in Zoomed Ref. Frames
		// m_ppxlcRefZoom0Y +  (xRefC, yRefC);
		const PixelC* ppxlcPrevZoomYC;
		const PixelC* ppxlcPrevZoomYT;
		const PixelC* ppxlcPrevZoomYB;
		const PixelC* ppxlcPrevZoomYR;
		const PixelC* ppxlcPrevZoomYL;
		ppxlcPrevZoomYC = m_puciRefQZoom0->pixels () + 
			(yRefC + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
			xRefC + EXPANDY_REF_FRAMEx2;
		ppxlcPrevZoomYT = m_puciRefQZoom0->pixels () + 
			(yRefT + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
			xRefT + EXPANDY_REF_FRAMEx2;
		ppxlcPrevZoomYB = m_puciRefQZoom0->pixels () + 
			(yRefB + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
			xRefB + EXPANDY_REF_FRAMEx2;
		ppxlcPrevZoomYR = m_puciRefQZoom0->pixels () + 
			(yRefR + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
			xRefR + EXPANDY_REF_FRAMEx2;
		ppxlcPrevZoomYL = m_puciRefQZoom0->pixels () + 
			(yRefL + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
			xRefL + EXPANDY_REF_FRAMEx2;
		UInt *pWghtC, *pWghtT, *pWghtB, *pWghtR, *pWghtL;
		pWghtC = (UInt*) gWghtC;
		pWghtT = (UInt*) gWghtT;
		pWghtB = (UInt*) gWghtB;
		pWghtR = (UInt*) gWghtR;
		pWghtL = (UInt*) gWghtL;
		for (UInt iy = 0; iy < BLOCK_SIZE; iy++) {
			for (UInt ix = 0; ix < BLOCK_SIZE; ix++) {
				*ppxlcPred++ = (
					*ppxlcPrevZoomYC * *pWghtC++ + 
					*ppxlcPrevZoomYT * *pWghtT++ + 
					*ppxlcPrevZoomYB * *pWghtB++ + 
					*ppxlcPrevZoomYR * *pWghtR++ + 
					*ppxlcPrevZoomYL * *pWghtL++ + 4
				) >> 3;
				ppxlcPrevZoomYC += 2;
				ppxlcPrevZoomYT += 2;
				ppxlcPrevZoomYB += 2;
				ppxlcPrevZoomYR += 2;
				ppxlcPrevZoomYL += 2;
			}
			ppxlcPrevZoomYC += m_iFrameWidthZoomYx2Minus2Blk;
			ppxlcPrevZoomYT += m_iFrameWidthZoomYx2Minus2Blk;
			ppxlcPrevZoomYB += m_iFrameWidthZoomYx2Minus2Blk;
			ppxlcPrevZoomYR += m_iFrameWidthZoomYx2Minus2Blk;
			ppxlcPrevZoomYL += m_iFrameWidthZoomYx2Minus2Blk;
			ppxlcPred += BLOCK_SIZE;
		}
	}
}

// for B-VOP

Void CVideoObjectEncoder::averagePredAndComputeErrorY()
{
	Int ic;
	for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
		m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
		m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
	}
}

//INTERLACE
//new changes
Void CVideoObjectEncoder::averagePredAndComputeErrorY_WithShape()
{
	Int ic;
	for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
		if (m_ppxlcCurrMBBY [ic] == transpValue)
			m_ppxliErrorMBY [ic] = 0;
		else {
		m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
		m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
		}
	}
}
// new changes
//INTERLACE

Void CVideoObjectEncoder::motionCompAndDiff_BVOP_MB (
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
	CMBMode* pmbmd, 
	CoordI x, CoordI y,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
    if (m_vopmd.bInterlace) {           // Should work for both progressive and interlaced, but keep
                                        // original code for now due to differences in direct mode.   Bob Eifrig
	    switch (pmbmd->m_mbType) {

	    case FORWARD:
		    motionCompOneBVOPReference(m_pvopcPredMB, FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
		    computeTextureError();
		    break;

	    case BACKWARD:
		    motionCompOneBVOPReference(m_pvopcPredMB, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
		    computeTextureError();
		    break;

	    case DIRECT:
		    motionCompDirectMode(x, y, pmbmd,
                &m_rgmvRef[(PVOP_MV_PER_REF_PER_MB*(x + m_iNumMBX * y)) / MB_SIZE],
                prctMVLimitForward, prctMVLimitBackward, 0);
		    averagePredAndComputeErrorY();
		    averagePredAndComputeErrorUV();
		    break;

	    case INTERPOLATE:
		    motionCompOneBVOPReference(m_pvopcPredMB,     FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
		    motionCompOneBVOPReference(m_pvopcPredMBBack, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
		    averagePredAndComputeErrorY();
		    averagePredAndComputeErrorUV();
		    break;
	    }