sys_decoder_mcdec.cpp

完整的RTP RTSP代码库

      ppxlcRef = m_pvopcRefQ0->pixelsA (iAuxComp); // point to left-top of the reference VOP
      prctMVLimit = prctMVLimitForward;
      itmpref1=pmbmd->m_bForwardTop; // 12.22.98
      itmpref2=pmbmd->m_bForwardBottom; // 12.22.98
    }
    else {
      pmv = pmvBackward;
      ppxlcRef = m_pvopcRefQ1->pixelsA (iAuxComp); // point to left-top of the reference VOP
      prctMVLimit = prctMVLimitBackward;
      itmpref1=pmbmd->m_bBackwardTop;  // 12.22.98
      itmpref2=pmbmd->m_bBackwardBottom;  // 12.22.98
    }
// INTERLACE  12.22.98, mod. for Quarter Sample , mwi
    if (pmbmd -> m_bFieldMV) {
      const CMotionVector* pmvTop = pmv + 1 + itmpref1;
      if (m_volmd.bQuarterSample) // Quarter sample
        motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp], 
                                 ppxlcRef + itmpref1 * m_iFrameWidthY, 0, 
                                 4*x + pmvTop->trueMVHalfPel ().x,
                                 4*y + pmvTop->trueMVHalfPel ().y,
                                 m_vopmd.iRoundingControl, prctMVLimit);
      else
        motionCompYField(m_ppxlcPredMBA[iAuxComp],
                         ppxlcRef + itmpref1 * m_iFrameWidthY,
                         2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y,
                         prctMVLimit); // added by Y.Suzuki for the extended bounding box support

      const CMotionVector* pmvBottom = pmv + 3 + itmpref2;
      if (m_volmd.bQuarterSample) // Quarter sample
        motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp] + MB_SIZE, 
                                 ppxlcRef + itmpref2 * m_iFrameWidthY, 0, 
                                 4*x + pmvBottom->trueMVHalfPel ().x,
                                 4*y + pmvBottom->trueMVHalfPel ().y,
                                 m_vopmd.iRoundingControl, prctMVLimit);
      else
        motionCompYField(m_ppxlcPredMBA[iAuxComp] + MB_SIZE,
                         ppxlcRef + itmpref2 * m_iFrameWidthY,
                         2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y,
                         prctMVLimit); // added by Y.Suzuki for the extended bounding box support
    }
    else
// ~INTERLACE 12.22.98			
    if (m_volmd.bQuarterSample) // Quarter sample
      motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp], 
                               ppxlcRef, MB_SIZE, 
                               x * 4 + pmv->trueMVHalfPel ().x, 
                               y * 4 + pmv->trueMVHalfPel ().y,
                               m_vopmd.iRoundingControl, prctMVLimit);
    else
      motionComp (
                  m_ppxlcPredMBA[iAuxComp],
                  ppxlcRef,
                  MB_SIZE, // MB size
                  x * 2 + pmv->trueMVHalfPel ().x, 
                  y * 2 + pmv->trueMVHalfPel ().y,
                  0,
                  prctMVLimit
                  );
  }
}

Void CVideoObjectDecoder::copyFromRefToCurrQ_BVOP (
	const CMBMode* pmbmd,
	CoordI x, CoordI y, 
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
	if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) { // Y is done when doing motion estimation
      if (m_volmd.bQuarterSample) // Quarter sample
        motionCompQuarterSample (m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (), MB_SIZE,
				                     x * 4, y * 4,
				                     m_vopmd.iRoundingControl, prctMVLimitForward);
      else
		motionComp (
			m_ppxlcPredMBY,
			m_pvopcRefQ0->pixelsY (),
			MB_SIZE, // either MB or BLOCK size
			x * 2, 
			y * 2,
			m_vopmd.iRoundingControl,
			prctMVLimitForward
		);
		motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
			x, y, 0, 0, m_vopmd.iRoundingControl,prctMVLimitForward);
		
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBBackY, m_pvopcRefQ1->pixelsY (), MB_SIZE,
                                   x * 4, y * 4,
                                   m_vopmd.iRoundingControl, prctMVLimitBackward);
        else
		motionComp (
			m_ppxlcPredMBBackY,
			m_pvopcRefQ1->pixelsY (),
			MB_SIZE, // either MB or BLOCK size
			x * 2, 
			y * 2,
			m_vopmd.iRoundingControl,
			prctMVLimitBackward
		);
		motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1,
			x, y, 0, 0, m_vopmd.iRoundingControl, prctMVLimitBackward);
		averagePredAndAssignToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
	else { 
		const CVOPU8YUVBA* pvopcRef; // point to left-top of the reference VOP
		CRct *prctMVLimit;
		if (pmbmd->m_mbType == FORWARD){
			pvopcRef = m_pvopcRefQ0;
			prctMVLimit = prctMVLimitForward;
		}
		else {
			pvopcRef = m_pvopcRefQ1;
			prctMVLimit = prctMVLimitBackward;
		}
		copyFromRefToCurrQ (pvopcRef, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, prctMVLimit);
	}
}

Void CVideoObjectDecoder::motionCompSkipMB_BVOP (
	const CMBMode* pmbmd, const CMotionVector* pmvForward, const CMotionVector* pmvBackward,
	CoordI x, CoordI y, 
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
	Int iBlk;
	if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) {
        //if (pmbmd->m_bhas4MVForward != TRUE) //removed by mwi
		if (pmbmd->m_bhas4MVForward != TRUE && pmbmd->m_mbType != DIRECT)
          if (m_volmd.bQuarterSample) // Quarter sample
            motionCompQuarterSample (m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (), MB_SIZE,
                                     x * 4 + pmvForward->trueMVHalfPel ().x, 
                                     y * 4 + pmvForward->trueMVHalfPel ().y,
                                     m_vopmd.iRoundingControl, prctMVLimitForward);
          else
			motionComp (
				m_ppxlcPredMBY,
				m_pvopcRefQ0->pixelsY (),
				MB_SIZE, // either MB or BLOCK size
				x * 2 + pmvForward->trueMVHalfPel ().x, 
				y * 2 + pmvForward->trueMVHalfPel ().y,
				m_vopmd.iRoundingControl,
				prctMVLimitForward
			);
		else {
			const CMotionVector* pmv8 = pmvForward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
              pmv8++;
              if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
                if (m_volmd.bQuarterSample) // Quarter sample
                  motionCompQuarterSample (m_ppxlcPredMBY + rgiBlkOffsetPixel [iBlk],
                                           m_pvopcRefQ0->pixelsY (), BLOCK_SIZE, 
                                           (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                           (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                           m_vopmd.iRoundingControl, prctMVLimitForward);
                else
                  motionComp (
                              m_ppxlcPredMBY + rgiBlkOffsetPixel [iBlk], 
                              m_pvopcRefQ0->pixelsY (),
                              BLOCK_SIZE, 
                              (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                              (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                              m_vopmd.iRoundingControl,
                              prctMVLimitForward
                              );
			}
		}
		CoordI xRefUVForward, yRefUVForward;
		mvLookupUVWithShape (pmbmd, pmvForward, xRefUVForward, yRefUVForward);
		motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, xRefUVForward, yRefUVForward, m_vopmd.iRoundingControl, prctMVLimitForward);

		//if (pmbmd->m_bhas4MVBackward != TRUE)		 //removed by mwi
		if (pmbmd->m_bhas4MVBackward != TRUE && pmbmd->m_mbType != DIRECT)
          if (m_volmd.bQuarterSample) // Quarter sample
            motionCompQuarterSample (m_ppxlcPredMBBackY, m_pvopcRefQ1->pixelsY (), MB_SIZE,
                                     x * 4 + pmvBackward->trueMVHalfPel ().x, 
                                     y * 4 + pmvBackward->trueMVHalfPel ().y,
                                     m_vopmd.iRoundingControl, prctMVLimitBackward);
          else
			motionComp (
				m_ppxlcPredMBBackY,
				m_pvopcRefQ1->pixelsY (),
				MB_SIZE, // either MB or BLOCK size
				x * 2 + pmvBackward->trueMVHalfPel ().x, 
				y * 2 + pmvBackward->trueMVHalfPel ().y,
				m_vopmd.iRoundingControl,
				prctMVLimitBackward
			);
		else {
			const CMotionVector* pmv8 = pmvBackward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
				pmv8++;
				if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
                  if (m_volmd.bQuarterSample) // Quarter sample
                    motionCompQuarterSample (m_ppxlcPredMBBackY + rgiBlkOffsetPixel [iBlk], 
                                             m_pvopcRefQ1->pixelsY (),BLOCK_SIZE, 
                                             (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                             (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                             m_vopmd.iRoundingControl, prctMVLimitBackward);
                  else
                    motionComp (
                                m_ppxlcPredMBBackY + rgiBlkOffsetPixel [iBlk], 
                                m_pvopcRefQ1->pixelsY (),
                                BLOCK_SIZE, 
                                (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                                (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                                m_vopmd.iRoundingControl,
                                prctMVLimitBackward
                                );
			}
		}
		CoordI xRefUVBackward, yRefUVBackward;
		mvLookupUVWithShape (pmbmd, pmvBackward, xRefUVBackward, yRefUVBackward);
		motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y, xRefUVBackward, yRefUVBackward, m_vopmd.iRoundingControl, prctMVLimitBackward);
		averagePredAndAssignToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
	else { 
		const CVOPU8YUVBA* pvopcRef; // point to left-top of the reference VOP
		CRct *prctMVLimit;
		if (pmbmd->m_mbType == FORWARD){
			pvopcRef = m_pvopcRefQ0;
			prctMVLimit = prctMVLimitForward;
		}
		else {
			pvopcRef = m_pvopcRefQ1;
			prctMVLimit = prctMVLimitBackward;
		}
		copyFromRefToCurrQ (pvopcRef, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, prctMVLimit);
	}
}