mc.cpp

完整的RTP RTSP代码库

        
//        iXFBQSUV += 2*x; iYFBQSUV += 2*y; // deleted by Y.Suzuki for the extended bounding box support
//        limitMVRangeToExtendedBBHalfPel(iXFBQSUV, iYFBQSUV, prctMVLimitFwd, MB_SIZE); // delted by Y.Suzuki for the extended bounding box support
//        iXFBQSUV -= 2*x; iYFBQSUV -= 2*y; // deleted by Y.Suzuki for the extended bounding box support
        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;
//      limitMVRangeToExtendedBBHalfPel(iXFwdBot, iYFwdBot, prctMVLimitFwd, MB_SIZE); // deleted by Y.Suzuki for the extended bounding box support
      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;
//      limitMVRangeToExtendedBBQuarterPel(iXBakBot, iYBakBot, prctMVLimitFwd, MB_SIZE); // deleted by Y.Suzuki for the extended bounding box support
      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

//        iXBBQSUV += 2*x; iYBBQSUV += 2*y; // deleted by Y.Suzuki for the extended bounding box support
//        limitMVRangeToExtendedBBHalfPel(iXBBQSUV, iYBBQSUV, prctMVLimitBak, MB_SIZE); // deleted by Y.Suzuki for the extended bounding box support
//        iXBBQSUV -= 2*x; iYBBQSUV -= 2*y; // deleted by Y.Suzuki for the extended bounding box support
        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;
//      limitMVRangeToExtendedBBHalfPel(iXBakBot, iYBakBot, prctMVLimitBak, MB_SIZE); // deleted by Y.Suzuki for the extended bounding box support
      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 {

    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) {
              vctFwd = (pmvRef[iBlk + 1].m_vctTrueHalfPel * iTempRefB) / iTempRefD + pmbmd->m_vctDirectDeltaMV;
              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);
              if (m_volmd.bQuarterSample) {
                motionCompQuarterSample(m_ppxlcPredMBY + iMBOffset[iBlk], 
                                        m_pvopcRefQ0->pixelsY(), BLOCK_SIZE, 
                                        x * 4 + iBlkXOffset[iBlk] * 2 + vctFwd.x, 
                                        y * 4 + iBlkYOffset[iBlk] * 2 + vctFwd.y, m_vopmd.iRoundingControl, prctMVLimitFwd);
                motionCompQuarterSample(m_ppxlcPredMBBackY + iMBOffset[iBlk], 
                                        m_pvopcRefQ1->pixelsY(), BLOCK_SIZE,
                                        x * 4 + iBlkXOffset[iBlk] * 2 + vctBak.x,
                                        y * 4 + iBlkYOffset[iBlk] * 2 + vctBak.y, m_vopmd.iRoundingControl, prctMVLimitBak);
              }
              else {
                motionComp(m_ppxlcPredMBY + iMBOffset[iBlk], m_pvopcRefQ0->pixelsY(), BLOCK_SIZE,
                           x * 2 + iBlkXOffset[iBlk] + vctFwd.x, y * 2 + iBlkYOffset[iBlk] + vctFwd.y, m_vopmd.iRoundingControl, prctMVLimitFwd);
                motionComp(m_ppxlcPredMBBackY + iMBOffset[iBlk], m_pvopcRefQ1->pixelsY(), BLOCK_SIZE,
                           x * 2 + iBlkXOffset[iBlk] + vctBak.x, y * 2 + iBlkYOffset[iBlk] + vctBak.y, m_vopmd.iRoundingControl, prctMVLimitBak);
              }
              
              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;
            }
          }
          switch (uiDivisor)	{
          case 4:
            rgiMvRound = grgiMvRound4;
            break;
          case 8:
            rgiMvRound = grgiMvRound8;
            break;
          case 12:
            rgiMvRound = grgiMvRound12;
            break;
          case 16:
            rgiMvRound = grgiMvRound16;
            break;
          }
          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 {
          vctFwd = (pmvRef[0].m_vctTrueHalfPel * iTempRefB) / iTempRefD + pmbmd->m_vctDirectDeltaMV;
          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) :
            ((pmvRef[0].m_vctTrueHalfPel.y * (iTempRefB - iTempRefD)) / iTempRefD);
          if (m_volmd.bQuarterSample) {
            // mod 991201 mwi
            for (Int iBlk = 0; iBlk < 4; iBlk++) {
              motionCompQuarterSample(m_ppxlcPredMBY + iMBOffset[iBlk], 
                                      m_pvopcRefQ0->pixelsY(), BLOCK_SIZE,
                                      x * 4 + iBlkXOffset[iBlk] * 2 + vctFwd.x, 
                                      y * 4 + iBlkYOffset[iBlk] * 2 + vctFwd.y, 
                                      m_vopmd.iRoundingControl, prctMVLimitFwd);
              motionCompQuarterSample(m_ppxlcPredMBBackY + iMBOffset[iBlk] , 
                                      m_pvopcRefQ1->pixelsY(), BLOCK_SIZE,
                                      x * 4 + iBlkXOffset[iBlk] * 2 + vctBak.x, 
                                      y * 4 + iBlkYOffset[iBlk] * 2 + vctBak.y, 
                                      m_vopmd.iRoundingControl, prctMVLimitBak);
            }
            // ~mod 991201 mwi
          }
          
          else {
            motionComp(m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY(), MB_SIZE,
                       x * 2 +  vctFwd.x, y * 2 +  vctFwd.y, m_vopmd.iRoundingControl, prctMVLimitFwd);
            motionComp(m_ppxlcPredMBBackY , m_pvopcRefQ1->pixelsY(), MB_SIZE,
                       x * 2 +  vctBak.x, y * 2 +  vctBak.y, m_vopmd.iRoundingControl, prctMVLimitBak);
          }
          
          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;
          }
          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);
        }
      }
    // begin of new changes 10/21/98
    else
      {
        vctFwd = pmbmd->m_vctDirectDeltaMV;
        vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? vctFwd.x :0;
        vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? vctFwd.y :0;
        if (m_volmd.bQuarterSample) { // Quarter Sample, mwi
          // mod 991201 mwi
          for (Int iBlk = 0; iBlk < 4; iBlk++) {
            motionCompQuarterSample(m_ppxlcPredMBY + iMBOffset[iBlk], 
                                    m_pvopcRefQ0->pixelsY(), BLOCK_SIZE,
                                    x * 4 + iBlkXOffset[iBlk] * 2 + vctFwd.x, 
                                    y * 4 + iBlkYOffset[iBlk] * 2 + vctFwd.y, 
                                    m_vopmd.iRoundingControl, prctMVLimitFwd);
            motionCompQuarterSample(m_ppxlcPredMBBackY + iMBOffset[iBlk], 
                                    m_pvopcRefQ1->pixelsY(), BLOCK_SIZE,
                                    x * 4 + iBlkXOffset[iBlk] * 2 + vctBak.x, 
                                    y * 4 + iBlkYOffset[iBlk] * 2 + vctBak.y, 
                                    m_vopmd.iRoundingControl, prctMVLimitBak);
          }
          // ~mod 991201 mwi
        }
        else {
          motionComp(m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY(), MB_SIZE,
                     x * 2 +  vctFwd.x, y * 2 +  vctFwd.y, m_vopmd.iRoundingControl, prctMVLimitFwd);
          motionComp(m_ppxlcPredMBBackY , m_pvopcRefQ1->pixelsY(), MB_SIZE,
                     x * 2 +  vctBak.x, y * 2 +  vctBak.y, m_vopmd.iRoundingControl, prctMVLimitBak);
        }
        
        if (m_volmd.bQuarterSample) { // Quarter Sample, mwi
          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;
        }
        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
        
    motionCompUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                 xRefUVF,
                 yRefUVF,m_vopmd.iRoundingControl, prctMVLimitFwd);
    motionCompUV(m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y,
                 xRefUVB,
                 yRefUVB,m_vopmd.iRoundingControl, prctMVLimitBak);
  }
}

Void CVideoObject::motionCompOneBVOPReference(
	CVOPU8YUVBA *pvopcPred,
	MBType type,
	CoordI x, CoordI y,
	const CMBMode *pmbmd,
	const CMotionVector *pmv,
	CRct *prctMVLimit
)
{ 
  CVOPU8YUVBA *pvopcRef;
  Int topRef, botRef;

  if (type == BACKWARD) {
    pvopcRef = m_pvopcRefQ1;
    topRef = (Int)pmbmd->m_bBackwardTop;
    botRef = (Int)pmbmd->m_bBackwardBottom;
  } else {
    pvopcRef = m_pvopcRefQ0;
    topRef = (Int)pmbmd->m_bForwardTop;
    botRef = (Int)pmbmd->m_bForwardBottom;
  }
  if (pmbmd->m_bFieldMV) {
    const CMotionVector *pmvTop = pmv + 1 + topRef;
    const CMotionVector *pmvBot = pmv + 3 + botRef;
    assert((topRef & ~1) == 0); assert((botRef & ~1) == 0);
    CoordI iMVX, iMVY;

    if (m_volmd.bQuarterSample) {
      iMVX = 4*x + pmvTop->m_vctTrueHalfPel.x;
      iMVY = 4*y + pmvTop->m_vctTrueHalfPel.y;
//      limitMVRangeToExtendedBBQuarterPel(iMVX, iMVY, prctMVLimit, MB_SIZE);
      // Luma top field
      motionCompQuarterSample((PixelC *)pvopcPred->pixelsY(),
                              pvopcRef->pixelsY() + topRef * m_iFrameWidthY, 0, 
                              iMVX, iMVY, m_vopmd.iRoundingControl, prctMVLimit);