JVET-N0329: IBC Search Improvement

source/Lib/CommonLib/IbcHashMap.cpp

@@ -274,6 +274,9 @@ bool IbcHashMap::ibcHashMatch(const Area& lumaArea, std::vector<Position>& cand,
   // find the block with least candidates
   size_t minSize = MAX_UINT;
   unsigned int targetHashOneBlock = 0;
+#if JVET_N0329_IBC_SEARCH_IMP 
+  Position targetBlockOffsetInCu(0, 0);
+#endif
   for (SizeType y = 0; y < lumaArea.height && minSize > 1; y += MIN_PU_SIZE)
   {
     for (SizeType x = 0; x < lumaArea.width && minSize > 1; x += MIN_PU_SIZE)
@@ -283,6 +286,9 @@ bool IbcHashMap::ibcHashMatch(const Area& lumaArea, std::vector<Position>& cand,
       {
         minSize = m_hash2Pos[hash].size();
         targetHashOneBlock = hash;
+#if JVET_N0329_IBC_SEARCH_IMP 
+        targetBlockOffsetInCu.repositionTo(Position(x, y));
+#endif
       }
     }
   }
@@ -294,11 +300,20 @@ bool IbcHashMap::ibcHashMatch(const Area& lumaArea, std::vector<Position>& cand,
     // check whether whole block match
     for (std::vector<Position>::iterator refBlockPos = candOneBlock.begin(); refBlockPos != candOneBlock.end(); refBlockPos++)
     {
+#if JVET_N0329_IBC_SEARCH_IMP 
+      Position topLeft = refBlockPos->offset(-targetBlockOffsetInCu.x, -targetBlockOffsetInCu.y);
+      Position bottomRight = topLeft.offset(lumaArea.width - 1, lumaArea.height - 1);
+#else
       Position bottomRight = refBlockPos->offset(lumaArea.width - 1, lumaArea.height - 1);
+#endif
       bool wholeBlockMatch = true;
       if (lumaArea.width > MIN_PU_SIZE || lumaArea.height > MIN_PU_SIZE)
       {
+#if JVET_N0329_IBC_SEARCH_IMP 
+        if (!cs.isDecomp(bottomRight, cs.chType) || bottomRight.x >= m_picWidth || bottomRight.y >= m_picHeight || topLeft.x < 0 || topLeft.y < 0)
+#else
         if (!cs.isDecomp(bottomRight, cs.chType) || bottomRight.x >= m_picWidth || bottomRight.y >= m_picHeight)
+#endif
         {
           continue;
         }
@@ -307,20 +322,33 @@ bool IbcHashMap::ibcHashMatch(const Area& lumaArea, std::vector<Position>& cand,
           for (SizeType x = 0; x < lumaArea.width && wholeBlockMatch; x += MIN_PU_SIZE)
           {
             // whether the reference block and current block has the same hash
+#if JVET_N0329_IBC_SEARCH_IMP 
+            wholeBlockMatch &= (m_pos2Hash[lumaArea.pos().y + y][lumaArea.pos().x + x] == m_pos2Hash[topLeft.y + y][topLeft.x + x]);
+#else
             wholeBlockMatch &= (m_pos2Hash[lumaArea.pos().y + y][lumaArea.pos().x + x] == m_pos2Hash[refBlockPos->y + y][refBlockPos->x + x]);
+#endif
           }
         }
       }
       else
       {
+#if JVET_N0329_IBC_SEARCH_IMP 
+        CHECK(topLeft != *refBlockPos, "4x4 target block should not have offset!");
+        if (abs(topLeft.x - lumaArea.x) > searchRange4SmallBlk || abs(topLeft.y - lumaArea.y) > searchRange4SmallBlk || !cs.isDecomp(bottomRight, cs.chType))
+#else
         if (abs(refBlockPos->x - lumaArea.x) > searchRange4SmallBlk || abs(refBlockPos->y - lumaArea.y) > searchRange4SmallBlk || !cs.isDecomp(bottomRight, cs.chType))
+#endif
         {
           continue;
         }
       }
       if (wholeBlockMatch)
       {
+#if JVET_N0329_IBC_SEARCH_IMP 
+        cand.push_back(topLeft);
+#else
         cand.push_back(*refBlockPos);
+#endif
         if (cand.size() > maxCand)
         {
           break;
@@ -349,5 +377,76 @@ int IbcHashMap::getHashHitRatio(const Area& lumaArea)
   return 100 * hit / total;
 }
 
+#if JVET_N0329_IBC_SEARCH_IMP
+int IbcHashMap::calHashBlkMatchPerc(const Area& lumaArea)
+{
+  int maxX = std::min((int)(lumaArea.x + lumaArea.width), m_picWidth);
+  int maxY = std::min((int)(lumaArea.y + lumaArea.height), m_picHeight);
+  int          maxUsage[100];
+  unsigned int mostSelHash[100];
+
+  static   int numExcludedHashValue = 36;
+
+  for (int i = 0; i < numExcludedHashValue; i++)
+  {
+    maxUsage[i] = 0;
+    mostSelHash[i] = 0;
+  }
+
+  for (std::unordered_map<unsigned int, std::vector<Position>>::iterator it = m_hash2Pos.begin(); it != m_hash2Pos.end(); ++it)
+  {
+    unsigned int hash = it->first;
+    int usage = (int)it->second.size();
+    assert(usage == m_hash2Pos[hash].size());
+
+    int insertPos = -1;
+    for (insertPos = 0; insertPos < numExcludedHashValue; insertPos++)
+    {
+      if (usage > maxUsage[insertPos])
+      {
+        break;
+      }
+    }
+    assert(insertPos <= numExcludedHashValue);
+
+    if (insertPos < numExcludedHashValue)
+    {
+      for (int i = (numExcludedHashValue - 1); i >= (insertPos + 1); i--)
+      {
+        maxUsage[i] = maxUsage[i - 1];
+        mostSelHash[i] = mostSelHash[i - 1];
+      }
+      maxUsage[insertPos] = usage;
+      mostSelHash[insertPos] = hash;
+    }
+  }
+
+  int hit = 0, total = 0;
+  for (int y = lumaArea.y; y < maxY; y += MIN_PU_SIZE)
+  {
+    for (int x = lumaArea.x; x < maxX; x += MIN_PU_SIZE)
+    {
+      unsigned int hash = m_pos2Hash[y][x];
+
+      bool excludedHash = false;
+      for (int i = 0; i < numExcludedHashValue && !excludedHash; i++)
+      {
+        if (hash == mostSelHash[i])
+        {
+          excludedHash = true;
+        }
+      }
+
+      if (excludedHash)
+      {
+        continue;
+      }
 
+      hit += (m_hash2Pos[hash].size() > 1);
+      total++;
+    }
+  }
+  return 100 * hit / total;
+}
+#endif
 //! \}

source/Lib/CommonLib/IbcHashMap.h

@@ -82,6 +82,10 @@ public:
   bool    ibcHashMatch(const Area& lumaArea, std::vector<Position>& cand, const CodingStructure& cs, const int maxCand, const int searchRange4SmallBlk);
   int     getHashHitRatio(const Area& lumaArea);
 
+#if JVET_N0329_IBC_SEARCH_IMP
+  int     calHashBlkMatchPerc(const Area& lumaArea);
+#endif
+
 #ifdef TARGET_SIMD_X86
   void    initIbcHashMapX86();
   template <X86_VEXT vext>

source/Lib/CommonLib/MotionInfo.h

@@ -224,4 +224,11 @@ struct LutMotionCand
   static_vector<MotionInfo, MAX_NUM_HMVP_CANDS> lutShare;
   static_vector<MotionInfo, MAX_NUM_HMVP_CANDS> lutShareIbc;
 };
+#if JVET_N0329_IBC_SEARCH_IMP
+struct PatentBvCand
+{
+  Mv m_bvCands[IBC_NUM_CANDIDATES];
+  int currCnt;
+};
+#endif
 #endif // __MOTIONINFO__

source/Lib/CommonLib/RdCost.h

@@ -179,7 +179,11 @@ public:
 
   inline Distortion getBvCostMultiplePreds(int x, int y, bool useIMV)
   {
+#if JVET_N0329_IBC_SEARCH_IMP
+    return Distortion(m_dCost * getBitsMultiplePreds(x, y, useIMV));
+#else
     return Distortion((m_dCost * getBitsMultiplePreds(x, y, useIMV)) / 65536.0);
+#endif
   }
 
   unsigned int    getBitsMultiplePreds(int x, int y, bool useIMV)

source/Lib/CommonLib/Slice.h

@@ -1828,6 +1828,9 @@ private:
   int                        m_apsId;
   APS*                       m_aps;
   bool                       m_tileGroupAlfEnabledFlag;
+#if JVET_N0329_IBC_SEARCH_IMP 
+  bool                       m_disableSATDForRd;
+#endif
   SliceReshapeInfo           m_sliceReshapeInfo;
 public:
                               Slice();
@@ -2114,7 +2117,10 @@ public:
 
   bool                        getTileGroupAlfEnabledFlag() const { return m_tileGroupAlfEnabledFlag; }
   void                        setTileGroupAlfEnabledFlag(bool b) { m_tileGroupAlfEnabledFlag = b; }
-
+#if JVET_N0329_IBC_SEARCH_IMP 
+  void                        setDisableSATDForRD(bool b) { m_disableSATDForRd = b; }
+  bool                        getDisableSATDForRD() { return m_disableSATDForRd; }
+#endif
   const SliceReshapeInfo&     getReshapeInfo() const { return m_sliceReshapeInfo; }
         SliceReshapeInfo&     getReshapeInfo()       { return m_sliceReshapeInfo; }
 protected:

source/Lib/CommonLib/TypeDef.h

@@ -58,6 +58,8 @@
 
 #define JVET_N0242_NON_LINEAR_ALF                         1 // enable CE5-3.2, Non-linear ALF based on clipping function
 
+#define JVET_N0329_IBC_SEARCH_IMP                         1 // IBC encoder-side improvement
+
 #define JVET_N0325_BDOF                                   1  // unified right-shifts for BDOF derivation
 
 #define JVET_N0449_MMVD_SIMP                              1 // Configurable number of mmvd distance entries used

source/Lib/CommonLib/UnitTools.cpp

@@ -2186,9 +2186,121 @@ bool PU::isDiffMER(const PredictionUnit &pu1, const PredictionUnit &pu2)
 
   return false;
 }
+
+#if JVET_N0329_IBC_SEARCH_IMP
+bool PU::isAddNeighborMv(const Mv& currMv, Mv* neighborMvs, int numNeighborMv)
+{
+  bool existed = false;
+  for (uint32_t cand = 0; cand < numNeighborMv && !existed; cand++)
+  {
+    if (currMv == neighborMvs[cand])
+    {
+      existed = true;
+    }
+  }
+
+  if (!existed)
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+#endif
+
+#if JVET_N0329_IBC_SEARCH_IMP
+void PU::getIbcMVPsEncOnly(PredictionUnit &pu, Mv* mvPred, int& nbPred)
+#else
 void PU::getIbcMVPsEncOnly(PredictionUnit &pu, Mv* MvPred, int& nbPred)
+#endif
 {
+#if JVET_N0329_IBC_SEARCH_IMP
+  const PreCalcValues   &pcv = *pu.cs->pcv;
+  const int  cuWidth = pu.blocks[COMPONENT_Y].width;
+  const int  cuHeight = pu.blocks[COMPONENT_Y].height;
+  const int  log2UnitWidth = g_aucLog2[pcv.minCUWidth];
+  const int  log2UnitHeight = g_aucLog2[pcv.minCUHeight];
+  const int  totalAboveUnits = (cuWidth >> log2UnitWidth) + 1;
+  const int  totalLeftUnits = (cuHeight >> log2UnitHeight) + 1;
+
+  nbPred = 0;
+  Position posLT = pu.Y().topLeft();
+
+  // above-left
+  const PredictionUnit *aboveLeftPU = pu.cs->getPURestricted(posLT.offset(-1, -1), pu, pu.cs->chType);
+  if (aboveLeftPU && CU::isIBC(*aboveLeftPU->cu))
+  {
+    if (isAddNeighborMv(aboveLeftPU->bv, mvPred, nbPred))
+    {
+      mvPred[nbPred++] = aboveLeftPU->bv;
+    }
+  }
+
+  // above neighbors
+  for (uint32_t dx = 0; dx < totalAboveUnits && nbPred < IBC_NUM_CANDIDATES; dx++)
+  {
+    const PredictionUnit* tmpPU = pu.cs->getPURestricted(posLT.offset((dx << log2UnitWidth), -1), pu, pu.cs->chType);
+    if (tmpPU && CU::isIBC(*tmpPU->cu))
+    {
+      if (isAddNeighborMv(tmpPU->bv, mvPred, nbPred))
+      {
+        mvPred[nbPred++] = tmpPU->bv;
+      }
+    }
+  }
+
+  // left neighbors
+  for (uint32_t dy = 0; dy < totalLeftUnits && nbPred < IBC_NUM_CANDIDATES; dy++)
+  {
+    const PredictionUnit* tmpPU = pu.cs->getPURestricted(posLT.offset(-1, (dy << log2UnitHeight)), pu, pu.cs->chType);
+    if (tmpPU && CU::isIBC(*tmpPU->cu))
+    {
+      if (isAddNeighborMv(tmpPU->bv, mvPred, nbPred))
+      {
+        mvPred[nbPred++] = tmpPU->bv;
+      }
+    }
+  }
+
+  size_t numAvaiCandInLUT = pu.cs->motionLut.lutIbc.size();
+  for (uint32_t cand = 0; cand < numAvaiCandInLUT && nbPred < IBC_NUM_CANDIDATES; cand++)
+  {
+    MotionInfo neibMi = pu.cs->motionLut.lutIbc[cand];
+    if (isAddNeighborMv(neibMi.bv, mvPred, nbPred))
+    {
+      mvPred[nbPred++] = neibMi.bv;
+    }
+  }
 
+  bool isBvCandDerived[IBC_NUM_CANDIDATES];
+  ::memset(isBvCandDerived, false, IBC_NUM_CANDIDATES);
+
+  int curNbPred = nbPred;
+  if (curNbPred < IBC_NUM_CANDIDATES)
+  {
+    do
+    {
+      curNbPred = nbPred;
+      for (uint32_t idx = 0; idx < curNbPred && nbPred < IBC_NUM_CANDIDATES; idx++)
+      {
+        if (!isBvCandDerived[idx])
+        {
+          Mv derivedBv;
+          if (getDerivedBV(pu, mvPred[idx], derivedBv))
+          {
+            if (isAddNeighborMv(derivedBv, mvPred, nbPred))
+            {
+              mvPred[nbPred++] = derivedBv;
+            }
+          }
+          isBvCandDerived[idx] = true;
+        }
+      }
+    } while (nbPred > curNbPred && nbPred < IBC_NUM_CANDIDATES);
+  }
+#else
   //-- Get Spatial MV
   Position posLT = pu.Y().topLeft();
   Position posRT = pu.Y().topRight();
@@ -2257,6 +2369,7 @@ void PU::getIbcMVPsEncOnly(PredictionUnit &pu, Mv* MvPred, int& nbPred)
     if (getDerivedBV(pu, MvPred[nbPred - 1], MvPred[nbPred]))
       nbPred++;
   }
+#endif
 }
 
 bool PU::getDerivedBV(PredictionUnit &pu, const Mv& currentMv, Mv& derivedMv)

source/Lib/CommonLib/UnitTools.h

@@ -184,7 +184,12 @@ namespace PU
   bool isUniqueTriangleCandidates     (const PredictionUnit &pu, MergeCtx &triangleMrgCtx);
   void spanTriangleMotionInfo         (      PredictionUnit &pu, MergeCtx &triangleMrgCtx, const bool splitDir, const uint8_t candIdx0, const uint8_t candIdx1);
   int32_t mappingRefPic               (const PredictionUnit &pu, int32_t refPicPoc, bool targetRefPicList);
+#if JVET_N0329_IBC_SEARCH_IMP
+  bool isAddNeighborMv  (const Mv& currMv, Mv* neighborMvs, int numNeighborMv);
+  void getIbcMVPsEncOnly(PredictionUnit &pu, Mv* mvPred, int& nbPred);
+#else
   void getIbcMVPsEncOnly(PredictionUnit &pu, Mv* MvPred, int& nbPred);
+#endif
   bool getDerivedBV(PredictionUnit &pu, const Mv& currentMv, Mv& derivedMv);
   bool isBlockVectorValid(PredictionUnit& pu, int xPos, int yPos, int width, int height, int picWidth, int picHeight, int xStartInCU, int yStartInCU, int xBv, int yBv, int ctuSize);
   bool checkDMVRCondition(const PredictionUnit& pu);

source/Lib/EncoderLib/EncCu.cpp

@@ -1803,7 +1803,11 @@ void EncCu::xCheckRDCostMerge2Nx2N( CodingStructure *&tempCS, CodingStructure *&
       PredictionUnit &pu  = tempCS->addPU( cu, partitioner.chType );
 
       DistParam distParam;
+#if JVET_N0329_IBC_SEARCH_IMP
+      const bool bUseHadamard = !encTestMode.lossless && !tempCS->slice->getDisableSATDForRD();
+#else
       const bool bUseHadamard= !encTestMode.lossless;
+#endif
       m_pcRdCost->setDistParam (distParam, tempCS->getOrgBuf().Y(), m_acMergeBuffer[0].Y(), sps.getBitDepth (CHANNEL_TYPE_LUMA), COMPONENT_Y, bUseHadamard);
 
       const UnitArea localUnitArea( tempCS->area.chromaFormat, Area( 0, 0, tempCS->area.Y().width, tempCS->area.Y().height) );
@@ -2308,7 +2312,11 @@ void EncCu::xCheckRDCostMergeTriangle2Nx2N( CodingStructure *&tempCS, CodingStru
   }
 
   DistParam distParam;
+#if JVET_N0329_IBC_SEARCH_IMP 
+  const bool useHadamard = !encTestMode.lossless && !tempCS->slice->getDisableSATDForRD();
+#else
   const bool useHadamard = !encTestMode.lossless;
+#endif
   m_pcRdCost->setDistParam( distParam, tempCS->getOrgBuf().Y(), m_acMergeBuffer[0].Y(), sps.getBitDepth( CHANNEL_TYPE_LUMA ), COMPONENT_Y, useHadamard );
 
   const UnitArea localUnitArea( tempCS->area.chromaFormat, Area( 0, 0, tempCS->area.Y().width, tempCS->area.Y().height) );
@@ -2627,7 +2635,11 @@ void EncCu::xCheckRDCostAffineMerge2Nx2N( CodingStructure *&tempCS, CodingStruct
       PredictionUnit &pu = tempCS->addPU( cu, partitioner.chType );
 
       DistParam distParam;
+#if JVET_N0329_IBC_SEARCH_IMP
+      const bool bUseHadamard = !encTestMode.lossless && !tempCS->slice->getDisableSATDForRD();
+#else
       const bool bUseHadamard = !encTestMode.lossless;
+#endif
       m_pcRdCost->setDistParam( distParam, tempCS->getOrgBuf().Y(), m_acMergeBuffer[0].Y(), sps.getBitDepth( CHANNEL_TYPE_LUMA ), COMPONENT_Y, bUseHadamard );
 
       const UnitArea localUnitArea( tempCS->area.chromaFormat, Area( 0, 0, tempCS->area.Y().width, tempCS->area.Y().height ) );
@@ -2887,7 +2899,11 @@ void EncCu::xCheckRDCostIBCModeMerge2Nx2N(CodingStructure *&tempCS, CodingStruct
       cu.mmvdSkip = false;
       cu.triangle = false;
       DistParam distParam;
+#if JVET_N0329_IBC_SEARCH_IMP
+      const bool bUseHadamard = !encTestMode.lossless && !cu.slice->getDisableSATDForRD();
+#else
       const bool bUseHadamard = !encTestMode.lossless;
+#endif
       PredictionUnit &pu = tempCS->addPU(cu, partitioner.chType); //tempCS->addPU(cu);
       pu.mmvdMergeFlag = false;
       Picture* refPic = pu.cu->slice->getPic();

source/Lib/EncoderLib/EncModeCtrl.cpp

@@ -1533,7 +1533,11 @@ bool EncModeCtrlMTnoRQT::tryMode( const EncTestMode& encTestmode, const CodingSt
     if( lastTestMode().type != ETM_INTRA && cuECtx.bestCS && cuECtx.bestCU && interHadActive( cuECtx ) )
     {
       // Get SATD threshold from best Inter-CU
+#if JVET_N0329_IBC_SEARCH_IMP
+      if (!cs.slice->isIRAP() && m_pcEncCfg->getUsePbIntraFast() && !cs.slice->getDisableSATDForRD())
+#else
       if( !cs.slice->isIRAP() && m_pcEncCfg->getUsePbIntraFast() )
+#endif
       {
         CodingUnit* bestCU = cuECtx.bestCU;
         if (bestCU && !CU::isIntra(*bestCU))

source/Lib/EncoderLib/EncSlice.cpp

@@ -738,6 +738,9 @@ void EncSlice::initEncSlice(Picture* pcPic, const int pocLast, const int pocCurr
     rpcSlice->setMaxBTSizeIChroma( rpcSlice->getSPS()->getMaxBTSizeIChroma() );
     rpcSlice->setMaxTTSizeIChroma( rpcSlice->getSPS()->getMaxTTSizeIChroma() );
   }
+#if JVET_N0329_IBC_SEARCH_IMP 
+  rpcSlice->setDisableSATDForRD(false);
+#endif
 }
 
 
@@ -1584,11 +1587,20 @@ void EncSlice::encodeCtus( Picture* pcPic, const bool bCompressEntireSlice, cons
   if ( pcSlice->getSPS()->getDisFracMmvdEnabledFlag() ||
       (pcSlice->getSPS()->getIBCFlag() && m_pcCuEncoder->getEncCfg()->getIBCHashSearch()))
   {
+#if JVET_N0329_IBC_SEARCH_IMP
+    m_pcCuEncoder->getIbcHashMap().rebuildPicHashMap(cs.picture->getTrueOrigBuf());
+    if (m_pcCfg->getIntraPeriod() != -1)
+    {
+      int hashBlkHitPerc = m_pcCuEncoder->getIbcHashMap().calHashBlkMatchPerc(cs.area.Y());
+      cs.slice->setDisableSATDForRD(hashBlkHitPerc > 59);
+    }
+#else
     if (pcSlice->getSPS()->getUseReshaper() && m_pcLib->getReshaper()->getCTUFlag() && pcSlice->getSPS()->getIBCFlag())
       cs.picture->getOrigBuf(COMPONENT_Y).rspSignal(m_pcLib->getReshaper()->getFwdLUT());
     m_pcCuEncoder->getIbcHashMap().rebuildPicHashMap( cs.picture->getOrigBuf() );
     if (pcSlice->getSPS()->getUseReshaper() && m_pcLib->getReshaper()->getCTUFlag() && pcSlice->getSPS()->getIBCFlag())
       cs.picture->getOrigBuf().copyFrom(cs.picture->getTrueOrigBuf());
+#endif
   }
   checkDisFracMmvd( pcPic, startCtuTsAddr, boundingCtuTsAddr );
   // for every CTU in the slice segment (may terminate sooner if there is a byte limit on the slice-segment)

source/Lib/EncoderLib/InterSearch.h

@@ -118,6 +118,9 @@ private:
   int             m_affMVListMaxSize;
   Distortion      m_hevcCost;
   EncAffineMotion m_affineMotion;
+#if JVET_N0329_IBC_SEARCH_IMP
+  PatentBvCand    m_defaultCachedBvs;
+#endif
 protected:
   // interface to option
   EncCfg*         m_pcEncCfg;
@@ -150,8 +153,14 @@ protected:
   Mv              m_integerMv2Nx2N              [NUM_REF_PIC_LIST_01][MAX_NUM_REF];
 
   bool            m_isInitialized;
+
+#if JVET_N0329_IBC_SEARCH_IMP
+  Mv              m_acBVs[2 * IBC_NUM_CANDIDATES];
+  unsigned int    m_numBVs;
+#else
   unsigned int    m_numBVs, m_numBV16s;
   Mv              m_acBVs[IBC_NUM_CANDIDATES];
+#endif
   bool            m_useCompositeRef;
   Distortion      m_estMinDistSbt[NUMBER_SBT_MODE + 1]; // estimated minimum SSE value of the PU if using a SBT mode
   uint8_t         m_sbtRdoOrder[NUMBER_SBT_MODE];       // order of SBT mode in RDO
@@ -281,7 +290,18 @@ public:
   bool  predIBCSearch           ( CodingUnit& cu, Partitioner& partitioner, const int localSearchRangeX, const int localSearchRangeY, IbcHashMap& ibcHashMap);
   void  xIntraPatternSearch         ( PredictionUnit& pu, IntTZSearchStruct&  cStruct, Mv& rcMv, Distortion&  ruiCost, Mv* cMvSrchRngLT, Mv* cMvSrchRngRB, Mv* pcMvPred);
   void  xSetIntraSearchRange        ( PredictionUnit& pu, int iRoiWidth, int iRoiHeight, const int localSearchRangeX, const int localSearchRangeY, Mv& rcMvSrchRngLT, Mv& rcMvSrchRngRB);
+#if JVET_N0329_IBC_SEARCH_IMP
+  void  resetIbcSearch()
+  {
+    for (int i = 0; i < IBC_NUM_CANDIDATES; i++)
+    {
+      m_defaultCachedBvs.m_bvCands[i].setZero();
+    }
+    m_defaultCachedBvs.currCnt = 0;
+  }
+#else
   void  resetIbcSearch() { m_numBVs = m_numBV16s = 0; }
+#endif
   void  xIBCEstimation   ( PredictionUnit& pu, PelUnitBuf& origBuf, Mv     *pcMvPred, Mv     &rcMv, Distortion &ruiCost, const int localSearchRangeX, const int localSearchRangeY);
   void  xIBCSearchMVCandUpdate  ( Distortion  uiSad, int x, int y, Distortion* uiSadBestCand, Mv* cMVCand);
   int   xIBCSearchMVChromaRefine( PredictionUnit& pu, int iRoiWidth, int iRoiHeight, int cuPelX, int cuPelY, Distortion* uiSadBestCand, Mv*     cMVCand);

source/Lib/EncoderLib/IntraSearch.cpp

@@ -678,7 +678,11 @@ void IntraSearch::estIntraPredLumaQT( CodingUnit &cu, Partitioner &partitioner,
     // after this point, don't use numModesForFullRD
 
     // PBINTRA fast
+#if JVET_N0329_IBC_SEARCH_IMP
+    if (m_pcEncCfg->getUsePbIntraFast() && !cs.slice->isIntra() && uiRdModeList.size() < numModesAvailable && !cs.slice->getDisableSATDForRD())
+#else
     if( m_pcEncCfg->getUsePbIntraFast() && !cs.slice->isIntra() && uiRdModeList.size() < numModesAvailable )
+#endif
     {
       if( CandHadList.size() < 3 || CandHadList[2] > cs.interHad * PBINTRA_RATIO )
       {
@@ -976,7 +980,11 @@ void IntraSearch::estIntraPredChromaQT( CodingUnit &cu, Partitioner &partitioner
       }
 
       DistParam distParam;
+#if JVET_N0329_IBC_SEARCH_IMP
+      const bool useHadamard = !cu.transQuantBypass;
+#else
       const bool useHadamard = true;
+#endif
       pu.intraDir[1] = MDLM_L_IDX; // temporary assigned, just to indicate this is a MDLM mode. for luma down-sampling operation.
 
       initIntraPatternChType(cu, pu.Cb());