Changeset 1039 in 3DVCSoftware for trunk/source/Lib/TLibCommon

Timestamp:

4 Aug 2014, 11:36:05 (10 years ago)

Author:

tech

Message:

Merged 11.2-dev0@1038.

Location:

trunk/source/Lib/TLibCommon

Files:

• ContextTables.h (modified) (3 diffs)
• TComDataCU.cpp (modified) (29 diffs)
• TComDataCU.h (modified) (7 diffs)
• TComMotionInfo.h (modified) (1 diff)
• TComPrediction.cpp (modified) (30 diffs)
• TComPrediction.h (modified) (2 diffs)
• TComRom.cpp (modified) (4 diffs)
• TComRom.h (modified) (1 diff)
• TComSlice.cpp (modified) (9 diffs)
• TComSlice.h (modified) (13 diffs)
• TComWedgelet.cpp (modified) (6 diffs)
• TComWedgelet.h (modified) (4 diffs)
• TComYuv.cpp (modified) (6 diffs)
• TypeDef.h (modified) (12 diffs)

trunk/source/Lib/TLibCommon/ContextTables.h

@@ -51 +51 @@
 #define NUM_SPLIT_FLAG_CTX            3       ///< number of context models for split flag
 #define NUM_SKIP_FLAG_CTX             3       ///< number of context models for skip flag
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+#define NUM_SINGLEDEPTH_FLAG_CTX                     1
+#define NUM_SINGLE_DEPTH_VALUE_DATA_CTX              1       
+#endif
 #define NUM_MERGE_FLAG_EXT_CTX        1       ///< number of context models for merge flag of merge extended
 #define NUM_MERGE_IDX_EXT_CTX         1       ///< number of context models for merge index of merge extended
@@ -150 +153 @@
   { CNU,  CNU,  CNU, }, 
 };
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+static const UChar 
+INIT_SINGLEDEPTH_FLAG[3][NUM_SINGLEDEPTH_FLAG_CTX] =  
+{
+  { 185 }, 
+  { 185 }, 
+  { 185 }, 
+};
+static const UChar
+INIT_SINGLE_DEPTH_VALUE_DATA[3][NUM_SINGLE_DEPTH_VALUE_DATA_CTX] = 
+{
+  { 137 }, 
+  { 137 }, 
+  { 137 }, 
+};
+#endif
 static const UChar
 INIT_MERGE_FLAG_EXT[3][NUM_MERGE_FLAG_EXT_CTX] = 
@@ -432 +450 @@
 static const UChar INIT_DBBP_FLAG[3][DBBP_NUM_FLAG_CTX] =
 {
+#if SEC_DBBP_EXPLICIT_SIG_I0077
+  { CNU },
+  { CNU },
+  { CNU },
+#else
   { 161 },
   { 161 },
   { 161 },
-};
-#endif
-
-#endif
+#endif
+};
+#endif
+
+#endif

trunk/source/Lib/TLibCommon/TComDataCU.cpp

@@ -60 +60 @@
   
   m_skipFlag           = NULL;
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  m_singleDepthFlag     = NULL;
+  m_apSingleDepthValue  = NULL;
+#endif  
   m_pePartSize         = NULL;
   m_pePredMode         = NULL;
@@ -182 +185 @@
 
     m_skipFlag           = new Bool[ uiNumPartition ];
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+    m_singleDepthFlag     = new Bool[ uiNumPartition ];
+    m_apSingleDepthValue  = (Pel*)xMalloc(Pel, uiNumPartition);
+#endif
     m_pePartSize         = new Char[ uiNumPartition ];
     memset( m_pePartSize, SIZE_NONE,uiNumPartition * sizeof( *m_pePartSize ) );
@@ -329 +335 @@
 
     if ( m_skipFlag           ) { delete[] m_skipFlag;          m_skipFlag          = NULL; }
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+    if ( m_singleDepthFlag    ) { delete[] m_singleDepthFlag;   m_singleDepthFlag     = NULL; }
+    if ( m_apSingleDepthValue ) { xFree(m_apSingleDepthValue);  m_apSingleDepthValue  = NULL; }
+#endif
     if ( m_pePartSize         ) { delete[] m_pePartSize;        m_pePartSize        = NULL; }
     if ( m_pePredMode         ) { delete[] m_pePredMode;        m_pePredMode        = NULL; }
@@ -494 +503 @@
     TComDataCU * pcFrom = pcPic->getCU(getAddr());
     m_skipFlag[ui]   = pcFrom->getSkipFlag(ui);
+#if MTK_SINGLE_DEPTH_MODE_I0095
+    m_singleDepthFlag[ui]    = pcFrom->getSingleDepthFlag(ui);
+    m_apSingleDepthValue[ui] = pcFrom->getSingleDepthValue(ui);
+#endif
     m_pePartSize[ui] = pcFrom->getPartitionSize(ui);
     m_pePredMode[ui] = pcFrom->getPredictionMode(ui);
@@ -550 +563 @@
   {
     memset( m_skipFlag          + firstElement, false,                    numElements * sizeof( *m_skipFlag ) );
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+    memset( m_singleDepthFlag     + firstElement, false,                  numElements * sizeof( *m_singleDepthFlag ) );
+    memset( m_apSingleDepthValue  + firstElement,     0,                  numElements * sizeof( *m_apSingleDepthValue ) );
+#endif
     memset( m_pePartSize        + firstElement, SIZE_NONE,                numElements * sizeof( *m_pePartSize ) );
     memset( m_pePredMode        + firstElement, MODE_NONE,                numElements * sizeof( *m_pePredMode ) );
@@ -738 +754 @@
       m_puhTransformSkip[2][ui] = 0;
       m_skipFlag[ui]   = false;
+#if MTK_SINGLE_DEPTH_MODE_I0095
+      m_singleDepthFlag[ui]     = false;
+      m_apSingleDepthValue[ui]  = 0;
+#endif
       m_pePartSize[ui] = SIZE_NONE;
       m_pePredMode[ui] = MODE_NONE;
@@ -913 +933 @@
   {
     m_skipFlag[ui]   = false;
+#if MTK_SINGLE_DEPTH_MODE_I0095
+    m_singleDepthFlag[ui]   = false;
+    m_apSingleDepthValue[ui]= 0;
+#endif
     m_pePartSize[ui] = SIZE_NONE;
     m_pePredMode[ui] = MODE_NONE;
@@ -934 +958 @@
       m_puhTransformSkip[2][ui] = pcCU->getTransformSkip(uiPartOffset+ui,TEXT_CHROMA_V);
       m_skipFlag[ui]   = pcCU->getSkipFlag(uiPartOffset+ui);
+#if MTK_SINGLE_DEPTH_MODE_I0095
+      m_singleDepthFlag[ui]    = pcCU->getSingleDepthFlag(uiPartOffset+ui);
+      m_apSingleDepthValue[ui] = pcCU->getSingleDepthValue(uiPartOffset+ui);
+#endif
       m_pePartSize[ui] = pcCU->getPartitionSize(uiPartOffset+ui);
       m_pePredMode[ui] = pcCU->getPredictionMode(uiPartOffset+ui);
@@ -1083 +1111 @@
   
   m_skipFlag=pcCU->getSkipFlag()          + uiPart;
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  m_singleDepthFlag     = pcCU->getSingleDepthFlag()   + uiPart;
+  m_apSingleDepthValue  = pcCU->getSingleDepthValue()  + uiPart;
+#endif  
   m_phQP=pcCU->getQP()                    + uiPart;
   m_pePartSize = pcCU->getPartitionSize() + uiPart;
@@ -1221 +1252 @@
   
   m_skipFlag           = pcCU->getSkipFlag ()             + uiAbsPartIdx;
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  m_singleDepthFlag     = pcCU->getSingleDepthFlag ()             + uiAbsPartIdx;
+  m_apSingleDepthValue  = pcCU->getSingleDepthValue ()            + uiAbsPartIdx;
+#endif  
   m_pePartSize         = pcCU->getPartitionSize ()        + uiAbsPartIdx;
 #if H_3D_NBDV
@@ -1297 +1331 @@
   Int sizeInChar  = sizeof( Char ) * uiNumPartition;
   memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  memcpy( m_singleDepthFlag     + uiOffset, pcCU->getSingleDepthFlag(),       sizeof( *m_singleDepthFlag )   * uiNumPartition );
+  memcpy( m_apSingleDepthValue  + uiOffset, pcCU->getSingleDepthValue(),      sizeof( *m_apSingleDepthValue ) * uiNumPartition);
+#endif
   memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
   memcpy( m_pePartSize + uiOffset, pcCU->getPartitionSize(),  sizeof( *m_pePartSize ) * uiNumPartition );
@@ -1417 +1455 @@
 
   memcpy( rpcCU->getSkipFlag() + m_uiAbsIdxInLCU, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  memcpy( rpcCU->getSingleDepthFlag()  + m_uiAbsIdxInLCU, m_singleDepthFlag,    sizeof( *m_singleDepthFlag ) * m_uiNumPartition );
+  memcpy( rpcCU->getSingleDepthValue() + m_uiAbsIdxInLCU, m_apSingleDepthValue, sizeof( *m_apSingleDepthValue ) * m_uiNumPartition);
+#endif
   memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, sizeInChar  );
 #if H_3D_NBDV
@@ -1533 +1574 @@
   Int sizeInChar  = sizeof( Char ) * uiQNumPart;
   memcpy( rpcCU->getSkipFlag()       + uiPartOffset, m_skipFlag,   sizeof( *m_skipFlag )   * uiQNumPart );
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  memcpy( rpcCU->getSingleDepthFlag()  + uiPartOffset, m_singleDepthFlag,    sizeof( *m_singleDepthFlag )   * uiQNumPart );
+  memcpy( rpcCU->getSingleDepthValue() + uiPartOffset, m_apSingleDepthValue, sizeof( *m_apSingleDepthValue ) * uiQNumPart);
+#endif
   memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, sizeInChar );
   memcpy( rpcCU->getPartitionSize()  + uiPartOffset, m_pePartSize, sizeof( *m_pePartSize ) * uiQNumPart );
@@ -2453 +2497 @@
   memset( m_skipFlag + absPartIdx, skip, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
 }
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+Void TComDataCU::setSingleDepthFlagSubParts( Bool singleDepth, UInt absPartIdx, UInt depth )
+{
+  assert( sizeof( *m_singleDepthFlag) == 1 );
+  memset( m_singleDepthFlag + absPartIdx, singleDepth, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
+}
+
+Void TComDataCU::setSingleDepthValueSubParts(Pel singleDepthValue, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth )
+{
+  setSubPartT<Pel>( singleDepthValue, m_apSingleDepthValue, uiAbsPartIdx, uiDepth, uiPUIdx );
+}
+#endif
 Void TComDataCU::setPredModeSubParts( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth )
 {
@@ -2622 +2677 @@
   }
 
+#if HS_DMM_SIGNALLING_I0120
+  if( isDimMode( getLumaIntraDir( uiAbsPartIdx ) ) )
+#else
   if( isDimMode( getLumaIntraDir( uiAbsPartIdx ) ) && !isDimDeltaDC( getLumaIntraDir( uiAbsPartIdx ) ) )
+#endif
   {
     return true;
@@ -2635 +2694 @@
   // check prediction mode
   UInt uiLumaPredMode = getLumaIntraDir( uiAbsPartIdx );  
+#if HS_DMM_SIGNALLING_I0120
+  if( uiLumaPredMode == PLANAR_IDX || ( getDimType( uiLumaPredMode ) == DMM1_IDX  ) )
+#else
   if( uiLumaPredMode == PLANAR_IDX || ( getDimType( uiLumaPredMode ) == DMM1_IDX && !isDimDeltaDC( uiLumaPredMode ) ) )
+#endif
     return true;
   
@@ -3310 +3373 @@
   for(Int iLoop = 0; iLoop < 2; iLoop ++ ) 
   {
+#if !SEC_SIMP_SHIFTED_DV_I0086
     // IvDcShift (Derived from spatial Iv neighboring blocks)
     if( iLoop == 1 )
@@ -3343 +3407 @@
       }
     }
+#endif
 
     /// iLoop = 0 --> IvMCShift
@@ -3390 +3455 @@
 } 
 
+#if !SEC_SIMP_SHIFTED_DV_I0086
 inline Bool TComDataCU::xGetPosFirstAvailDmvCand(Int iCount, Int& posFirstAvailDmvCand )
 {
@@ -3406 +3472 @@
   return false;  
 }
+#endif
                                       
 #endif
@@ -3854 +3921 @@
 Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours
 #endif
-#if H_3D_VSP
+#if H_3D_VSP && !FIX_TICKET_79
       , InheritedVSPDisInfo*  inheritedVSPDisInfo
 #endif
@@ -3884 +3951 @@
   //////////////////////////////////
   DisInfo cDisInfo = getDvInfo(uiAbsPartIdx);
+#if !FIX_TICKET_79
   for(Int i = 0; i < MRG_MAX_NUM_CANDS_MEM; i++)
   {
     inheritedVSPDisInfo[i].m_acDvInfo = cDisInfo;   // To prevent run-time error, this code must be executed always for merging process.
   }
+#endif
   m_cDefaultDisInfo = cDisInfo;
 
@@ -4178 +4247 @@
                 TComMv cMv = cDefaultMvField.getMv() + cMvRounding;
                 cMv >>= 2;
+#if !FIX_TICKET_68
                 clipMv( cMv );
+#endif
                 cMvFieldSaved[eCurrRefPicList].setMvField(cMv, iRefPicList) ;
                 break;
@@ -5250 +5321 @@
 #endif
 
-
+#if !FIX_TICKET_76
 #if H_3D_VSP
 inline Void TComDataCU::xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount, InheritedVSPDisInfo*  inheritedVSPDisInfo)
@@ -5257 +5328 @@
   inheritedVSPDisInfo[iCount].m_acDvInfo.m_aVIdxCan = pcCURef->getDvInfo(uiAbsPartIdx).m_aVIdxCan;
 }
+#endif
 #endif
 /** Check whether the current PU and a spatial neighboring PU are in a same ME region.
@@ -5900 +5972 @@
     Int iColRefViewId  = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewIndex(); 
     iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
+#if SEC_HLS_CLEANUP_I0100
+    if ( iScale != 4096 && m_pcSlice->getVPS()->getIvMvScalingFlag(getSlice()->getLayerIdInVps()) ) 
+#else
     if ( iScale != 4096 && m_pcSlice->getVPS()->getIvMvScalingFlag() ) 
+#endif
     {
       rcMv = cColMv.scaleMv( iScale );
@@ -6083 +6159 @@
 
   TComMv cMv; 
+#if MTK_I0093
+  Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[ 1 << ( getSlice()->getSPS()->getBitDepthY() - 1 ) ];
+#else
   Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[ 128 ];
+#endif
   cMv.setHor(iDisp);
   cMv.setVer(0);
@@ -6091 +6171 @@
   return true;
 }
+#endif
+
+#if MTK_SINGLE_DEPTH_MODE_I0095
+Bool TComDataCU::getNeighDepth (UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index)
+{
+
+  Bool bDepAvail = false;
+  Pel *pDepth  = this->getPic()->getPicYuvRec()->getLumaAddr();
+  Int iDepStride =  this->getPic()->getPicYuvRec()->getStride();
+
+  Int xP, yP, nPSW, nPSH;
+  this->getPartPosition(uiPartIdx, xP, yP, nPSW, nPSH);
+  UInt PicHeight=this->getPic()->getPicYuvRec()->getHeight();
+  UInt PicWidth=this->getPic()->getPicYuvRec()->getWidth();
+  switch(index)
+  {
+  case 0: // Mid Left
+    if( ( xP != 0 ) && ( ( yP + ( nPSH >> 1 ) ) < PicHeight ) )
+    {
+      *pNeighDepth = pDepth[ (yP+(nPSH>>1)) * iDepStride + (xP-1) ];
+      bDepAvail = true;
+    }
+    break;
+  case 1: // Mid Above
+    if( ( yP != 0 ) && ( ( xP + ( nPSW >> 1 ) ) < PicWidth ) )
+    {
+      *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP + (nPSW>>1)) ];
+      bDepAvail = true;
+    }
+    break;
+  case 2: // Above
+    if(yP != 0)
+    {
+      *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP) ];
+      bDepAvail = true;
+    }
+    break;
+  case 3: // Left
+    if(xP != 0)
+    {
+      *pNeighDepth = pDepth[ (yP) * iDepStride + (xP-1) ];
+      bDepAvail = true;
+    }
+    break;
+  case 4: // Above_Left
+    if(xP != 0 && yP != 0)
+    {
+      *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP-1) ];
+      bDepAvail = true;
+    }
+    break;
+  default:
+      break;
+  }
+  return bDepAvail;
+}
+
 #endif
 #if H_3D_NBDV 
@@ -6650 +6787 @@
   if( getSlice()->getIsDepth() )
   {
+#if MTK_I0099_VPS_EX2
+    iSubPUSize = 1<<getSlice()->getVPS()->getSubPUMPILog2Size(getSlice()->getLayerId());
+#else
     iSubPUSize = 1 << getSlice()->getVPS()->getSubPUMPILog2Size();
+#endif
   }
 

trunk/source/Lib/TLibCommon/TComDataCU.h

@@ -110 +110 @@
   // -------------------------------------------------------------------------------------------------------------------
   Bool*         m_skipFlag;           ///< array of skip flags
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  Bool*         m_singleDepthFlag;           ///< array of single depth flags
+  Pel*          m_apSingleDepthValue;
+#endif
   Char*         m_pePartSize;         ///< array of partition sizes
   Char*         m_pePredMode;         ///< array of prediction modes
@@ -246 +250 @@
 #if H_3D_IV_MERGE
   Bool          xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Int*   ivCandDir, TComMv* ivCandMv, Int* ivCandRefIdx ); 
+#if! SEC_SIMP_SHIFTED_DV_I0086
   Bool          xGetPosFirstAvailDmvCand( Int iCount, Int& iFirDispCand );
+#endif
 #endif
 
@@ -347 +353 @@
   Void         setSkipFlag           ( UInt idx, Bool skip)     { m_skipFlag[idx] = skip;   }
   Void         setSkipFlagSubParts   ( Bool skip, UInt absPartIdx, UInt depth );
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  Bool*        getSingleDepthFlag            ()                        { return m_singleDepthFlag;          }
+  Bool         getSingleDepthFlag            (UInt idx)                { return m_singleDepthFlag[idx];     }
+  Void         setSingleDepthFlag           ( UInt idx, Bool singleDepth)     { m_singleDepthFlag[idx] = singleDepth;   }
+  Void         setSingleDepthFlagSubParts   ( Bool singleDepth, UInt absPartIdx, UInt depth );
+
+  Pel*         getSingleDepthValue( ) { return m_apSingleDepthValue; }
+  Pel          getSingleDepthValue            (UInt idx)                { return m_apSingleDepthValue[idx];     }
+  Void         setSingleDepthValue           ( UInt idx, Pel pDepthValue)     { m_apSingleDepthValue[idx] = pDepthValue;   }
+  Void         setSingleDepthValueSubParts   (Pel singleDepthValue, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth );
+#endif  
   Char*         getPredictionMode     ()                        { return m_pePredMode;        }
   PredMode      getPredictionMode     ( UInt uiIdx )            { return static_cast<PredMode>( m_pePredMode[uiIdx] ); }
@@ -489 +505 @@
   Bool          getDispMvPredCan(UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDis, Int* iPdm );
 #endif
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+   Bool          getNeighDepth (UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index);
+#endif
 #if H_3D_NBDV_REF
   Pel           getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iWidth, Int iHeight, Int* aiShiftLUT );
@@ -652 +670 @@
   Void          getInterMergeCandidates ( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours
 #endif
-#if H_3D_VSP
+#if H_3D_VSP && !FIX_TICKET_79
                                             , InheritedVSPDisInfo*  inheritedVSPDisInfo
 #endif
@@ -662 +680 @@
 
 #if H_3D_VSP
+#if !FIX_TICKET_76
   inline Void   xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount,  InheritedVSPDisInfo*  inheritedVSPDisInfo);
+#endif
 
 #if H_3D_SPIVMP
@@ -750 +770 @@
 
 #endif
+
+#if SHARP_DMM1_I0110
+  Bool         isDMM1UpscaleMode       ( UInt uiWidth ){ Bool bDMM1UpsampleModeFlag = true; UInt uiBaseWidth = 16; if( uiBaseWidth >= uiWidth ){ bDMM1UpsampleModeFlag = false; } return bDMM1UpsampleModeFlag; };
+  UInt         getDMM1BasePatternWidth ( UInt uiWidth ){ UInt uiBaseWidth = 16; if( uiBaseWidth >= uiWidth ){ uiBaseWidth =  uiWidth; } return uiBaseWidth; }
+#endif
+
 };
 

trunk/source/Lib/TLibCommon/TComMotionInfo.h

@@ -79 +79 @@
 } IDVInfo;
 #endif
-#if H_3D_VSP
+#if H_3D_VSP && !FIX_TICKET_79
 typedef struct _InheritedVSPDisCand 
 {

trunk/source/Lib/TLibCommon/TComPrediction.cpp

@@ -423 +423 @@
 
   UInt dimType    = getDimType  ( uiIntraMode );
-  Bool dimDeltaDC = isDimDeltaDC( uiIntraMode );    
+#if !HS_DMM_SIGNALLING_I0120
+  Bool dimDeltaDC = isDimDeltaDC( uiIntraMode );
+#endif
   Bool isDmmMode  = (dimType <  DMM_NUM_TYPE);
 
@@ -438 +440 @@
     case( DMM1_IDX ): 
       {
+#if SHARP_DMM1_I0110
+        dmmSegmentation = pcCU->isDMM1UpscaleMode((UInt)iWidth) ? 
+            &(g_dmmWedgeLists[ g_aucConvertToBit[pcCU->getDMM1BasePatternWidth((UInt)iWidth)] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]) : 
+            &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
+#else
         dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
+#endif
       } break;
     case( DMM4_IDX ): 
@@ -456 +464 @@
     }
     assert( dmmSegmentation );
+#if SHARP_DMM1_I0110
+    if( dimType == DMM1_IDX && pcCU->isDMM1UpscaleMode((UInt)iWidth) ) 
+    {
+        biSegPattern = dmmSegmentation->getScaledPattern((UInt)iWidth);
+        patternStride = iWidth;
+    } 
+    else 
+    { 
+        biSegPattern  = dmmSegmentation->getPattern();
+        patternStride = dmmSegmentation->getStride ();
+    }
+#else
     biSegPattern  = dmmSegmentation->getPattern();
     patternStride = dmmSegmentation->getStride ();
+#endif
   }
 #endif
@@ -474 +495 @@
   Pel segDC1 = 0;
   Pel segDC2 = 0;
+#if HS_DMM_SIGNALLING_I0120
+  if( !pcCU->getSDCFlag( uiAbsPartIdx ) )
+#else
   if( dimDeltaDC )
+#endif
   {
     Pel deltaDC1 = pcCU->getDimDeltaDC( dimType, 0, uiAbsPartIdx );
@@ -543 +568 @@
     pcCU->getSPAbsPartIdx(uiPartAddr, iSPWidth, iSPHeight, i, iNumSPInOneLine, uiSPAddr[i]);
   }
+#if SHARP_ARP_CHROMA_I0104
+  if( pcCU->getARPW( uiPartAddr ) != 0 )
+  {
+    return;
+  }
+#endif
   // horizontal sub-PU merge
   for (Int i=0; i<iNumSP; i++)
@@ -714 +745 @@
   Int uiMinDepth = MAX_INT;
   Int uiMaxDepth = 0;
+#if SEC_DBBP_DMM4_THRESHOLD_I0076
+  iSumDepth  = pDepthPels[ 0 ];
+  iSumDepth += pDepthPels[ uiWidth - 1 ];
+  iSumDepth += pDepthPels[ uiDepthStride * (uiHeight - 1) ];
+  iSumDepth += pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ];
+
+  uiMinDepth = pDepthPels[ 0 ];
+  uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiWidth - 1 ]);
+  uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) ]);
+  uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
+
+  uiMaxDepth = pDepthPels[ 0 ];
+  uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiWidth - 1 ]);
+  uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) ]);
+  uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
+#else
   for (Int y=0; y<uiHeight; y++)
   {
@@ -734 +781 @@
     pDepthPels += uiDepthStride;
   }
+#endif
   
   // don't generate mask for blocks with small depth range (encoder decision)
@@ -742 +790 @@
   
   AOF(uiWidth==uiHeight);
+#if SEC_DBBP_DMM4_THRESHOLD_I0076
+  Int iMean = iSumDepth >> 2;
+#else
   Int iSizeInBits = g_aucConvertToBit[uiWidth]+2;
   Int iMean = iSumDepth >> iSizeInBits*2;       // iMean /= (uiWidth*uiHeight);
+#endif
   
   // start again for segmentation
@@ -790 +842 @@
 }
 
+#if SHARP_DBBP_SIMPLE_FLTER_I0109
+Void TComPrediction::combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr, UInt partSize )
+#else
 Void TComPrediction::combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr )
+#endif
 {
   Pel*  piSrc[2]    = {pInYuv[0]->getLumaAddr(uiPartAddr), pInYuv[1]->getLumaAddr(uiPartAddr)};
@@ -798 +854 @@
   
   UInt  uiMaskStride= MAX_CU_SIZE;
+#if !SHARP_DBBP_SIMPLE_FLTER_I0109
   Pel  filSrc = 0;
+#endif
   Pel* tmpTar = 0;
   tmpTar = (Pel *)xMalloc(Pel, uiWidth*uiHeight);
@@ -822 +880 @@
   }
   
+#if SHARP_DBBP_SIMPLE_FLTER_I0109
+  if (partSize == SIZE_Nx2N)
+  {
+    for (Int y=0; y<uiHeight; y++)
+    {
+      for (Int x=0; x<uiWidth; x++)
+      {
+        Bool l = (x==0)?pMaskStart[y*uiMaskStride+x]:pMaskStart[y*uiMaskStride+x-1];
+        Bool r = (x==uiWidth-1)?pMaskStart[y*uiMaskStride+x]:pMaskStart[y*uiMaskStride+x+1];
+        
+        Pel left, right;
+        left   = (x==0)          ? tmpTar[y*uiWidth+x] : tmpTar[y*uiWidth+x-1];
+        right  = (x==uiWidth-1)  ? tmpTar[y*uiWidth+x] : tmpTar[y*uiWidth+x+1];
+        
+        piDst[x] = (l!=r) ? ClipY( Pel(( left + (tmpTar[y*uiWidth+x] << 1) + right ) >> 2 )) : tmpTar[y*uiWidth+x]; 
+      }
+      piDst     += uiDstStride;
+    }
+  }
+  else // SIZE_2NxN
+  {
+    for (Int y=0; y<uiHeight; y++)
+    {
+      for (Int x=0; x<uiWidth; x++)
+      {
+        Bool t = (y==0)?pMaskStart[y*uiMaskStride+x]:pMaskStart[(y-1)*uiMaskStride+x];
+        Bool b = (y==uiHeight-1)?pMaskStart[y*uiMaskStride+x]:pMaskStart[(y+1)*uiMaskStride+x];
+        
+        Pel top, bottom;
+        top    = (y==0)          ? tmpTar[y*uiWidth+x] : tmpTar[(y-1)*uiWidth+x];
+        bottom = (y==uiHeight-1) ? tmpTar[y*uiWidth+x] : tmpTar[(y+1)*uiWidth+x];
+        
+        piDst[x] = (t!=b) ? ClipY( Pel(( top + (tmpTar[y*uiWidth+x] << 1) + bottom ) >> 2 )) : tmpTar[y*uiWidth+x];
+      }
+      piDst     += uiDstStride;
+    }
+  }
+#else
   for (Int y=0; y<uiHeight; y++)
   {
@@ -855 +951 @@
     piDst     += uiDstStride;
   }
+#endif
+
   if ( tmpTar    ) { xFree(tmpTar);             tmpTar        = NULL; }
   
@@ -891 +989 @@
   }
 
+#if SHARP_DBBP_SIMPLE_FLTER_I0109
+  if (partSize == SIZE_Nx2N)
+  {
+    for (Int y=0; y<uiHeightC; y++)
+    {
+      for (Int x=0; x<uiWidthC; x++)
+      {
+        Bool l = (x==0)?pMaskStart[y*2*uiMaskStride+x*2]:pMaskStart[y*2*uiMaskStride+(x-1)*2];
+        Bool r = (x==uiWidthC-1)?pMaskStart[y*2*uiMaskStride+x*2]:pMaskStart[y*2*uiMaskStride+(x+1)*2];
+
+        Pel leftU, rightU;
+        leftU   = (x==0)           ? tmpTarU[y*uiWidthC+x] : tmpTarU[y*uiWidthC+x-1];
+        rightU  = (x==uiWidthC-1)  ? tmpTarU[y*uiWidthC+x] : tmpTarU[y*uiWidthC+x+1];
+        Pel leftV, rightV;
+        leftV   = (x==0)           ? tmpTarV[y*uiWidthC+x] : tmpTarV[y*uiWidthC+x-1];
+        rightV  = (x==uiWidthC-1)  ? tmpTarV[y*uiWidthC+x] : tmpTarV[y*uiWidthC+x+1];
+
+        if (l!=r)
+        {
+          filSrcU = ClipC( Pel(( leftU + (tmpTarU[y*uiWidthC+x] << 1) + rightU ) >> 2 ));
+          filSrcV = ClipC( Pel(( leftV + (tmpTarV[y*uiWidthC+x] << 1) + rightV ) >> 2 ));
+        }
+        else
+        {
+          filSrcU = tmpTarU[y*uiWidthC+x];
+          filSrcV = tmpTarV[y*uiWidthC+x];
+        }
+        piDstU[x] = filSrcU;
+        piDstV[x] = filSrcV;
+      }
+      piDstU      += uiDstStrideC;
+      piDstV      += uiDstStrideC;
+    }
+  }
+  else
+  {
+    for (Int y=0; y<uiHeightC; y++)
+    {
+      for (Int x=0; x<uiWidthC; x++)
+      {
+        Bool t = (y==0)?pMaskStart[y*2*uiMaskStride+x*2]:pMaskStart[(y-1)*2*uiMaskStride+x*2];
+        Bool b = (y==uiHeightC-1)?pMaskStart[y*2*uiMaskStride+x*2]:pMaskStart[(y+1)*2*uiMaskStride+x*2];
+
+        Pel topU, bottomU;
+        topU    = (y==0)           ? tmpTarU[y*uiWidthC+x] : tmpTarU[(y-1)*uiWidthC+x];
+        bottomU = (y==uiHeightC-1) ? tmpTarU[y*uiWidthC+x] : tmpTarU[(y+1)*uiWidthC+x];
+        Pel topV, bottomV;
+        topV    = (y==0)           ? tmpTarV[y*uiWidthC+x] : tmpTarV[(y-1)*uiWidthC+x];
+        bottomV = (y==uiHeightC-1) ? tmpTarV[y*uiWidthC+x] : tmpTarV[(y+1)*uiWidthC+x];
+
+        if (t!=b)
+        {
+          filSrcU = ClipC( Pel(( topU + (tmpTarU[y*uiWidthC+x] << 1) + bottomU ) >> 2 ));
+          filSrcV = ClipC( Pel(( topV + (tmpTarV[y*uiWidthC+x] << 1) + bottomV ) >> 2 ));
+        }
+        else
+        {
+          filSrcU = tmpTarU[y*uiWidthC+x];
+          filSrcV = tmpTarV[y*uiWidthC+x];
+        }
+        piDstU[x] = filSrcU;
+        piDstV[x] = filSrcV;
+      }
+      piDstU      += uiDstStrideC;
+      piDstV      += uiDstStrideC;
+    }
+  }
+#else
   for (Int y=0; y<uiHeightC; y++)
   {
@@ -936 +1102 @@
     piDstV      += uiDstStrideC;
   }
+#endif
   if ( tmpTarU    ) { xFree(tmpTarU);             tmpTarU        = NULL; }
   if ( tmpTarV    ) { xFree(tmpTarV);             tmpTarV        = NULL; }
@@ -1308 +1475 @@
   pcCU->clipMv(cMv);
   TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
+#if QC_I0129_ARP_FIX
+  xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi || ( dW > 0 ), true );
+  xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi || ( dW > 0 ), true );
+#else
   xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
   xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
-
+#endif
   if( dW > 0 )
   {
@@ -1318 +1489 @@
     TComMv cMVwithDisparity = cMv + cDistparity.m_acNBDV;
     pcCU->clipMv(cMVwithDisparity);
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth <= 8)
+    {
+      pYuvB0->clear(); pYuvB1->clear();
+    }
+#endif
 
     assert ( cDistparity.bDV );
@@ -1326 +1503 @@
     
     pcPicYuvRef = pcPicYuvBaseCol->getPicYuvRec();
+#if QC_I0129_ARP_FIX
+    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cNBDV, iWidth, iHeight, pYuvB0, true, true );
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth > 8)
+#endif
+    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cNBDV, iWidth, iHeight, pYuvB0, true, true );
+#else
     xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cNBDV, iWidth, iHeight, pYuvB0, bi, true );
     xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cNBDV, iWidth, iHeight, pYuvB0, bi, true );
+#endif
 #else
     pcPicYuvRef = pcPicYuvBaseCol->getPicYuvRec();
@@ -1335 +1520 @@
     
     pcPicYuvRef = pcPicYuvBaseRef->getPicYuvRec();
+#if QC_I0129_ARP_FIX
+    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, true, true );
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth > 8)
+#endif
+    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, true, true );
+#else
     xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
     xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
-
+#endif
     pYuvB0->subtractARP( pYuvB0 , pYuvB1 , uiPartAddr , iWidth , iHeight );
 
@@ -1347 +1539 @@
   }
 }
+
+#if QC_I0051_ARP_SIMP
+Bool TComPrediction::xCheckBiInterviewARP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eBaseRefPicList, TComPic*& pcPicYuvCurrTRef, TComMv& cBaseTMV, Int& iCurrTRefPoc )
+{
+  Int         iRefIdx       = pcCU->getCUMvField( eBaseRefPicList )->getRefIdx( uiPartAddr );
+  TComMv      cDMv          = pcCU->getCUMvField( eBaseRefPicList )->getMv( uiPartAddr );
+  TComPic* pcPicYuvBaseCol  = pcCU->getSlice()->getRefPic( eBaseRefPicList, iRefIdx );  
+  TComPicYuv* pcYuvBaseCol  = pcPicYuvBaseCol->getPicYuvRec();
+  Int uiLCUAddr,uiAbsPartAddr;
+  Int irefPUX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[uiPartAddr]] + iWidth/2  + ((cDMv.getHor() + 2)>>2);
+  Int irefPUY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[uiPartAddr]] + iHeight/2 + ((cDMv.getVer() + 2)>>2);
+
+  irefPUX = (Int)Clip3<Int>(0, pcCU->getSlice()->getSPS()-> getPicWidthInLumaSamples()-1, irefPUX);
+  irefPUY = (Int)Clip3<Int>(0, pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples()-1, irefPUY);  
+  pcYuvBaseCol->getCUAddrAndPartIdx( irefPUX, irefPUY, uiLCUAddr, uiAbsPartAddr);
+  TComDataCU *pColCU = pcPicYuvBaseCol->getCU( uiLCUAddr );
+
+  TComPic* pcPicYuvBaseTRef = NULL;
+  pcPicYuvCurrTRef = NULL;
+
+  //If there is available motion in base reference list, use it
+  if(!pColCU->isIntra(uiAbsPartAddr))
+  {
+    for(Int iList = 0; iList < (pColCU->getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      RefPicList eRefPicListCurr = RefPicList(iList);
+      Int iRef = pColCU->getCUMvField(eRefPicListCurr)->getRefIdx(uiAbsPartAddr);
+      if( iRef != -1)
+      {
+        pcPicYuvBaseTRef = pColCU->getSlice()->getRefPic(eRefPicListCurr, iRef);  
+        Int  iCurrPOC    = pColCU->getSlice()->getPOC();
+        Int  iCurrRefPOC = pcPicYuvBaseTRef->getPOC();
+        Int  iCurrRef    = pcCU->getSlice()->getFirstTRefIdx(eRefPicListCurr);
+#if MTK_I0072_IVARP_SCALING_FIX
+        if( iCurrRef >= 0 && iCurrPOC != iCurrRefPOC)
+#else
+        if( iCurrRef >= 0)
+#endif
+        {
+          pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic(eRefPicListCurr,iCurrRef);  
+          Int iTargetPOC = pcPicYuvCurrTRef->getPOC();
+          pcPicYuvBaseTRef =  pcCU->getSlice()->getBaseViewRefPic(iTargetPOC,  pcPicYuvBaseCol->getViewIndex() );  
+          if(pcPicYuvBaseTRef)
+          {
+            cBaseTMV = pColCU->getCUMvField(eRefPicListCurr)->getMv(uiAbsPartAddr);
+            Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iTargetPOC, iCurrPOC, iCurrRefPOC);
+            if ( iScale != 4096 )
+            {
+              cBaseTMV = cBaseTMV.scaleMv( iScale );
+            }
+            iCurrTRefPoc = iTargetPOC;
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  //If there is no available motion in base reference list, use ( 0, 0 )
+  if( pcCU->getSlice()->getFirstTRefIdx( eBaseRefPicList ) >= 0 )
+  {
+    cBaseTMV.set( 0, 0 );
+    pcPicYuvCurrTRef = pcCU->getSlice()->getRefPic( eBaseRefPicList,  pcCU->getSlice()->getFirstTRefIdx( eBaseRefPicList ) );
+    iCurrTRefPoc = pcPicYuvCurrTRef->getPOC();
+    return true;
+  }
+
+  return false;
+}
+#endif
+
 Void TComPrediction::xPredInterUniARPviewRef( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi, TComMvField * pNewMvFiled )
 {
@@ -1380 +1643 @@
   pcYuvBaseCol->getCUAddrAndPartIdx( irefPUX, irefPUY, uiLCUAddr, uiAbsPartAddr);
   TComDataCU *pColCU = pcPicYuvBaseCol->getCU( uiLCUAddr );
-
+#if QC_I0051_ARP_SIMP
+  if( pcCU->getSlice()->isInterB() && !pcCU->getSlice()->getIsDepth() )
+  {
+    RefPicList eOtherRefList = ( eRefPicList == REF_PIC_LIST_0 ) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
+    Int iOtherRefIdx = pcCU->getCUMvField( eOtherRefList )->getRefIdx( uiPartAddr );
+    //The other prediction direction is temporal ARP
+    if( iOtherRefIdx >= 0 && pcCU->getSlice()->getViewIndex() == pcCU->getSlice()->getRefPic( eOtherRefList, iOtherRefIdx )->getViewIndex() )
+    {
+      bTMVAvai = true;
+      pcPicYuvBaseTRef = pcCU->getSlice()->getRefPic( eOtherRefList, iOtherRefIdx );
+      Int  iCurrPOC    = pcCU->getSlice()->getPOC();
+      Int  iCurrRefPOC = pcPicYuvBaseTRef->getPOC();
+      Int  iCurrRef    = pcCU->getSlice()->getFirstTRefIdx( eOtherRefList );
+      
+      if( iCurrRef >= 0 )
+      {
+        pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic( eOtherRefList,iCurrRef );  
+        Int iTargetPOC = pcPicYuvCurrTRef->getPOC();
+        pcPicYuvBaseTRef =  pcCU->getSlice()->getBaseViewRefPic( iTargetPOC,  pcPicYuvBaseCol->getViewIndex() );
+        if( pcPicYuvBaseTRef )
+        {
+          cBaseTMV = pcCU->getCUMvField( eOtherRefList )->getMv( uiPartAddr );
+          Int iScale = pcCU-> xGetDistScaleFactor( iCurrPOC, iTargetPOC, iCurrPOC, iCurrRefPOC );
+          if ( iScale != 4096 )
+          {
+            cBaseTMV = cBaseTMV.scaleMv( iScale );
+          }
+        }
+        else
+        {
+          dW = 0;
+        }
+      }
+      else
+      {
+        dW = 0;
+      }
+    }
+
+    //Both prediction directions are inter-view ARP
+    if ( iOtherRefIdx >= 0 && !bTMVAvai )
+    {
+      RefPicList eBaseList = REF_PIC_LIST_0;
+      Int iCurrTRefPoc;
+      bTMVAvai = ( eBaseList != eRefPicList ) && ( pcCU->getSlice()->getViewIndex() != pcCU->getSlice()->getRefPic( eOtherRefList, iOtherRefIdx )->getViewIndex() );
+
+      if ( bTMVAvai )
+      {
+        if( xCheckBiInterviewARP( pcCU, uiPartAddr, iWidth, iHeight, eBaseList, pcPicYuvCurrTRef, cBaseTMV, iCurrTRefPoc ) )
+        {
+          pcPicYuvBaseTRef = pcCU->getSlice()->getBaseViewRefPic( iCurrTRefPoc,  pcPicYuvBaseCol->getViewIndex() );
+          if ( pcPicYuvBaseTRef == NULL )
+          {
+            dW = 0;
+          }
+        }
+        else
+        {
+          dW = 0;
+        }
+      }
+    }
+  }
+
+  if( !pColCU->isIntra( uiAbsPartAddr ) && !bTMVAvai )
+#else
   if(!pColCU->isIntra(uiAbsPartAddr))
+#endif
   {
     TComMvField puMVField;
@@ -1394 +1723 @@
         Int  iCurrRefPOC = pcPicYuvBaseTRef->getPOC();
         Int  iCurrRef    = pcCU->getSlice()->getFirstTRefIdx(eRefPicListCurr);
+#if MTK_I0072_IVARP_SCALING_FIX
+        if (iCurrRef >= 0 && iCurrRefPOC != iCurrPOC)
+#else
         if( iCurrRef >= 0)
+#endif
         {
           pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic(eRefPicListCurr,iCurrRef);  
@@ -1421 +1754 @@
     pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic  (eRefPicList,  pcCU->getSlice()->getFirstTRefIdx(eRefPicList));      
   }
-
+#if QC_I0129_ARP_FIX
+  xPredInterLumaBlk  ( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi || ( dW > 0 && bTMVAvai ),        bTMVAvai);
+  xPredInterChromaBlk( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi || ( dW > 0 && bTMVAvai ),        bTMVAvai);
+#else
   xPredInterLumaBlk  ( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi,        bTMVAvai);
   xPredInterChromaBlk( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi,        bTMVAvai);
-
+#endif
   if( dW > 0 && bTMVAvai ) 
   {
@@ -1435 +1771 @@
     pcCU->clipMv(cBaseTMV);
     pcCU->clipMv(cTempMv);
-
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth <= 8)
+    {
+      pYuvCurrTRef->clear(); pYuvBaseTRef->clear();
+    }
+#endif
+#if QC_I0129_ARP_FIX
+    xPredInterLumaBlk  ( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, true,   true);
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth > 8)
+#endif
+    xPredInterChromaBlk( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, true,   true);
+    xPredInterLumaBlk  ( pcCU, pcYuvBaseTref, uiPartAddr, &cTempMv,  iWidth, iHeight, pYuvBaseTRef, true,   true); 
+#if SHARP_ARP_CHROMA_I0104
+    if (iWidth > 8)
+#endif
+    xPredInterChromaBlk( pcCU, pcYuvBaseTref, uiPartAddr, &cTempMv,  iWidth, iHeight, pYuvBaseTRef, true,   true); 
+#else
     xPredInterLumaBlk  ( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, bi,   true);
     xPredInterChromaBlk( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, bi,   true);
@@ -1441 +1794 @@
     xPredInterChromaBlk( pcCU, pcYuvBaseTref, uiPartAddr, &cTempMv,  iWidth, iHeight, pYuvBaseTRef, bi,   true); 
 
+#endif
     pYuvCurrTRef->subtractARP( pYuvCurrTRef , pYuvBaseTRef , uiPartAddr , iWidth , iHeight );  
     if(dW == 2)
@@ -1974 +2328 @@
   Int iRecStride = ( eType == TEXT_LUMA ) ? pRecPic->getStride() : pRecPic->getCStride();
   Int iRefStride = ( eType == TEXT_LUMA ) ? pRefPic->getStride() : pRefPic->getCStride();
+#if SEC_IC_NEIGHBOR_CLIP_I0080
+  Int iRefOffset, iHor, iVer;
+#else
   Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset, iHor, iVer;
 
   iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
   iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
+#endif
   iHor = pcCU->getSlice()->getIsDepth() ? pMv->getHor() : ( ( pMv->getHor() + 2 ) >> 2 );
   iVer = pcCU->getSlice()->getIsDepth() ? pMv->getVer() : ( ( pMv->getVer() + 2 ) >> 2 );
+#if !SEC_IC_NEIGHBOR_CLIP_I0080
   iRefX   = iCUPelX + iHor;
   iRefY   = iCUPelY + iVer;
+#endif
   if( eType != TEXT_LUMA )
   {
@@ -1997 +2357 @@
   Int precShift = std::max(0, (( eType == TEXT_LUMA ) ? g_bitDepthY : g_bitDepthC) - 12);
 
+#if SEC_IC_NEIGHBOR_CLIP_I0080
+  if( pcCU->getPUAbove( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) )
+#else
   if( pcCU->getPUAbove( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelY > 0 && iRefY > 0 )
+#endif
   {
     iRefOffset = iHor + iVer * iRefStride - iRefStride;
@@ -2027 +2391 @@
   }
 
-
+#if SEC_IC_NEIGHBOR_CLIP_I0080
+  if( pcCU->getPULeft( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) )
+#else
   if( pcCU->getPULeft( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelX > 0 && iRefX > 0 )
+#endif
   {
     iRefOffset = iHor + iVer * iRefStride - 1;
@@ -2061 +2428 @@
     iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 1 );
   }
+
+#if FIX_TICKET_71
+  if( iCountShift == 0 )
+  {
+    a = ( 1 << IC_CONST_SHIFT );
+    b = 0;
+    return;
+  }
+#endif
 
   xy += xx >> IC_REG_COST_SHIFT;
@@ -2177 +2553 @@
   // find contour for texture luma block
   UInt iDC = 0;
+#if SEC_DBBP_DMM4_THRESHOLD_I0076
+  iDC  = piRefBlkY[ 0 ];
+  iDC += piRefBlkY[ uiWidth - 1 ];
+  iDC += piRefBlkY[ uiWidth * (uiHeight - 1) ];
+  iDC += piRefBlkY[ uiWidth * (uiHeight - 1) + uiWidth - 1 ];
+  iDC = iDC >> 2;
+#else
   for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) 
   { 
@@ -2184 +2567 @@
   Int cuMaxLog2Size = g_aucConvertToBit[g_uiMaxCUWidth]+2;   // 
   iDC = iDC >> (cuMaxLog2Size - pcCU->getDepth(0))*2;        //  iDC /= (uiWidth*uiHeight);
+#endif
 
   piRefBlkY = cTempYuv.getLumaAddr();

trunk/source/Lib/TLibCommon/TComPrediction.h

@@ -90 +90 @@
 #if H_3D_ARP
   Void xPredInterUniARP         ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi=false, TComMvField * pNewMvFiled = NULL );
+#if QC_I0051_ARP_SIMP
+  Bool xCheckBiInterviewARP     ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eBaseRefPicList, TComPic*& pcPicYuvCurrTRef, TComMv& cBaseTMV, Int& iCurrTRefPoc );
+#endif
   Void xPredInterUniARPviewRef( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi, TComMvField * pNewMvFiled = NULL );
 #endif
@@ -176 +179 @@
   PartSize      getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize);
   Bool          getSegmentMaskFromDepth( Pel* pDepthPels, UInt uiDepthStride, UInt uiWidth, UInt uiHeight, Bool* pMask );
+#if SHARP_DBBP_SIMPLE_FLTER_I0109
+  Void          combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr, UInt partSize );
+#else
   Void          combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr = 0 );
+#endif
 #endif
 

trunk/source/Lib/TLibCommon/TComRom.cpp

@@ -336 +336 @@
   HALF_PEL,    //   8x8
   FULL_PEL,    //  16x16
+#if SHARP_DMM1_I0110
+  FULL_PEL,    //  32x32
+  FULL_PEL,    //  64x64
+  FULL_PEL     // 128x128
+#else
   DOUBLE_PEL,  //  32x32
   DOUBLE_PEL,  //  64x64
   DOUBLE_PEL   // 128x128
+#endif
 };
 
@@ -348 +354 @@
 { //2x2   4x4   8x8 16x16 32x32 64x64
      0,    4,    7,    8,    8,    0 };
+
+#if SHARP_DMM1_I0110
+Bool g_wedgePattern[32*32];
+#endif
 
 extern std::vector< std::vector<TComWedgelet> >   g_dmmWedgeLists;
@@ -646 +656 @@
   if( !g_dmmWedgeLists.empty() ) return;
 
+#if SHARP_DMM1_I0110
+  for( UInt ui = g_aucConvertToBit[DIM_MIN_SIZE]; ui < (g_aucConvertToBit[DIM_MAX_SIZE]); ui++ )
+#else
   for( UInt ui = g_aucConvertToBit[DIM_MIN_SIZE]; ui < (g_aucConvertToBit[DIM_MAX_SIZE]+1); ui++ )
+#endif
   {
     UInt uiWedgeBlockSize = ((UInt)DIM_MIN_SIZE)<<ui;
@@ -730 +744 @@
   switch( eWedgeRes )
   {
+#if !SHARP_DMM1_I0110
   case( DOUBLE_PEL ): { uiBlockSize = (uiWidth>>1); break; }
+#endif
   case(   FULL_PEL ): { uiBlockSize =  uiWidth;     break; }
   case(   HALF_PEL ): { uiBlockSize = (uiWidth<<1); break; }

trunk/source/Lib/TLibCommon/TComRom.h

@@ -166 +166 @@
 extern const UChar                                           g_dmm3IntraTabIdxBits[6];
 
+#if SHARP_DMM1_I0110
+extern Bool                                                  g_wedgePattern[32*32];
+#endif 
+
 extern       std::vector< std::vector<TComWedgelet> >        g_dmmWedgeLists;
 extern       std::vector< std::vector<TComWedgeRef> >        g_dmmWedgeRefLists;

trunk/source/Lib/TLibCommon/TComSlice.cpp

@@ -139 +139 @@
 , m_depthToDisparityF             ( NULL )
 #endif
+#if MTK_SINGLE_DEPTH_MODE_I0095
+, m_bApplySingleDepthMode         (false)
+#endif
 #endif
 {
@@ -644 +647 @@
   
   TComPic**             refPicSetStCurr    [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
+#if FIX_WARNING
+  Int numPocStCurr[2] = { (Int)NumPocStCurr0, (Int)NumPocStCurr1 }; 
+#else
   Int numPocStCurr[2] = { NumPocStCurr0, NumPocStCurr1 }; 
+#endif
 
   for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
@@ -1091 +1098 @@
     m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 
   }
+#endif
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  m_bApplySingleDepthMode = pSrc->m_bApplySingleDepthMode;
 #endif
 #if H_3D_IC
@@ -1942 +1952 @@
     m_viewIndex         [i] = -1; 
     m_vpsDepthModesFlag [i] = false;
+#if SEC_HLS_CLEANUP_I0100
+    m_ivMvScalingFlag[i] = true; 
+#else
     m_ivMvScalingFlag = true; 
+#endif
+#if SEPARATE_FLAG_I0085
+    m_bIVPFlag [i]      = false;
+#endif
 #endif
 
@@ -1974 +1991 @@
 #endif
 #endif
+#if MTK_I0099_VPS_EX2
+    m_bLimQtPredFlag       [ i ] = false;
+#endif
 #if H_3D_VSP
     m_viewSynthesisPredFlag[ i ] = false;
@@ -1982 +2002 @@
 #if H_3D_INTER_SDC
     m_bInterSDCFlag        [ i ] = false;
+#endif
+#if SEPARATE_FLAG_I0085
+    m_bIVPFlag             [ i ] = false;
 #endif
 #if H_3D_DBBP
@@ -2502 +2525 @@
 , m_pcmLog2MaxSize            (  5)
 , m_uiPCMLog2MinSize          (  7)
+#if !MTK_I0099_VPS_EX2
 #if H_3D_QTLPC
 , m_bUseQTL                   (false)
 , m_bUsePC                    (false)
+#endif
 #endif
 , m_bitDepthY                 (  8)
@@ -2774 +2799 @@
     // allocate some memory and initialize with default mapping
     m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
+#if !FIX_TICKET_77
     m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
-
+#endif
     m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
     m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
@@ -2864 +2890 @@
   // update DLT variables
   m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
+#if !FIX_TICKET_77
   m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
+#endif
 }
 

trunk/source/Lib/TLibCommon/TComSlice.h

@@ -798 +798 @@
 #if H_3D_IV_MERGE
   Bool        m_ivMvPredFlag             [ MAX_NUM_LAYERS ]; 
+#if SEC_HLS_CLEANUP_I0100
+  Bool        m_ivMvScalingFlag          [ MAX_NUM_LAYERS ]; 
+#endif
 #if H_3D_SPIVMP
   Int         m_iSubPULog2Size           [MAX_NUM_LAYERS   ];
+#if MTK_I0099_VPS_EX2
+  Int         m_iSubPUMPILog2Size        [MAX_NUM_LAYERS   ];
+#else
   Int         m_iSubPUMPILog2Size;
 #endif
+#endif
+#endif
+#if MTK_I0099_VPS_EX2
+  Bool        m_bLimQtPredFlag           [ MAX_NUM_LAYERS ];
 #endif
 #if H_3D_VSP
@@ -810 +820 @@
 #endif
   Bool        m_vpsDepthModesFlag        [MAX_NUM_LAYERS   ];
+#if SEPARATE_FLAG_I0085
+  Bool        m_bIVPFlag                 [MAX_NUM_LAYERS   ];
+#endif
 
 #if H_3D
@@ -817 +830 @@
   Int         ***m_aaaiCodedScale ;
   Int         ***m_aaaiCodedOffset;
+
+#if !SEC_HLS_CLEANUP_I0100
   Bool        m_ivMvScalingFlag; 
+#endif
+
 #endif
 #if H_3D_INTER_SDC
@@ -1130 +1147 @@
   Int     getSubPULog2Size(Int layerIdInVps)           { return m_iSubPULog2Size[layerIdInVps]; }
   Void    setSubPULog2Size(Int layerIdInVps, Int u)    { m_iSubPULog2Size[layerIdInVps] = u;}
+#if MTK_I0099_VPS_EX2
+  Int     getSubPUMPILog2Size(Int layerIdInVps)           { return m_iSubPUMPILog2Size[layerIdInVps]; }
+  Void    setSubPUMPILog2Size(Int layerIdInVps, Int u)    { m_iSubPUMPILog2Size[layerIdInVps] = u;}
+#else
   Int     getSubPUMPILog2Size( )           { return m_iSubPUMPILog2Size; }
   Void    setSubPUMPILog2Size( Int u )     { m_iSubPUMPILog2Size = u;    }
 #endif
+#endif
+#endif
+#if MTK_I0099_VPS_EX2
+  Void    setLimQtPredFlag    ( Int layerIdInVps, Bool val )  { m_bLimQtPredFlag[ layerIdInVps ] = val; }
+  Bool    getLimQtPredFlag    ( Int layerIdInVps ) { return m_bLimQtPredFlag[layerIdInVps];}
 #endif
 #if H_3D_VSP
@@ -1144 +1170 @@
   Void    setVpsDepthModesFlag( Int layerIdInVps, Bool val )               { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
   Bool    getVpsDepthModesFlag( Int layerIdInVps )                         { return m_vpsDepthModesFlag[ layerIdInVps ]; }
-
+#if SEPARATE_FLAG_I0085
+  Void    setIVPFlag( Int layerIdInVps, Bool val )                    { m_bIVPFlag[ layerIdInVps ] = val; }
+  Bool    getIVPFlag( Int layerIdInVps )                              { return m_bIVPFlag[ layerIdInVps ]; }
+#endif
+
+#if SEC_HLS_CLEANUP_I0100
+  Bool    getIvMvScalingFlag   ( Int layerIdInVps )                        { return m_ivMvScalingFlag[ layerIdInVps ]; }
+  Void    setIvMvScalingFlag   (Int layerIdInVps, Bool b )                 { m_ivMvScalingFlag[ layerIdInVps ] = b;    }  
+#else
   Bool    getIvMvScalingFlag   (  )                       { return m_ivMvScalingFlag; }
   Void    setIvMvScalingFlag   ( Bool b )                 { m_ivMvScalingFlag = b;    }  
+#endif
+
 #if H_3D_INTER_SDC
   Bool    getInterSDCFlag      ( Int layerIdInVps )           { return m_bInterSDCFlag[layerIdInVps]; }
@@ -1171 +1207 @@
   Bool        m_bInterViewDltPredEnableFlag[ MAX_NUM_LAYERS ];
 
+#if !FIX_TICKET_77
   Int         m_iBitsPerDepthValue       [ MAX_NUM_LAYERS ];
+#endif
   Int         m_iNumDepthmapValues       [ MAX_NUM_LAYERS ];
   Int*        m_iDepthValue2Idx          [ MAX_NUM_LAYERS ];
@@ -1198 +1236 @@
   UInt    getDepthViewBitDepth()                          { return m_uiDepthViewBitDepth; }
 
+#if !FIX_TICKET_77
   Int     getBitsPerDepthValue( Int layerIdInVps )        { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
+#endif
   Int     getNumDepthValues( Int layerIdInVps )           { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
   Int     depthValue2idx( Int layerIdInVps, Pel value )   { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
+#if RWTH_DLT_CLIP_I0057
+  Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][ClipY(uiIdx)]:uiIdx; }
+#else
   Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
+#endif
   Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
 #if H_3D_DELTA_DLT
@@ -1466 +1510 @@
   Bool        m_useAMP;
 
+#if !MTK_I0099_VPS_EX2
 #if H_3D_QTLPC
   Bool        m_bUseQTL;
   Bool        m_bUsePC;
+#endif
 #endif
   // Parameter
@@ -1732 +1778 @@
 
 #endif
+#if !MTK_I0099_VPS_EX2
 #if H_3D_QTLPC
   Void setUseQTL( Bool b ) { m_bUseQTL = b;    }
@@ -1737 +1784 @@
   Void setUsePC ( Bool b ) { m_bUsePC  = b;    }
   Bool getUsePC ()         { return m_bUsePC;  }
+#endif
 #endif
 #if H_MV
@@ -2205 +2253 @@
   UInt         m_aiDDDShift    [MAX_NUM_LAYERS];
 #endif
-
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  Bool      m_bApplySingleDepthMode;
+#endif
 public:
   TComSlice();
@@ -2275 +2325 @@
 #if H_3D
   TComPic*  getTexturePic       ()                              { return  m_ivPicsCurrPoc[0][ m_viewIndex ]; }
+#endif
+#if MTK_SINGLE_DEPTH_MODE_I0095
+  Void      setApplySingleDepthMode( Bool b )                                { m_bApplySingleDepthMode = b; }
+  Bool      getApplySingleDepthMode()                                        { return m_bApplySingleDepthMode; }
 #endif
 #if H_3D_IC
@@ -2509 +2563 @@
   Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ refViewIdx ]; }; 
   Bool getVpsDepthModesFlag  ()  { return getVPS()->getVpsDepthModesFlag( getVPS()->getLayerIdInVps( m_layerId ) ); }
-
+#if SEPARATE_FLAG_I0085
+  Bool getIVPFlag       ()  { return getVPS()->getIVPFlag( getVPS()->getLayerIdInVps( m_layerId ) ); }
+#endif
 #endif
 #if H_MV

trunk/source/Lib/TLibCommon/TComWedgelet.cpp

@@ -68 +68 @@
                                                             m_uiHeight ( rcWedge.m_uiHeight  ),
                                                             m_pbPattern( (Bool*)xMalloc( Bool, (m_uiWidth * m_uiHeight) ) )
+#if SHARP_DMM1_I0110
+                                                            ,m_pbScaledPattern( g_wedgePattern )
+#endif
 {
   ::memcpy( m_pbPattern, rcWedge.m_pbPattern, sizeof(Bool) * (m_uiWidth * m_uiHeight));
@@ -85 +88 @@
 
   m_pbPattern = (Bool*)xMalloc( Bool, (m_uiWidth * m_uiHeight) );
+#if SHARP_DMM1_I0110
+  m_pbScaledPattern = g_wedgePattern;
+#endif
 }
 
@@ -181 +187 @@
   switch( m_eWedgeRes )
   {
+#if !SHARP_DMM1_I0110
   case( DOUBLE_PEL ): { uiTempBlockSize =  m_uiWidth;     uhXs = (m_uhXs<<1); uhYs = (m_uhYs<<1); uhXe = (m_uhXe<<1); uhYe = (m_uhYe<<1); } break;
+#endif
   case(   FULL_PEL ): { uiTempBlockSize =  m_uiWidth;     uhXs =  m_uhXs;     uhYs =  m_uhYs;     uhXe =  m_uhXe;     uhYe =  m_uhYe;     } break;
   case(   HALF_PEL ): { uiTempBlockSize = (m_uiWidth<<1); uhXs =  m_uhXs;     uhYs =  m_uhYs;     uhXe =  m_uhXe;     uhYe =  m_uhYe;     } break;
   }
 
+#if !SHARP_DMM1_I0110
   if( m_eWedgeRes == DOUBLE_PEL) // adjust line-end for DOUBLE_PEL resolution
   {
@@ -194 +203 @@
     if( m_uhOri == 5 ) { uhXs = uiTempBlockSize-1; }
   }
+#endif
 
   Bool* pbTempPattern = new Bool[ (uiTempBlockSize * uiTempBlockSize) ];
@@ -223 +233 @@
   switch( m_eWedgeRes )
   {
+#if !SHARP_DMM1_I0110
   case( DOUBLE_PEL ): { for( UInt k = 0; k < (m_uiWidth * m_uiHeight); k++ ) { m_pbPattern[k] = pbTempPattern[k]; }; } break;
+#endif
   case(   FULL_PEL ): { for( UInt k = 0; k < (m_uiWidth * m_uiHeight); k++ ) { m_pbPattern[k] = pbTempPattern[k]; }; } break;
   case(   HALF_PEL ): // sub-sampling by factor 2
@@ -315 +327 @@
 }
 
+#if SHARP_DMM1_I0110
+Bool* TComWedgelet::getScaledPattern(UInt uiDstSize)
+{
+    Bool *pbSrcPat = this->getPattern();
+    UInt uiSrcSize = this->getStride();
+
+    Int scale = (g_aucConvertToBit[uiDstSize] - g_aucConvertToBit[uiSrcSize]);
+    assert(scale>=0);
+    for (Int y=0; y<uiDstSize; y++)
+    {
+       for (Int x=0; x<uiDstSize; x++)
+       {
+           Int srcX = x>>scale;
+           Int srcY = y>>scale;
+           m_pbScaledPattern[y*uiDstSize + x] = pbSrcPat[ srcY*uiSrcSize + srcX ];
+       }
+   }
+   return m_pbScaledPattern;
+}
+#endif
+
 TComWedgeNode::TComWedgeNode()
 {

trunk/source/Lib/TLibCommon/TComWedgelet.h

@@ -58 +58 @@
 #define DIM_NO_IDX     MAX_UINT
 
+#if HS_DMM_SIGNALLING_I0120
+__inline UInt getDimType  ( Int intraMode ) 
+{ 
+    Int dimType = intraMode-DIM_OFFSET; 
+    return (dimType >= 0 && dimType < DIM_NUM_TYPE) ? (UInt)dimType : DIM_NO_IDX; 
+}
+#else
 __inline UInt getDimType  ( Int intraMode ) { Int dimType = (intraMode-DIM_OFFSET)/2; return (dimType >= 0 && dimType < DIM_NUM_TYPE) ? (UInt)dimType : DIM_NO_IDX; }
+#endif
 __inline Bool isDimMode   ( Int intraMode ) { return (getDimType( intraMode ) < DIM_NUM_TYPE); }
+#if !HS_DMM_SIGNALLING_I0120
 __inline Bool isDimDeltaDC( Int intraMode ) { return (isDimMode( intraMode ) && ((intraMode-DIM_OFFSET)%2) == 1); }
+#endif
 #endif
 
@@ -69 +79 @@
 enum WedgeResolution
 {
+#if !SHARP_DMM1_I0110
   DOUBLE_PEL,
+#endif
   FULL_PEL,
   HALF_PEL
@@ -94 +106 @@
 
   Bool* m_pbPattern;
+#if SHARP_DMM1_I0110
+  Bool* m_pbScaledPattern;
+#endif
 
   Void  xGenerateWedgePattern();
@@ -119 +134 @@
   Bool            getIsCoarse() { return m_bIsCoarse; }
   UInt            getAng     () { return m_uiAng; }
+#if SHARP_DMM1_I0110
+  Bool*           getScaledPattern(UInt uiWidth);
+#endif
 
   Void  setWedgelet( UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe, UChar uhOri, WedgeResolution eWedgeRes, Bool bIsCoarse = false );

trunk/source/Lib/TLibCommon/TComYuv.cpp

@@ -689 +689 @@
   UInt iSrc1Stride = pcYuvSrc1->getStride();
   UInt iDstStride  = getStride();
+#if QC_I0129_ARP_FIX
+  Int iIFshift = IF_INTERNAL_PREC - g_bitDepthY;
+  Int iOffSet  = ( 1 << ( iIFshift - 1 ) ) + IF_INTERNAL_OFFS;
+#endif
   for ( y = uiHeight-1; y >= 0; y-- )
   {
@@ -696 +700 @@
       if( bClip )
       {
+#if QC_I0129_ARP_FIX
+        pDst[x] = ClipY( ( pDst[x] + iOffSet ) >> iIFshift );
+#else
         pDst[x] = ClipY( pDst[x] );
+#endif
       }
     }
@@ -719 +727 @@
   UInt  iSrc1Stride = pcYuvSrc1->getCStride();
   UInt  iDstStride  = getCStride();
+#if QC_I0129_ARP_FIX
+  Int iIFshift = IF_INTERNAL_PREC - g_bitDepthC;
+  Int iOffSet  = ( 1 << ( iIFshift - 1 ) ) + IF_INTERNAL_OFFS;
+#endif
   for ( y = uiHeight-1; y >= 0; y-- )
   {
@@ -727 +739 @@
       if( bClip )
       {
+#if QC_I0129_ARP_FIX
+        pDstU[x] = ClipC( ( pDstU[x] + iOffSet ) >> iIFshift );
+        pDstV[x] = ClipC( ( pDstV[x] + iOffSet ) >> iIFshift );
+#else
         pDstU[x] = ClipC( pDstU[x] );
         pDstV[x] = ClipC( pDstV[x] );
+#endif
       }
     }
@@ -744 +761 @@
 {
   subtractARPLuma  ( pcYuvSrc0, pcYuvSrc1,  uiAbsPartIdx, uiWidth    , uiHeight    );
+#if SHARP_ARP_CHROMA_I0104
+  if (uiWidth > 8)
+#endif
   subtractARPChroma( pcYuvSrc0, pcYuvSrc1,  uiAbsPartIdx, uiWidth>>1 , uiHeight>>1 );
 }
@@ -803 +823 @@
 {
   multiplyARPLuma( uiAbsPartIdx , uiWidth , uiHeight , dW );
+#if SHARP_ARP_CHROMA_I0104
+  if (uiWidth > 8)
+#endif
   multiplyARPChroma( uiAbsPartIdx , uiWidth >> 1 , uiHeight >> 1 , dW );
 }

trunk/source/Lib/TLibCommon/TypeDef.h

@@ -68 +68 @@
 #define BUG_FIX_TK65        1
 
+#define MTK_I0093           1
 /////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////   MAJOR DEFINES   ///////////////////////////////////  
@@ -123 +124 @@
                                               // MTK_LOW_LATENCY_IC_ENCODING_H0086  Low-latency IC encoding in JCT3V-H0086
 
+#define SEC_IC_NEIGHBOR_CLIP_I0080        1   // Clipping of neighboring sample position, JCT3V-I0080
+
 
 #if H_3D_NBDV
@@ -172 +175 @@
                                               // MTK_DIS_SPBIP8X4_H0205        Disable bi-prediction for 8x4 and 4x8 sub PU and remove the SPIVMP 2Nx2N restriction
                                               // SEC_ADAPT_DISABLE_IVMP        Disalbing IVMP merge candidates when IC is enabled, JCT3V-H0070
+
+#define SEC_SIMP_SHIFTED_DV_I0086         1   // Simplification of Shifted DV candidate, JCT3V-I0086
 
 #define H_3D_TMVP                         1   // QC_TMVP_C0047 
@@ -215 +220 @@
                                               // MTK_DLT_CODING_FIX_H0091 
 
+#define MTK_SINGLE_DEPTH_MODE_I0095       1   // Single depth mode proposed in JCT3V-I0095
+#if MTK_SINGLE_DEPTH_MODE_I0095
+#define MTK_SINGLE_DEPTH_MODE_CANDIDATE_LIST_SIZE            2 // size of the sample candidate list
+#endif
 
 #define H_3D_INTER_SDC                    1   // INTER SDC, Inter simplified depth coding
@@ -233 +242 @@
                                               // H_3D_FIX_DBBP_IVMP        Fix . Enable IVMP is always disabled, when DBBP is enabled. The original intention is to disable Sub-PU IVMP when DBBP is enabled, not to disable IVMP itself. 
 
+#define SEC_DBBP_EXPLICIT_SIG_I0077       1   // Remove the partition derivation and signal dbbp_flag only when the partion mode is 2NxN/Nx2N, JCT3V-I0077
+#define SEC_DBBP_DISALLOW_8x8_I0078       1   // Disallow DBBP in 8x8 CU, JCT3V-I0078
+#define SHARP_DBBP_SIMPLE_FLTER_I0109     1   // Simple condition and one dimensional dilter for DBBP
+#define SEC_DBBP_DMM4_THRESHOLD_I0076     1   // Simplification of threshold derivation for DBBP and DMM4, JCT3V-I0076
+
 
 #define H_3D_DDD                          1   // Disparity derived depth coding
@@ -238 +252 @@
 #define H_3D_FCO                          0   // Flexible coding order for 3D
 
-
+#define SCU_HS_FAST_INTRA_SDC_I0123       1
 
 // OTHERS
@@ -250 +264 @@
 #endif
 
+#define MTK_I0099_VPS_EX2                 1  ///< JCT3V-I0099, sub-PU size signaling and lim_qt_pred_flag in VPS extension 2
+#define MTK_I0099_FIX                     1  ///< Fix the problem of removing encoder only QTL 
+
 // Rate Control
 #define KWU_FIX_URQ                       1
@@ -255 +272 @@
 #define KWU_RC_MADPRED_E0227              0  ///< JCT3V-E0227, inter-view MAD prediction
 
+#define SEC_VPS_CLEANUP_I0090             1
+#define SEC_HLS_CLEANUP_I0100             1
+
 #endif // H_3D
 
@@ -262 +282 @@
 ///////////////////////////////////   DERIVED DEFINES ///////////////////////////////////  
 /////////////////////////////////////////////////////////////////////////////////////////
+
+// Fixes
+#define FIX_TICKET_79                     1    // Unused VSP code
+#define FIX_TICKET_75                     1    // Bi-pred restriction bug in VSP
+#define FIX_TICKET_68                     1    // MV clipping bug in the sub-PU MPI default MV generation
+#define FIX_TICKET_71                     1    // IC parameters is meaningless in HTM when no training samples are available
+#define FIX_TICKET_77                     1    // Unused variable m_iBitsPerDepthValue
+#define FIX_TICKET_76                     1    // unused functions
+#define FIX_TICKET_62                     1    // buffer overflow for print
+#define FIX_TICKET_61                     1    // layerIdsInSets size check
 
 ///// ***** VIEW SYNTHESIS OPTIMIZAION *********
@@ -283 +313 @@
 #if H_3D_ARP
 #define H_3D_ARP_WFNR                     3
+#define QC_I0129_ARP_FIX                  1
+#define QC_I0051_ARP_SIMP                 1
+#define SHARP_ARP_CHROMA_I0104            1
+#define MTK_I0072_IVARP_SCALING_FIX       1
 #endif
 
@@ -290 +324 @@
 #define H_3D_DIM_SDC                      1   // Simplified Depth Coding method
 #define H_3D_DIM_DLT                      1   // Depth Lookup Table
+#define HS_DMM_SIGNALLING_I0120  1   
+#define SHARP_DMM1_I0110                  1   // LUT size reduction for DMM1 proposed in JCT3V-I0110 
+#define FIX_WARNING                       1   // fix narrowing conversion of NumPocStCurr0,NumPocStCurr1 at TComSlice.cpp
+#define FAST_SDC_OFFSET_DECISION_I0084    1
+#define SEPARATE_FLAG_I0085               1
 
 #if H_3D_DIM_DLT
 #define H_3D_DELTA_DLT                    1
+#define RWTH_DLT_CLIP_I0057               1
 #endif
 #define H_3D_DIM_ENC                      1   // Depth Intra encoder optimizations, includes:
                                               // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
                                               // LG_ZEROINTRADEPTHRESI_A0087
+#define HHI_DMM4_ENC_I0066                1
 #endif
 ///// ***** VIEW SYNTHESIS PREDICTION *********
@@ -381 +422 @@
 
 // OTHERS
-//#define H_MV_HLS_8_HSB_Q0041_03  0 // #3  (HS     /Q0041/hybrid scalability) The proposed text was endorsed, with non-editorial open issues considered as follows 
-:// #define H_MV_HLS_7_OTHER_P0187_1          0 // (OTHER/P0187/NoOutputOfPriorPicsFlag) #1 Inference of NoOutputOfPriorPicsFlag and proposes to take into account colour format and bit depth for the inference in addition to spatial resolution 
+//#define H_MV_HLS_8_HSB_Q0041_03  0 // #3  (HS     /Q0041/hybrid scalability) The proposed text was endorsed, with non-editorial open issues considered as follows ?// #define H_MV_HLS_7_OTHER_P0187_1          0 // (OTHER/P0187/NoOutputOfPriorPicsFlag) #1 Inference of NoOutputOfPriorPicsFlag and proposes to take into account colour format and bit depth for the inference in addition to spatial resolution 
 //#define H_MV_HLS_8_MIS_Q0078_24  0 // #24 (MISC   /Q0078/scan and pic type) , Items 3 b,c and 4, clarifying which pictures in an output layer sets are applied the values of general_progressive_source_flag, general_interlaced_source_flag, general_non_packed_constraint_flag and general_frame_only_constraint_flag.
 //#define H_MV_HLS_7_HRD_P0138_6   0 //     (HRD/P0138/HRD parameters for bitstreams excluding) #6 Decision: Adopt (as revised in updated contribution, with the specification of a flag in the BP SEI (HRD/P0192/sub-DPB) #12 Establish sub-DPBs based on the representation format indicated at the VPS level. It was suggested that the expressed shared capacity limit would need to be less than or equal to the sum of the individual capacity limits. Decision: Adopt as modified. Further study is encouraged on profile/level constraint selections.