sys_decoder_mcdec.cpp

完整的RTP RTSP代码库

                    y * 2 + pmv->trueMVHalfPel ().y,
                    m_vopmd.iRoundingControl,
                    prctMVLimit
                    );
      CoordI xRefUV, yRefUV;
      mvLookupUVWithShape (pmbmd, pmv, xRefUV, yRefUV);
      motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, pvopcRef, x, y, xRefUV, yRefUV, m_vopmd.iRoundingControl, prctMVLimit);
      addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
}

Void CVideoObjectDecoder::motionCompAlphaMB_BVOP(
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward,
	CMBMode* pmbmd, 
	Int iMBX, Int iMBY, 
	CoordI x, CoordI y,
	PixelC* ppxlcCurrQMBA,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward, Int iAuxComp)
{
  Int iBlk;
  if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) {
    if (pmbmd->m_mbType == DIRECT && !pmbmd -> m_bFieldMV) { // added by mwi, changed for GS+IN 990219 mwi
      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_ppxlcPredMBA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                                     m_pvopcRefQ0->pixelsA (iAuxComp), BLOCK_SIZE, 
                                     (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                     (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                     m_vopmd.iRoundingControl, prctMVLimitForward);
          else
            motionComp (
                        m_ppxlcPredMBA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                        m_pvopcRefQ0->pixelsA (iAuxComp),
                        BLOCK_SIZE, 
                        (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                        (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                        0,
                        prctMVLimitForward
                        );
      }
      pmv8 = pmvBackward;
      for (iBlk = 0; iBlk < 4; iBlk++)	{
        pmv8++;
        if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
          if (m_volmd.bQuarterSample) // Quarter sample
            motionCompQuarterSample (
                                     m_ppxlcPredMBBackA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                                     m_pvopcRefQ1->pixelsA (iAuxComp), BLOCK_SIZE, 
                                     (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                     (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                     m_vopmd.iRoundingControl, prctMVLimitBackward);
          else
            motionComp (
                        m_ppxlcPredMBBackA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                        m_pvopcRefQ1->pixelsA (iAuxComp),
                        BLOCK_SIZE, 
                        (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                        (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                        0,
                        prctMVLimitBackward
                        );
      }

    } // ~added by mwi
    else {
      if (!pmbmd->m_bhas4MVForward && !pmbmd -> m_bFieldMV) //12.22.98
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp], m_pvopcRefQ0->pixelsA (iAuxComp), 
                                   MB_SIZE, x * 4 + pmvForward->trueMVHalfPel ().x
                                   , y * 4 + pmvForward->trueMVHalfPel ().y, 
                                   m_vopmd.iRoundingControl, prctMVLimitForward);
        else
          motionComp (m_ppxlcPredMBA[iAuxComp],
                      m_pvopcRefQ0->pixelsA (iAuxComp),
                      MB_SIZE, // either MB or BLOCK size
                      x * 2 + pmvForward->trueMVHalfPel ().x, 
                      y * 2 + pmvForward->trueMVHalfPel ().y,
                      0,
                      prctMVLimitForward
                      );
// INTERLACE  12.22.98, mod. for Quarter Sample by mwi, with new change 02-17-99
      else if ((pmbmd -> m_bFieldMV) && (pmbmd->m_mbType == INTERPOLATE)) { 
       const CMotionVector* pmvTop = pmvForward + 1 + pmbmd->m_bForwardTop;
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp], 
                                   m_pvopcRefQ0->pixelsA (iAuxComp) + pmbmd->m_bForwardTop * m_iFrameWidthY,0, 
                                   4*x + pmvTop->trueMVHalfPel ().x, 
                                   4*y + pmvTop->trueMVHalfPel ().y,
                                   m_vopmd.iRoundingControl, prctMVLimitForward);
        else
          motionCompYField(m_ppxlcPredMBA[iAuxComp],
                           m_pvopcRefQ0->pixelsA (iAuxComp) + pmbmd->m_bForwardTop * m_iFrameWidthY,
                           2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y,
                           prctMVLimitForward); // added by Y.Suzuki for the extended bounding box support

        const CMotionVector* pmvBottom = pmvForward + 3 + pmbmd->m_bForwardBottom;
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBA[iAuxComp] + MB_SIZE, 
                                   m_pvopcRefQ0->pixelsA (iAuxComp) + pmbmd->m_bForwardBottom * m_iFrameWidthY,0, 
                                   4*x + pmvBottom->trueMVHalfPel ().x, 
                                   4*y + pmvBottom->trueMVHalfPel ().y,
                                   m_vopmd.iRoundingControl, prctMVLimitForward);
        else
          motionCompYField(m_ppxlcPredMBA[iAuxComp] + MB_SIZE,
                           m_pvopcRefQ0->pixelsA (iAuxComp) + pmbmd->m_bForwardBottom * m_iFrameWidthY,
                           2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y,
                           prctMVLimitForward); // added by Y.Suzuki for the extended bounding box support

      }
// ~INTERLACE 12.22.98, mod. for Quarter Sample by mwi, with new change 02-17-99

// INTERLACE 02-17-99
      else if ((pmbmd -> m_bFieldMV) && (pmbmd->m_mbType == DIRECT)) {
        Int iOffset = (MIN (MAX (0,iMBX), m_iNumMBXRef - 1) +
                       MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef) * PVOP_MV_PER_REF_PER_MB;
        motionCompDirectMode(x, y, pmbmd, &m_rgmvRef[iOffset],
                             prctMVLimitForward, prctMVLimitBackward, 1);
      }
// ~INTERLACE 02-17-99

      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_ppxlcPredMBA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                                       m_pvopcRefQ0->pixelsA (iAuxComp), BLOCK_SIZE, 
                                       (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                       (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                       m_vopmd.iRoundingControl, prctMVLimitForward);
            else
              motionComp (
                          m_ppxlcPredMBA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                          m_pvopcRefQ0->pixelsA (iAuxComp),
                          BLOCK_SIZE, 
                          (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                          (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                          0,
                          prctMVLimitForward
                          );
        }
      }
      if (!pmbmd->m_bhas4MVBackward && !pmbmd -> m_bFieldMV)	//12.22.98 
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBBackA[iAuxComp], 
                                   m_pvopcRefQ1->pixelsA (iAuxComp), MB_SIZE, 
                                   x * 4 + pmvBackward->trueMVHalfPel ().x, 
                                   y * 4 + pmvBackward->trueMVHalfPel ().y,
                                   m_vopmd.iRoundingControl, prctMVLimitBackward);
        else
          motionComp (
                      m_ppxlcPredMBBackA[iAuxComp],
                      m_pvopcRefQ1->pixelsA (iAuxComp),
                      MB_SIZE, // either MB or BLOCK size
                      x * 2 + pmvBackward->trueMVHalfPel ().x, 
                      y * 2 + pmvBackward->trueMVHalfPel ().y,
                      0,
                      prctMVLimitBackward
                      );
// INTERLACE  12.22.98 with new change 02-17-99, mod for Quarter Sample

      else if (pmbmd -> m_bFieldMV && (pmbmd->m_mbType == INTERPOLATE)) {
        const CMotionVector* pmvTop = pmvBackward + 1 + pmbmd->m_bBackwardTop;
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBBackA[iAuxComp], 
                                   m_pvopcRefQ1->pixelsA (iAuxComp) + pmbmd->m_bBackwardTop * m_iFrameWidthY,0, 
                                   4*x + pmvTop->trueMVHalfPel ().x, 
                                   4*y + pmvTop->trueMVHalfPel ().y,
                                   m_vopmd.iRoundingControl, prctMVLimitBackward);
        else
          motionCompYField(m_ppxlcPredMBBackA[iAuxComp],
                           m_pvopcRefQ1->pixelsA (iAuxComp) + pmbmd->m_bBackwardTop * m_iFrameWidthY,
                           2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y,
                           prctMVLimitBackward); // added by Y.Suzuki for the extended bounding box support
        
        const CMotionVector* pmvBottom = pmvBackward + 3 + pmbmd->m_bBackwardBottom;
        if (m_volmd.bQuarterSample) // Quarter sample
          motionCompQuarterSample (m_ppxlcPredMBBackA[iAuxComp] + MB_SIZE, 
                                   m_pvopcRefQ1->pixelsA (iAuxComp) + pmbmd->m_bBackwardBottom * m_iFrameWidthY,0, 
                                   4*x + pmvBottom->trueMVHalfPel ().x, 
                                   4*y + pmvBottom->trueMVHalfPel ().y,
                                   m_vopmd.iRoundingControl, prctMVLimitBackward);
        else
          motionCompYField(m_ppxlcPredMBBackA[iAuxComp] + MB_SIZE,
                           m_pvopcRefQ1->pixelsA (iAuxComp) + pmbmd->m_bBackwardBottom * m_iFrameWidthY,
                           2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y,
                           prctMVLimitBackward); // added by Y.Suzuki for the extended bounding box support
      }
      else if (((pmbmd -> m_bFieldMV)==0) || (pmbmd->m_mbType != DIRECT)) {
//		else {
// ~INTERLACE 12.22.98 with new change 02-17-99
        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_ppxlcPredMBBackA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                                       m_pvopcRefQ1->pixelsA (iAuxComp), BLOCK_SIZE, 
                                       (x + rgiBlkOffsetX [iBlk]) * 4 + pmv8->trueMVHalfPel ().x, 
                                       (y + rgiBlkOffsetY [iBlk]) * 4 + pmv8->trueMVHalfPel ().y,
                                       m_vopmd.iRoundingControl, prctMVLimitBackward);
            else
              motionComp (
                          m_ppxlcPredMBBackA[iAuxComp] + rgiBlkOffsetPixel [iBlk], 
                          m_pvopcRefQ1->pixelsA (iAuxComp),
                          BLOCK_SIZE, 
                          (x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
                          (y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
                          0,
                          prctMVLimitBackward
                          );
        }
      }
    }
    // average predictions
    Int i;
    for(i = 0; i<MB_SQUARE_SIZE; i++)
      m_ppxlcPredMBA[iAuxComp][i] = (m_ppxlcPredMBA[iAuxComp][i] + m_ppxlcPredMBBackA[iAuxComp][i] + 1)>>1;
  }
  else { 
    const CMotionVector* pmv;
    const PixelC* ppxlcRef; // point to left-top of the reference VOP
    CRct *prctMVLimit;
    Int itmpref1,itmpref2; // 12.22.98
    if (pmbmd->m_mbType == FORWARD) {
      pmv = pmvForward;