vopmbdec.c

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

INLINE Void	decodeVideoPacketHeader(Int *iCurrentQP)
{
    UInt uiHEC;
    Bool bShapeOnly;
    VOPpredType vopPredType;
    MVInfo	TmpmvInfoForward;
    MVInfo	TmpmvInfoBackward;
    Int nBitsResyncMarker;
    UInt uiResyncMarker;
    Int	NumOfMB;
    Int iVal;
    Int iLengthOfMBNumber = 0, nLocalBit;
    UInt uiMBNumber = 0;

    MP4V_FLUSH (8);
    bShapeOnly = g_pVOL->bShapeOnly;
    vopPredType = g_pVOP->vopPredType; 
    TmpmvInfoForward = g_pVOP->mvInfoForward;
    TmpmvInfoBackward = g_pVOP->mvInfoBackward;

	nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
	if(bShapeOnly==FALSE)
	{
		if(vopPredType == PVOP) // GMC_V2
			nBitsResyncMarker += (TmpmvInfoForward.uiFCode - 1);
		else if(vopPredType == BVOP)
			nBitsResyncMarker += max(TmpmvInfoForward.uiFCode, TmpmvInfoBackward.uiFCode) - 1;
	}

	uiResyncMarker =  getBits (nBitsResyncMarker);

	NumOfMB = g_pVO->m_iNumMBX * g_pVO->m_iNumMBY;
#ifndef NO_ASSERTS
	assert (NumOfMB>0);
#endif

	iVal = NumOfMB - 1;
	for(; iVal; iLengthOfMBNumber++)
		iVal>>=1;

#ifdef ENABLE_NON_RECTANGLE_USAGE
	if (g_pVOL->fAUsage != RECTANGLE) 
    {
        uiHEC =  getBits (NUMBITS_VP_HEC);
        if (uiHEC && !(g_pVO->m_uiSprite == 1 && vopPredType == IVOP)) 
        {
    		Int width =  getBits (NUMBITS_VOP_WIDTH);
            MP4V_RETSINGLEBIT (&nLocalBit); // marker bit
#ifndef NO_ASSERTS
    		assert(nLocalBit==1);
#endif
    		Int height =  getBits (NUMBITS_VOP_HEIGHT);
            MP4V_RETSINGLEBIT (&nLocalBit); // marker bit
#ifndef NO_ASSERTS
    		assert(nLocalBit==1);
#endif
    		//wchen: cd changed to 2s complement
            MP4V_RETSINGLEBIT (&nLocalBit);
    		Int left = (nLocalBit  == 0) ? getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) : ((Int)getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1)));
    
            MP4V_RETSINGLEBIT (&nLocalBit); // marker bit
#ifndef NO_ASSERTS
    		assert(nLocalBit==1);
#endif
            MP4V_RETSINGLEBIT (&nLocalBit);
    		Int top = (nLocalBit == 0) ? getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) : ((Int)getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_VERTICAL_SPA_REF - 1)));
    		MP4V_RETSINGLEBIT (&nLocalBit); // marker bit
#ifndef NO_ASSERTS
    		assert(nLocalBit==1);
    		assert(((left | top)&1)==0); // must be even pix unit
#endif
	  }
	}
#endif

	if(NumOfMB>1)
		uiMBNumber =  getBits (iLengthOfMBNumber);
	
	g_pVO->m_iVPMBnum = uiMBNumber;
	if(bShapeOnly==FALSE) 
    {
		Int stepDecoded =  getBits (NUMBITS_VP_QUANTIZER);
		*iCurrentQP = stepDecoded; 
	}

	if (g_pVOL->fAUsage == RECTANGLE)
		uiHEC =  getBits (NUMBITS_VP_HEC);
		
	if (uiHEC)
    {
		// Time reference and VOP_pred_type
		Int iModuloInc = 0;
        Time tCurrSec, tVopIncr=0;
        VOPpredType TmpPredType;

        MP4V_RETSINGLEBIT (&nLocalBit);
        while (nLocalBit != 0)
        {
            iModuloInc++;
    		MP4V_RETSINGLEBIT (&nLocalBit);
        }

		tCurrSec = iModuloInc + (vopPredType != BVOP ? g_pDecoder->m_tOldModuloBaseDecd : g_pDecoder->m_tOldModuloBaseDisp);
   		MP4V_RETSINGLEBIT (&nLocalBit);
#ifndef NO_ASSERTS
		assert(nLocalBit == 1);
#endif
		if(g_pVO->m_iNumBitsTimeIncr!=0)
			tVopIncr =  getBits (g_pVO->m_iNumBitsTimeIncr);
   		MP4V_RETSINGLEBIT (&nLocalBit);
#ifndef NO_ASSERTS
		assert(nLocalBit == 1);
#endif

		TmpPredType = (VOPpredType)  getBits (NUMBITS_VP_PRED_TYPE);
#ifndef NO_ASSERTS
		assert(TmpPredType == vopPredType);
#endif

#ifdef ENABLE_NON_RECTANGLE_USAGE
		if (g_pVOL->fAUsage != RECTANGLE)
        {
            MP4V_RETSINGLEBIT (&g_pVOL->bNoCrChange); //VOP_CR_Change_Disable

            if (bShapeOnly==FALSE && vopPredType != IVOP)
			{	
                MP4V_RETSINGLEBIT (&g_pVOP->bShapeCodingType);
            }
		}
#endif

		if(bShapeOnly==FALSE) 
        {
			Int	iIntraDcSwitchThr = getBits (NUMBITS_VP_INTRA_DC_SWITCH_THR);
#ifndef NO_ASSERTS
			assert(g_pVOP->iIntraDcSwitchThr == iIntraDcSwitchThr);
#endif

#ifdef DUAL_MODE
			if (m_uiSprite == 2 && vopPredType == SPRITE && m_iNumOfPnts > 0)
				decodeWarpPoints ();
#endif

			if (vopPredType == PVOP)  // GMC_V2
            {
				UInt uiFCode =  getBits (NUMBITS_VOP_FCODE);
#ifndef NO_ASSERTS
				assert(uiFCode == TmpmvInfoForward.uiFCode);
#endif
			}
			else if (vopPredType == BVOP) 
            {
				UInt uiForwardFCode =  getBits (NUMBITS_VOP_FCODE);
				UInt uiBackwardFCode =  getBits (NUMBITS_VOP_FCODE);
#ifndef NO_ASSERTS
				assert(uiForwardFCode == TmpmvInfoForward.uiFCode);
				assert(uiBackwardFCode == TmpmvInfoBackward.uiFCode);
#endif
			}
		}
	}
}

Bool checkGOBMarker()
{
  Int iBitsLeft;
  UInt uiGOBMarker;
  MP4V_FATAL_ERROR("checkGOBMarker : m_lCounter not updated!!\n");
	iBitsLeft =  8 - (m_lCounter & 7);
	if(iBitsLeft==8)
		iBitsLeft = 0;
	uiGOBMarker = peekBits (17 + iBitsLeft);
	uiGOBMarker &= ((1 << 17) - 1);
	return (uiGOBMarker == 1);
}

// From mc.c
INLINE Void motionCompMB (CMotionVector* pmv, CMBMode* pmbmd) 
{
#ifdef INLINE_MV_CLIPPING
  xpos2 = g_pHeader3->xpos * MULTIPLY_BY;
  ypos2 = g_pHeader3->ypos * MULTIPLY_BY;
  xposuv_2 = xpos2 >> SHIFT_BY;
  yposuv_2 = ypos2 >> SHIFT_BY;
#endif

    // 16x16 case
#ifdef ENABLE_INTERLACING
    if (!pmbmd->m_bhas4MVForward && !pmbmd->m_bFieldMV) 
#else
    if (!pmbmd->m_bhas4MVForward) 
#endif
    {
        g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
        g_pHeader3->mbtype = MBT_16x16;

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

#ifdef INLINE_MV_CLIPPING
        MP4V_CLIP_LUMA_16x16_X();
        MP4V_CLIP_LUMA_16x16_Y();
#endif

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

    // 8x8 case
    else
    {
        pmv8 = pmv;

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

        for (iBlk = 0; iBlk < 4; iBlk++)
        {
            // Multiply by 2 to get qpel
            pmv8++;

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

#ifdef INLINE_MV_CLIPPING
            MP4V_CLIP_LUMA_8x8_X();
            MP4V_CLIP_LUMA_8x8_Y();
#endif

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

    mvLookupUV (pmbmd, pmv, &xRefUV, &yRefUV);

#ifdef INLINE_MV_CLIPPING
    MP4V_CLIP_CHROMA_X();
    MP4V_CLIP_CHROMA_Y();
#endif

    g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV  & 0x0000FFFF);
}

INLINE Void motionCompMB_BVOP (CMotionVector* pmvForward, CMotionVector* pmvBackward, CMBMode* pmbmd)
{
#ifdef INLINE_MV_CLIPPING
    xpos2 = g_pHeader3->xpos * MULTIPLY_BY;
    ypos2 = g_pHeader3->ypos * MULTIPLY_BY;
    xposuv_2 = xpos2 >> SHIFT_BY;
    yposuv_2 = ypos2 >> SHIFT_BY;
#endif

    if (g_pHeader3->mbtype == MBT_16x16)
    {
        // Get the half-pel values
        MVX = TRUEMVHALFPEL_X(pmvForward);
        MVY = TRUEMVHALFPEL_Y(pmvForward);

#ifdef INLINE_MV_CLIPPING
        MP4V_CLIP_LUMA_16x16_X();
        MP4V_CLIP_LUMA_16x16_Y();
#endif

        // Use hpel (4 MVs each 32-bit)
        g_pMV[0] = g_pMV[1] = ((MVX << 16) | (MVY & 0x0000FFFF));
    }

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

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

#ifdef INLINE_MV_CLIPPING
            MP4V_CLIP_LUMA_8x8_X();
            MP4V_CLIP_LUMA_8x8_Y();
#endif

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

    mvLookupUVWithShape (pmbmd, pmvForward, &xRefUV, &yRefUV);

#ifdef INLINE_MV_CLIPPING
    MP4V_CLIP_CHROMA_X();
    MP4V_CLIP_CHROMA_Y();
#endif

    g_pMV[g_UVMVId++] = ((xRefUV << 16) | (yRefUV & 0x0000FFFF));

    if (g_pHeader3->mbtype == MBT_16x16)
    {
        // Get the half-pel values
        MVX = TRUEMVHALFPEL_X(pmvBackward);
        MVY = TRUEMVHALFPEL_Y(pmvBackward);

#ifdef INLINE_MV_CLIPPING
        MP4V_CLIP_LUMA_16x16_X();
        MP4V_CLIP_LUMA_16x16_Y();
#endif

        g_pMV[2] = g_pMV[3] = (MVX << 16) | (MVY & 0x0000FFFF);
    }

    else
    {
        pmv8 = pmvBackward;

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

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

#ifdef INLINE_MV_CLIPPING
            MP4V_CLIP_LUMA_8x8_X();
            MP4V_CLIP_LUMA_8x8_Y();
#endif

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

    mvLookupUVWithShape (pmbmd, pmvBackward, &xRefUV, &yRefUV);

#ifdef INLINE_MV_CLIPPING
    MP4V_CLIP_CHROMA_X();
    MP4V_CLIP_CHROMA_Y();
#endif

    g_pMV[g_UVMVId++] = (xRefUV << 16) | (yRefUV & 0x0000FFFF);
}

INLINE Void motionCompAndAddErrorMB_BVOP (CMotionVector* pmvForward, CMotionVector* pmvBackward, CMBMode* pmbmd)
{
    if (g_pHeader2->mbmode == MBMODE_BID_ALL_420)
    {
        motionCompMB_BVOP (pmvForward, pmvBackward, pmbmd);
	} 

	else
    { 
#ifdef INLINE_MV_CLIPPING
        xpos2 = g_pHeader3->xpos * MULTIPLY_BY;
        ypos2 = g_pHeader3->ypos * MULTIPLY_BY;
        xposuv_2 = xpos2 >> SHIFT_BY;
        yposuv_2 = ypos2 >> SHIFT_BY;
#endif

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

		else
        {
			pmv8 = pmvBackward;
		}
           
        // forward or backward MVs Get the half-pel values
        MVX = TRUEMVHALFPEL_X(pmv8);
        MVY = TRUEMVHALFPEL_Y(pmv8);

#ifdef INLINE_MV_CLIPPING
        if (g_pHeader3->mbtype == MBT_16x16)
        {
            MP4V_CLIP_LUMA_16x16_X();
            MP4V_CLIP_LUMA_16x16_Y();
        }

        else
        {
            if ((xpos2 + MVX) < -16)
                 MVX = -16 - xpos2;
            else 
            {
                if (((xpos2 + MVX) >> 1) > iPicWidth_1)
                   MVX = iPicWidth_3 - xpos2;
            }

            if ((ypos2 + MVY) < -16)
                MVY = -16 - ypos2;
            else 
            {
                if (((ypos2 + MVY) >> 1) > iPicHeight_1)
                     MVY = iPicHeight_3 - ypos2;
            }
        }
#endif

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

		mvLookupUVWithShape (pmbmd, pmv8, &xRefUV, &yRefUV);

#ifdef INLINE_MV_CLIPPING
        MP4V_CLIP_CHROMA_X();
        MP4V_CLIP_CHROMA_Y();
#endif

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

INLINE Void motionCompSkipMB_BVOP (CMotionVector* pmvForward, CMotionVector* pmvBackwa