mc.cpp

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

      ppxlcblk = (U8*) calloc(blkSizeX*blkSizeX,sizeof(U8));
      blkInterpolateY (ppxlcRefLeftTop,iSize,xRef,yRef,ppxlcblk,iRoundingControl);
      
      for (iy = 0; iy < blkSizeX; iy++) { 
        if (!(iy&1)) 
          for (ix = 0; ix < blkSizeX; ix++) { 
            ppxlcPred [ix] = *(ppxlcblk+ix+iy*blkSizeX);
          }
        ppxlcPred += blkSizeX;
      }
    } //~INTERLACED
    else { 
      blkSizeX = iSize;
      blkSizeY = iSize;
      
      ppxlcblk = (U8*) calloc(blkSizeX*blkSizeX,sizeof(U8));
      blkInterpolateY (ppxlcRefLeftTop,iSize,xRef,yRef,ppxlcblk,iRoundingControl);
 
      for (iy = 0; iy < blkSizeX; iy++) { 
        for (ix = 0; ix < blkSizeX; ix++) { 
          ppxlcPred [ix] = *(ppxlcblk+ix+iy*blkSizeX);
        }
        ppxlcPred += MB_SIZE;
      }
    }

  free(ppxlcblk);
}

Void CVideoObject::motionCompDirectMode(                // Interlaced direct mode
    CoordI x, CoordI y,
    CMBMode *pmbmd,
    const CMotionVector *pmvRef,
    CRct *prctMVLimitFwd, CRct *prctMVLimitBak,
	Int plane	// plane=1 for grey scale, plane=0 for texture, 02-17-99
                                     )
{
	Int* rgiMvRound;
	UInt uiDivisor = 0;
	Int xRefUVF,yRefUVF,xRefUVB,yRefUVB;
	CoordI iMVX, iMVY;

// begin of new changes 10/21/98
	Int iMBX,iMBY;
	const CMBMode *pmbmdRef; 

	if(m_volmd.fAUsage != RECTANGLE)
	{
		iMBX=(x-m_rctCurrVOPY.left)/MB_SIZE;
		iMBY=(y-m_rctCurrVOPY.top)/MB_SIZE;
		pmbmdRef= m_rgmbmdRef +
				(iMBX+iMBY*m_iNumMBXRef);
	}
	else
	{
		iMBX=x/MB_SIZE;
		iMBY=y/MB_SIZE;
		pmbmdRef= m_rgmbmdRef +
				iMBX+iMBY*m_iNumMBXRef;
	}
// end of new changes 10/21/98

	if (pmbmdRef->m_rgTranspStatus[0]==ALL) 
	{
		static CMotionVector mvZero[5];
		pmvRef = mvZero;
	}

#ifdef ENABLE_INTERLACING
	if ((iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0)&& // new change 10/21/98
		(pmbmdRef->m_bFieldMV&&pmbmdRef->m_rgTranspStatus[0]!=ALL)) 
	{
      static I8 iTROffsetTop[] = {  0, 0,  1, 1, 0, 0, -1, -1 };
      static I8 iTROffsetBot[] = { -1, 0, -1, 0, 1, 0,  1,  0 };
      CoordI iXFwdTop, iXFwdBot, iXBakTop, iXBakBot;
      CoordI iYFwdTop, iYFwdBot, iYBakTop, iYBakBot;
      CoordI iXFTQSUV, iXFBQSUV, iXBTQSUV, iXBBQSUV;
      CoordI iYFTQSUV, iYFBQSUV, iYBTQSUV, iYBBQSUV;
      const CMotionVector *pmvRefTop, *pmvRefBot;
      Int iTopRefFldOffset = 0, iBotRefFldOffset = 0;
      Int iCode = (Int)(vopmd().bTopFieldFirst) << 2;
      
      pmbmd->m_bFieldMV = 1;  // set field direct mode for grey scale, Krit 02-17-99

      assert((pmbmdRef->m_dctMd != INTRA) && (pmbmdRef->m_dctMd != INTRAQ));
      if (pmbmdRef->m_bForwardTop) {
        iCode |= 2;
        iTopRefFldOffset = 1;
        pmvRefTop = pmvRef + 6;
      } else
        pmvRefTop = pmvRef + 5;
      if (pmbmdRef->m_bForwardBottom) {
        iCode |= 1;
        iBotRefFldOffset = 1;
        pmvRefBot = pmvRef + 8;
      } else
        pmvRefBot = pmvRef + 7;
      Int iTempRefDTop = 2*(m_tFutureRef - m_tPastRef) + iTROffsetTop[iCode];
      Int iTempRefDBot = 2*(m_tFutureRef - m_tPastRef) + iTROffsetBot[iCode];
      Int iTempRefBTop = 2*(m_t          - m_tPastRef) + iTROffsetTop[iCode];
      Int iTempRefBBot = 2*(m_t          - m_tPastRef) + iTROffsetBot[iCode];
      
      assert(iTempRefDTop > 0); assert(iTempRefDBot > 0); assert(iTempRefBTop > 0); assert(iTempRefBBot > 0);
      
      // Find MVs for the top field
      iXFwdTop = (pmvRefTop->m_vctTrueHalfPel.x * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.x;
      iYFwdTop = (pmvRefTop->m_vctTrueHalfPel.y * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.y;
      iXBakTop = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdTop - pmvRefTop->m_vctTrueHalfPel.x) :
        ((pmvRefTop->m_vctTrueHalfPel.x * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
      iYBakTop = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdTop - pmvRefTop->m_vctTrueHalfPel.y) :
        ((pmvRefTop->m_vctTrueHalfPel.y * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
      
      // Find MVs for the bottom field
      iXFwdBot = (pmvRefBot->m_vctTrueHalfPel.x * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.x;
      iYFwdBot = (pmvRefBot->m_vctTrueHalfPel.y * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.y;
      iXBakBot = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdBot - pmvRefBot->m_vctTrueHalfPel.x) :
        ((pmvRefBot->m_vctTrueHalfPel.x * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
      iYBakBot = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdBot - pmvRefBot->m_vctTrueHalfPel.y) :
        ((pmvRefBot->m_vctTrueHalfPel.y * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
    
      // Motion compensate the top field forward
      if (m_volmd.bQuarterSample) {
        iXFTQSUV = iXFwdTop/2; 
        iYFTQSUV = iYFwdTop/2;
        iXBTQSUV = iXBakTop/2; 
        iYBTQSUV = iYBakTop/2;

        iXFBQSUV = iXFwdBot/2;
        iYFBQSUV = iYFwdBot/2;
        iXBBQSUV = iXBakBot/2; 
        iYBBQSUV = iYBakBot/2;

        iYFwdTop = iYFwdTop & ~1;
        iYBakTop = iYBakTop & ~1;
        iYFwdBot = iYFwdBot & ~1;
        iYBakBot = iYBakBot & ~1;
    
        iXFwdTop += 4*x; iYFwdTop += 4*y;
      if (plane==0) {  // texture MC
          motionCompQuarterSample(m_ppxlcPredMBY, 
                                  m_pvopcRefQ0->pixelsY() + iTopRefFldOffset * m_iFrameWidthY, 0, 
                                  iXFwdTop, iYFwdTop, m_vopmd.iRoundingControl, prctMVLimitFwd);
          
          motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                            (iXFTQSUV & 3) ? ((iXFTQSUV >> 1) | 1) : (iXFTQSUV >> 1),
                            (iYFTQSUV & 6) ? ((iYFTQSUV >> 1) | 2) : (iYFTQSUV >> 1), 
                            iTopRefFldOffset,
                            prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
        }
        else {  // plane=1, grey scale MC
          for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
            motionCompQuarterSample(m_ppxlcPredMBA[iAuxComp], 
              m_pvopcRefQ0->pixelsA(iAuxComp) + iTopRefFldOffset * m_iFrameWidthY, 0, 
              iXFwdTop, iYFwdTop, m_vopmd.iRoundingControl, prctMVLimitFwd);
          }
        }
      }
      else {
          iXFwdTop += 2*x; iYFwdTop += 2*y;
        if (plane==0) { // texture MC

			// GW: MAE doesn't support texture coding
#if TRUE
			throw CUnsupportedTextureCodingException();
#else
          motionCompYField(m_ppxlcPredMBY,
                           m_pvopcRefQ0->pixelsY() + iTopRefFldOffset * m_iFrameWidthY, iXFwdTop, iYFwdTop,
                           prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
          iXFwdTop -= 2*x; iYFwdTop -= 2*y;
          motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                            (iXFwdTop & 3) ? ((iXFwdTop >> 1) | 1) : (iXFwdTop >> 1),
                            (iYFwdTop & 6) ? ((iYFwdTop >> 1) | 2) : (iYFwdTop >> 1), iTopRefFldOffset,
                            prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
#endif
        }
        else { // plane=1, grey scale MC
          for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
            motionCompYField(m_ppxlcPredMBA[iAuxComp],
                           m_pvopcRefQ0->pixelsA(iAuxComp) + iTopRefFldOffset * m_iFrameWidthY, iXFwdTop, iYFwdTop,
                           prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
          }

          iXFwdTop -= 2*x; iYFwdTop -= 2*y;
        }
      }
    

      // Motion compensate the top field backward
    if (m_volmd.bQuarterSample) {
      iXBakTop += 4*x; iYBakTop += 4*y;
      if (plane==0) {  // texture MC
        motionCompQuarterSample(m_ppxlcPredMBBackY, 
                                m_pvopcRefQ1->pixelsY(), 0, 
                                iXBakTop, iYBakTop, m_vopmd.iRoundingControl, prctMVLimitBak);
        
        motionCompFieldUV(m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y,
                          (iXBTQSUV & 3) ? ((iXBTQSUV >> 1) | 1) : (iXBTQSUV >> 1),
                          (iYBTQSUV & 6) ? ((iYBTQSUV >> 1) | 2) : (iYBTQSUV >> 1), 
                          0,
                          prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompQuarterSample(m_ppxlcPredMBBackA[iAuxComp], 
                                  m_pvopcRefQ1->pixelsA(iAuxComp), 0, 
                                  iXBakTop, iYBakTop, m_vopmd.iRoundingControl, prctMVLimitBak);
        }
      }
    }
    else {
      iXBakTop += 2*x; iYBakTop += 2*y;
      if (plane==0) { // texture MC
        motionCompYField(m_ppxlcPredMBBackY, m_pvopcRefQ1->pixelsY(), iXBakTop,  iYBakTop,
          prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
        iXBakTop -= 2*x; iYBakTop -= 2*y;
        motionCompFieldUV(m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y,
                          (iXBakTop & 3) ? ((iXBakTop >> 1) | 1) : (iXBakTop >> 1),
                          (iYBakTop & 6) ? ((iYBakTop >> 1) | 2) : (iYBakTop >> 1), 0,
          prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompYField(m_ppxlcPredMBBackA[iAuxComp], m_pvopcRefQ1->pixelsA(iAuxComp), iXBakTop,  iYBakTop,
            prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
        }
        iXBakTop -= 2*x; iYBakTop -= 2*y;
      }
    }
    

    // Motion compensate the bottom field forward
    if (m_volmd.bQuarterSample) {
      iXFwdBot += 4*x; iYFwdBot += 4*y;
      if (plane==0) { // texture MC
        motionCompQuarterSample(m_ppxlcPredMBY + MB_SIZE, 
                                m_pvopcRefQ0->pixelsY() + iBotRefFldOffset * m_iFrameWidthY, 0, 
                                iXFwdBot, iYFwdBot, m_vopmd.iRoundingControl, prctMVLimitFwd);
        
        motionCompFieldUV(
                          m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE, 
                          m_pvopcRefQ0, x, y,
                          (iXFBQSUV & 3) ? ((iXFBQSUV >> 1) | 1) : (iXFBQSUV >> 1),
                          (iYFBQSUV & 6) ? ((iYFBQSUV >> 1) | 2) : (iYFBQSUV >> 1), 
                          iBotRefFldOffset,
                          prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompQuarterSample(
                                  m_ppxlcPredMBA[iAuxComp] + MB_SIZE, 
                                  m_pvopcRefQ0->pixelsA(iAuxComp) + iBotRefFldOffset * m_iFrameWidthY, 0, 
                                  iXFwdBot, iYFwdBot, m_vopmd.iRoundingControl, prctMVLimitFwd);
        }
      }
    }
    else {
      iXFwdBot += 2*x; iYFwdBot += 2*y;
      if (plane==0) { // texture MC
        motionCompYField(m_ppxlcPredMBY + MB_SIZE,
                         m_pvopcRefQ0->pixelsY() + iBotRefFldOffset * m_iFrameWidthY, iXFwdBot, iYFwdBot,
                         prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
        iXFwdBot -= 2*x; iYFwdBot -= 2*y;
        motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE, m_pvopcRefQ0, x, y,
                          (iXFwdBot & 3) ? ((iXFwdBot >> 1) | 1) : (iXFwdBot >> 1),
                          (iYFwdBot & 6) ? ((iYFwdBot >> 1) | 2) : (iYFwdBot >> 1), iBotRefFldOffset,
                           prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompYField(m_ppxlcPredMBA[iAuxComp] + MB_SIZE,
                           m_pvopcRefQ0->pixelsA(iAuxComp) + iBotRefFldOffset * m_iFrameWidthY, iXFwdBot, iYFwdBot,
                           prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
        }
        iXFwdBot -= 2*x; iYFwdBot -= 2*y;
      }
    }
    

    // Motion compensate the bottom field backward
    if (m_volmd.bQuarterSample) {
      iXBakBot += 4*x; iYBakBot += 4*y;
      if (plane==0) { // texture MC
        motionCompQuarterSample(m_ppxlcPredMBBackY + MB_SIZE, 
                                m_pvopcRefQ1->pixelsY() + m_iFrameWidthY, 0, 
                                iXBakBot, iYBakBot, m_vopmd.iRoundingControl, prctMVLimitBak); // 991201 mwi, chg Fwd->Bak

        motionCompFieldUV(m_ppxlcPredMBBackU + BLOCK_SIZE, 
                          m_ppxlcPredMBBackV + BLOCK_SIZE, m_pvopcRefQ1, x, y,
                          (iXBBQSUV & 3) ? ((iXBBQSUV >> 1) | 1) : (iXBBQSUV >> 1),
                          (iYBBQSUV & 6) ? ((iYBBQSUV >> 1) | 2) : (iYBBQSUV >> 1), 
                          1,
                          prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support // 991201 mwi, chg Fwd->Bak
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompQuarterSample(m_ppxlcPredMBBackA[iAuxComp] + MB_SIZE, 
                                  m_pvopcRefQ1->pixelsA(iAuxComp) + m_iFrameWidthY, 0, 
                                  iXBakBot, iYBakBot, m_vopmd.iRoundingControl, prctMVLimitBak); // 991201 mwi, chg Fwd->Bak
        }
      }
    }
    else {
      iXBakBot += 2*x; iYBakBot += 2*y;
      if (plane==0) { // texture MC
        motionCompYField(m_ppxlcPredMBBackY + MB_SIZE, m_pvopcRefQ1->pixelsY() + m_iFrameWidthY,
                         iXBakBot, iYBakBot,
                         prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
        iXBakBot -= 2*x; iYBakBot -= 2*y;
        motionCompFieldUV(m_ppxlcPredMBBackU + BLOCK_SIZE, m_ppxlcPredMBBackV + BLOCK_SIZE, m_pvopcRefQ1, x, y,
                          (iXBakBot & 3) ? ((iXBakBot >> 1) | 1) : (iXBakBot >> 1),
                          (iYBakBot & 6) ? ((iYBakBot >> 1) | 2) : (iYBakBot >> 1), 1,
                          prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
      }
      else { // plane=1, grey scale MC
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
          motionCompYField(m_ppxlcPredMBBackA[iAuxComp] + MB_SIZE, m_pvopcRefQ1->pixelsA(iAuxComp) + m_iFrameWidthY,
                           iXBakBot, iYBakBot,
                           prctMVLimitBak); // added by Y.Suzuki for the extended bounding box support
        }
        iXBakBot -= 2*x; iYBakBot -= 2*y;
      }
    }    
  } 
  else 
#endif
  {
    Int iTempRefD = m_tFutureRef - m_tPastRef;
    Int iTempRefB = m_t          - m_tPastRef;
    assert(iTempRefD > 0); assert(iTempRefB > 0);
    Int iChromaFwdX = 0, iChromaFwdY = 0, iChromaBakX = 0, iChromaBakY = 0;
    CVector vctFwd, vctBak;
    static I8 iBlkXOffset[] = { 0, 2*BLOCK_SIZE, 0, 2*BLOCK_SIZE };
    static I8 iBlkYOffset[] = { 0, 0, 2*BLOCK_SIZE, 2*BLOCK_SIZE };
    static Int iMBOffset[] = { 0, BLOCK_SIZE, MB_SIZE*BLOCK_SIZE, MB_SIZE*BLOCK_SIZE + BLOCK_SIZE };

    if ((pmbmdRef->m_dctMd == INTRA) || (pmbmdRef->m_dctMd == INTRAQ)) 
	{
      static CMotionVector mvZero[5];
      pmvRef = mvZero;
    }

    if(iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0) // new changes 10/21/98
    {
		if (pmbmdRef -> m_bhas4MVForward || m_volmd.bQuarterSample)	
		{
          for (Int iBlk = 0; iBlk < 4; iBlk++) 
		  {
            if(pmbmd->m_rgTranspStatus[iBlk+1]!=ALL) 
			{
                MUL_VECT (pmvRef[iBlk + 1].m_vctTrueHalfPel, iTempRefB);
                DIV_VECT (g_CMulVect, iTempRefD);
                ADD_VECT (g_CDivVect, pmbmd->m_vctDirectDeltaMV);
                vctFwd = g_CAddVect;

                vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? (vctFwd.x - pmvRef[iBlk + 1].m_vctTrueHalfPel.x) :
                            ((pmvRef[iBlk + 1].m_vctTrueHalfPel.x * (iTempRefB - iTempRefD)) / iTempRefD);
                vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? (vctFwd.y - pmvRef[iBlk + 1].m_vctTrueHalfPel.y) :
                            ((pmvRef[iBlk + 1].m_vctTrueHalfPel.y * (iTempRefB - iTempRefD)) / iTempRefD);

                // Y MVs
                iMVX = vctFwd.x;
                iMVY = vctFwd.y;
                g_pMV[iBlk] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

                // Y MVs
                iMVX = vctBak.x;
                iMVY = vctBak.y;
                g_pMV[iBlk+4] = ((iMVX << 16) | (iMVY & 0x0000FFFF));

                if (m_volmd.bQuarterSample) 
                {
                    iChromaFwdX += vctFwd.x/2;
                    iChromaFwdY += vctFwd.y/2;
                    iChromaBakX += vctBak.x/2;
                    iChromaBakY += vctBak.y/2;
                }
                else 
                {	
                    iChromaFwdX += vctFwd.x;
                    iChromaFwdY += vctFwd.y;
                    iChromaBakX += vctBak.x;
                    iChromaBakY += vctBak.y;
                }

                uiDivisor += 4;
            }
          }

          (uiDivisor == 4) ? (rgiMvRound = grgiMvRound4) : (((uiDivisor == 8) ? (rgiMvRound = grgiMvRound8) : 
                                                             ((uiDivisor == 12) ? (rgiMvRound = grgiMvRound12) : (rgiMvRound = grgiMvRound16))));

          xRefUVF = sign (iChromaFwdX) * (rgiMvRound [abs (iChromaFwdX) % uiDivisor] + (abs (iChromaFwdX) / uiDivisor) * 2);
          yRefUVF = sign (iChromaFwdY) * (rgiMvRound [abs (iChromaFwdY) % uiDivisor] + (abs (iChromaFwdY) / uiDivisor) * 2);
          xRefUVB = sign (iChromaBakX) * (rgiMvRound [abs (iChromaBakX) % uiDivisor] + (abs (iChromaBakX) / uiDivisor) * 2);
          yRefUVB = sign (iChromaBakY) * (rgiMvRound [abs (iChromaBakY) % uiDivisor] + (abs (iChromaBakY) / uiDivisor) * 2);
        }
        else 
		{
          MUL_VECT (pmvRef[0].m_vctTrueHalfPel, iTempRefB);
          DIV_VECT (g_CMulVect, iTempRefD);
          ADD_VECT (g_CDivVect, pmbmd->m_vctDirectDeltaMV);
          vctFwd = g_CAddVect;

          vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? (vctFwd.x - pmvRef[0].m_vctTrueHalfPel.x) :
            ((pmvRef[0].m_vctTrueHalfPel.x * (iTempRefB - iTempRefD)) / iTempRefD);
          vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? (vctFwd.y - pmvRef[0].m_vctTrueHalfPel.y) :