mcdec.c

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

        iTmpX = x + xRefUVBackward;
        iTmpY = y + yRefUVBackward;

        LIMITMVRANGETOEXTENDEDBBFULLPEL (&iTmpX,&iTmpY,prctMVLimitBackward, MB_SIZE);
        xRefUV = iTmpX - x;
        yRefUV = iTmpY - y;

        // U & V Motion Vectors are already in Half-Pel
        // units. So, lets just pass it down
        // ********************************************
        g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV & 0x0000FFFF);
#else
        // U & V Motion Vectors are already in Half-Pel
        // units. So, lets just pass it down
        // ********************************************
        g_pMV[g_UVMVId++] = (xRefUVBackward << 16) | (yRefUVBackward & 0x0000FFFF);
#endif
	} 

	else
    { 
		CMotionVector* pmv;
		CRct *prctMVLimit;

		if (pmbmd->m_mbType == FORWARD) // Y is done when doing motion estimation
        {
			pmv = pmvForward;
			prctMVLimit = prctMVLimitForward;

            g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
		}

		else
        {
			pmv = pmvBackward;
			prctMVLimit = prctMVLimitBackward;

            g_pHeader2->mbmode = MBMODE_BWD_ALL_420;
		}

        g_pHeader3->mbtype = MBT_16x16;
            
        // forward or backward MVs
        // Get the half-pel values
        MVX = TRUEMVHALFPEL_X(pmv);
        MVY = TRUEMVHALFPEL_Y(pmv);

        // Use hpel
        g_pMV[0] = g_pMV[1] = g_pMV[2] = g_pMV[3] = ((MVX << 16) | (MVY & 0x0000FFFF));

		CoordI xRefUV, yRefUV;
		mvLookupUVWithShape (pmbmd, pmv, &xRefUV, &yRefUV);

#ifdef EXTRA_MV_CLIPPING
        CoordI tmp_xRefUV, tmp_yRefUV, iTmpX, iTmpY;

        iTmpX = x + xRefUV;
        iTmpY = y + yRefUV;			

        LIMITMVRANGETOEXTENDEDBBFULLPEL (&iTmpX,&iTmpY,prctMVLimit, MB_SIZE);
        tmp_xRefUV = iTmpX - x;
        tmp_yRefUV = iTmpY - y;

        // U & V Motion Vectors are already in Half-Pel units.
        g_pMV[g_UVMVId++] = (tmp_xRefUV << 16) | (tmp_yRefUV  & 0x0000FFFF);
#else
        // U & V Motion Vectors are already in Half-Pel units.
        g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV  & 0x0000FFFF);
#endif
	}
}

Void motionCompSkipMB_BVOP (CMBMode* pmbmd, CMotionVector* pmvForward, CMotionVector* pmvBackward, CoordI x, CoordI y, 
                            CRct *prctMVLimitForward,CRct *prctMVLimitBackward)
{
	int MVX, MVY;
	Int iBlk;

	// Reset mbmode to begin with
    g_pHeader2->mbmode = MBM_INTRA;

	if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE)
    {
		if (pmbmd->m_bhas4MVForward != TRUE && pmbmd->m_mbType != DIRECT)
        {
            g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
            g_pHeader3->mbtype = MBT_16x16;

            // Get the half-pel values
            MVX = TRUEMVHALFPEL_X(pmvForward);
            MVY = TRUEMVHALFPEL_Y(pmvForward);

            // Use hpel
            g_pMV[0] = g_pMV[1] = g_pMV[2] = g_pMV[3] = ((MVX << 16) | (MVY & 0x0000FFFF));
        }
        else
        {
			const CMotionVector* pmv8 = pmvForward;

			for (iBlk = 0; iBlk < 4; iBlk++)
            {
				pmv8++;

                g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
                g_pHeader3->mbtype = MBT_8x8;

                // Get the half-pel values
                MVX = TRUEMVHALFPEL_X(pmv8);
                MVY = TRUEMVHALFPEL_Y(pmv8);

                // Use hpel
                g_pMV[iBlk] = ((MVX << 16) | (MVY & 0x0000FFFF));
			}
		}

		CoordI xRefUVForward, yRefUVForward;
		mvLookupUVWithShape (pmbmd, pmvForward, &xRefUVForward, &yRefUVForward);

        // For Chroma MVs, update here only if we are 
        // handling the MBM_BIDIRECTIONAL case. For 
        // the regular case, it gets filled within 
        // motionCompUV()
#ifdef EXTRA_MV_CLIPPING
        CoordI xRefUV, yRefUV, iTmpX, iTmpY;

        iTmpX = x + xRefUVForward;
        iTmpY = y + yRefUVForward;	

        LIMITMVRANGETOEXTENDEDBBFULLPEL (&iTmpX,&iTmpY,prctMVLimitForward, MB_SIZE);
        xRefUV = iTmpX - x;
        yRefUV = iTmpY - y;

        // U & V Motion Vectors are already in Half-Pel units
        g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV & 0x0000FFFF);
#else
        // U & V Motion Vectors are already in Half-Pel units
        g_pMV[g_UVMVId++] = (xRefUVForward << 16) | (yRefUVForward & 0x0000FFFF);
#endif
		//if (pmbmd->m_bhas4MVBackward != TRUE)		 //removed by mwi
		if (pmbmd->m_bhas4MVBackward != TRUE && pmbmd->m_mbType != DIRECT)
        {
            g_pHeader2->mbmode |= MBMODE_BWD_ALL_420;
            g_pHeader3->mbtype = MBT_16x16;

            // Get the half-pel values
            MVX = TRUEMVHALFPEL_X(pmvBackward);
            MVY = TRUEMVHALFPEL_Y(pmvBackward);

            // Use hpel. If we are doing bi-directional, then retain the first 2 values
            if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
                g_pMV[2] = g_pMV[3] = ((MVX << 16) | (MVY & 0x0000FFFF));
            else
                g_pMV[0] = g_pMV[1] = g_pMV[2] = g_pMV[3] = ((MVX << 16) | (MVY & 0x0000FFFF));
		}

        else
        {
			CMotionVector* pmv8 = pmvBackward;

			for (iBlk = 0; iBlk < 4; iBlk++)
           	{
				pmv8++;

                g_pHeader2->mbmode |= MBMODE_BWD_ALL_420;
                g_pHeader3->mbtype = MBT_8x8;

                // Get the half-pel values
                MVX = TRUEMVHALFPEL_X(pmv8);
                MVY = TRUEMVHALFPEL_Y(pmv8);

                // Use hpel. If we are doing bi-directional, then retain the first 2 values
                if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
                    g_pMV[iBlk+4] = ((MVX << 16) | (MVY & 0x0000FFFF));
                else
                    g_pMV[iBlk] = ((MVX << 16) | (MVY & 0x0000FFFF));
			}
		}

		CoordI xRefUVBackward, yRefUVBackward;
		mvLookupUVWithShape (pmbmd, pmvBackward, &xRefUVBackward, &yRefUVBackward);

        // For Chroma MVs, update here only if we are handling the MBM_BIDIRECTIONAL 
        // case. For the regular case, it gets filled within motionCompUV()
#ifdef EXTRA_MV_CLIPPING
        iTmpX = x + xRefUVBackward;
        iTmpY = y + yRefUVBackward;

        LIMITMVRANGETOEXTENDEDBBFULLPEL (&iTmpX,&iTmpY,prctMVLimitBackward, MB_SIZE);
        xRefUV = iTmpX - x;
        yRefUV = iTmpY - y;

        // U & V Motion Vectors are already in Half-Pel units
        g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV  & 0x0000FFFF);
#else
        // U & V Motion Vectors are already in Half-Pel units
        g_pMV[g_UVMVId++] = (xRefUVBackward << 16) | (yRefUVBackward  & 0x0000FFFF);
#endif
	}

	else
    { 
		CRct *prctMVLimit;

		if (pmbmd->m_mbType == FORWARD)
			prctMVLimit = prctMVLimitForward;

		else
			prctMVLimit = prctMVLimitBackward;

        COPYFROMREFTOCURRQ (x, y, prctMVLimit);

        // Since inside the above function the mbmode is initialized as forward, 
        // we need to check again here & set to backward if needed
        if (pmbmd->m_mbType != FORWARD)
        {
            MP4V_FATAL_ERROR("NFS: bad -- seems like things are broken if this happens!\n");
            g_pHeader2->mbmode = MBMODE_BWD_ALL_420;
        }
	}
}

#ifdef ENABLE_INTERLACING
Void CVideoObjectDecoder::Get_BVOP_YUVILMVs (
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward,
	CMBMode* pmbmd, 
	Int iMBX, Int iMBY, 
	CoordI x, CoordI y,
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward)
{
	switch (pmbmd->m_mbType) 
	{
		case FORWARD:
			g_MAEWrapper->Set_MAEMB_mbmode(MBM_FORWARD,"CVideoObjectDecoder::Get_BVOP_YUVILMVs",
				__LINE__, __FILE__);
			g_MAEWrapper->Set_MAEMB_mbtype(MBT_16x8,"CVideoObjectDecoder::Get_BVOP_YUVILMVs", 
					__LINE__, __FILE__);
			motionCompOneBVOPReference(FORWARD, pmbmd, pmvForward);
		break;

		case BACKWARD:
			g_MAEWrapper->Set_MAEMB_mbmode(MBM_BACKWARD,"CVideoObjectDecoder::Get_BVOP_YUVILMVs",
				__LINE__, __FILE__);
			g_MAEWrapper->Set_MAEMB_mbtype(MBT_16x8,"CVideoObjectDecoder::Get_BVOP_YUVILMVs", 
					__LINE__, __FILE__);
			motionCompOneBVOPReference(BACKWARD, pmbmd, pmvBackward);
		break;

		case DIRECT:
			// TBD!!!!
			printf("\nUNSUPPORTED NOW--TBD!!!!");
			exit(0);

			Int iOffset;
			if(m_volmd.fAUsage != RECTANGLE)
				iOffset = (min (max (0, iMBX), m_iNumMBXRef - 1) + 
				min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef) * PVOP_MV_PER_REF_PER_MB;
			else
				iOffset=PVOP_MV_PER_REF_PER_MB*(iMBX + iMBY*m_iNumMBX);
			motionCompDirectMode(x, y, pmbmd, &m_rgmvRef[iOffset],
			  prctMVLimitForward, prctMVLimitBackward, 0);
		break;

		case INTERPOLATE:
			g_MAEWrapper->Set_MAEMB_mbmode(MBM_BIDIRECTIONAL,"CVideoObjectDecoder::Get_BVOP_YUVILMVs",
				__LINE__, __FILE__);
			g_MAEWrapper->Set_MAEMB_mbtype(MBT_16x8,"CVideoObjectDecoder::Get_BVOP_YUVILMVs", 
					__LINE__, __FILE__);
			motionCompOneBVOPReference(FORWARD, pmbmd, pmvForward);
			motionCompOneBVOPReference(BACKWARD,pmbmd, pmvBackward);
		break;
	}

	// Set the ft & fb fields here
	g_MAEWrapper->Set_MAEMB_ft ((pmbmd->m_bForwardTop ? 0 : 1),
	  "CVideoObjectDecoder::Get_BVOP_YUVILMVs", __LINE__, __FILE__);
	g_MAEWrapper->Set_MAEMB_fb ((pmbmd->m_bForwardBottom ? 0 : 1),
	  "CVideoObjectDecoder::Get_BVOP_YUVILMVs", __LINE__, __FILE__);

	// Set the bt & bb fields here
	g_MAEWrapper->Set_MAEMB_bt ((pmbmd->m_bBackwardTop ? 0 : 1),
	  "CVideoObjectDecoder::Get_BVOP_YUVILMVs", __LINE__, __FILE__);
	g_MAEWrapper->Set_MAEMB_bb ((pmbmd->m_bBackwardBottom ? 0 : 1),
	  "CVideoObjectDecoder::Get_BVOP_YUVILMVs", __LINE__, __FILE__);

	// Now that we have all MVs, lets check if any of these go Out-Of-Frame 
	// If so, since MAE constructs the OOF differently
	// it will fail to get the correct Reference-Blocks & hence fail 
	// MotionComp. For such MBs, we will NOT invoke MAE at all.
	if(g_MAEWrapper->CheckForOOFYFields(iMBY))
	{
		nFlipToRef = FLIP_TO_REF;
		nBldOpt = USE_REF;
	}

	// Chroma OOF check
	if (nFlipToRef == NO_FLIP)
	{
		if(g_MAEWrapper->CheckForOOFUVFields(iMBY))
		{
			nFlipToRef = FLIP_TO_REF;
			nBldOpt = USE_REF;
		}
	}
}
#endif