motionestimation.cpp

JMVM MPEG MVC/3DAV 测试平台 国际通用标准

    {
      x += dx;
      y += dy;
      pucSearch = pucRef + x + y * iStride;
    }
  }

  ruiSAD = uiBestSad - xGetCost( x, y );
  rcMv.setHor( x );
  rcMv.setVer( y );


  DO_DBG( m_cXDSS.pYSearch = pucRef + y * iStride + x );
  AOF_DBG( ruiSAD == ( uiSad  = m_cXDSS.Func( &m_cXDSS ) ) );
}

















#define TZ_SEARCH_CONFIGURATION                                                                                 \
  const Int  iRaster                  = 3;  /* TZ soll von aussen 黚ergeben werden */                           \
  const Bool bTestOtherPredictedMV    = 1;                                                                      \
  const Bool bTestZeroVector          = 1;                                                                      \
  const Bool bTestZeroVectorStar      = 0;                                                                      \
  const Bool bTestZeroVectorStop      = 0;                                                                      \
  const Bool bFirstSearchDiamond      = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
  const Bool bFirstSearchStop         = 0;                                                                      \
  const UInt uiFirstSearchRounds      = 3;  /* first search stop X rounds after best match (must be >=1) */     \
  const Bool bEnableRasterSearch      = 1;                                                                      \
  const Bool bAlwaysRasterSearch      = 0;  /* ===== 1: BETTER but factor 2 slower ===== */                     \
  const Bool bRasterRefinementEnable  = 0;  /* enable either raster refinement or star refinement */            \
  const Bool bRasterRefinementDiamond = 0;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
  const Bool bStarRefinementEnable    = 1;  /* enable either star refinement or raster refinement */            \
  const Bool bStarRefinementDiamond   = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
  const Bool bStarRefinementStop      = 0;                                                                      \
  const UInt uiStarRefinementRounds   = 2;  /* star refinement stop X rounds after best match (must be >=1) */  \



__inline
Void MotionEstimation::xTZSearchHelp( IntTZSearchStrukt& rcStrukt, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance )
{
#if 0 //degug
  std::cout << "Pruefpunkt           "
            << "  PX:"  << std::setw(4) << std::setfill(' ') << iSearchX
            << "  PY:"  << std::setw(4) << std::setfill(' ') << iSearchY
            << "  Dis:" << std::setw(6) << std::setfill(' ') << uiDistance << std::endl;
#endif
//JVT-W080 BUG_FIX
  if( OmitPDISearch( iSearchX, iSearchY, false ) ) //full pel
		return;
//~JVT-W080 BUG_FIX

  m_cXDSS.pYSearch = rcStrukt.pucYRef +  iSearchY     * rcStrukt.iYStride +  iSearchX;
  m_cXDSS.pUSearch = rcStrukt.pucURef + (iSearchY>>1) * rcStrukt.iCStride + (iSearchX>>1);
  m_cXDSS.pVSearch = rcStrukt.pucVRef + (iSearchY>>1) * rcStrukt.iCStride + (iSearchX>>1);
  
  UInt uiSad       = m_cXDSS.Func( &m_cXDSS );
  uiSad           += MotionEstimationCost::xGetCost( iSearchX, iSearchY );
  if( rcStrukt.uiBestSad > uiSad )
  {
    rcStrukt.uiBestSad      = uiSad;
    rcStrukt.iBestX         = iSearchX;
    rcStrukt.iBestY         = iSearchY;
    rcStrukt.uiBestDistance = uiDistance;
    rcStrukt.uiBestRound    = 0;
    rcStrukt.ucPointNr      = ucPointNr;

#if JMVM_ONLY  // JVT-U052
    // KJH: save best ICP value in rcStrukt
    if (rcStrukt.sBestIcpInMs.sIcAct)
    {
      rcStrukt.sBestIcpInMs.sOffset   = m_cXDSS.sIcpInMs.sOffset;
    }
#endif
  }
}

__inline
Void MotionEstimation::xTZ2PointSearch( IntTZSearchStrukt& rcStrukt, SearchRect rcSearchRect )
{ // 2 point search,                   //   1 2 3
  // check only the 2 untested points  //   4 0 5
  // around the start point            //   6 7 8
  Int iStartX = rcStrukt.iBestX;
  Int iStartY = rcStrukt.iBestY;
  switch( rcStrukt.ucPointNr )
  {
  case 1:
    {
      if ( (iStartX - 1) >= -rcSearchRect.iNegHorLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX - 1, iStartY, 0, 2 );
      }
      if ( (iStartY - 1) >= -rcSearchRect.iNegVerLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX, iStartY - 1, 0, 2 );
      }
    }
    break;
  case 2:
    {
      if ( (iStartY - 1) >= -rcSearchRect.iNegVerLimit )
      {
        if ( (iStartX - 1) >= -rcSearchRect.iNegHorLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX - 1, iStartY - 1, 0, 2 );
        }
        if ( (iStartX + 1) <= rcSearchRect.iPosHorLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX + 1, iStartY - 1, 0, 2 );
        }
      }
    }
    break;
  case 3:
    {
      if ( (iStartY - 1) >= -rcSearchRect.iNegVerLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX, iStartY - 1, 0, 2 );
      }
      if ( (iStartX + 1) <= rcSearchRect.iPosHorLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX + 1, iStartY, 0, 2 );
      }
    }
    break;
  case 4:
    {
      if ( (iStartX - 1) >= -rcSearchRect.iNegHorLimit )
      {
        if ( (iStartY + 1) <= rcSearchRect.iPosVerLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX - 1, iStartY + 1, 0, 2 );
        }
        if ( (iStartY - 1) >= -rcSearchRect.iNegVerLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX - 1, iStartY - 1, 0, 2 );
        }
      }
    }
    break;
  case 5:
    {
      if ( (iStartX + 1) <= rcSearchRect.iPosHorLimit )
      {
        if ( (iStartY - 1) >= -rcSearchRect.iNegVerLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX + 1, iStartY - 1, 0, 2 );
        }
        if ( (iStartY + 1) <= rcSearchRect.iPosVerLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX + 1, iStartY + 1, 0, 2 );
        }
      }
    }
    break;
  case 6:
    {
      if ( (iStartX - 1) >= -rcSearchRect.iNegHorLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX - 1, iStartY , 0, 2 );
      }
      if ( (iStartY + 1) <= rcSearchRect.iPosVerLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX, iStartY + 1, 0, 2 );
      }
    }
    break;
  case 7:
    {
      if ( (iStartY + 1) <= rcSearchRect.iPosVerLimit )
      {
        if ( (iStartX - 1) >= -rcSearchRect.iNegHorLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX - 1, iStartY + 1, 0, 2 );
        }
        if ( (iStartX + 1) <= rcSearchRect.iPosHorLimit )
        {
          xTZSearchHelp( rcStrukt, iStartX + 1, iStartY + 1, 0, 2 );
        }
      }
    }
    break;
  case 8:
    {
      if ( (iStartX + 1) <= rcSearchRect.iPosHorLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX + 1, iStartY, 0, 2 );
      }
      if ( (iStartY + 1) <= rcSearchRect.iPosVerLimit )
      {
        xTZSearchHelp( rcStrukt, iStartX, iStartY + 1, 0, 2 );
      }
    }
    break;
  default:
    {
      AF();
    }
    break;
  } // switch( rcStrukt.ucPointNr )
}

__inline
Void MotionEstimation::xTZ8PointSquareSearch( IntTZSearchStrukt& rcStrukt, SearchRect rcSearchRect,
                                              const Int iStartX, const Int iStartY, const Int iDist )
{ // 8 point search,                   //   1 2 3
  // search around the start point     //   4 0 5
  // with the required  distance       //   6 7 8
  AOT_DBG( iDist == 0 );
  const Int iTop        = iStartY - iDist;
  const Int iBottom     = iStartY + iDist;
  const Int iLeft       = iStartX - iDist;
  const Int iRight      = iStartX + iDist;
  rcStrukt.uiBestRound += 1;

  if ( iTop >= -rcSearchRect.iNegVerLimit ) // check top
  {
    if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check top left
    {
      xTZSearchHelp( rcStrukt, iLeft, iTop, 1, iDist );
    }
    // top middle
    xTZSearchHelp( rcStrukt, iStartX, iTop, 2, iDist );

    if ( iRight <= rcSearchRect.iPosHorLimit ) // check top right
    {
      xTZSearchHelp( rcStrukt, iRight, iTop, 3, iDist );
    }
  } // check top
  if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check middle left
  {
    xTZSearchHelp( rcStrukt, iLeft, iStartY, 4, iDist );
  }
  if ( iRight <= rcSearchRect.iPosHorLimit ) // check middle right
  {
    xTZSearchHelp( rcStrukt, iRight, iStartY, 5, iDist );
  }
  if ( iBottom <= rcSearchRect.iPosVerLimit ) // check bottom
  {
    if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check bottom left
    {
      xTZSearchHelp( rcStrukt, iLeft, iBottom, 6, iDist );
    }
    // check bottom middle
    xTZSearchHelp( rcStrukt, iStartX, iBottom, 7, iDist );

    if ( iRight <= rcSearchRect.iPosHorLimit ) // check bottom right
    {
      xTZSearchHelp( rcStrukt, iRight, iBottom, 8, iDist );
    }
  } // check bottom
}

__inline
Void MotionEstimation::xTZ8PointDiamondSearch( IntTZSearchStrukt& rcStrukt, SearchRect rcSearchRect,
                                        const Int iStartX, const Int iStartY, const Int iDist )
{ // 8 point search,                   //   1 2 3
  // search around the start point     //   4 0 5
  // with the required  distance       //   6 7 8
  AOT_DBG( iDist == 0 );
  const Int iTop        = iStartY - iDist;
  const Int iBottom     = iStartY + iDist;
  const Int iLeft       = iStartX - iDist;
  const Int iRight      = iStartX + iDist;
  rcStrukt.uiBestRound += 1;

  if ( iDist == 1 ) // iDist == 1
  {
    if ( iTop >= -rcSearchRect.iNegVerLimit ) // check top
    {
      xTZSearchHelp( rcStrukt, iStartX, iTop, 2, iDist );
    }
    if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check middle left
    {
      xTZSearchHelp( rcStrukt, iLeft, iStartY, 4, iDist );
    }
    if ( iRight <= rcSearchRect.iPosHorLimit ) // check middle right
    {
      xTZSearchHelp( rcStrukt, iRight, iStartY, 5, iDist );
    }
    if ( iBottom <= rcSearchRect.iPosVerLimit ) // check bottom
    {
      xTZSearchHelp( rcStrukt, iStartX, iBottom, 7, iDist );
    }
  }
  else // iDist == 1
  {
    if ( iDist <= 8 )
    {
      const Int iTop_2      = iStartY - (iDist>>1);
      const Int iBottom_2   = iStartY + (iDist>>1);
      const Int iLeft_2     = iStartX - (iDist>>1);
      const Int iRight_2    = iStartX + (iDist>>1);

      if (  iTop >= -rcSearchRect.iNegVerLimit && iLeft   >= -rcSearchRect.iNegHorLimit &&
          iRight <=  rcSearchRect.iPosHorLimit && iBottom <= rcSearchRect.iPosVerLimit ) // check border
      {
        xTZSearchHelp( rcStrukt, iStartX,  iTop,      2, iDist    );
        xTZSearchHelp( rcStrukt, iLeft_2,  iTop_2,    1, iDist>>1 );
        xTZSearchHelp( rcStrukt, iRight_2, iTop_2,    3, iDist>>1 );
        xTZSearchHelp( rcStrukt, iLeft,    iStartY,   4, iDist    );
        xTZSearchHelp( rcStrukt, iRight,   iStartY,   5, iDist    );
        xTZSearchHelp( rcStrukt, iLeft_2,  iBottom_2, 6, iDist>>1 );
        xTZSearchHelp( rcStrukt, iRight_2, iBottom_2, 8, iDist>>1 );
        xTZSearchHelp( rcStrukt, iStartX,  iBottom,   7, iDist    );
      }
      else // check border
      {
        if ( iTop >= -rcSearchRect.iNegVerLimit ) // check top
        {
          xTZSearchHelp( rcStrukt, iStartX, iTop, 2, iDist );
        }
        if ( iTop_2 >= -rcSearchRect.iNegVerLimit ) // check half top
        {
          if ( iLeft_2 >= -rcSearchRect.iNegHorLimit ) // check half left
          {
            xTZSearchHelp( rcStrukt, iLeft_2, iTop_2, 1, (iDist>>1) );
          }
          if ( iRight_2 <= rcSearchRect.iPosHorLimit ) // check half right
          {
            xTZSearchHelp( rcStrukt, iRight_2, iTop_2, 3, (iDist>>1) );
          }
        } // check half top
        if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check left
        {
          xTZSearchHelp( rcStrukt, iLeft, iStartY, 4, iDist );
        }
        if ( iRight <= rcSearchRect.iPosHorLimit ) // check right
        {
          xTZSearchHelp( rcStrukt, iRight, iStartY, 5, iDist );
        }
        if ( iBottom_2 <= rcSearchRect.iPosVerLimit ) // check half bottom
        {
          if ( iLeft_2 >= -rcSearchRect.iNegHorLimit ) // check half left
          {
            xTZSearchHelp( rcStrukt, iLeft_2, iBottom_2, 6, (iDist>>1) );
          }
          if ( iRight_2 <= rcSearchRect.iPosHorLimit ) // check half right
          {
            xTZSearchHelp( rcStrukt, iRight_2, iBottom_2, 8, (iDist>>1) );
          }
        } // check half bottom
        if ( iBottom <= rcSearchRect.iPosVerLimit ) // check bottom
        {
          xTZSearchHelp( rcStrukt, iStartX, iBottom, 7, iDist );
        }
      } // check border
    }
    else // iDist <= 8
    {
      if ( iTop >= -rcSearchRect.iNegVerLimit && iLeft   >= -rcSearchRect.iNegHorLimit &&
          iRight <=  rcSearchRect.iPosHorLimit && iBottom <= rcSearchRect.iPosVerLimit ) // check border
      {
        xTZSearchHelp( rcStrukt, iStartX, iTop,    0, iDist );
        xTZSearchHelp( rcStrukt, iLeft,   iStartY, 0, iDist );
        xTZSearchHelp( rcStrukt, iRight,  iStartY, 0, iDist );
        xTZSearchHelp( rcStrukt, iStartX, iBottom, 0, iDist );
        for ( Int index = 1; index < 4; index++ )
        {
          Int iPosYT = iTop    + ((iDist>>2) * index);
          Int iPosYB = iBottom - ((iDist>>2) * index);
          Int iPosXL = iStartX - ((iDist>>2) * index);
          Int iPosXR = iStartX + ((iDist>>2) * index);
          xTZSearchHelp( rcStrukt, iPosXL, iPosYT, 0, iDist );
          xTZSearchHelp( rcStrukt, iPosXR, iPosYT, 0, iDist );
          xTZSearchHelp( rcStrukt, iPosXL, iPosYB, 0, iDist );
          xTZSearchHelp( rcStrukt, iPosXR, iPosYB, 0, iDist );
        }
      }
      else // check border
      {
        if ( iTop >= -rcSearchRect.iNegVerLimit ) // check top
        {
          xTZSearchHelp( rcStrukt, iStartX, iTop, 0, iDist );
        }
        if ( iLeft >= -rcSearchRect.iNegHorLimit ) // check left
        {