JVET-O0050 encapsulated by JVET_O0050_LOCAL_DUAL_TREE

source/Lib/CommonLib/AdaptiveLoopFilter.cpp

@@ -1107,10 +1107,13 @@ void AdaptiveLoopFilter::filterBlk(AlfClassifier** classifier, const PelUnitBuf
           for( blkX=0; blkX<4; blkX+=2 )
           {
             Position pos(j + blkDst.x + blkX, i + blkDst.y + blkY);
-#if JVET_O0090_ALF_CHROMA_FILTER_ALTERNATIVES_CTB
+#if JVET_O0090_ALF_CHROMA_FILTER_ALTERNATIVES_CTB && !JVET_O0050_LOCAL_DUAL_TREE
             const CodingUnit* cu = isDualTree ? cs.getCU(pos, CH_C) : cs.getCU(recalcPosition(nChromaFormat, CH_C, CH_L, pos), CH_L);
 #else
             CodingUnit* cu = isDualTree ? cs.getCU(pos, CH_C) : cs.getCU(recalcPosition(nChromaFormat, CH_C, CH_L, pos), CH_L);
+#endif
+#if JVET_O0050_LOCAL_DUAL_TREE
+            cu = cu->isSepTree() ? cs.getCU( pos, CH_C ) : cu;
 #endif
             *flags++ = cu->ipcm ? 1 : 0;
           }

source/Lib/CommonLib/CodingStructure.cpp

@@ -86,7 +86,10 @@ CodingStructure::CodingStructure(CUCache& cuCache, PUCache& puCache, TUCache& tu
 
   m_motionBuf     = nullptr;
   features.resize( NUM_ENC_FEATURES );
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+  treeType = TREE_D;
+  modeType = MODE_TYPE_ALL;
+#endif
 }
 
 void CodingStructure::destroy()
@@ -183,14 +186,102 @@ void CodingStructure::setDecomp(const UnitArea &_area, const bool _isCoded /*= t
   }
 }
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+const int CodingStructure::signalModeCons( const PartSplit split, Partitioner &partitioner, const ModeType modeTypeParent ) const
+{
+  if( CS::isDualITree( *this ) || modeTypeParent != MODE_TYPE_ALL )
+    return 0;
+
+  int width = partitioner.currArea().lwidth();
+  int height = partitioner.currArea().lheight();
+
+  //0: not constrain
+  //1: constrain with intra, no need signaling the flag
+  //2: constrain with intra or inter, need signaling the flag
+  if( width * height == 64 )
+  {
+    if( split == CU_QUAD_SPLIT || split == CU_TRIH_SPLIT || split == CU_TRIV_SPLIT ) // qt or tt
+      return slice->isIntra() ? 1 : 1; //only intra mode allowed for child nodes (have 4x4)
+    else // bt
+      return slice->isIntra() ? 1 : 2;
+  }
+  else if( width * height == 128 )
+  {
+    if( split == CU_TRIH_SPLIT || split == CU_TRIV_SPLIT )
+      return slice->isIntra() ? 1 : 2;
+    else
+      return 0;
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+void CodingStructure::clearCuPuTuIdxMap( const UnitArea &_area, uint32_t numCu, uint32_t numPu, uint32_t numTu, uint32_t* pOffset )
+{
+  UnitArea clippedArea = clipArea( _area, *picture );
+  uint32_t numCh = ::getNumberValidChannels( _area.chromaFormat );
+  for( uint32_t i = 0; i < numCh; i++ )
+  {
+    const CompArea &_selfBlk = area.blocks[i];
+    const CompArea     &_blk = clippedArea.blocks[i];
+
+    const UnitScale& scale = unitScale[_blk.compID];
+    const Area scaledSelf = scale.scale( _selfBlk );
+    const Area scaledBlk = scale.scale( _blk );
+    const size_t offset = rsAddr( scaledBlk.pos(), scaledSelf.pos(), scaledSelf.width );
+    unsigned *idxPtrCU = m_cuIdx[i] + offset;
+    AreaBuf<uint32_t>( idxPtrCU, scaledSelf.width, scaledBlk.size() ).fill( 0 );
+
+    unsigned *idxPtrPU = m_puIdx[i] + offset;
+    AreaBuf<uint32_t>( idxPtrPU, scaledSelf.width, scaledBlk.size() ).fill( 0 );
+
+    unsigned *idxPtrTU = m_tuIdx[i] + offset;
+    AreaBuf<uint32_t>( idxPtrTU, scaledSelf.width, scaledBlk.size() ).fill( 0 );
+  }
+
+  //pop cu/pu/tus
+  for( int i = m_numTUs; i > numTu; i-- )
+  {
+    m_tuCache.cache( tus.back() );
+    tus.pop_back();
+    m_numTUs--;
+  }
+  for( int i = m_numPUs; i > numPu; i-- )
+  {
+    m_puCache.cache( pus.back() );
+    pus.pop_back();
+    m_numPUs--;
+  }
+  for( int i = m_numCUs; i > numCu; i-- )
+  {
+    m_cuCache.cache( cus.back() );
+    cus.pop_back();
+    m_numCUs--;
+  }
+  for( int i = 0; i < 3; i++ )
+  {
+    m_offsets[i] = pOffset[i];
+  }
+}
+#endif
 
 
 CodingUnit* CodingStructure::getCU( const Position &pos, const ChannelType effChType )
 {
   const CompArea &_blk = area.blocks[effChType];
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+  if( !_blk.contains( pos ) || (treeType == TREE_C && effChType == CHANNEL_TYPE_LUMA) )
+#else
   if( !_blk.contains( pos ) )
+#endif
   {
+#if JVET_O0050_LOCAL_DUAL_TREE
+    if( treeType == TREE_C && effChType == CHANNEL_TYPE_LUMA )
+      CHECK( parent->treeType != TREE_D, "wrong parent treeType " );
+#endif
     if( parent ) return parent->getCU( pos, effChType );
     else         return nullptr;
   }
@@ -207,8 +298,16 @@ const CodingUnit* CodingStructure::getCU( const Position &pos, const ChannelType
 {
   const CompArea &_blk = area.blocks[effChType];
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+  if( !_blk.contains( pos ) || (treeType == TREE_C && effChType == CHANNEL_TYPE_LUMA) )
+#else
   if( !_blk.contains( pos ) )
+#endif
   {
+#if JVET_O0050_LOCAL_DUAL_TREE
+    if( treeType == TREE_C && effChType == CHANNEL_TYPE_LUMA )
+      CHECK( parent->treeType != TREE_D, "wrong parent treeType" );
+#endif
     if( parent ) return parent->getCU( pos, effChType );
     else         return nullptr;
   }
@@ -289,6 +388,10 @@ TransformUnit* CodingStructure::getTU( const Position &pos, const ChannelType ef
             while( !tus[idx - 1 + extraIdx]->blocks[getFirstComponentOfChannel( effChType )].contains( pos ) )
             {
               extraIdx++;
+#if JVET_O0050_LOCAL_DUAL_TREE
+              CHECK( tus[idx - 1 + extraIdx]->cu->treeType == TREE_C, "tu searched by position points to a chroma tree CU" );
+              CHECK( extraIdx > 3, "extraIdx > 3" );
+#endif
             }
           }
         }
@@ -330,6 +433,10 @@ const TransformUnit * CodingStructure::getTU( const Position &pos, const Channel
             while ( !tus[idx - 1 + extraIdx]->blocks[getFirstComponentOfChannel( effChType )].contains(pos) )
             {
               extraIdx++;
+#if JVET_O0050_LOCAL_DUAL_TREE
+              CHECK( tus[idx - 1 + extraIdx]->cu->treeType == TREE_C, "tu searched by position points to a chroma tree CU" );
+              CHECK( extraIdx > 3, "extraIdx > 3" );
+#endif
             }
           }
         }
@@ -355,6 +462,10 @@ CodingUnit& CodingStructure::addCU( const UnitArea &unit, const ChannelType chTy
   cu->firstTU   = nullptr;
   cu->lastTU    = nullptr;
   cu->chType    = chType;
+#if JVET_O0050_LOCAL_DUAL_TREE
+  cu->treeType = treeType;
+  cu->modeType = modeType;
+#endif
 
   CodingUnit *prevCU = m_numCUs > 0 ? cus.back() : nullptr;
 
@@ -551,8 +662,45 @@ CUTraverser CodingStructure::traverseCUs( const UnitArea& unit, const ChannelTyp
 {
   CodingUnit* firstCU = getCU( isLuma( effChType ) ? unit.lumaPos() : unit.chromaPos(), effChType );
   CodingUnit* lastCU = firstCU;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+  if( !CS::isDualITree( *this ) ) //for a more generalized separate tree
+  {
+    bool bContinue = true;
+    CodingUnit* currCU = firstCU;
+    while( bContinue )
+    {
+      if( currCU == nullptr )
+      {
+        bContinue = false;
+        lastCU = currCU;
+      }
+      else if( currCU->chType != effChType )
+      {
+        lastCU = currCU;
+        currCU = currCU->next;
+      }
+      else
+      {
+        if( unit.contains( *currCU ) )
+        {
+          lastCU = currCU;
+          currCU = currCU->next;
+        }
+        else
+        {
+          bContinue = false;
+          lastCU = currCU;
+        }
+      }
+    }
+  }
+  else
+  {
+#endif
   do { } while( lastCU && ( lastCU = lastCU->next ) && unit.contains( *lastCU ) );
+#if JVET_O0050_LOCAL_DUAL_TREE
+  }
+#endif
 
   return CUTraverser( firstCU, lastCU );
 }
@@ -784,6 +932,11 @@ void CodingStructure::initSubStructure( CodingStructure& subStruct, const Channe
 
   subStruct.motionLut = motionLut;
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+  subStruct.treeType  = treeType;
+  subStruct.modeType  = modeType;
+#endif
+
   subStruct.initStructData( currQP[_chType], isLossless );
 
   if( isTuEnc )
@@ -872,8 +1025,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
         {
           // add an analogue CU into own CU store
           const UnitArea &cuPatch = *pcu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+          CodingUnit &cu = addCU( cuPatch, pcu->chType );
+#else
           CodingUnit &cu = addCU( cuPatch, chType );
+#endif
 
           // copy the CU info from subPatch
           cu = *pcu;
@@ -891,8 +1047,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
         {
           // add an analogue PU into own PU store
           const UnitArea &puPatch = *ppu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+          PredictionUnit &pu = addPU( puPatch, ppu->chType );
+#else   
           PredictionUnit &pu = addPU( puPatch, chType );
+#endif
 
           // copy the PU info from subPatch
           pu = *ppu;
@@ -903,8 +1062,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
       {
         // add an analogue TU into own TU store
         const UnitArea &tuPatch = *ptu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+        TransformUnit &tu = addTU( tuPatch, ptu->chType );
+#else
         TransformUnit &tu = addTU( tuPatch, chType );
+#endif
 
         // copy the TU info from subPatch
         tu = *ptu;
@@ -936,8 +1098,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
     {
       // add an analogue CU into own CU store
       const UnitArea &cuPatch = *pcu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+      CodingUnit &cu = addCU( cuPatch, pcu->chType );
+#else
       CodingUnit &cu = addCU( cuPatch, chType );
+#endif
 
       // copy the CU info from subPatch
       cu = *pcu;
@@ -955,8 +1120,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
     {
       // add an analogue PU into own PU store
       const UnitArea &puPatch = *ppu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+      PredictionUnit &pu = addPU( puPatch, ppu->chType );
+#else   
       PredictionUnit &pu = addPU( puPatch, chType );
+#endif
 
       // copy the PU info from subPatch
       pu = *ppu;
@@ -967,8 +1135,11 @@ void CodingStructure::useSubStructure( const CodingStructure& subStruct, const C
   {
     // add an analogue TU into own TU store
     const UnitArea &tuPatch = *ptu;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+    TransformUnit &tu = addTU( tuPatch, ptu->chType );
+#else
     TransformUnit &tu = addTU( tuPatch, chType );
+#endif
 
     // copy the TU info from subPatch
     tu = *ptu;
@@ -1420,7 +1591,11 @@ IbcLumaCoverage CodingStructure::getIbcLumaCoverage(const CompArea& chromaArea)
     for (SizeType x = 0; x < lumaArea.width; x += MIN_PU_SIZE)
     {
       Position pos = lumaArea.offset(x, y);
+#if JVET_O0050_LOCAL_DUAL_TREE
+      if (picture->cs->getMotionInfo(pos).isInter && picture->cs->getMotionInfo(pos).isIBCmot)
+#else
       if (picture->cs->getMotionInfo(pos).isInter) // need to change if inter slice allows dualtree
+#endif
       {
         ibcArea += unitAreaSubBlock;
       }

source/Lib/CommonLib/CodingStructure.h

@@ -171,6 +171,10 @@ public:
   uint64_t      fracBits;
   Distortion  dist;
   Distortion  interHad;
+#if JVET_O0050_LOCAL_DUAL_TREE
+  TreeType    treeType; //because partitioner can not go deep to tu and cu coding (e.g., addCU()), need another variable for indicating treeType
+  ModeType    modeType;
+#endif
 
   void initStructData  (const int &QP = MAX_INT, const bool &_isLosses = false, const bool &skipMotBuf = false);
   void initSubStructure(      CodingStructure& cs, const ChannelType chType, const UnitArea &subArea, const bool &isTuEnc);
@@ -182,6 +186,15 @@ public:
   void clearTUs();
   void clearPUs();
   void clearCUs();
+#if JVET_O0050_LOCAL_DUAL_TREE
+  const int signalModeCons( const PartSplit split, Partitioner &partitioner, const ModeType modeTypeParent ) const;
+  void clearCuPuTuIdxMap  ( const UnitArea &_area, uint32_t numCu, uint32_t numPu, uint32_t numTu, uint32_t* pOffset );
+  void getNumCuPuTuOffset ( uint32_t* pArray )
+  {
+    pArray[0] = m_numCUs;     pArray[1] = m_numPUs;     pArray[2] = m_numTUs;
+    pArray[3] = m_offsets[0]; pArray[4] = m_offsets[1]; pArray[5] = m_offsets[2];
+  }
+#endif
 
 
 private:

source/Lib/CommonLib/CommonDef.h

@@ -447,6 +447,10 @@ static const int SBT_MAX_SIZE =                                    64; ///< maxi
 static const int SBT_NUM_SL =                                      10; ///< maximum number of historical PU decision saved for a CU
 static const int SBT_NUM_RDO =                                      2; ///< maximum number of SBT mode tried for a PU
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+static const int NUM_INTER_CU_INFO_SAVE =                           8; ///< maximum number of inter cu information saved for fast algorithm
+#endif
+
 static const int IBC_MAX_CAND_SIZE = 16; // max block size for ibc search
 static const int IBC_NUM_CANDIDATES = 64; ///< Maximum number of candidates to store/test
 static const int CHROMA_REFINEMENT_CANDIDATES = 8; /// 8 candidates BV to choose from

source/Lib/CommonLib/ContextModelling.cpp

@@ -134,7 +134,24 @@ void CoeffCodingContext::initSubblock( int SubsetId, bool sigGroupFlag )
 }
 
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+unsigned DeriveCtx::CtxModeConsFlag( const CodingStructure& cs, Partitioner& partitioner )
+{
+  assert( partitioner.chType == CHANNEL_TYPE_LUMA );
+  const Position pos = partitioner.currArea().blocks[partitioner.chType];
+  const unsigned curSliceIdx = cs.slice->getIndependentSliceIdx();
+  const unsigned curTileIdx = cs.picture->brickMap->getBrickIdxRsMap( partitioner.currArea().lumaPos() );
+
+  // get left depth
+  const CodingUnit* cuLeft = cs.getCURestricted( pos.offset( -1, 0 ), pos, curSliceIdx, curTileIdx, partitioner.chType );
+
+  // get above depth
+  const CodingUnit* cuAbove = cs.getCURestricted( pos.offset( 0, -1 ), pos, curSliceIdx, curTileIdx, partitioner.chType );
 
+  unsigned ctxId = ((cuAbove && cuAbove->predMode == MODE_INTRA) || (cuLeft && cuLeft->predMode == MODE_INTRA)) ? 1 : 0;
+  return ctxId;
+}
+#endif
 
 
 void DeriveCtx::CtxSplit( const CodingStructure& cs, Partitioner& partitioner, unsigned& ctxSpl, unsigned& ctxQt, unsigned& ctxHv, unsigned& ctxHorBt, unsigned& ctxVerBt, bool* _canSplit /*= nullptr */ )

source/Lib/CommonLib/ContextModelling.h

@@ -501,6 +501,9 @@ public:
 namespace DeriveCtx
 {
 void     CtxSplit     ( const CodingStructure& cs, Partitioner& partitioner, unsigned& ctxSpl, unsigned& ctxQt, unsigned& ctxHv, unsigned& ctxHorBt, unsigned& ctxVerBt, bool* canSplit = nullptr );
+#if JVET_O0050_LOCAL_DUAL_TREE
+unsigned CtxModeConsFlag( const CodingStructure& cs, Partitioner& partitioner );
+#endif
 #if JVET_O0193_REMOVE_TR_DEPTH_IN_CBF_CTX
 unsigned CtxQtCbf     ( const ComponentID compID, const bool prevCbf = false, const int ispIdx = 0 );
 #else

source/Lib/CommonLib/Contexts.cpp

@@ -240,6 +240,16 @@ const CtxSet ContextSetCfg::Split12Flag = ContextSetCfg::addCtxSet
   {  12,  12,  12,  12, },
 });
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+const CtxSet ContextSetCfg::ModeConsFlag = ContextSetCfg::addCtxSet
+({
+  { 192, 168, },
+  { 179, 139, },
+  { CNU, CNU, },
+  {   5,   2, },
+});
+#endif
+
 const CtxSet ContextSetCfg::SkipFlag = ContextSetCfg::addCtxSet
 ({
   { 197, 214, 216, },

source/Lib/CommonLib/Contexts.h

@@ -201,6 +201,9 @@ public:
   static const CtxSet   SplitQtFlag;
   static const CtxSet   SplitHvFlag;
   static const CtxSet   Split12Flag;
+#if JVET_O0050_LOCAL_DUAL_TREE
+  static const CtxSet   ModeConsFlag;
+#endif
   static const CtxSet   SkipFlag;
   static const CtxSet   MergeFlag;
   static const CtxSet   RegularMergeFlag;

source/Lib/CommonLib/LoopFilter.cpp

@@ -655,7 +655,11 @@ unsigned LoopFilter::xGetBoundaryStrengthSingle ( const CodingUnit& cu, const De
   }
 
   const TransformUnit& tuQ = *cuQ.cs->getTU(posQ, cuQ.chType);
+#if JVET_O0050_LOCAL_DUAL_TREE
+  const TransformUnit& tuP = *cuP.cs->getTU(posP, cuQ.chType); //based on chType of the current cu, because cuQ.chType and cuP.chType are not the same when local dual-tree is applied
+#else
   const TransformUnit& tuP = *cuP.cs->getTU(posP, cuP.chType);
+#endif
   const PreCalcValues& pcv = *cu.cs->pcv;
   const unsigned rasterIdx = getRasterIdx( Position{ localPos.x,  localPos.y }, pcv );
   if (m_aapucBS[edgeDir][rasterIdx] && (cuP.firstPU->mhIntraFlag || cuQ.firstPU->mhIntraFlag))

source/Lib/CommonLib/TypeDef.h

@@ -89,6 +89,7 @@
 #define JVET_N0288_PROPOSAL1                              1   // JVET-N0288 Proposal 1
 
 #define JVET_O0090_ALF_CHROMA_FILTER_ALTERNATIVES_CTB     1 // JVET-O0090 test 2: CTB selection of ALF alternative chroma filters
+#define JVET_O0050_LOCAL_DUAL_TREE                        1 // JVET-O0050: avoid small intra chroma block by a "local dual-tree" technique
 
 #define JVET_O0216_ALF_COEFF_EG3                          1 // JVET-O0216/O0302/O0648: using EG3 for ALF coefficients coding
 
@@ -381,6 +382,9 @@ typedef       uint32_t            Intermediate_UInt; ///< used as intermediate v
 #endif
 
 typedef       uint64_t          SplitSeries;       ///< used to encoded the splits that caused a particular CU size
+#if JVET_O0050_LOCAL_DUAL_TREE
+typedef       uint64_t          ModeTypeSeries;    ///< used to encoded the ModeType at different split depth
+#endif
 
 typedef       uint64_t        Distortion;        ///< distortion measurement
 
@@ -502,6 +506,22 @@ enum ChannelType
   MAX_NUM_CHANNEL_TYPE = 2
 };
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+enum TreeType
+{
+  TREE_D = 0, //default tree status (for single-tree slice, TREE_D means joint tree; for dual-tree I slice, TREE_D means TREE_L for luma and TREE_C for chroma)
+  TREE_L = 1, //separate tree only contains luma (may split)
+  TREE_C = 2, //separate tree only contains chroma (not split), to avoid small chroma block
+};
+
+enum ModeType
+{
+  MODE_TYPE_ALL = 0, //all modes can try
+  MODE_TYPE_INTER = 1, //can try inter
+  MODE_TYPE_INTRA = 2, //can try intra, ibc, palette
+};
+#endif
+
 #define CH_L CHANNEL_TYPE_LUMA
 #define CH_C CHANNEL_TYPE_CHROMA
 

source/Lib/CommonLib/Unit.cpp

@@ -287,7 +287,11 @@ CodingUnit& CodingUnit::operator=( const CodingUnit& other )
   smvdMode        = other.smvdMode;
   ispMode           = other.ispMode;
   mipFlag           = other.mipFlag;
-
+#if JVET_O0050_LOCAL_DUAL_TREE
+  treeType          = other.treeType;
+  modeType          = other.modeType;
+  modeTypeSeries    = other.modeTypeSeries;
+#endif
   return *this;
 }
 
@@ -325,14 +329,30 @@ void CodingUnit::initData()
   smvdMode        = 0;
   ispMode           = 0;
   mipFlag           = false;
+#if JVET_O0050_LOCAL_DUAL_TREE
+  treeType          = TREE_D;
+  modeType          = MODE_TYPE_ALL;
+  modeTypeSeries    = 0;
+#endif
+}
+
+#if JVET_O0050_LOCAL_DUAL_TREE
+const bool CodingUnit::isSepTree() const
+{
+  return treeType != TREE_D || CS::isDualITree( *cs );
 }
+#endif
 
 #if JVET_O1124_ALLOW_CCLM_COND
 const bool CodingUnit::checkCCLMAllowed() const
 {
   bool allowCCLM = false;
 
-  if( chType != CHANNEL_TYPE_CHROMA ) //single tree
+#if JVET_O0050_LOCAL_DUAL_TREE
+  if( !CS::isDualITree( *cs ) ) //single tree I slice or non-I slice (Note: judging chType is no longer equivalent to checking dual-tree I slice since the local dual-tree is introduced)
+#else
+  if( chType != CHANNEL_TYPE_CHROMA ) //single tree I slice or non-I slice
+#endif
   {
     allowCCLM = true;
   }

source/Lib/CommonLib/Unit.h

@@ -298,6 +298,11 @@ struct CodingUnit : public UnitArea
   int8_t          chromaQpAdj;
   int8_t          qp;
   SplitSeries    splitSeries;
+#if JVET_O0050_LOCAL_DUAL_TREE
+  TreeType       treeType;
+  ModeType       modeType;
+  ModeTypeSeries modeTypeSeries;
+#endif
   bool           skip;
   bool           mmvdSkip;
   bool           affine;
@@ -353,6 +358,11 @@ struct CodingUnit : public UnitArea
 #if JVET_O1124_ALLOW_CCLM_COND
   const bool        checkCCLMAllowed() const;
 #endif
+#if JVET_O0050_LOCAL_DUAL_TREE
+  const bool        isSepTree() const;
+  const bool        isConsInter() const { return modeType == MODE_TYPE_INTER; }
+  const bool        isConsIntra() const { return modeType == MODE_TYPE_INTRA; }
+#endif
 };
 
 // ---------------------------------------------------------------------------

source/Lib/CommonLib/UnitPartitioner.cpp

@@ -106,6 +106,29 @@ SplitSeries Partitioner::getSplitSeries() const
   return splitSeries;
 }
 
+#if JVET_O0050_LOCAL_DUAL_TREE
+ModeTypeSeries Partitioner::getModeTypeSeries() const
+{
+  ModeTypeSeries modeTypeSeries = 0;
+  int depth = 0;
+
+  for( const auto &level : m_partStack )
+  {
+    if( level.split == CTU_LEVEL ) continue;
+    else modeTypeSeries += static_cast<int>(level.modeType) << (depth * 3);
+
+    depth++;
+  }
+
+  return modeTypeSeries;
+}
+
+bool Partitioner::isSepTree( const CodingStructure &cs )
+{
+  return treeType != TREE_D || CS::isDualITree( cs );
+}
+#endif
+
 void Partitioner::setCUData( CodingUnit& cu )
 {
   cu.depth       = currDepth;
@@ -113,6 +136,9 @@ void Partitioner::setCUData( CodingUnit& cu )
   cu.mtDepth     = currMtDepth;
   cu.qtDepth     = currQtDepth;
   cu.splitSeries = getSplitSeries();
+#if JVET_O0050_LOCAL_DUAL_TREE
+  cu.modeTypeSeries = getModeTypeSeries();
+#endif
 }
 
 void Partitioner::copyState( const Partitioner& other )
@@ -234,6 +260,10 @@ void QTBTPartitioner::initCtu( const UnitArea& ctuArea, const ChannelType _chTyp
 
   m_partStack.clear();
   m_partStack.push_back( PartLevel( CTU_LEVEL, Partitioning{ ctuArea } ) );
+#if JVET_O0050_LOCAL_DUAL_TREE
+  treeType = TREE_D;
+  modeType = MODE_TYPE_ALL;
+#endif
 }
 
 void QTBTPartitioner::splitCurrArea( const PartSplit split, const CodingStructure& cs )
@@ -249,14 +279,23 @@ void QTBTPartitioner::splitCurrArea( const PartSplit split, const CodingStructur