mb.cpp

完整的RTP RTSP代码库

                ppxlcBotFieldBY += iCFieldSkip;
        }
        piNonTransPixels[3] /= opaqueValue;
        piNonTransPixels[4] /= opaqueValue;
        for (ix=3; ix<=4; ix++) {
                if (piNonTransPixels [ix] == 0)
                        pmbmd-> m_rgFieldTranspStatus [ix] = ALL;
                else if (piNonTransPixels [ix] == BLOCK_SQUARE_SIZE/2)
                        pmbmd -> m_rgFieldTranspStatus [ix] = NONE;
                else    pmbmd -> m_rgFieldTranspStatus [ix] = PARTIAL;
        }
        
        delete piNonTransPixels;
}

Void CVideoObject::fieldBasedDownSampleBY (
        const PixelC* ppxlcMBBY,
        PixelC* ppxlcMBBUV
)
{
        UInt  ix, iy, x, iFieldSkip = 4*m_iFrameWidthY;
        const PixelC* ppxlcTopFieldBY = ppxlcMBBY;
        const PixelC* ppxlcBotFieldBY = ppxlcMBBY + m_iFrameWidthY;
        const PixelC* ppxlcTopFieldBYNext = ppxlcTopFieldBY + 2*m_iFrameWidthY;
        const PixelC* ppxlcBotFieldBYNext = ppxlcBotFieldBY + 2*m_iFrameWidthY;
 
        for (iy = 0; iy < BLOCK_SIZE/2; iy++) {
                for (ix = 0, x = 0; ix < BLOCK_SIZE; ix++, x = 2*ix)
                        ppxlcMBBUV [ix] = (ppxlcTopFieldBY [x] | ppxlcTopFieldBY [x+1] |
                                                ppxlcTopFieldBYNext [x] | ppxlcTopFieldBYNext [x+1]);
                ppxlcMBBUV += m_iFrameWidthUV;
                for (ix = 0, x = 0; ix < BLOCK_SIZE; ix++, x = 2*ix)
                        ppxlcMBBUV [ix] = (ppxlcBotFieldBY [x] | ppxlcBotFieldBY [x+1] |
                                                ppxlcBotFieldBYNext [x] | ppxlcBotFieldBYNext [x+1]);
                ppxlcMBBUV += m_iFrameWidthUV;
                ppxlcTopFieldBY += iFieldSkip;
                ppxlcBotFieldBY += iFieldSkip;
                ppxlcTopFieldBYNext += iFieldSkip;
                ppxlcBotFieldBYNext += iFieldSkip;
        }
}

// End of Hyundai(1998-5-9)

//Changed HHI 2000-04-11
Void CVideoObject::downSampleBY (const PixelC* ppxlcMBBY, PixelC* ppxlcMBBUV, CMBMode* pmbmd)
{
	const PixelC* ppxlcMBBYNextRow = ppxlcMBBY + MB_SIZE;
	UInt ix, iy;
	PixelC* ppxlcMBBUV_t = ppxlcMBBUV; // Changed HHI 2000-04-11
	// Added for Chroma Subsampling by Hyundai(1998-5-9)
        if (m_vopmd.bInterlace) {
                UInt  x, iFieldSkip = 4*MB_SIZE;
                const PixelC* ppxlcTopFieldBY = ppxlcMBBY;
                const PixelC* ppxlcBotFieldBY = ppxlcMBBY + MB_SIZE;
                const PixelC* ppxlcTopFieldBYNext = ppxlcTopFieldBY + 2*MB_SIZE;
                const PixelC* ppxlcBotFieldBYNext = ppxlcBotFieldBY + 2*MB_SIZE;
                for (iy = 0; iy < BLOCK_SIZE/2; iy++) {
                        for (ix = 0, x = 0; ix < BLOCK_SIZE; ix++, x = 2*ix)
                                ppxlcMBBUV [ix] = (ppxlcTopFieldBY [x] | ppxlcTopFieldBY [x+1] |
                                                        ppxlcTopFieldBYNext [x] | ppxlcTopFieldBYNext [x+1]);
                        ppxlcMBBUV += BLOCK_SIZE;
                        for (ix = 0, x = 0; ix < BLOCK_SIZE; ix++, x = 2*ix)
                                ppxlcMBBUV [ix] = (ppxlcBotFieldBY [x] | ppxlcBotFieldBY [x+1] |
                                                        ppxlcBotFieldBYNext [x] | ppxlcBotFieldBYNext [x+1]);
                        ppxlcMBBUV += BLOCK_SIZE;
                        ppxlcTopFieldBY += iFieldSkip;
                        ppxlcBotFieldBY += iFieldSkip;
                        ppxlcTopFieldBYNext += iFieldSkip;
                        ppxlcBotFieldBYNext += iFieldSkip;
                }
                // return;
        } else
		{
	// End of Hyundai(1998-5-9)
			for (iy = 0; iy < BLOCK_SIZE; iy++) {
				for (ix = 0; ix < BLOCK_SIZE; ix++) {
					ppxlcMBBUV [ix] = (
						(ppxlcMBBY [2 * ix] | ppxlcMBBY [2 * ix + 1]) |
						(ppxlcMBBYNextRow [2 * ix] | ppxlcMBBYNextRow [2 * ix + 1])
						);
				}
				ppxlcMBBUV += BLOCK_SIZE;
				ppxlcMBBY += 2 * MB_SIZE;
				ppxlcMBBYNextRow += 2 * MB_SIZE;
			}
		}
	// Begin Changed HHI 2000-04-11
	if (pmbmd!=NULL) {
		UInt uiNonTransPixelsUV = 0;
		for (iy = 0; iy < BLOCK_SIZE; iy++) {
			for (ix = 0; ix < BLOCK_SIZE; ix++) {
				uiNonTransPixelsUV += ppxlcMBBUV_t[ix];
			}
			ppxlcMBBUV_t+=BLOCK_SIZE;
		}
		uiNonTransPixelsUV /= opaqueValue;
		pmbmd->m_rgNumNonTranspPixels [5] = uiNonTransPixelsUV;
		if (pmbmd -> m_rgNumNonTranspPixels [5] == 0)
			pmbmd -> m_rgTranspStatus [U_BLOCK] = ALL;
		else if (pmbmd -> m_rgNumNonTranspPixels [5] == BLOCK_SQUARE_SIZE)
			pmbmd -> m_rgTranspStatus [U_BLOCK] = NONE;
		else
			pmbmd -> m_rgTranspStatus [U_BLOCK] = PARTIAL;
		pmbmd->m_rgTranspStatus [V_BLOCK] = pmbmd->m_rgTranspStatus [U_BLOCK];
	}
	// End Changed HHI 2000-04-11
}

Void CVideoObject::addErrorAndPredToCurrQ (
	PixelC* ppxlcQMBY, 
	PixelC* ppxlcQMBU, 
	PixelC* ppxlcQMBV
)
{
	CoordI ix, iy, ic = 0;
// RRV modification
	for (iy = 0; iy < (MB_SIZE *m_iRRVScale); iy++) {
		for (ix = 0; ix < (MB_SIZE *m_iRRVScale); ix++, ic++) {
// ~RRV
			ppxlcQMBY [ix] = m_rgiClipTab [m_ppxlcPredMBY [ic] + m_ppxliErrorMBY [ic]];

		}
		ppxlcQMBY += m_iFrameWidthY;
	}

	ic = 0;
// RRV modification
	for (iy = 0; iy < (BLOCK_SIZE *m_iRRVScale); iy++) {
		for (ix = 0; ix < (BLOCK_SIZE *m_iRRVScale); ix++, ic++) {
// ~RRV
			ppxlcQMBU [ix] = m_rgiClipTab [m_ppxlcPredMBU [ic] + m_ppxliErrorMBU [ic]];
			ppxlcQMBV [ix] = m_rgiClipTab [m_ppxlcPredMBV [ic] + m_ppxliErrorMBV [ic]];
		}
		ppxlcQMBU += m_iFrameWidthUV;
		ppxlcQMBV += m_iFrameWidthUV;
	}
}

Void CVideoObject::addAlphaErrorAndPredToCurrQ (PixelC* ppxlcQMBA, Int iAuxComp)
{
	CoordI ix, iy, ic = 0;
  
  for (iy = 0; iy < MB_SIZE; iy++) {
	 	for (ix = 0; ix < MB_SIZE; ix++, ic++)
      ppxlcQMBA[ix] = m_rgiClipTab [m_ppxlcPredMBA[iAuxComp][ic] + m_ppxliErrorMBA[iAuxComp] [ic]];
    ppxlcQMBA += m_iFrameWidthY;     
	}
}

Void CVideoObject::assignPredToCurrQ (
	PixelC* ppxlcQMBY, 
	PixelC* ppxlcQMBU, 
	PixelC* ppxlcQMBV
)
{
	CoordI ix;
	const PixelC* ppxlcPredMBY = m_ppxlcPredMBY;
	const PixelC* ppxlcPredMBU = m_ppxlcPredMBU;
	const PixelC* ppxlcPredMBV = m_ppxlcPredMBV;
// RRV modification
	for (ix = 0; ix < (BLOCK_SIZE *m_iRRVScale); ix++) {
		memcpy(ppxlcQMBY, ppxlcPredMBY,
			   (MB_SIZE *m_iRRVScale) *sizeof(PixelC));
		memcpy(ppxlcQMBU, ppxlcPredMBU,
			   (BLOCK_SIZE *m_iRRVScale) *sizeof(PixelC));
		memcpy(ppxlcQMBV, ppxlcPredMBV, 
			   (BLOCK_SIZE *m_iRRVScale) *sizeof(PixelC));
		ppxlcPredMBY += (MB_SIZE *m_iRRVScale);
		ppxlcPredMBU += (BLOCK_SIZE *m_iRRVScale);
		ppxlcPredMBV += (BLOCK_SIZE *m_iRRVScale);
// ~RRV
		ppxlcQMBY += m_iFrameWidthY;
		ppxlcQMBU += m_iFrameWidthUV;
		ppxlcQMBV += m_iFrameWidthUV;

// RRV modification
		memcpy(ppxlcQMBY, ppxlcPredMBY, 
			   (MB_SIZE *m_iRRVScale) *sizeof(PixelC));
		ppxlcPredMBY += (MB_SIZE *m_iRRVScale);
// ~RRV
		ppxlcQMBY += m_iFrameWidthY;
	}
}

Void CVideoObject::assignAlphaPredToCurrQ (PixelC* ppxlcQMBA, Int iAuxComp)
{
	CoordI ix;
	const PixelC* ppxlcPredMBA = m_ppxlcPredMBA[iAuxComp];
	for (ix = 0; ix < MB_SIZE; ix++) {
		memcpy (ppxlcQMBA, ppxlcPredMBA, MB_SIZE*sizeof(PixelC));
		ppxlcPredMBA += MB_SIZE;
		ppxlcQMBA += m_iFrameWidthY;
	}
}

Void CVideoObject::findColocatedMB (Int iMBX, Int iMBY,
									const CMBMode*& pmbmdRef,
									const CMotionVector*& pmvRef)
{
	Bool bColocatedMBExist = FALSE;

	if(m_bCodedFutureRef!=FALSE)
		if(iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0)
		{
			pmbmdRef = &m_rgmbmdRef [iMBX + iMBY * m_iNumMBXRef];
			if(pmbmdRef -> m_rgTranspStatus [0] != ALL)
			{
				Int iOffset = min (max (0, iMBX), m_iNumMBXRef - 1) + 
 					min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef;
				pmvRef = m_rgmvRef + iOffset * PVOP_MV_PER_REF_PER_MB;
				bColocatedMBExist = TRUE;
			}
		}

	if(bColocatedMBExist==FALSE)
	{
		pmbmdRef = NULL;
		pmvRef = NULL;
	}
}