mc_interlaced.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

          iChromaFwdY = vctFwd.y;
          iChromaBakX = vctBak.x;
          iChromaBakY = vctBak.y;
        }

        xRefUVF = sign (iChromaFwdX) * (grgiMvRound4  [abs (iChromaFwdX) % 4] + (abs (iChromaFwdX) / 4) * 2);
        yRefUVF = sign (iChromaFwdY) * (grgiMvRound4  [abs (iChromaFwdY) % 4] + (abs (iChromaFwdY) / 4) * 2);
        xRefUVB = sign (iChromaBakX) * (grgiMvRound4  [abs (iChromaBakX) % 4] + (abs (iChromaBakX) / 4) * 2);
        yRefUVB = sign (iChromaBakY) * (grgiMvRound4  [abs (iChromaBakY) % 4] + (abs (iChromaBakY) / 4) * 2);       
      }
    // end of new changes 10/21/98
        
	// UV Handling
    // FWD UV MVs
    iMVX = xRefUVF;
    iMVY = yRefUVF;
    g_pMV[g_UVMVId++] = (iMVX << 16) | (iMVY & 0x0000FFFF);

    // BWD UV MVs
    iMVX = xRefUVB;
    iMVY = yRefUVB;
    g_pMV[g_UVMVId++] = (iMVX << 16) | (iMVY & 0x0000FFFF);
  }
}

Void motionCompOneBVOPReference(MBType type, CMBMode* pmbmd, CMotionVector *pmv)
{ 
  CVOPU8YUVBA *pvopcRef;
  Int topRef, botRef;
  CoordI iMVX, iMVY;
  CoordI iUVMVX, iUVMVY;

// HV For Travis
  PixelC *m_RefY;
// ~HV For Travis

  if (type == BACKWARD) 
  {
    pvopcRef = g_pDecoder->m_pvopcRefQ1;

// HV For Travis
#ifdef ENABLE_INTERLACING
		if (nFlipToRef == FLIP_TO_REF)
		{
			m_RefY = m_OOFFlipQ1_Y;
			m_ActiveRef = BACKWARD_REFERENCES;
		}
		else
#endif
			m_RefY = (PixelC*) pvopcRef->pixelsY();
// ~HV For Travis

    topRef = (Int)pmbmd->m_bBackwardTop;
    botRef = (Int)pmbmd->m_bBackwardBottom;
  } 

  else 
  {
    pvopcRef = g_pDecoder->m_pvopcRefQ0;

#ifdef ENABLE_INTERLACING
		if (nFlipToRef == FLIP_TO_REF)
		{
			m_RefY = m_OOFFlipQ0_Y;
			m_ActiveRef = FORWARD_REFERENCES;
		}
		else
#endif
			m_RefY = (PixelC*) pvopcRef->pixelsY();

    topRef = (Int)pmbmd->m_bForwardTop;
    botRef = (Int)pmbmd->m_bForwardBottom;
  }

#ifdef ENABLE_INTERLACING
  if (pmbmd->m_bFieldMV) 
  {
    const CMotionVector *pmvTop = pmv + 1 + topRef;
    const CMotionVector *pmvBot = pmv + 3 + botRef;
    assert((topRef & ~1) == 0); assert((botRef & ~1) == 0);

    // Upper Y MVs
    iMVX = pmvTop->m_vctTrueHalfPel.x;
    iMVY = pmvTop->m_vctTrueHalfPel.y;

    // Upper UV MVs
    iUVMVX = (iMVX & 3) ? ((iMVX >> 1) | 1) : (iMVX >> 1);
    iUVMVY = (iMVY & 6) ? ((iMVY >> 1) | 2) : (iMVY >> 1);

    if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
    {
        if (type == FORWARD) 
        {
            // Y
            g_pMV[0] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

            // UV
            g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
        }

        else if (type == BACKWARD) 
        {
            // Y
            g_pMV[2] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

            // UV
            g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
        }
    }
    else  // MBM_FORWARD & MBM_BACKWARD cases
    {
        // Y
        g_pMV[0] = g_pMV[1] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

        // UV
        g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
    }

    // Upper Y MVs
    iMVX = pmvBot->m_vctTrueHalfPel.x;
    iMVY = pmvBot->m_vctTrueHalfPel.y;

    // Upper UV MVs
    iUVMVX = (iMVX & 3) ? ((iMVX >> 1) | 1) : (iMVX >> 1);
    iUVMVY = (iMVY & 6) ? ((iMVY >> 1) | 2) : (iMVY >> 1);

    if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
    {
        if (type == FORWARD) 
        {
            // Y
            g_pMV[1] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

            // UV
            g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
        }

        else if (type == BACKWARD) 
        {
            // Y
            g_pMV[3] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

            // UV
            g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
        }
    }
    else // MBM_FORWARD & MBM_BACKWARD cases
    {
        // Y
        g_pMV[2] = g_pMV[3] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

        // UV
        g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
    }
  } 
  else 
#endif
  { 
	// Non-Interlaced MB in an Interlaced frame (m_vopmd.bInterlace is TRUE) but not 16x8 
	// MBType (since pmbmd->m_bFieldMV is FALSE). So, this should be a 16x6 or 8x8 case
    // **********************************************************************************
    // Y MVs
    iMVX = TRUEMVHALFPEL_X(pmv);
    iMVY = TRUEMVHALFPEL_Y(pmv);

    // Upper UV MVs
    if (g_pVOL->bQuarterSample)
    {
        iUVMVX = (pmv->iMVX & 3) ? ((pmv->iMVX >> 1) | 1) :  (pmv->iMVX >> 1);
        iUVMVY = (pmv->iMVY & 3) ? ((pmv->iMVY >> 1) | 1) :  (pmv->iMVY >> 1);
    }
    else
    {
        iUVMVX = (pmv->m_vctTrueHalfPel.x & 3) ? ((pmv->m_vctTrueHalfPel.x >> 1) | 1) : (pmv->m_vctTrueHalfPel.x >> 1);
        iUVMVY = (pmv->m_vctTrueHalfPel.y & 3) ? ((pmv->m_vctTrueHalfPel.y >> 1) | 1) : (pmv->m_vctTrueHalfPel.y >> 1);
    }

    // Handle all 16x16 FWD, BWD & BI cases here
    if (g_pHeader3->mbtype == MBT_16x16)
    {
        if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
        {
            if (type == FORWARD) 
            {
                // Y
                g_pMV[0] = g_pMV[1] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

                // UV
                g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
            }
            else
            {
                // Y
                g_pMV[2] = g_pMV[2] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

                // UV
                g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
            }
        }
        else
        {
            // Y
            g_pMV[0] = g_pMV[1] = g_pMV[2] = g_pMV[3] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

            // UV
            g_pMV[g_UVMVId++] = (iUVMVX << 16) | (iUVMVY & 0x0000FFFF);
        }
    }
    else
    {
        printf("\nOOPS!! Handle me 8x8 MC--CVideoObject::motionCompOneBVOPReference!!");
        exit(0);
    }
  }
}

Void CVideoObject::motionCompYField (
	PixelC* ppxlcPred, // can be either Y or A
	const PixelC* ppxlcRefLeftTop, // point to left-top of the frame
	CoordI xRef, CoordI yRef, // current coordinate system
	CRct *prctMVLimit, // added by Y.Suzuki for the extended bounding box support
	int nMBType,
	int nBlockNum,
	const CMotionVector* pmv,
	int nSkip)
{
	CoordI ix, iy;

	LIMITMVRANGETOEXTENDEDBBHALFPEL(&xRef, &yRef, prctMVLimit, MB_SIZE); // added by Y.Suzuki for the extended bounding box support

	const PixelC* ppxlcRef = ppxlcRefLeftTop + 
		(((yRef >> 1) & ~1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRef >> 1) + EXPANDY_REF_FRAME;
	Int iRound = 1 - m_vopmd.iRoundingControl;
	Int iFieldStep = 2 * m_iFrameWidthY;

	const PixelC* ActualRefFrame = ppxlcRef;

	if (!(yRef & 2)) {
		if (!(xRef & 1)) { //!bXSubPxl && !bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				memcpy (ppxlcPred, ppxlcRef, MB_SIZE*sizeof(PixelC));
				ppxlcRef += iFieldStep;
				ppxlcPred += MB_SIZE*2;
			}
		}
		else { //bXSubPxl && !bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				for (ix = 0; ix < MB_SIZE; ix++)
					ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRef [ix + 1] + iRound) >> 1;
				ppxlcRef += iFieldStep;
				ppxlcPred += MB_SIZE*2;
			}
		}
	}
	else {
		const PixelC* ppxlcRefBot;

		// The reference block for the bottom fields 
		// The folllowing commented out by JPE.  Appears to hose up RefBlocksMVPn.ref.
		// ***************************************************************************
		// ActualRefFrame = ppxlcRef + iFieldStep;

		if (!(xRef & 1)) {  //!bXSubPxl&& bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				ppxlcRefBot = ppxlcRef + iFieldStep;		//UPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < MB_SIZE; ix++) 
					ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRefBot [ix] + iRound) >> 1;
				ppxlcRef = ppxlcRefBot;
				ppxlcPred += MB_SIZE*2;
			}
		}
		else { // bXSubPxl && bYSubPxl
			iRound++;
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				ppxlcRefBot = ppxlcRef + iFieldStep;		//UPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < MB_SIZE; ix++) {
					ppxlcPred [ix] = (ppxlcRef [ix + 1] + ppxlcRef [ix] +
						ppxlcRefBot [ix + 1] + ppxlcRefBot [ix] + iRound) >> 2;

				}
				ppxlcRef = ppxlcRefBot;
				ppxlcPred += MB_SIZE*2;
			}
		}
	}
}

Void CVideoObject::motionCompFieldUV (	PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
								 const CVOPU8YUVBA* pvopcRef,
								 CoordI x, CoordI y, 
								 CoordI xRefUV, CoordI yRefUV,Int iRefFieldSelect,
								 CRct* prctMVLimit, // added by Y.Suzuki for the extended bounding box support
								 int nUVMVConfigSelect, int nDumpRef)
{
	UInt ix, iy;
	CoordI	maeXRefUV, maeYRefUV;
// added by Y.Suzuki for the extended bounding box support
	maeXRefUV = xRefUV;
	maeYRefUV = yRefUV;
	CoordI iTmpX = x + xRefUV;
	CoordI iTmpY = y + yRefUV;
	LIMITMVRANGETOEXTENDEDBBFULLPEL(&iTmpX, &iTmpY, prctMVLimit, MB_SIZE);
	xRefUV = iTmpX - x;
	yRefUV = iTmpY - y;
// ~extended bounding box support

	// delete by Hyundai for Microsoft and MoMusys alignment
	//Int iPxLoc = ((((y + yRefUV) >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
	// insert by Hyundai for Microsoft and MoMusys alignment
	Int iPxLoc = (y/2 + ((yRefUV >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;

	const PixelC* ppxlcPrevU;
	const PixelC* ppxlcPrevV;

// HV For Travis
	if (nFlipToRef == FLIP_TO_REF)
	{
#ifdef COPY_FRAME_FROM_CMODEL
		ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
		ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
#else
		if (m_ActiveRef == FORWARD_REFERENCES)
		{
			ppxlcPrevU = m_OOFFlipQ0_U + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
			ppxlcPrevV = m_OOFFlipQ0_V + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
		}
		else if (m_ActiveRef == BACKWARD_REFERENCES)
		{
			ppxlcPrevU = m_OOFFlipQ1_U + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
			ppxlcPrevV = m_OOFFlipQ1_V + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
		}
#endif
	}
	else
	{
		ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
		ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
	}
// ~HV For Travis