Changeset 296 for trunk – JCT-3V 3D-HEVC

trunk/CommonTestConditionsCfgs/baseCfg_2view+depth.cfg

r210	r296
157	157	SignHideFlag : 1 # sign hiding
158	158	SignHideThreshold : 4 # sign hiding threshold
159		IlluCompEnable : 1 # illumination compensation (0: OFF, 1: ON)
	159	IlluCompEnable : 1 1 # illumination compensation (0: OFF, 1: ON)
160	160
161	161	#============ PCM ================

trunk/CommonTestConditionsCfgs/baseCfg_3view+depth.cfg

r210	r296
161	161	SignHideFlag : 1 # sign hiding
162	162	SignHideThreshold : 4 # sign hiding threshold
163		IlluCompEnable : 1 # illumination compensation (0: OFF, 1: ON)
	163	IlluCompEnable : 1 1 # illumination compensation (0: OFF, 1: ON)
164	164
165	165	#============ PCM ================

trunk/source/App/TAppDecoder/TAppDecTop.cpp

-                      r210
+                      r296
 #endif
-#if SONY_COLPIC_AVAILABILITY
-  m_tDecTop[0]->setViewOrderIdx(0);
-#endif
   Int                 viewDepthId = 0;
   Int                 previousViewDepthId  = 0;
 …
     newPicture[i] = false;
 #if FLEX_CODING_ORDER_M23723
-#if  FIX_FCO_COMP_WARNING
     m_fcoOrder[i] = ' ';
-#else
-    m_fcoOrder[i]=NULL;
-#endif
 #endif
 …
       if( ( viewDepthId == 0 && (viewDepthId != previousViewDepthId) ) || m_tDecTop.size() == 1 )
+      {
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
         for( Int i = 0; i < m_tDecTop.size(); i++ )
+        {
 …
       if(newPicture[viewDepthId])
+      {
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
         xWriteOutput( pcListPic[viewDepthId], viewDepthId, nalu.m_temporalId );
-#else
-        xWriteOutput( pcListPic[viewDepthId], viewDepthId );
-#endif
+      }
+    }
 …
+}
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
 Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, Int viewDepthId, UInt tId )
-#else
-Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, Int viewDepthId )
-#endif
+{
   TComList<TComPic*>::iterator iterPic   = pcListPic->begin();
 …
+  {
     TComPic* pcPic = *(iterPic);
-#if PIC_CROPPING
     TComSPS *sps = pcPic->getSlice(0)->getSPS();
-#endif
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
     if ( pcPic->getOutputMark() && (not_displayed >  pcPic->getSlice(0)->getSPS()->getNumReorderPics(tId) && pcPic->getPOC() > m_pocLastDisplay[viewDepthId]))
-#else
-    if ( pcPic->getOutputMark() && (not_displayed >  pcPic->getSlice(0)->getSPS()->getNumReorderFrames() && pcPic->getPOC() > m_pocLastDisplay[viewDepthId]))
-#endif
+    {
       // write to file
 …
       if ( m_pchReconFile )
+      {
-#if PIC_CROPPING
         m_tVideoIOYuvReconFile[viewDepthId]->write( pcPic->getPicYuvRec(), sps->getPicCropLeftOffset(), sps->getPicCropRightOffset(), sps->getPicCropTopOffset(), sps->getPicCropBottomOffset() );
-#else
-        m_tVideoIOYuvReconFile[viewDepthId]->write( pcPic->getPicYuvRec(), pcPic->getSlice(0)->getSPS()->getPad() );
-#endif
+      }
 …
+  {
     TComPic* pcPic = *(iterPic);
-#if PIC_CROPPING
     TComSPS *sps = pcPic->getSlice(0)->getSPS();
-#endif
     if ( pcPic->getOutputMark() )
 …
       if ( m_pchReconFile )
+      {
-#if PIC_CROPPING
         m_tVideoIOYuvReconFile[viewDepthId]->write( pcPic->getPicYuvRec(), sps->getPicCropLeftOffset(), sps->getPicCropRightOffset(), sps->getPicCropTopOffset(), sps->getPicCropBottomOffset() );
-#else
-        m_tVideoIOYuvReconFile[viewDepthId]->write( pcPic->getPicYuvRec(), pcPic->getSlice(0)->getSPS()->getPad() );
-#endif
+      }
 …
 #endif
+}
+#if MERL_VSP_C0152
+Void TAppDecTop::setBWVSPLUT(TComSlice* pcSlice,  Int iCodedViewIdx,  Int iCurPoc)
+{
+  //first view does not have VSP
+  if((iCodedViewIdx == 0)) return;
+  AOT( iCodedViewIdx <= 0);
+  //AOT( iCodedViewIdx >= m_iNumberOfViews );
+  Int iNeighborViewId = 0;
+  //  Int* piShiftLUT = bRenderFromLeft ? m_cCamParsCollector.getBaseViewShiftLUTI()[iCodedViewIdx][iNeighborViewId][0] : m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx][0];
+  Int* piShiftLUT = m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx][0];
+  pcSlice->setBWVSPLUTParam(piShiftLUT, 2-LOG2_DISP_PREC_LUT );
+}
+#endif
 //! \}

trunk/source/App/TAppDecoder/TAppDecTop.h

-                      r210
+                      r296
 #endif
+#if MERL_VSP_C0152
+  Void  setBWVSPLUT( TComSlice* pcSlice, Int iCodedViewIdx, Int iCurPoc   );
+#endif
 protected:
 //  Void  xCreateDecLib     (); ///< create internal classes
 …
 //  Void  xInitDecLib       (); ///< initialize decoder class
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Void  xWriteOutput      ( TComList<TComPic*>* pcListPic, Int viewDepthId, UInt tId); ///< write YUV to file
-#else
-  Void  xWriteOutput      ( TComList<TComPic*>* pcListPic, Int viewDepthId ); ///< write YUV to file
-#endif
   Void  xFlushOutput      ( TComList<TComPic*>* pcListPic, Int viewDepthId ); ///< flush all remaining decoded pictures to file

trunk/source/App/TAppEncoder/TAppEncCfg.cpp

-                      r210
+                      r296
   /* File, I/O and source parameters */
+  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM , "original Yuv input file name %d")
+  ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM , "original Yuv depth input file name %d")
+  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv output file name %d")
+  ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv depth output file name %d")
+  ("BitstreamFile,b", cfg_BitstreamFile, string(""), "bitstream output file name")
+  ("CodeDepthMaps",         m_bUsingDepthMaps, false, "Encode depth maps" )
+  ("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
+  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( double )1.0, "Lambda modifier for temporal layer 0")
+  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( double )1.0, "Lambda modifier for temporal layer 1")
+  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( double )1.0, "Lambda modifier for temporal layer 2")
+  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( double )1.0, "Lambda modifier for temporal layer 3")
+  ("SourceWidth,-wdt",      m_iSourceWidth,  0, "Source picture width")
+  ("SourceHeight,-hgt",     m_iSourceHeight, 0, "Source picture height")
+#if PIC_CROPPING
+  ("CroppingMode",          m_croppingMode,  0, "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
+  ("CropLeft",              m_cropLeft,      0, "Left cropping/padding for cropping mode 3")
+  ("CropRight",             m_cropRight,     0, "Right cropping/padding for cropping mode 3")
+  ("CropTop",               m_cropTop,       0, "Top cropping/padding for cropping mode 3")
+  ("CropBottom",            m_cropBottom,    0, "Bottom cropping/padding for cropping mode 3")
+  ("HorizontalPadding,-pdx",m_aiPad[0],      0, "horizontal source padding for cropping mode 2")
+  ("VerticalPadding,-pdy",  m_aiPad[1],      0, "vertical source padding for cropping mode 2")
+#endif
+  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM ,   "original Yuv input file name %d")
+  ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM ,   "original Yuv depth input file name %d")
+  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv output file name %d")
+  ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv depth output file name %d")
+  ("BitstreamFile,b",         cfg_BitstreamFile,        string(""),                   "bitstream output file name")
+  ("CodeDepthMaps",           m_bUsingDepthMaps,        false,                        "Encode depth maps" )
+  ("CodedCamParsPrecision",   m_iCodedCamParPrecision,  STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
+  ("LambdaModifier0,-LM0",    m_adLambdaModifier[ 0 ],  ( double )1.0,                "Lambda modifier for temporal layer 0")
+  ("LambdaModifier1,-LM1",    m_adLambdaModifier[ 1 ],  ( double )1.0,                "Lambda modifier for temporal layer 1")
+  ("LambdaModifier2,-LM2",    m_adLambdaModifier[ 2 ],  ( double )1.0,                "Lambda modifier for temporal layer 2")
+  ("LambdaModifier3,-LM3",    m_adLambdaModifier[ 3 ],  ( double )1.0,                "Lambda modifier for temporal layer 3")
+  ("SourceWidth,-wdt",        m_iSourceWidth,           0,                            "Source picture width")
+  ("SourceHeight,-hgt",       m_iSourceHeight,          0,                            "Source picture height")
+  ("CroppingMode",            m_croppingMode,           0,                            "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
+  ("CropLeft",                m_cropLeft,               0,                            "Left cropping/padding for cropping mode 3")
+  ("CropRight",               m_cropRight,              0,                            "Right cropping/padding for cropping mode 3")
+  ("CropTop",                 m_cropTop,                0,                            "Top cropping/padding for cropping mode 3")
+  ("CropBottom",              m_cropBottom,             0,                            "Bottom cropping/padding for cropping mode 3")
+  ("HorizontalPadding,-pdx",  m_aiPad[0],               0,                            "horizontal source padding for cropping mode 2")
+  ("VerticalPadding,-pdy",    m_aiPad[1],               0,                            "vertical source padding for cropping mode 2")
   ("InputBitDepth",         m_uiInputBitDepth, 8u, "bit-depth of input file")
   ("BitDepth",              m_uiInputBitDepth, 8u, "deprecated alias of InputBitDepth")
   ("OutputBitDepth",        m_uiOutputBitDepth, 0u, "bit-depth of output file")
   ("InternalBitDepth",      m_uiInternalBitDepth, 0u, "Internal bit-depth (BitDepth+BitIncrement)")
-#if !PIC_CROPPING
-  ("HorizontalPadding,-pdx",m_aiPad[0],      0, "horizontal source padding size")
-  ("VerticalPadding,-pdy",  m_aiPad[1],      0, "vertical source padding size")
-  ("PAD",                   m_bUsePAD,   false, "automatic source padding of multiple of 16" )
-#endif
   ("FrameRate,-fr",         m_iFrameRate,        0, "Frame rate")
   ("FrameSkip,-fs",         m_FrameSkip,         0u, "Number of frames to skip at start of input YUV")
   ("FramesToBeEncoded,f",   m_iFrameToBeEncoded, 0, "number of frames to be encoded (default=all)")
   ("FrameToBeEncoded",        m_iFrameToBeEncoded, 0, "deprecated alias of FramesToBeEncoded")
+  ("FrameToBeEncoded",      m_iFrameToBeEncoded, 0, "deprecated alias of FramesToBeEncoded")
   ("NumberOfViews",         m_iNumberOfViews,    0, "Number of views")
 …
   ("DecodingRefreshType,-dr",m_iDecodingRefreshType, 0, "intra refresh, (0:none 1:CRA 2:IDR)")
   ("GOPSize,g",      m_iGOPSize,      1, "GOP size of temporal structure")
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-  ("MaxNumberOfReorderPictures",   m_numReorderFrames,               -1, "Max. number of reorder pictures: -1: encoder determines value, >=0: set explicitly")
-  ("MaxNumberOfReferencePictures", m_maxNumberOfReferencePictures, 6, "Max. number of reference pictures")
-#endif
   ("ListCombination,-lc", m_bUseLComb, true, "combined reference list flag for uni-prediction in B-slices")
   ("LCModification", m_bLCMod, false, "enables signalling of combined reference list derivation")
 …
   ("TemporalLayerQPOffset_L3,-tq3", m_aiTLayerQPOffset[3], MAX_QP + 1, "QP offset of temporal layer 3")
-#if !H0566_TLA
-  ("TLayeringBasedOnCodingStruct,-tl", m_bTLayering, false, "Temporal ID is set based on the hierarchical coding structure")
-  ("TLayerSwitchingFlag_L0,-ts0", m_abTLayerSwitchingFlag[0], false, "Switching flag for temporal layer 0")
-  ("TLayerSwitchingFlag_L1,-ts1", m_abTLayerSwitchingFlag[1], false, "Switching flag for temporal layer 1")
-  ("TLayerSwitchingFlag_L2,-ts2", m_abTLayerSwitchingFlag[2], false, "Switching flag for temporal layer 2")
-  ("TLayerSwitchingFlag_L3,-ts3", m_abTLayerSwitchingFlag[3], false, "Switching flag for temporal layer 3")
-#endif
   /* Entropy coding parameters */
 …
   ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
 #if LGE_ILLUCOMP_B0045
+#if LGE_ILLUCOMP_DEPTH_C0046
+  ("IlluCompEnable", m_abUseIC, std::vector<Bool>(2, true), "Enable illumination compensation for inter-view prediction")
+#else
   ("IlluCompEnable",                  m_bUseIC                  , true         , "Use illumination compensation for inter-view prediction" )
 #endif
+#if DBL_CONTROL
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  ("IVSEnable",                       m_bUseIVS                 , true         , "Use inter-view vector scaling" )
+#endif
   ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, true)
-#endif
   /* Camera Paremetes */
 …
   ("PredDepthMapGen",  m_uiPredDepthMapGeneration, (UInt)0, "generation of prediction depth maps for motion data prediction" )
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   ("MultiviewMvPred",  m_uiMultiviewMvPredMode,    (UInt)0, "usage of predicted depth maps" )
   ("MultiviewMvRegMode",        m_uiMultiviewMvRegMode,         (UInt)0, "regularization mode for multiview motion vectors" )
   ("MultiviewMvRegLambdaScale", m_dMultiviewMvRegLambdaScale, (Double)0, "lambda scale for multiview motion vector regularization" )
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   ("MultiviewResPred", m_uiMultiviewResPredMode,   (UInt)0, "usage of inter-view residual prediction" )
 #endif
 …
   ("ALF", m_abUseALF, std::vector<Bool>(1,true), "Enables ALF")
   ("SAO", m_abUseSAO, std::vector<Bool>(1, true), "SAO")
-#if SAO_UNIT_INTERLEAVING
   ("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "2048: default")
   ("SAOInterleaving", m_saoInterleavingFlag, false, "0: SAO Picture Mode, 1: SAO Interleaving ")
-#endif
   ("ALFEncodePassReduction", m_iALFEncodePassReduction, 0, "0:Original 16-pass, 1: 1-pass, 2: 2-pass encoding")
   ("ALFMaxNumFilter,-ALFMNF", m_iALFMaxNumberFilters, 16, "16: No Constrained, 1-15: Constrained max number of filter")
-#if LCU_SYNTAX_ALF
   ("ALFParamInSlice", m_bALFParamInSlice, false, "ALF parameters in 0: APS, 1: slice header")
   ("ALFPicBasedEncode", m_bALFPicBasedEncode, true, "ALF picture-based encoding 0: false, 1: true")
-#endif
     ("SliceMode",            m_iSliceMode,           0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes")
 …
     ("TileInfoPresentFlag",         m_iColumnRowInfoPresent,         1,          "0: tiles parameters are NOT present in the PPS. 1: tiles parameters are present in the PPS")
     ("UniformSpacingIdc",           m_iUniformSpacingIdr,            0,          "Indicates if the column and row boundaries are distributed uniformly")
-#if !REMOVE_TILE_DEPENDENCE
-    ("TileBoundaryIndependenceIdc", m_iTileBoundaryIndependenceIdr,  1,          "Indicates if the column and row boundaries break the prediction")
-#endif
     ("NumTileColumnsMinus1",        m_iNumColumnsMinus1,             0,          "Number of columns in a picture minus 1")
     ("ColumnWidthArray",            cfg_ColumnWidth,                 string(""), "Array containing ColumnWidth values in units of LCU")
 …
     ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
     ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
-#if MULTIBITS_DATA_HIDING
     ("SignHideFlag,-SBH",                m_signHideFlag, 1)
     ("SignHideThreshold,-TSIG",          m_signHidingThreshold,         4)
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
   ("DMM",                         m_bUseDMM,                       false,      "depth model modes flag")
 …
   ("FEN", m_bUseFastEnc, false, "fast encoder setting")
   ("ECU", m_bUseEarlyCU, false, "Early CU setting")
-#if FAST_DECISION_FOR_MRG_RD_COST
   ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
-#endif
   ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
 #if HHI_INTERVIEW_SKIP
 …
+  }
-#if PIC_CROPPING
   switch (m_croppingMode)
+  {
 …
+    }
+  }
-#else
-  // compute source padding size
-  if ( m_bUsePAD )
+  {
-    if ( m_iSourceWidth%MAX_PAD_SIZE )
+    {
-      m_aiPad[0] = (m_iSourceWidth/MAX_PAD_SIZE+1)*MAX_PAD_SIZE - m_iSourceWidth;
+    }
-    if ( m_iSourceHeight%MAX_PAD_SIZE )
+    {
-      m_aiPad[1] = (m_iSourceHeight/MAX_PAD_SIZE+1)*MAX_PAD_SIZE - m_iSourceHeight;
+    }
+  }
-  m_iSourceWidth  += m_aiPad[0];
-  m_iSourceHeight += m_aiPad[1];
-#endif
   // allocate slice-based dQP values
 …
   xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
   xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
-#if H0736_AVC_STYLE_QP_RANGE
   xConfirmPara( m_aiQP[0] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[0] > 51,         "QP exceeds supported range (-QpBDOffsety to 51)" );
   if ( m_aiQP.size() >= 2 )
 …
     xConfirmPara( m_aiQP[1] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[1] > 51,       "QP depth exceeds supported range (-QpBDOffsety to 51)" );
+  }
-#else
-  xConfirmPara( m_aiQP[0] < 0 || m_aiQP[0] > 51,                                             "QP exceeds supported range (0 to 51)" );
-  if ( m_aiQP.size() >= 2 )
+  {
-    xConfirmPara( m_aiQP[1] < 0 || m_aiQP[1] > 51,                                           "QP Depth exceeds supported range (0 to 51)" );
+  }
-#endif
   xConfirmPara( m_iALFEncodePassReduction < 0 || m_iALFEncodePassReduction > 2,             "ALFEncodePassReduction must be equal to 0, 1 or 2");
-#if LCU_SYNTAX_ALF
   xConfirmPara( m_iALFMaxNumberFilters < 1,                                                 "ALFMaxNumFilter should be larger than 1");
-#else
-  xConfirmPara( m_iALFMaxNumberFilters < 1 || m_iALFMaxNumberFilters > 16,                  "ALFMaxNumFilter exceeds supported range (1 to 16)");
-#endif
   xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 || m_loopFilterBetaOffsetDiv2 > 13,          "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
   xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 || m_loopFilterTcOffsetDiv2 > 13,              "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
 …
   xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
   xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
-#if PIC_CROPPING
   xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
   xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
-#else
-  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Frame width should be multiple of minimum CU size");
-  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Frame height should be multiple of minimum CU size");
-#endif
   xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
 …
   xConfirmPara    ( m_uiPredDepthMapGeneration >= 2 && !m_bUsingDepthMaps,            "PredDepthMapGen >= 2 requires CodeDepthMaps = 1" );
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   xConfirmPara    ( m_uiMultiviewMvPredMode > 7,                                      "MultiviewMvPred must be less than or equal to 7" );
   xConfirmPara    ( m_uiMultiviewMvPredMode > 0 && m_uiPredDepthMapGeneration == 0 ,  "MultiviewMvPred > 0 requires PredDepthMapGen > 0" );
 …
+  }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   xConfirmPara    ( m_uiMultiviewResPredMode > 1,                                     "MultiviewResPred must be less than or equal to 1" );
   xConfirmPara    ( m_uiMultiviewResPredMode > 0 && m_uiPredDepthMapGeneration == 0 , "MultiviewResPred > 0 requires PredDepthMapGen > 0" );
 …
+  }
 #if ADAPTIVE_QP_SELECTION
-#if H0736_AVC_STYLE_QP_RANGE
   xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[0] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
   xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[1] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
   xConfirmPara( m_bUseAdaptQpSelect == true && (m_iChromaQpOffset !=0 || m_iChromaQpOffset2nd != 0 ),  "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
-#endif
 #endif
 …
+  }
-#if FIXED_NUMBER_OF_TILES_SLICE_MODE
   xConfirmPara( m_iSliceMode < 0 || m_iSliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
-#endif
   if (m_iSliceMode!=0)
+  {
     xConfirmPara( m_iSliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
+  }
-#if FIXED_NUMBER_OF_TILES_SLICE_MODE
   if (m_iSliceMode==3)
+  {
     xConfirmPara( m_iSliceGranularity > 0 ,      "When SliceMode == 3 is chosen, the SliceGranularity must be 0" );
+  }
-#endif
   xConfirmPara( m_iEntropySliceMode < 0 || m_iEntropySliceMode > 2, "EntropySliceMode exceeds supported range (0 to 2)" );
   if (m_iEntropySliceMode!=0)
 …
   xConfirmPara( m_iSliceGranularity > m_iMaxCuDQPDepth, "SliceGranularity must be smaller smaller than or equal to maximum dqp depth" );
-#if NO_COMBINED_PARALLEL
   bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
   xConfirmPara( tileFlag && m_iEntropySliceMode,            "Tile and Entropy Slice can not be applied together");
   xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
   xConfirmPara( m_iWaveFrontSynchro && m_iEntropySliceMode, "Wavefront and Entropy Slice can not be applied together");
-#endif
   // max CU width and height should be power of 2
 …
       for( Int i = 0; i < MAX_GOP; i++ ) { isOK[i] = false; }
       Int numOK = 0;
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-      Int numReorderFramesRequired=0;
-      m_maxNumberOfReferencePictures=0;
-      Int lastDisp = -1;
-#endif
       m_extraRPSs[viewId] = 0;
       //start looping through frames in coding order until we can verify that the GOP structure is correct.
 …
+            }
+          }
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-          if(m_maxNumberOfReferencePictures<numRefs)
+          {
-            m_maxNumberOfReferencePictures=numRefs;
+          }
-#endif
           refList[numRefs] = curPOC;
           numRefs++;
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-          Int nonDisplayed=0;
-          for(Int i=0; i<numRefs; i++)
+          {
-            if(refList[i]==lastDisp+1)
+            {
-              lastDisp=refList[i];
-              i=0;
+            }
+          }
-          for(Int i=0; i<numRefs; i++)
+          {
-            if(refList[i]>lastDisp)
+            {
-              nonDisplayed++;
+            }
+          }
-          if(nonDisplayed>numReorderFramesRequired)
+          {
-            numReorderFramesRequired=nonDisplayed;
+          }
-#endif
+        }
         checkGOP++;
+      }
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-      if (m_numReorderFrames == -1)
+      {
-        m_numReorderFrames = numReorderFramesRequired;
+      }
-#endif
       xConfirmPara( errorGOP, "Invalid GOP structure given" );
-#if H0566_TLA
       m_maxTempLayer[viewId] = 1;
-#endif
       for( Int i = 0; i < m_iGOPSize; i++ )
+      {
-#if H0566_TLA
         if( m_GOPListsMvc[viewId][i].m_temporalId >= m_maxTempLayer[viewId] )
+        {
           m_maxTempLayer[viewId] = m_GOPListsMvc[viewId][i].m_temporalId + 1;
+        }
-#endif
         xConfirmPara( m_GOPListsMvc[viewId][i].m_sliceType != 'B' && m_GOPListsMvc[viewId][i].m_sliceType != 'P', "Slice type must be equal to B or P" );
+      }
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
       for( Int i = 0; i < MAX_TLAYER; i++ )
+      {
 …
         m_maxDecPicBuffering[viewId][MAX_TLAYER-1] = m_numReorderPics[viewId][MAX_TLAYER-1];
+      }
+#endif
+#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
       xConfirmPara( m_bUseLComb == false && m_numReorderPics[viewId][MAX_TLAYER-1] != 0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" );  // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
-#else
-      xConfirmPara( m_bUseLComb==false && m_numReorderFrames!=0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" );  // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
-      xConfirmPara( m_numReorderFrames < numReorderFramesRequired, "For the used GOP the encoder requires more pictures for reordering than specified in MaxNumberOfReorderPictures" );
-#endif
+    }
+  }
 …
+    }
+  }
-#if PIC_CROPPING
   printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_cropLeft - m_cropRight, m_iSourceHeight - m_cropTop - m_cropBottom, m_iFrameRate );
-#else
-  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_aiPad[0], m_iSourceHeight-m_aiPad[1], m_iFrameRate );
-#endif
   printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
   printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_iFrameToBeEncoded-1, m_iFrameToBeEncoded );
 …
   printf("TOOL CFG General: ");
-#if LCU_SYNTAX_ALF
   printf("ALFMNF:%d ", m_iALFMaxNumberFilters);
   printf("ALFInSlice:%d ", m_bALFParamInSlice);
   printf("ALFPicEnc:%d ", m_bALFPicBasedEncode);
-#endif
   printf("IBD:%d ", !!g_uiBitIncrement);
   printf("HAD:%d ", m_bUseHADME           );
 …
   printf("SQP:%d ", m_uiDeltaQpRD         );
   printf("ASR:%d ", m_bUseASR             );
-#if !PIC_CROPPING
-  printf("PAD:%d ", m_bUsePAD             );
-#endif
   printf("LComb:%d ", m_bUseLComb         );
   printf("LCMod:%d ", m_bLCMod         );
   printf("FEN:%d ", m_bUseFastEnc         );
   printf("ECU:%d ", m_bUseEarlyCU         );
-#if FAST_DECISION_FOR_MRG_RD_COST
   printf("FDM:%d ", m_useFastDecisionForMerge );
-#endif
   printf("CFM:%d ", m_bUseCbfFastMode         );
   printf("RQT:%d ", 1     );
 …
+  }
   printf("CIP:%d ", m_bUseConstrainedIntraPred);
-#if BURST_IPCM
   printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
-#else
-  printf("PCM:%d ", ((1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
-#endif
-#if SAO_UNIT_INTERLEAVING
   printf("SAOInterleaving:%d ", (m_saoInterleavingFlag)?(1):(0));
-#endif
 #if LOSSLESS_CODING
   printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
 …
   printf("WPP:%d ", (Int)m_bUseWeightPred);
   printf("WPB:%d ", m_uiBiPredIdc);
-#if !REMOVE_TILE_DEPENDENCE
-  printf("TileBoundaryIndependence:%d ", m_iTileBoundaryIndependenceIdr );
-#endif
   printf("TileLocationInSliceHdr:%d ", m_iTileLocationInSliceHeaderFlag);
   printf("TileMarker:%d", m_iTileMarkerFlag);
 …
 #endif
-#if MULTIBITS_DATA_HIDING
   printf(" SignBitHidingFlag:%d SignBitHidingThreshold:%d", m_signHideFlag, m_signHidingThreshold);
-#endif
   printf("\n");
   printf("TOOL CFG VIDEO  : ");
 …
 #endif
 #if LGE_ILLUCOMP_B0045
+#if LGE_ILLUCOMP_DEPTH_C0046
+  printf("IlluCompEnable: %d %d", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0);
+#else
   printf("IlluCompEnable: %d ", m_bUseIC);
 #endif
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  printf("IVSEnable: %d ", m_bUseIVS);
+#endif
   printf("\n");

trunk/source/App/TAppEncoder/TAppEncCfg.h

-                      r210
+                      r296
   Int       m_iSourceWidth;                                   ///< source width in pixel
   Int       m_iSourceHeight;                                  ///< source height in pixel
-#if PIC_CROPPING
   Int       m_croppingMode;
   Int       m_cropLeft;
 …
   Int       m_cropTop;
   Int       m_cropBottom;
-#endif
   Int       m_iFrameToBeEncoded;                              ///< number of encoded frames
-#if !PIC_CROPPING
-  Bool      m_bUsePAD;                                        ///< flag for using source padding
-#endif
   Int       m_aiPad[2];                                       ///< number of padded pixels for width and height
 …
   Int       m_extraRPSs[MAX_VIEW_NUM];
   GOPEntryMvc m_GOPListsMvc[MAX_VIEW_NUM][MAX_GOP+1];
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Int       m_numReorderPics[MAX_VIEW_NUM][MAX_TLAYER];       ///< total number of reorder pictures
   Int       m_maxDecPicBuffering[MAX_VIEW_NUM][MAX_TLAYER];   ///< total number of reference pictures needed for decoding
-#else
-  Int       m_numReorderFrames;                               ///< total number of reorder pictures
-  Int       m_maxNumberOfReferencePictures;                   ///< total number of reference pictures needed for decoding
-#endif
   Bool      m_bUseLComb;                                      ///< flag for using combined reference list for uni-prediction in B-slices (JCTVC-D421)
   Bool      m_bLCMod;                                         ///< flag for specifying whether the combined reference list for uni-prediction in B-slices is uploaded explicitly
 …
   Int       m_iQPAdaptationRange;                             ///< dQP range by QP adaptation
-#if H0566_TLA
   Int       m_maxTempLayer[MAX_VIEW_NUM];                     ///< Max temporal layer
-#else
-  Bool      m_bTLayering;                                     ///< indicates whether temporal IDs are set based on the hierarchical coding structure
-  Bool      m_abTLayerSwitchingFlag[MAX_TLAYER];              ///< temporal layer switching flags corresponding to each temporal layer
-#endif
   // coding unit (CU) definition
 …
   vector<Bool> m_abUseSAO;
 #if LGE_ILLUCOMP_B0045
+#if LGE_ILLUCOMP_DEPTH_C0046
+  vector<Bool> m_abUseIC;                                    ///< flag for using illumination compensation for inter-view prediction
+#else
   Bool      m_bUseIC;                                     ///< flag for using illumination compensation for inter-view prediction
 #endif
+#if SAO_UNIT_INTERLEAVING
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Bool      m_bUseIVS;                                        ///< flag for using inter-view vector scaling
+#endif
   Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
   Bool      m_saoInterleavingFlag;                            ///< SAO interleaving flag
-#endif
   // coding tools (loop filter)
   vector<Bool> m_abUseALF;                                    ///< flag for using adaptive loop filter [0] - video, [1] - depth
 …
   Int       m_iALFMaxNumberFilters;                           ///< ALF Max Number Filters in one picture
-#if LCU_SYNTAX_ALF
   Bool      m_bALFParamInSlice;
   Bool      m_bALFPicBasedEncode;
-#endif
   vector<Bool> m_abLoopFilterDisable;                         ///< flag for using deblocking filter filter [0] - video, [1] - depth
 …
   Int       m_loopFilterBetaOffsetDiv2;                     ///< beta offset for deblocking filter
   Int       m_loopFilterTcOffsetDiv2;                       ///< tc offset for deblocking filter
-#if DBL_CONTROL
   Bool      m_DeblockingFilterControlPresent;                 ///< deblocking filter control present flag in PPS
-#endif
   Bool      m_bUseLMChroma;                                  ///< JL: Chroma intra prediction based on luma signal
 …
   UInt      m_uiPredDepthMapGeneration;                       ///< using of (virtual) depth maps for texture coding
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   UInt      m_uiMultiviewMvPredMode;                          ///< usage of predictors for multi-view mv prediction
   UInt      m_uiMultiviewMvRegMode;                           ///< regularization for multiview motion vectors
   Double    m_dMultiviewMvRegLambdaScale;                     ///< lambda scale for multiview motion vectors regularization
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt      m_uiMultiviewResPredMode;          ///< using multiview residual prediction
 #endif
-#if FAST_DECISION_FOR_MRG_RD_COST
   Bool      m_useFastDecisionForMerge;         ///< flag for using Fast Decision Merge RD-Cost
-#endif
   Bool      m_bUseCbfFastMode;                 ///< flag for using Cbf Fast PU Mode Decision
   Int       m_iSliceMode;                      ///< 0: Disable all Recon slice limits, 1 : Maximum number of largest coding units per slice, 2: Maximum number of bytes in a slice
 …
   Int       m_iColumnRowInfoPresent;
   Int       m_iUniformSpacingIdr;
-#if !REMOVE_TILE_DEPENDENCE
-  Int       m_iTileBoundaryIndependenceIdr;
-#endif
   Int       m_iNumColumnsMinus1;
   char*     m_pchColumnWidth;
 …
 #endif
-#if MULTIBITS_DATA_HIDING
   Int       m_signHideFlag;
   Int       m_signHidingThreshold;
-#endif
 #if HHI_MPI
   Bool      m_bUseMVI;  ///< flag for using Motion Vector Inheritance for depth map coding

trunk/source/App/TAppEncoder/TAppEncTop.cpp

-                      r210
+                      r296
     m_acTEncTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
     m_acTEncTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
-#if PIC_CROPPING
     m_acTEncTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
     m_acTEncTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
 …
     m_acTEncTopList[iViewIdx]->setCropTop                      ( m_cropTop );
     m_acTEncTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
-#endif
     m_acTEncTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
     m_acTEncTopList[iViewIdx]->setViewId                       ( iViewIdx );
 …
     m_cVPS.setDependentFlag                                    ( iViewIdx ? true:false, layerId );
     m_cVPS.setDependentLayer                                   ( layerId - (m_bUsingDepthMaps ? 2:1), layerId );
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    m_cVPS.setIVScalingFlag                                    ( m_bUseIVS );
+#endif
 #endif
 …
     m_acTEncTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
     m_acTEncTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
     for(Int i = 0; i < MAX_TLAYER; i++)
+    {
 …
       m_acTEncTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
+    }
-#else
-    m_acTEncTopList[iViewIdx]->setNumReorderFrames             ( m_numReorderFrames );
-    m_acTEncTopList[iViewIdx]->setMaxNumberOfReferencePictures ( m_maxNumberOfReferencePictures );
-#endif
     for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
+    {
 …
     m_acTEncTopList[iViewIdx]->setPad                          ( m_aiPad );
-#if H0566_TLA
     m_acTEncTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
-#else
-    m_acTEncTopList[iViewIdx]->setTLayering                    ( m_bTLayering );
-    m_acTEncTopList[iViewIdx]->setTLayerSwitchingFlag          ( m_abTLayerSwitchingFlag );
-#endif
     m_acTEncTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
 …
     m_acTEncTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
     m_acTEncTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
-#if DBL_CONTROL
     m_acTEncTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
-#endif
   //====== Motion search ========
 …
 #if LOSSLESS_CODING
     Int lowestQP;
-#if H0736_AVC_STYLE_QP_RANGE
     lowestQP =  - ( (Int)(6*(g_uiBitDepth + g_uiBitIncrement - 8)) );
-#else
-    lowestQP = 0;
-#endif
     if ((m_iMaxDeltaQP == 0 ) && (m_aiQP[0] == lowestQP) && (m_useLossless == true))
+    {
 …
     m_acTEncTopList[iViewIdx]->setPdmOffset                    (       m_cCameraData.getPdmOffset        () );
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     m_acTEncTopList[iViewIdx]->setMultiviewMvPredMode          ( m_uiMultiviewMvPredMode );
     m_acTEncTopList[iViewIdx]->setMultiviewMvRegMode           ( iViewIdx ? m_uiMultiviewMvRegMode       : 0   );
     m_acTEncTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( iViewIdx ? m_dMultiviewMvRegLambdaScale : 0.0 );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     m_acTEncTopList[iViewIdx]->setMultiviewResPredMode         ( m_uiMultiviewResPredMode );
 #endif
 …
     m_acTEncTopList[iViewIdx]->setdQPs                         ( m_aidQP        );
     m_acTEncTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[0] );
-#if !PIC_CROPPING
-    m_acTEncTopList[iViewIdx]->setUsePAD                       ( m_bUsePAD      );
-#endif
     m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
     m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
 …
     m_acTEncTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
     m_acTEncTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  );
-#if FAST_DECISION_FOR_MRG_RD_COST
     m_acTEncTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
-#endif
     m_acTEncTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
 #if HHI_INTERVIEW_SKIP
 …
       m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
+    }
-#if FIXED_NUMBER_OF_TILES_SLICE_MODE
     if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
+    {
       m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
+    }
-#endif
     m_acTEncTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
     if(m_iSliceMode == 0 )
 …
     m_acTEncTopList[iViewIdx]->setUseSAO               ( m_abUseSAO[0]     );
 #if LGE_ILLUCOMP_B0045
+#if LGE_ILLUCOMP_DEPTH_C0046
+    m_acTEncTopList[iViewIdx]->setUseIC                ( m_abUseIC[0]      );
+#else
     m_acTEncTopList[iViewIdx]->setUseIC                ( m_bUseIC          );
 #endif
+#if SAO_UNIT_INTERLEAVING
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    m_acTEncTopList[iViewIdx]->setUseIVS               ( m_bUseIVS          );
+#endif
     m_acTEncTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
     m_acTEncTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
-#endif
     m_acTEncTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
     m_acTEncTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
 …
     m_acTEncTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
     m_acTEncTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
-#if !REMOVE_TILE_DEPENDENCE
-    m_acTEncTopList[iViewIdx]->setTileBoundaryIndependenceIdr( m_iTileBoundaryIndependenceIdr );
-#endif
     m_acTEncTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
     m_acTEncTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
 …
     m_acTEncTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
     m_acTEncTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
-#if !REMOVE_TILE_DEPENDENCE
-    if(m_iTileBoundaryIndependenceIdr == 0 || uiTilesCount == 1)
-#else
     if(uiTilesCount == 1)
-#endif
+    {
       m_bLFCrossTileBoundaryFlag = true;
 …
     m_acTEncTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
     m_acTEncTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
-#if MULTIBITS_DATA_HIDING
     m_acTEncTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
     m_acTEncTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
+#endif
+#if LCU_SYNTAX_ALF
     if(uiTilesCount > 1)
+    {
 …
     m_acTEncTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
     m_acTEncTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
-#endif
     //====== Depth tools ========
 …
       m_acTEncDepthTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
       m_acTEncDepthTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
-#if PIC_CROPPING
       m_acTEncDepthTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
       m_acTEncDepthTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
 …
       m_acTEncDepthTopList[iViewIdx]->setCropTop                      ( m_cropTop );
       m_acTEncDepthTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
-#endif
       m_acTEncDepthTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
       m_acTEncDepthTopList[iViewIdx]->setViewId                       ( iViewIdx );
 …
       m_acTEncDepthTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
       m_acTEncDepthTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
       for(Int i = 0; i < MAX_TLAYER; i++)
+      {
 …
         m_acTEncDepthTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
+      }
-#else
-      m_acTEncDepthTopList[iViewIdx]->setNumReorderFrames             ( m_numReorderFrames );
-      m_acTEncDepthTopList[iViewIdx]->setMaxNumberOfReferencePictures ( m_maxNumberOfReferencePictures );
-#endif
       for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
+      {
 …
       m_acTEncDepthTopList[iViewIdx]->setPad                          ( m_aiPad );
-#if H0566_TLA
       m_acTEncDepthTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
-#else
-      m_acTEncDepthTopList[iViewIdx]->setTLayering                    ( m_bTLayering );
-      m_acTEncDepthTopList[iViewIdx]->setTLayerSwitchingFlag          ( m_abTLayerSwitchingFlag );
-#endif
       m_acTEncDepthTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
 …
       m_acTEncDepthTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
       m_acTEncDepthTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
-#if DBL_CONTROL
       m_acTEncDepthTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
-#endif
       //====== Motion search ========
 …
       m_acTEncDepthTopList[iViewIdx]->setdQPs                         ( m_aidQPdepth   );
       m_acTEncDepthTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[1] );
-#if !PIC_CROPPING
-      m_acTEncDepthTopList[iViewIdx]->setUsePAD                       ( m_bUsePAD      );
-#endif
       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
 …
       m_acTEncDepthTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
       m_acTEncDepthTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  );
-#if FAST_DECISION_FOR_MRG_RD_COST
       m_acTEncDepthTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
-#endif
       m_acTEncDepthTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
 #if HHI_INTERVIEW_SKIP
 …
       m_acTEncDepthTopList[iViewIdx]->setPredDepthMapGeneration       ( 0 );
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvPredMode          ( 0 );
       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegMode           ( 0 );
       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( 0.0 );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       m_acTEncDepthTopList[iViewIdx]->setMultiviewResPredMode         ( 0 );
 #endif
 …
         m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
+      }
-#if FIXED_NUMBER_OF_TILES_SLICE_MODE
       if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
+      {
         m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
+      }
-#endif
       m_acTEncDepthTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
       if(m_iSliceMode == 0 )
 …
       m_acTEncDepthTopList[iViewIdx]->setUseIC                ( false     );
 #endif
+#if SAO_UNIT_INTERLEAVING
+#if INTER_VIEW_VECTOR_SCALING_C0115
+     m_acTEncDepthTopList[iViewIdx]->setUseIVS                ( m_bUseIVS );
+#endif
       m_acTEncDepthTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
       m_acTEncDepthTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
-#endif
       m_acTEncDepthTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
       m_acTEncDepthTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
 …
       m_acTEncDepthTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
       m_acTEncDepthTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
-#if !REMOVE_TILE_DEPENDENCE
-      m_acTEncDepthTopList[iViewIdx]->setTileBoundaryIndependenceIdr( m_iTileBoundaryIndependenceIdr );
-#endif
       m_acTEncDepthTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
       m_acTEncDepthTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
 …
       m_acTEncDepthTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
       m_acTEncDepthTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
-#if !REMOVE_TILE_DEPENDENCE
-      if(m_iTileBoundaryIndependenceIdr == 0 || uiTilesCount == 1)
-#else
       if(uiTilesCount == 1)
-#endif
+      {
         m_bLFCrossTileBoundaryFlag = true;
 …
       m_acTEncDepthTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
       m_acTEncDepthTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
-#if MULTIBITS_DATA_HIDING
       m_acTEncDepthTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
       m_acTEncDepthTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
+#endif
+#if LCU_SYNTAX_ALF
       if(uiTilesCount > 1)
+      {
 …
       m_acTEncDepthTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
       m_acTEncDepthTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
-#endif
   //====== Depth tools ========
 …
+  }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   else if( m_uiMultiviewMvRegMode )
+  {
 …
       m_acTEncDepthTopList[iViewIdx]->create();
+    }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     else if( m_uiMultiviewMvRegMode )
+    {
 …
   TComPicYuv*       pcPicYuvRec = NULL;
   TComPicYuv*       pcDepthPicYuvRec = NULL;
   // initialize internal class & member variables
   xInitLibCfg();
 …
   pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   if( m_uiMultiviewMvRegMode )
+  {
 …
         m_acTVideoIOYuvInputFileList[iViewIdx]->read( pcPicYuvOrg, m_aiPad );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
         if( m_uiMultiviewMvRegMode && iViewIdx )
+        {
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
         m_acTEncTopList[iViewIdx]->initNewPic( pcPicYuvOrg, ( m_uiMultiviewMvRegMode && iViewIdx ? pcPdmDepthOrg : 0 ) );
 #else
 …
       if ( iNextPoc < m_iFrameToBeEncoded )
+      {
       m_cCameraData.update( iNextPoc );
+        m_cCameraData.update( iNextPoc );
+      }
 #endif
 …
 #endif
         iNumEncoded = 0;
+#if MERL_VSP_C0152
+        Int iCurPoc = m_acTEncDepthTopList[iViewIdx]->getFrameId(gopId);
+        if( iCurPoc < m_acTEncDepthTopList[iViewIdx]->getFrameToBeEncoded() && iViewIdx!=0 )
+        {
+          TComPic* pcBaseTxtPic   = getPicFromView(  0, m_acTEncDepthTopList[iViewIdx]->getFrameId(gopId), false ); //get base view reconstructed texture
+          TComPic* pcBaseDepthPic = getPicFromView(  0, m_acTEncDepthTopList[iViewIdx]->getFrameId(gopId), true );  //get base view reconstructed depth
+          TEncSlice* pEncSlice = m_acTEncTopList[iViewIdx]->getSliceEncoder();
+          pEncSlice->setRefPicBaseTxt(pcBaseTxtPic);
+          pEncSlice->setRefPicBaseDepth(pcBaseDepthPic);
+        }
+        setBWVSPLUT( iViewIdx, gopId, false);
+#endif
         // call encoding function for one frame
         m_acTEncTopList[iViewIdx]->encode( eos[iViewIdx], pcPicYuvOrg, *m_picYuvRec[iViewIdx], outputAccessUnits, iNumEncoded, gopId );
 …
+        {
           Int  iNumDepthEncoded = 0;
+#if MERL_VSP_C0152
+        Int iCurPocDepth = m_acTEncDepthTopList[iViewIdx]->getFrameId(gopId);
+        if( iCurPocDepth < m_acTEncDepthTopList[iViewIdx]->getFrameToBeEncoded() && iViewIdx!=0 )
+        {
+          TComPic* pcBaseDepthPic = getPicFromView(  0, m_acTEncDepthTopList[iViewIdx]->getFrameId(gopId), true );
+          TEncSlice* pcSlice = (TEncSlice*) m_acTEncDepthTopList[iViewIdx]->getSliceEncoder();
+          pcSlice->setRefPicBaseDepth(pcBaseDepthPic);
+        }
+        setBWVSPLUT( iViewIdx, gopId, true);
+#endif
           // call encoding function for one depth frame
           m_acTEncDepthTopList[iViewIdx]->encode( depthEos[iViewIdx], pcDepthPicYuvOrg, *m_picYuvDepthRec[iViewIdx], outputAccessUnits, iNumDepthEncoded, gopId );
 …
 #endif
 #if HHI_INTERVIEW_SKIP || HHI_INTER_VIEW_MOTION_PRED || HHI_INTER_VIEW_RESIDUAL_PRED
+#if HHI_INTERVIEW_SKIP || H3D_IVMP || H3D_IVRP
       for( Int iViewIdx = 0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
+      {
 …
 #if !QC_MVHEVC_B0046
-#if FIX_DEL_NULLPTR
   if ( pcPdmDepthOrg != NULL && m_uiMultiviewMvRegMode )
-#else
-  if ( pcPdmDepthOrg != NULL )
-#endif
+  {
     pcPdmDepthOrg->destroy();
 …
         if (m_pchReconFileList[iViewIdx])
+        {
-#if PIC_CROPPING
           m_acTVideoIOYuvReconFileList[iViewIdx]->write( pcPicYuvRec, m_cropLeft, m_cropRight, m_cropTop, m_cropBottom );
-#else
-          m_acTVideoIOYuvReconFileList[iViewIdx]->write( pcPicYuvRec, m_aiPad );
-#endif
+        }
+      }
 …
         if (m_pchDepthReconFileList[iViewIdx])
+        {
-#if PIC_CROPPING
           m_acTVideoIOYuvDepthReconFileList[iViewIdx]->write( pcPicYuvRec, m_cropLeft, m_cropRight, m_cropTop, m_cropBottom );
-#else
-          m_acTVideoIOYuvDepthReconFileList[iViewIdx]->write( pcPicYuvRec, m_aiPad );
-#endif
+        }
+      }
 …
+    {
     case NAL_UNIT_CODED_SLICE:
-#if H0566_TLA
 #if !QC_REM_IDV_B0046
     case NAL_UNIT_CODED_SLICE_IDV:
 …
     case NAL_UNIT_CODED_SLICE_TLA:
     case NAL_UNIT_CODED_SLICE_CRA:
-#else
-    case NAL_UNIT_CODED_SLICE_DATAPART_A:
-    case NAL_UNIT_CODED_SLICE_DATAPART_B:
-    case NAL_UNIT_CODED_SLICE_CDR:
-#endif
     case NAL_UNIT_CODED_SLICE_IDR:
     case NAL_UNIT_SPS:
 …
 #endif
+#if MERL_VSP_C0152
+Void TAppEncTop::setBWVSPLUT(Int iCodedViewIdx, Int gopId, Bool isDepth)
+{
+  //first view does not have VSP
+  if((iCodedViewIdx == 0)) return;
+  AOT( iCodedViewIdx <= 0);
+  AOT( iCodedViewIdx >= m_iNumberOfViews );
+  Int iNeighborViewId = 0;
+  //setting look-up table
+  Int* piShiftLUT = m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx][0];
+  if(isDepth)
+  {
+    TEncSlice* pcEncSlice = (TEncSlice*) m_acTEncDepthTopList[iCodedViewIdx]->getSliceEncoder();
+    pcEncSlice->setBWVSPLUTParam(  piShiftLUT, LOG2_DISP_PREC_LUT );
+  }
+  else
+  {
+    TEncSlice* pcEncSlice = (TEncSlice*) m_acTEncTopList[iCodedViewIdx]->getSliceEncoder();
+    pcEncSlice->setBWVSPLUTParam(  piShiftLUT, LOG2_DISP_PREC_LUT );
+  }
+}
+#endif
 //! \}

trunk/source/App/TAppEncoder/TAppEncTop.h

-                      r210
+                      r296
   TRenTop  m_cUsedPelsRenderer;                               ///< renderer for used pels map
 #endif
 protected:
   // initialization
 …
 #endif
+#if MERL_VSP_C0152
+  Void setBWVSPLUT( Int iCodedViewIdx, Int gopId, Bool isDepth);
+#endif
 };// END CLASS DEFINITION TAppEncTop

trunk/source/App/TAppRenderer/TAppRendererTop.cpp

-                      r210
+                      r296
       // Write Output
-#if PIC_CROPPING
       m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iSynthViewIdx]->write( pcPicYuvSynthOut, 0, 0, 0, 0 );
-#else
-      m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iSynthViewIdx]->write( pcPicYuvSynthOut, aiPad );
-#endif
+    }
     iFrame++;
 …
           // Write Output
-#if PIC_CROPPING
           m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iModelNum]->write( pcPicYuvSynthOut, 0 ,0 ,0, 0 );
-#else
-          m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iModelNum]->write( pcPicYuvSynthOut, aiPad );
-#endif
+        }
+      }
 …
       // Write Output
-#if PIC_CROPPING
       m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iSynthViewIdx]->write( pcPicYuvSynthOut, 0, 0, 0, 0 );
-#else
-      m_apcTVideoIOYuvSynthOutput[m_bSweep ? 0 : iSynthViewIdx]->write( pcPicYuvSynthOut, aiPad );
-#endif
+    }
     iFrame++;
 …
       // Write Output
-#if PIC_CROPPING
       m_apcTVideoIOYuvSynthOutput[iViewIdx-1]->write( pcPicYuvSynthOut, 0, 0, 0 );
-#else
-      m_apcTVideoIOYuvSynthOutput[iViewIdx-1]->write( pcPicYuvSynthOut, aiPad );
-#endif
+    }

trunk/source/Lib/TAppCommon/TAppComCamPara.cpp

r106	r296
89	89	}
90	90
91
92	91	Void
93	92	TAppComCamPara::xCreate2dArray( UInt uiNum1Ids, UInt uiNum2Ids, Int**& raaiArray )
…	…
928	927	}
929	928
930
931	929	Void
932	930	TAppComCamPara::xSetShiftParametersAndLUT( UInt uiFrame )

trunk/source/Lib/TAppCommon/TAppComCamPara.h

-                      r102
+                      r296
   Int****             m_aiSynthViewShiftLUT;                   ///< Disparity LUT
 protected:
   // create and delete arrays
 …
   Void  xSetShiftParametersAndLUT ( UInt uiNumViewDim1, UInt uiNumViewDim2, UInt uiFrame, Bool bExternalReference, Double****& radLUT, Int****& raiLUT, Double***& radShiftParams, Int64***& raiShiftParams );
   Void  xSetShiftParametersAndLUT ( UInt uiFrame );
   // getting conversion parameters for disparity to virtual depth conversion

trunk/source/Lib/TLibCommon/CommonDef.h

-                      r211
+                      r296
 #define MAX_VIEW_NUM                10
 #if ( HHI_INTER_VIEW_MOTION_PRED || HHI_INTER_VIEW_RESIDUAL_PRED )
+#if ( H3D_IVMP || H3D_IVRP )
 #define DEPTH_MAP_GENERATION        1
 #define PDM_REMOVE_DEPENDENCE       1      //bug-fix for DMDV JCT2-A0095
 …
 #define PDM_MERGE_POS                     0         // position of pdm in merge list (0..4)
+#if QC_MRG_CANS_B0048
+#if OL_DISMV_POS_B0069
+#if H3D_IVMP
 #define DMV_MERGE_POS                     4
 #else
 #define DMV_MERGE_POS                     1
 #endif
+#endif
+#if SAIT_IMPROV_MOTION_PRED_M24829&!QC_MULTI_DIS_CAN_A0097
+#if H3D_IVMP&!H3D_NBDV
 #define PDM_AMVP_POS                      0         // position of pdm in amvp list  (0..3)
 #else
 …
 // AMVP: advanced motion vector prediction
 #define AMVP_MAX_NUM_CANDS          2           ///< max number of final candidates
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 #define AMVP_MAX_NUM_CANDS_MEM      4           ///< max number of candidates
 #else
 …
 // MERGE
 #define MRG_MAX_NUM_CANDS           5
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 #define MRG_MAX_NUM_CANDS_MEM       (MRG_MAX_NUM_CANDS+1) // one extra for inter-view motion prediction
 #endif
 …
 // Explicit temporal layer QP offset
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
 #define MAX_TLAYER                  8           ///< max number of temporal layer
-#else
-#define MAX_TLAYER                  4           ///< max number of temporal layer
-#endif
 #define HB_LAMBDA_FOR_LDC           1           ///< use of B-style lambda for non-key pictures in low-delay mode
 …
 #define MAX_NUM_REF_PICS 16
-#if !NAL_REF_FLAG
-enum NalRefIdc
+{
-  NAL_REF_IDC_PRIORITY_LOWEST = 0,
-  NAL_REF_IDC_PRIORITY_LOW,
-  NAL_REF_IDC_PRIORITY_HIGH,
-  NAL_REF_IDC_PRIORITY_HIGHEST
-};
-#endif
 enum NalUnitType
 …
   NAL_UNIT_UNSPECIFIED_0 = 0,
   NAL_UNIT_CODED_SLICE,
-#if H0566_TLA
 #if QC_REM_IDV_B0046
   NAL_UNIT_RESERVED,
 …
   NAL_UNIT_CODED_SLICE_TLA,
   NAL_UNIT_CODED_SLICE_CRA,
-#else
-  NAL_UNIT_CODED_SLICE_DATAPART_A,
-  NAL_UNIT_CODED_SLICE_DATAPART_B,
-  NAL_UNIT_CODED_SLICE_CDR,
-#endif
   NAL_UNIT_CODED_SLICE_IDR,
   NAL_UNIT_SEI,

trunk/source/Lib/TLibCommon/ContextModel.cpp

-                      r56
+                      r296
 Void ContextModel::init( Int qp, Int initValue )
+{
-#if H0736_AVC_STYLE_QP_RANGE
   qp = Clip3(0, 51, qp);
-#endif
-#if CABAC_LINEAR_INIT
   Int  slope      = (initValue>>4)*5 - 45;
   Int  offset     = ((initValue&15)<<3)-16;
 …
   UInt mpState    = (initState >= 64 );
   m_ucState       = ( (mpState? (initState - 64):(63 - initState)) <<1) + mpState;
-#else
-  Int m = m_slopes[initValue>>4];
-  Int n = initValue & 15;
-  Int val = max( 0, min( 3839, (n<<8) + m * (qp-26) + 128 ) );
-  val -= 1920;
-  Int valMps = val >= 0;
-  val = ( val ^ (val>>11) ) + 128;
-  Int segmentIdx = val >> 8;
-  Int pStateIdx = m_accumulatedSegOffset[segmentIdx] + ( (val&255) * m_segOffset[segmentIdx] >> 8);
-  m_ucState = (pStateIdx<<1) + valMps;
-#endif
+}
 …
 #endif
 };
-#if !CABAC_LINEAR_INIT
-const Int ContextModel::m_slopes[16] = { -239, -143, -85, -51, -31, -19, -11, 0, 11, 19, 31, 51, 85, 143, 239, 399 };
-const Int ContextModel::m_segOffset[8]            = {   6,  7,  5,  7, 10, 14, 16,  1 };
-const Int ContextModel::m_accumulatedSegOffset[8] = {  -3,  3, 10, 15, 22, 32, 46, 62 };
-#endif
 //! \}

trunk/source/Lib/TLibCommon/ContextModel.h

-                      r56
+                      r296
   static UChar m_nextState[128][2];
 #endif
-#if !CABAC_LINEAR_INIT
-  static const Int m_slopes[16];
-  static const Int m_segOffset[8];
-  static const Int m_accumulatedSegOffset[8];
-#endif
 #if CABAC_INIT_FLAG
   UInt          m_binsCoded;

trunk/source/Lib/TLibCommon/ContextTables.h

-                      r189
+                      r296
 #define NUM_MERGE_FLAG_EXT_CTX        1       ///< number of context models for merge flag of merge extended
-#if MRG_IDX_CTX_RED
 #define NUM_MERGE_IDX_EXT_CTX         1       ///< number of context models for merge index of merge extended
+#else
+#define NUM_MERGE_IDX_EXT_CTX         4       ///< number of context models for merge index of merge extended
+#endif
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 #define NUM_RES_PRED_FLAG_CTX         4       ///< number of context for residual prediction flag
 #endif
 …
 #define NUM_ALF_CTRL_FLAG_CTX         1       ///< number of context models for ALF control flag
 #define NUM_PART_SIZE_CTX             4       ///< number of context models for partition size
-#if AMP_CTX
 #define NUM_CU_AMP_CTX                1       ///< number of context models for partition size (AMP)
-#else
-#define NUM_CU_X_POS_CTX              2       ///< number of context models for partition size (AMP)
-#define NUM_CU_Y_POS_CTX              2       ///< number of context models for partition size (AMP)
-#endif
 #define NUM_PRED_MODE_CTX             1       ///< number of context models for prediction mode
 …
 #define NUM_SIG_FLAG_CTX_LUMA         27      ///< number of context models for luma sig flag
 #define NUM_SIG_FLAG_CTX_CHROMA       21      ///< number of context models for chroma sig flag
-#if LAST_CTX_REDUCTION
 #define NUM_CTX_LAST_FLAG_XY          15      ///< number of context models for last coefficient position
+#else
+#define NUM_CTX_LAST_FLAG_XY          18      ///< number of context models for last coefficient position
+#endif
+#if LEVEL_CTX_LUMA_RED
 #define NUM_ONE_FLAG_CTX              24      ///< number of context models for greater than 1 flag
 #define NUM_ONE_FLAG_CTX_LUMA         16      ///< number of context models for greater than 1 flag of luma
 #define NUM_ONE_FLAG_CTX_CHROMA        8      ///< number of context models for greater than 1 flag of chroma
-#if RESTRICT_GR1GR2FLAG_NUMBER
 #define NUM_ABS_FLAG_CTX               6      ///< number of context models for greater than 2 flag
 #define NUM_ABS_FLAG_CTX_LUMA          4      ///< number of context models for greater than 2 flag of luma
 #define NUM_ABS_FLAG_CTX_CHROMA        2      ///< number of context models for greater than 2 flag of chroma
-#else
-#define NUM_ABS_FLAG_CTX              18      ///< number of context models for greater than 2 flag
-#define NUM_ABS_FLAG_CTX_LUMA         12      ///< number of context models for greater than 2 flag of luma
-#define NUM_ABS_FLAG_CTX_CHROMA        6      ///< number of context models for greater than 2 flag of chroma
-#endif
-#else
-#define NUM_ONE_FLAG_CTX              32      ///< number of context models for greater than 1 flag
-#define NUM_ONE_FLAG_CTX_LUMA         24      ///< number of context models for greater than 1 flag of luma
-#define NUM_ONE_FLAG_CTX_CHROMA        8      ///< number of context models for greater than 1 flag of chroma
-#if RESTRICT_GR1GR2FLAG_NUMBER
-#define NUM_ABS_FLAG_CTX               8      ///< number of context models for greater than 2 flag
-#define NUM_ABS_FLAG_CTX_LUMA          6      ///< number of context models for greater than 2 flag of luma
-#define NUM_ABS_FLAG_CTX_CHROMA        2      ///< number of context models for greater than 2 flag of chroma
-#else
-#define NUM_ABS_FLAG_CTX              24      ///< number of context models for greater than 2 flag
-#define NUM_ABS_FLAG_CTX_LUMA         18      ///< number of context models for greater than 2 flag of luma
-#define NUM_ABS_FLAG_CTX_CHROMA        6      ///< number of context models for greater than 2 flag of chroma
-#endif
-#endif
 #define NUM_MVP_IDX_CTX               2       ///< number of context models for MVP index
 …
 #define NUM_SAO_UVLC_CTX              2       ///< number of context models for SAO UVLC
 #define NUM_SAO_SVLC_CTX              3       ///< number of context models for SAO SVLC
-#if SAO_UNIT_INTERLEAVING
 #define NUM_SAO_RUN_CTX               3       ///< number of context models for AO SVLC (filter coeff.)
 #define NUM_SAO_MERGE_LEFT_FLAG_CTX   3       ///< number of context models for AO SVLC (filter coeff.)
 #define NUM_SAO_MERGE_UP_FLAG_CTX     1       ///< number of context models for AO SVLC (filter coeff.)
 #define NUM_SAO_TYPE_IDX_CTX          2       ///< number of context models for AO SVLC (filter coeff.)
-#endif
-#if CABAC_LINEAR_INIT
 #define CNU                          154      ///< dummy initialization value for unused context models 'Context model Not Used'
-#else
-#define CNU                          119      ///< dummy initialization value for unused context models 'Context model Not Used'
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 #define NUM_DMM_FLAG_CTX              1       ///< number of context models for DMM flag
 #define NUM_DMM_MODE_CTX              1       ///< number of context models for DMM mode
+#if LGE_DMM3_SIMP_C0044
+#define NUM_DMM_DATA_CTX              4       ///< number of context models for DMM data
+#else
 #define NUM_DMM_DATA_CTX              3       ///< number of context models for DMM data
+#endif
 #endif
 …
 // initial probability for split flag
-#if CABAC_LINEAR_INIT
 static const UChar
 INIT_SPLIT_FLAG[3][NUM_SPLIT_FLAG_CTX] =
 …
 INIT_MERGE_IDX_EXT[3][NUM_MERGE_IDX_EXT_CTX] =
+{
-#if MRG_IDX_CTX_RED
   { CNU, },
   { 122, },
   { 137, },
+#else
+  { CNU,  CNU,  CNU,  CNU, },
+  { 122,  138,  153,  182, },
+  { 137,  139,  154,  139, },
+#endif
+};
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+};
+#if H3D_IVRP
 static const UChar
 INIT_RES_PRED_FLAG[3][NUM_RES_PRED_FLAG_CTX] =
 …
 };
-#if AMP_CTX
 static const UChar
 INIT_CU_AMP_POS[3][NUM_CU_AMP_CTX] =
 …
   { 154, },
 };
-#else
-static const UChar
-INIT_CU_X_POS[3][NUM_CU_X_POS_CTX] =
+{
-  { CNU,  CNU, },
-  { 154,  139, },
-  { 154,  139, },
-};
-static const UChar
-INIT_CU_Y_POS[3][NUM_CU_Y_POS_CTX] =
+{
-  { CNU,  CNU, },
-  { 154,  154, },
-  { 154,  139, },
-};
-#endif
 static const UChar
 …
 };
-#if LAST_CTX_REDUCTION
 static const UChar
 INIT_LAST[3][2*NUM_CTX_LAST_FLAG_XY] =
 …
   },
 };
-#else
-static const UChar
-INIT_LAST[3][2*NUM_CTX_LAST_FLAG_XY] =
+{
-  { 110,  110,  124,  110,  140,  111,  124,  125,  111,  127,  111,  138,  111,  156,  127,  127,  111,   94,
-,  123,   63,   63,  139,  124,   93,  108,  125,  111,  110,   63,  CNU,  CNU,  CNU,  CNU,  CNU,  CNU,
-  },
-  { 125,  110,  124,  110,  125,  110,  153,  125,  111,  111,  110,  153,  139,  111,  111,  111,  125,  139,
-,  123,  108,  152,  124,   94,  123,  137,  139,  110,  110,  154,  CNU,  CNU,  CNU,  CNU,  CNU,  CNU,
-  },
-  { 125,  110,  124,  110,  125,  110,  153,  125,  111,  111,  110,  153,  139,  111,  111,  111,  125,  139,
-,  123,   93,  152,  124,   94,  123,  152,  139,  110,  110,  154,  CNU,  CNU,  CNU,  CNU,  CNU,  CNU,
-  },
-};
-#endif
 static const UChar
 …
 };
-#if LEVEL_CTX_LUMA_RED
 static const UChar
 INIT_ONE_FLAG[3][NUM_ONE_FLAG_CTX] =
 …
 };
-#if RESTRICT_GR1GR2FLAG_NUMBER
 static const UChar
 INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
 …
   { 107,  167,   91,  107,  107,  167, },
 };
-#else
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
-  { 138,  139,  111,  153,  139,  111,  136,  167,  139,  167,  153,  139,  152,  139,  140,  152,  184,  141, },
-  { 107,  153,  125,  167,  153,  140,   91,  137,  153,  122,  167,  139,  107,  153,  140,  167,  183,  140, },
-  { 107,  153,  125,  167,  153,  140,   91,  137,  153,  107,  167,  139,  107,  153,  140,  167,  183,  140, },
-};
-#endif
-#else
-static const UChar
-INIT_ONE_FLAG[3][NUM_ONE_FLAG_CTX] =
+{
-  { 140,   92,  137,  138,  140,  152,  138,  139,  126,  168,  139,  139,  153,   74,  149,   92,  139,  107,  122,  152,  110,   93,  152,  138,  140,  179,  166,  182,  140,  227,  122,  197, },
-  { 154,  196,  196,  167,  154,  152,  167,  182,  155,  139,  139,  139,  182,  134,  149,  136,  153,  121,  136,  137,  139,  122,  152,  167,  169,  194,  166,  167,  154,  167,  137,  182, },
-  { 154,  196,  167,  167,  154,  152,  167,  182,  155,  139,  139,  139,  182,  134,  149,  136,  153,  121,  136,  122,  139,  107,  152,  152,  169,  208,  166,  167,  154,  152,  167,  182, },
-};
-#if RESTRICT_GR1GR2FLAG_NUMBER
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
-  { 138,  153,  139,  136,  167,  153,  152,  152, },
-  { 107,  167,  139,   91,  122,  152,  107,  167, },
-  { 107,  167,  139,   91,  107,   93,  107,  167, },
-};
-#else
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
-  { 138,  139,  111,  153,  139,  111,  139,  125,  111,  136,  167,  139,  167,  153,  139,  153,  139,  110,  152,  139,  140,  152,  184,  141, },
-  { 107,  153,  125,  167,  153,  140,  139,  154,  155,   91,  137,  153,  122,  167,  139,  152,  138,  139,  107,  153,  140,  167,  183,  140, },
-  { 107,  153,  125,  167,  153,  140,  139,  154,  155,   91,  137,  153,  107,  167,  139,   93,  138,  139,  107,  153,  140,  167,  183,  140, },
-};
-#endif
-#endif
 static const UChar
 …
 };
-#if SAO_UNIT_INTERLEAVING
 static const UChar
 INIT_SAO_MERGE_LEFT_FLAG[3][NUM_SAO_MERGE_LEFT_FLAG_CTX] =
 …
   { 200,  140, },
 };
-#endif
 static const UChar
 …
 { CNU,  153,  138,  138,  CNU,  CNU,  CNU,  CNU,  CNU,  CNU, },
 };
+#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
+#if FIX_DMM_CTX_INIT_C0034
+static const UChar
 #else
+static const Short
+#endif
+INIT_DMM_FLAG[3][NUM_DMM_FLAG_CTX] =
+{
+  {
+    CNU
+  },
+  {
+    CNU
+  },
+  {
+    CNU
+  }
+};
+#if FIX_DMM_CTX_INIT_C0034
 static const UChar
+INIT_SPLIT_FLAG[3][NUM_SPLIT_FLAG_CTX] =
+{
+  {
+,  74, 107,
   },
+  {
 , 103, 105,
   },
+  {
 , 103, 105,
   },
 };
+// initial probability for skip flag
+#else
+static const Short
+#endif
+INIT_DMM_MODE[3][NUM_DMM_MODE_CTX] =
+{
+  {
+    CNU
+  },
+  {
+    CNU
+  },
+  {
+    CNU
+  }
+};
+#if FIX_DMM_CTX_INIT_C0034
 static const UChar
-INIT_SKIP_FLAG[3][NUM_SKIP_FLAG_CTX] =
+{
+  {
-    CNU, CNU, CNU,
-  },
+  {
-, 168, 154,
-  },
+  {
-, 168, 154,
-  },
-};
-// initial probability for skip flag
-static const UChar
-INIT_ALF_CTRL_FLAG[3][NUM_ALF_CTRL_FLAG_CTX] =
+{
+  {
-,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-// initial probability for merge flag
-static const UChar
-INIT_MERGE_FLAG_EXT[3][NUM_MERGE_FLAG_EXT_CTX] =
+{
+  {
-    CNU,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-static const UChar
-INIT_MERGE_IDX_EXT[3][NUM_MERGE_IDX_EXT_CTX] =
+{
-#if MRG_IDX_CTX_RED
+  {
-    CNU,
-  },
+  {
-,
-  },
+  {
-,
-  },
 #else
+  {
+    CNU, CNU, CNU, CNU,
+  },
+  {
+,  86, 102, 133,
+  },
+  {
+,  87, 119, 103,
+  },
+#endif
+};
+// initial probability for PU size
+static const UChar
+INIT_PART_SIZE[3][NUM_PART_SIZE_CTX] =
+{
+  {
+, CNU, CNU, CNU,
+  },
+  {
+,  87, CNU, CNU,
+  },
+  {
+,  87, CNU, CNU,
+  },
+};
+#if AMP_CTX
+static const UChar
+INIT_CU_AMP_POS[3][NUM_CU_AMP_CTX] =
+{
+  {
+    CNU,
+  },
+  {
+,
+  },
+  {
+,
+  },
+};
+static const Short
+#endif
+INIT_DMM_DATA[3][NUM_DMM_DATA_CTX] =
+{
+#if LGE_DMM3_SIMP_C0044
+  {
+    CNU, CNU, CNU, CNU
+  },
+  {
+    CNU, CNU, CNU, CNU
+  },
+  {
+    CNU, CNU, CNU, CNU
+  }
 #else
-// initial probability for AMP split position (X)
-static const UChar
-INIT_CU_X_POS[3][NUM_CU_X_POS_CTX] =
+{
+  {
-    CNU, CNU,
-  },
+  {
-, 103,
-  },
+  {
-, 103,
-  },
-};
-// initial probability for AMP split position (Y)
-static const UChar
-INIT_CU_Y_POS[3][NUM_CU_Y_POS_CTX] =
+{
+  {
-    CNU, CNU,
-  },
+  {
-, 119,
-  },
+  {
-, 103,
-  },
-};
-#endif
-// initial probability for prediction mode
-static const UChar
-INIT_PRED_MODE[3][NUM_PRED_MODE_CTX] =
+{
+  {
-    CNU,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-// initial probability for intra direction of luma
-static const UChar
-INIT_INTRA_PRED_MODE[3][NUM_ADI_CTX] =
+{
+  {
-,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-// initial probability for intra direction of chroma
-static const UChar
-INIT_CHROMA_PRED_MODE[3][NUM_CHROMA_PRED_CTX] =
+{
+  {
-, 103,
-  },
+  {
-,  87,
-  },
+  {
-,  87,
-  },
-};
-// initial probability for temporal direction
-static const UChar
-INIT_INTER_DIR[3][NUM_INTER_DIR_CTX] =
+{
+  {
-    CNU, CNU, CNU, CNU,
-  },
+  {
-    CNU, CNU, CNU, CNU,
-  },
+  {
-,  39,  38,  36,
-  },
-};
-// initial probability for motion vector difference
-static const UChar
-INIT_MVD[3][NUM_MV_RES_CTX] =
+{
+  {
-    CNU, CNU,
-  },
+  {
-, 166,
-  },
+  {
-, 166,
-  },
-};
-// initial probability for reference frame index
-static const UChar
-INIT_REF_PIC[3][NUM_REF_NO_CTX] =
+{
+  {
-    CNU, CNU, CNU, CNU,
-  },
+  {
-, 118, 103, CNU,
-  },
+  {
-, 118, 134, CNU,
-  },
-};
-// initial probability for dQP
-static const UChar
-INIT_DQP[3][NUM_DELTA_QP_CTX] =
+{
+  {
-    CNU, CNU, CNU,
-  },
+  {
-    CNU, CNU, CNU,
-  },
+  {
-    CNU, CNU, CNU,
-  },
-};
-static const UChar
-INIT_QT_CBF[3][2*NUM_QT_CBF_CTX] =
+{
+  {
-,  74, CNU, CNU, CNU,
-,  86, 133, CNU, CNU,
-  },
+  {
-,  89, CNU, CNU, CNU,
-,  84, 117, CNU, CNU,
-  },
+  {
-,  89, CNU, CNU, CNU,
-,  68, 117, CNU, CNU,
-  },
-};
-static const UChar
-INIT_QT_ROOT_CBF[3][NUM_QT_ROOT_CBF_CTX] =
+{
+  {
-    CNU,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-#if LAST_CTX_REDUCTION
-static const UChar
-INIT_LAST[3][2*NUM_CTX_LAST_FLAG_XY] =
+{
+  {
-,  72,  71,  72, 104,  89,  88,  89,  59,  73,  89, 106,  60,  59,  43,
-,  70,  53,  CNU, CNU, CNU,  CNU, CNU, CNU,  CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-,  72,  55,  72,  57,  72,   88,  73,  73,  72,  103,  73,  89,  73,  57,
-,  70,  54,  CNU, CNU, CNU,  CNU, CNU, CNU,  CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-,  72,  71,  72,  57,  72,  88,  73,  73,  72,   103,  73,  89,  73,  57,
-,  70,  69,   CNU, CNU, CNU,  CNU, CNU, CNU,  CNU, CNU, CNU, CNU, CNU, CNU,
-  },
-};
-#else
-static const UChar
-INIT_LAST[3][2*NUM_CTX_LAST_FLAG_XY] =
+{
+  {
-,  72,  71,  72, 104,  89,  71,  88,  89,  59,  73,  86,  89, 106,  60,  59,  43,  55,
-,  70,  53,  53,  87,  71,  69,  54,  88,  73,  72,  53, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-,  72,  71,  72,  57,  72, 102,  88,  73,  73,  72, 102, 103,  73,  89,  73,  57,  87,
-,  70,  54, 101,  71,  55,  70, 116, 103,  72,  72, 119, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-,  72,  71,  72,  57,  72, 102,  88,  73,  73,  72, 118, 103,  73,  89,  73,  57,  87,
-,  70,  69,  85,  71,  55,  70,  85, 103,  72,  72, 119, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
-};
-#endif
-static const UChar
-INIT_SIG_CG_FLAG[3][2 * NUM_SIG_CG_FLAG_CTX] =
+{
+  {
-, 122,
-, 121,
-  },
+  {
-, 120,
-, 119,
-  },
+  {
-, 120,
-, 119,
-  },
-};
-static const UChar
-INIT_SIG_FLAG[3][NUM_SIG_FLAG_CTX] =
+{
+  {
-,  73,  88,  72,  72,  55,  71,  54,  71,  88, 103,  71,  53,  87, 134,  86,  84,  70,  68,  89,  90,  84,  88,  74, 130, 118,  88,
-,  87, 149,  70,  52, 118, 133, 116, 114, 129, 132, 162, 115,  51, 115,  66, 120,  74, 115,  87,  89,
-  },
+  {
-, 119, 103, 118,  87,  70,  70,  53, 118, 134, 118, 101,  68,  85, 101, 116, 100,  68,  67, 136, 168, 147, 150, 120, 115, 118, 119,
-, 102,  70,  53,  67, 117, 102, 117, 115, 114,  84, 115,  99, 100,  83, 114, 152, 168, 131, 150, 120,
-  },
+  {
-, 119, 103, 118,  87,  70,  70,  53,  71, 103, 118, 101,  68,  85, 101, 116, 116,  68,  67, 152, 168, 147, 150, 120, 115, 118, 119,
-, 102,  86,  84,  67, 117, 102, 117, 115,  99, 100, 115,  99, 100,  83, 114, 152, 152, 131, 150, 120,
-  },
-};
-#if LEVEL_CTX_LUMA_RED
-static const UChar
-INIT_ONE_FLAG[3][NUM_ONE_FLAG_CTX] =
+{
+  {
-,  68, 116,  86, 104, 132,  86,  87, 102,  66, 114,  68,  87,  84, 100, 101,
-, 130, 147, 149, 104, 196, 100, 165,
-  },
+  {
-, 179, 179, 164, 119,  85, 117, 149, 133,  98, 114, 115, 118,  99, 115, 116,
-, 146, 147, 164, 119, 148, 116, 133,
-  },
+  {
-, 179, 148, 164, 119,  85, 117, 149, 133,  98, 114, 115, 118,  99, 115, 100,
-, 177, 147, 164, 119, 132, 148, 149,
-  },
-};
-#if RESTRICT_GR1GR2FLAG_NUMBER
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
+  {
-, 102, 115, 117, 101, 101,
-  },
+  {
-, 117, 83, 100, 84, 117,
-  },
+  {
-, 117, 83,  84, 84, 117,
-  },
-};
-#else
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
+  {
-, 103,  73, 102, 103,  73, 115, 117, 103, 117, 118, 103,
-, 103, 104, 101, 167, 121,
-  },
+  {
-, 102,  88, 117, 118, 104, 83, 116, 118, 100, 117,  87,
-, 118, 120, 117, 150, 120,
-    },
+    {
-, 102,  88, 117, 118, 104, 83, 116, 118,  84, 117,  87,
-, 118, 120, 117, 150, 120,
-    },
-};
-#endif
-#else
-static const UChar
-INIT_ONE_FLAG[3][NUM_ONE_FLAG_CTX] =
+{
+  {
-,  68, 116,  86, 104, 132,  86,  87, 105, 134,  87, 103, 102,  66, 114,  68,  87,  84, 100, 101,  72,  69, 101,  86,
-, 130, 147, 149, 104, 196, 100, 165,
-  },
+  {
-, 179, 179, 164, 119,  85, 117, 149, 136, 103, 103, 103, 133,  98, 114, 115, 118,  99, 115, 116,  87, 100,  85, 117,
-, 146, 147, 164, 119, 148, 116, 133,
-  },
+  {
-, 179, 148, 164, 119,  85, 117, 149, 136,  87, 103, 103, 133,  98, 114, 115, 118,  99, 115, 100,  87,  84,  85,  85,
-, 177, 147, 164, 119, 132, 148, 149,
-  },
-};
-#if RESTRICT_GR1GR2FLAG_NUMBER
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
+  {
-, 102, 103, 115, 117, 102, 101, 101,
-  },
+  {
-, 117, 103, 83, 100, 85, 84, 117,
-  },
+  {
-, 117, 87, 83, 84, 69, 84, 117,
-  },
-};
-#else
-static const UChar
-INIT_ABS_FLAG[3][NUM_ABS_FLAG_CTX] =
+{
+  {
-, 103,  73, 102, 103,  73, 103,  88,  89, 115, 117, 103, 117, 118, 103, 102, 103,  72,
-, 103, 104, 101, 167, 121,
-  },
+  {
-, 102,  88, 117, 118, 104, 103, 119, 136,  83, 116, 118, 100, 117,  87,  85,  86, 103,
-, 118, 120, 117, 150, 120,
-  },
+  {
-, 102,  88, 117, 118, 104,  87, 119, 136,  83, 116, 118,  84, 117,  87,  69,  86,  87,
-, 118, 120, 117, 150, 120,
-  },
-};
-#endif
-#endif
-// initial probability for motion vector predictor index
-static const UChar
-INIT_MVP_IDX[3][NUM_MVP_IDX_CTX] =
+{
+  {
-    CNU, CNU,
-  },
+  {
-, CNU,
-  },
+  {
-, CNU,
-  },
-};
-// initial probability for ALF flag
-static const UChar
-INIT_ALF_FLAG[3][NUM_ALF_FLAG_CTX] =
+{
+  {
-,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-// initial probability for ALF side information (unsigned)
-static const UChar
-INIT_ALF_UVLC[3][NUM_ALF_UVLC_CTX] =
+{
+  {
-, 119,
-  },
+  {
-, 119,
-  },
+  {
-, 119,
-  },
-};
-// initial probability for ALF side information (signed)
-static const UChar
-INIT_ALF_SVLC[3][NUM_ALF_SVLC_CTX] =
+{
+  {
-, 119, 124,
-  },
+  {
-, 119, 140,
-  },
+  {
-, 119, 124,
-  },
-};
-// initial probability for SAO flag
-static const UChar
-INIT_SAO_FLAG[3][NUM_SAO_FLAG_CTX] =
+{
+  {
-,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-// initial probability for SAO side information (unsigned)
-static const UChar
-INIT_SAO_UVLC[3][NUM_SAO_UVLC_CTX] =
+{
+  {
-, 104,
-  },
+  {
-, 120,
-  },
+  {
-, 120,
-  },
-};
-// initial probability for SAO side information (signed)
-static const UChar
-INIT_SAO_SVLC[3][NUM_SAO_SVLC_CTX] =
+{
+  {
-, 119, 199,
-  },
+  {
-, 119, 151,
-  },
+  {
-, 119, 151,
-  },
-};
-#if SAO_UNIT_INTERLEAVING
-static const UChar
-INIT_SAO_MERGE_LEFT_FLAG[3][NUM_SAO_MERGE_LEFT_FLAG_CTX] =
+{
+  {
-, 118, 118,
-  },
+  {
-, 102, 102,
-    },
+    {
-, 102, 102,
-    },
-};
-static const UChar
-INIT_SAO_MERGE_UP_FLAG[3][NUM_SAO_MERGE_UP_FLAG_CTX] =
+{
+  {
-,
-  },
+  {
-,
-  },
+  {
-,
-  },
-};
-static const UChar
-INIT_SAO_TYPE_IDX[3][NUM_SAO_TYPE_IDX_CTX] =
+{
+  {
-, 104
-  },
+  {
-, 120
-  },
+  {
-, 120
-  },
-};
-static const Short
-INIT_SAO_RUN[3][NUM_SAO_RUN_CTX][2] =
+{
+  {
-    {   11,   57 }, {   -1,   62 }, {    0,   64 }
-  },
+  {
-    {    6,   66 }, {   -1,   64 }, {    0,   64 }
-  },
+  {
-    {    1,   73 }, {    2,   61 }, {    0,   64 }
+  }
-};
-#endif
-static const UChar
-INIT_TRANS_SUBDIV_FLAG[3][NUM_TRANS_SUBDIV_FLAG_CTX] =
+{
+  {
-    CNU, 162, 148, 100, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-    CNU,  71,  86,  55, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
+  {
-    CNU, 102,  86,  86, CNU, CNU, CNU, CNU, CNU, CNU,
-  },
-};
-#endif
-#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
-static const Short
-INIT_DMM_FLAG[3][NUM_DMM_FLAG_CTX] =
+{
+  {
-    CNU
-  },
+  {
-    CNU
-  },
+  {
-    CNU
+  }
-};
-static const Short
-INIT_DMM_MODE[3][NUM_DMM_MODE_CTX] =
+{
+  {
-    CNU
-  },
+  {
-    CNU
-  },
+  {
-    CNU
+  }
-};
-static const Short
-INIT_DMM_DATA[3][NUM_DMM_DATA_CTX] =
+{
+  {
     CNU, CNU, CNU
 …
     CNU, CNU, CNU
+  }
+#endif
 };

trunk/source/Lib/TLibCommon/NAL.h

-                      r210
+                      r296
+{
   NalUnitType m_nalUnitType; ///< nal_unit_type
-#if NAL_REF_FLAG
   Bool        m_nalRefFlag;  ///< nal_ref_flag
-#else
-  NalRefIdc   m_nalRefIDC;   ///< nal_ref_idc
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   unsigned    m_layerId;
 …
   Bool        m_isDepth;     ///< is_depth
   unsigned    m_temporalId;  ///< temporal_id
-#if !H0388
-  bool        m_OutputFlag;  ///< output_flag
-#endif
 #endif
   /** construct an NALunit structure with given header values. */
-#if H0388
-#if NAL_REF_FLAG
   NALUnit(
     NalUnitType nalUnitType,
 …
     ,m_temporalId  (temporalId)
   {}
-#else
-  NALUnit(
-    NalUnitType  nalUnitType,
-    NalRefIdc    nalRefIDC,
-    Int          viewId,
-    Bool         isDepth,
-    unsigned temporalID = 0)
+  {
-    m_nalUnitType = nalUnitType;
-    m_nalRefIDC   = nalRefIDC;
-#if !VIDYO_VPS_INTEGRATION
-    m_viewId      = viewId;
-    m_isDepth     = isDepth;
-#else
-    m_layerId = layerId;
-#endif
-    m_temporalId  = temporalID;
+  }
-#endif
-#else
-  NALUnit(
-    NalUnitType  nalUnitType,
-    NalRefIdc    nalRefIDC,
-#if !VIDYO_VPS_INTEGRATION
-    Int          viewId,
-    Bool         isDepth,
-#else
-    unsigned         layerId,
-#endif
-    unsigned     temporalID = 0,
-    bool         outputFlag = true)
+  {
-    m_nalUnitType = nalUnitType;
-    m_nalRefIDC   = nalRefIDC;
-#if !VIDYO_VPS_INTEGRATION
-    m_viewId      = viewId;
-    m_isDepth     = isDepth;
-#else
-    m_layerId = layerId;
-#endif
-    m_temporalId  = temporalID;
-    m_OutputFlag  = outputFlag;
+  }
-#endif
   /** default constructor - no initialization; must be perfomed by user */
 …
+  {
     return m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR
-#if H0566_TLA
 #if !QC_REM_IDV_B0046
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDV
 …
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA
-#else
-        || m_nalUnitType == NAL_UNIT_CODED_SLICE_CDR
-#endif
         || m_nalUnitType == NAL_UNIT_CODED_SLICE;
+  }

trunk/source/Lib/TLibCommon/TComAdaptiveLoopFilter.cpp

-                      r56
+                      r296
-#if !LCU_SYNTAX_ALF
-ALFParam::~ALFParam()
+{
-  if (coeff_chroma != NULL)
+  {
-    delete[] coeff_chroma;
+  }
-  if (coeffmulti)
+  {
-    for (Int i=0; i<NO_VAR_BINS; i++)
+    {
-      if (coeffmulti[i] != NULL)
+      {
-        delete[] coeffmulti[i];
+      }
+    }
-    delete[] coeffmulti;
+  }
-  if (nbSPred != NULL)
+  {
-    delete[] nbSPred;
+  }
-  if (filterPattern != NULL)
+  {
-    delete[] filterPattern;
+  }
+}
-#endif
 // ====================================================================================================================
 …
 // ====================================================================================================================
-#if ALF_SINGLE_FILTER_SHAPE
 Int TComAdaptiveLoopFilter::weightsShape1Sym[ALF_MAX_NUM_COEF+1] =
+{
 …
   depthIntShape1Sym
 };
+#else
+//Shape0: Star5x5
+Int TComAdaptiveLoopFilter::weightsShape0Sym[10] =
+{
+,    2,    2,
+, 2, 2,
+, 2, 1, 1
+};
+//Shape1: Cross9x9
+Int TComAdaptiveLoopFilter::weightsShape1Sym[10] =
+{
+,
+,
+,
+,
+, 2, 2, 2, 1,
+};
+Int* TComAdaptiveLoopFilter::weightsTabShapes[NUM_ALF_FILTER_SHAPE] =
+{
+  weightsShape0Sym, weightsShape1Sym
+};
+Int TComAdaptiveLoopFilter::m_sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE] =
+{
+, 9
+};
+// Shape0
+Int depthIntShape0Sym[10] =
+{
+,    3,    1,
+, 4, 3,
+, 4, 5, 5
+};
+// Shape1
+Int depthIntShape1Sym[10] =
+{
+,
+,
+,
+,
+, 6, 7, 8, 9,
+};
+Int* pDepthIntTabShapes[NUM_ALF_FILTER_SHAPE] =
+{
+  depthIntShape0Sym, depthIntShape1Sym
+};
+#endif
+#if LCU_SYNTAX_ALF
 Int kTableShape1[ALF_MAX_NUM_COEF+1] =
+{
 …
   kTableShape1
 };
-#endif
 // ====================================================================================================================
 …
+}
-#if LCU_SYNTAX_ALF
 /// AlfCUCtrlInfo
 Void AlfCUCtrlInfo::reset()
 …
+}
-#endif
 …
   m_pvpAlfLCU    = NULL;
   m_pvpSliceTileAlfLCU = NULL;
-#if LCU_SYNTAX_ALF
   for(Int c=0; c< NUM_ALF_COMPONENT; c++)
+  {
 …
   m_varImg = NULL;
   m_filterCoeffSym = NULL;
-#endif
+}
 …
 Void TComAdaptiveLoopFilter::create( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth )
+{
-#if LCU_SYNTAX_ALF
   destroy();
-#endif
   if ( !m_pcTempPicYuv )
+  {
 …
   m_img_height = iPicHeight;
   m_img_width = iPicWidth;
-#if LCU_SYNTAX_ALF
   initMatrix_Pel(&(m_varImg), m_img_height, m_img_width);
-#else
-  for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+  {
-    initMatrix_Pel(&(m_varImgMethods[i]), m_img_height, m_img_width);
+  }
-#endif
   initMatrix_int(&m_filterCoeffSym, NO_VAR_BINS, ALF_MAX_NUM_COEF);
   UInt uiNumLCUsInWidth   = m_img_width  / uiMaxCUWidth;
 …
   m_uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight;
-#if LCU_SYNTAX_ALF
   m_numLCUInPicWidth = uiNumLCUsInWidth;
   m_numLCUInPicHeight= uiNumLCUsInHeight;
   m_lcuHeight = uiMaxCUHeight;
-#if ALF_SINGLE_FILTER_SHAPE
   m_lineIdxPadBot = m_lcuHeight - 4 - 3; // DFRegion, Vertical Taps
-#else
-  m_lineIdxPadBot = m_lcuHeight - 4 - 4; // DFRegion, Vertical Taps
-#endif
   m_lineIdxPadTop = m_lcuHeight - 4; // DFRegion
   m_lcuHeightChroma = m_lcuHeight>>1;
-#if ALF_SINGLE_FILTER_SHAPE
   m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 3; // DFRegion, Vertical Taps
-#else
-  m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 4; // DFRegion, Vertical Taps
-#endif
   m_lineIdxPadTopChroma = m_lcuHeightChroma - 2 ; // DFRegion
   createLCUAlfInfo();
-#else
-  createRegionIndexMap(m_varImgMethods[ALF_RA], m_img_width, m_img_height);
-#endif
+}
 …
     m_pcTempPicYuv->destroy();
     delete m_pcTempPicYuv;
-#if LCU_SYNTAX_ALF
     m_pcTempPicYuv = NULL;
+#endif
+  }
+#if LCU_SYNTAX_ALF
+  }
   if(m_varImg != NULL)
+  {
 …
     m_filterCoeffSym = NULL;
+  }
-#else
-  for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+  {
-    destroyMatrix_Pel(m_varImgMethods[i]);
+  }
-  destroyMatrix_int(m_filterCoeffSym);
-#endif
-#if LCU_SYNTAX_ALF
   destroyLCUAlfInfo();
+#endif
+}
+#if !LCU_SYNTAX_ALF
+// --------------------------------------------------------------------------------------------------------------------
+// allocate / free / copy functions
+// --------------------------------------------------------------------------------------------------------------------
+Void TComAdaptiveLoopFilter::allocALFParam(ALFParam* pAlfParam)
+{
+  pAlfParam->alf_flag = 0;
+  pAlfParam->coeff_chroma = new Int[ALF_MAX_NUM_COEF];
+  ::memset(pAlfParam->coeff_chroma, 0, sizeof(Int)*ALF_MAX_NUM_COEF );
+  pAlfParam->coeffmulti = new Int*[NO_VAR_BINS];
+  for (int i=0; i<NO_VAR_BINS; i++)
+  {
+    pAlfParam->coeffmulti[i] = new Int[ALF_MAX_NUM_COEF];
+    ::memset(pAlfParam->coeffmulti[i],        0, sizeof(Int)*ALF_MAX_NUM_COEF );
+  }
+  pAlfParam->nbSPred = new Int[NO_VAR_BINS];
+  ::memset(pAlfParam->nbSPred, 0, sizeof(Int)*NO_VAR_BINS);
+  pAlfParam->filterPattern = new Int[NO_VAR_BINS];
+  ::memset(pAlfParam->filterPattern, 0, sizeof(Int)*NO_VAR_BINS);
+  pAlfParam->alf_pcr_region_flag = 0;
+}
+Void TComAdaptiveLoopFilter::freeALFParam(ALFParam* pAlfParam)
+{
+  assert(pAlfParam != NULL);
+  if (pAlfParam->coeff_chroma != NULL)
+  {
+    delete[] pAlfParam->coeff_chroma;
+    pAlfParam->coeff_chroma = NULL;
+  }
+  for (int i=0; i<NO_VAR_BINS; i++)
+  {
+    delete[] pAlfParam->coeffmulti[i];
+    pAlfParam->coeffmulti[i] = NULL;
+  }
+  delete[] pAlfParam->coeffmulti;
+  pAlfParam->coeffmulti = NULL;
+  delete[] pAlfParam->nbSPred;
+  pAlfParam->nbSPred = NULL;
+  delete[] pAlfParam->filterPattern;
+  pAlfParam->filterPattern = NULL;
+}
+Void TComAdaptiveLoopFilter::copyALFParam(ALFParam* pDesAlfParam, ALFParam* pSrcAlfParam)
+{
+  pDesAlfParam->alf_flag = pSrcAlfParam->alf_flag;
+  pDesAlfParam->chroma_idc = pSrcAlfParam->chroma_idc;
+  pDesAlfParam->num_coeff = pSrcAlfParam->num_coeff;
+  pDesAlfParam->filter_shape_chroma = pSrcAlfParam->filter_shape_chroma;
+  pDesAlfParam->num_coeff_chroma = pSrcAlfParam->num_coeff_chroma;
+  pDesAlfParam->alf_pcr_region_flag = pSrcAlfParam->alf_pcr_region_flag;
+  ::memcpy(pDesAlfParam->coeff_chroma, pSrcAlfParam->coeff_chroma, sizeof(Int)*ALF_MAX_NUM_COEF);
+  pDesAlfParam->filter_shape = pSrcAlfParam->filter_shape;
+  ::memcpy(pDesAlfParam->filterPattern, pSrcAlfParam->filterPattern, sizeof(Int)*NO_VAR_BINS);
+  pDesAlfParam->startSecondFilter = pSrcAlfParam->startSecondFilter;
+  //Coeff send related
+  pDesAlfParam->filters_per_group = pSrcAlfParam->filters_per_group; //this can be updated using codedVarBins
+  pDesAlfParam->predMethod = pSrcAlfParam->predMethod;
+  ::memcpy(pDesAlfParam->nbSPred, pSrcAlfParam->nbSPred, sizeof(Int)*NO_VAR_BINS);
+  for (int i=0; i<NO_VAR_BINS; i++)
+  {
+    ::memcpy(pDesAlfParam->coeffmulti[i], pSrcAlfParam->coeffmulti[i], sizeof(Int)*ALF_MAX_NUM_COEF);
+  }
+}
+// --------------------------------------------------------------------------------------------------------------------
+// prediction of filter coefficients
+// --------------------------------------------------------------------------------------------------------------------
+Void TComAdaptiveLoopFilter::predictALFCoeffChroma( ALFParam* pAlfParam )
+{
+  Int i, sum, pred, N;
+  const Int* pFiltMag = NULL;
+  pFiltMag = weightsTabShapes[pAlfParam->filter_shape_chroma];
+  N = pAlfParam->num_coeff_chroma;
+  sum=0;
+  for(i=0; i<N;i++)
+  {
+    sum+=pFiltMag[i]*pAlfParam->coeff_chroma[i];
+  }
+  pred=(1<<ALF_NUM_BIT_SHIFT)-(sum-pAlfParam->coeff_chroma[N-1]);
+#if ALF_CHROMA_COEF_PRED_HARMONIZATION
+  pAlfParam->coeff_chroma[N-1]=pAlfParam->coeff_chroma[N-1] - pred;
+#else
+  pAlfParam->coeff_chroma[N-1]=pred-pAlfParam->coeff_chroma[N-1];
+#endif
+}
+#if ALF_CHROMA_COEF_PRED_HARMONIZATION
+Void TComAdaptiveLoopFilter::reconstructALFCoeffChroma( ALFParam* pAlfParam )
+{
+  Int i, sum, pred, N;
+  const Int* pFiltMag = NULL;
+  pFiltMag = weightsTabShapes[pAlfParam->filter_shape_chroma];
+  N = pAlfParam->num_coeff_chroma;
+  sum=0;
+  for(i=0; i<N;i++)
+  {
+    sum+=pFiltMag[i]*pAlfParam->coeff_chroma[i];
+  }
+  pred=(1<<ALF_NUM_BIT_SHIFT)-(sum-pAlfParam->coeff_chroma[N-1]);
+  pAlfParam->coeff_chroma[N-1]=pred+ pAlfParam->coeff_chroma[N-1];
+}
+#endif
+#endif
+}
 // --------------------------------------------------------------------------------------------------------------------
 …
 // --------------------------------------------------------------------------------------------------------------------
-#if LCU_SYNTAX_ALF
 /** ALF reconstruction process for one picture
  * \param [in, out] pcPic the decoded/filtered picture (input: decoded picture; output filtered picture)
 …
+}
-#else
-/**
- \param [in, out] pcPic         picture (TComPic) class (input/output)
- \param [in] pcAlfParam    ALF parameter
- \param [in,out] vAlfCUCtrlParam ALF CU control parameters
- \todo   for temporal buffer, it uses residual picture buffer, which may not be safe. Make it be safer.
- */
-Void TComAdaptiveLoopFilter::ALFProcess(TComPic* pcPic, ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam)
+{
-  assert(m_uiNumSlicesInPic == vAlfCUCtrlParam.size());
-  if(!pcAlfParam->alf_flag)
+  {
-    return;
+  }
-  m_lcuHeight     = pcPic->getSlice(0)->getSPS()->getMaxCUHeight();
-#if ALF_SINGLE_FILTER_SHAPE
-  m_lineIdxPadBot = m_lcuHeight - 4 - 3;             // DFRegion, Vertical Taps
-#else
-  m_lineIdxPadBot = m_lcuHeight - 4 - 4;             // DFRegion, Vertical Taps
-#endif
-  m_lineIdxPadTop = m_lcuHeight - 4;                 // DFRegion
-  m_lcuHeightChroma     = m_lcuHeight>>1;
-#if ALF_SINGLE_FILTER_SHAPE
-  m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 3; // DFRegion, Vertical Taps
-#else
-  m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 4; // DFRegion, Vertical Taps
-#endif
-  m_lineIdxPadTopChroma = m_lcuHeightChroma - 2 ;    // DFRegion
-  TComPicYuv* pcPicYuvRec    = pcPic->getPicYuvRec();
-  TComPicYuv* pcPicYuvExtRec = m_pcTempPicYuv;
-    pcPicYuvRec   ->copyToPic          ( pcPicYuvExtRec );
-    pcPicYuvExtRec->setBorderExtension ( false );
-    pcPicYuvExtRec->extendPicBorder    ();
-  if(m_uiNumSlicesInPic == 1)
+  {
-    AlfCUCtrlInfo* pcAlfCtrlParam = &(vAlfCUCtrlParam[0]);
-    if(pcAlfCtrlParam->cu_control_flag)
+    {
-      UInt idx = 0;
-      for(UInt uiCUAddr = 0; uiCUAddr < pcPic->getNumCUsInFrame(); uiCUAddr++)
+      {
-        TComDataCU *pcCU = pcPic->getCU(uiCUAddr);
-        setAlfCtrlFlags(pcAlfCtrlParam, pcCU, 0, 0, idx);
+      }
+    }
+  }
-  else
+  {
-    transferCtrlFlagsFromAlfParam(vAlfCUCtrlParam);
+  }
-  xALFLuma(pcPic, pcAlfParam, vAlfCUCtrlParam, pcPicYuvExtRec, pcPicYuvRec);
-  if(pcAlfParam->chroma_idc)
+  {
-#if ALF_CHROMA_COEF_PRED_HARMONIZATION
-    reconstructALFCoeffChroma(pcAlfParam);
-#else
-    predictALFCoeffChroma(pcAlfParam);
-#endif
-    checkFilterCoeffValue(pcAlfParam->coeff_chroma, pcAlfParam->num_coeff_chroma, true );
-    xALFChroma( pcAlfParam, pcPicYuvExtRec, pcPicYuvRec);
+  }
+}
-#endif
 // ====================================================================================================================
 // Protected member functions
 …
+}
-#if !LCU_SYNTAX_ALF
-Void TComAdaptiveLoopFilter::xALFLuma(TComPic* pcPic, ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam,TComPicYuv* pcPicDec, TComPicYuv* pcPicRest)
+{
-  Int    LumaStride = pcPicDec->getStride();
-  Pel* pDec = pcPicDec->getLumaAddr();
-  Pel* pRest = pcPicRest->getLumaAddr();
-  decodeFilterSet(pcAlfParam, m_varIndTab, m_filterCoeffSym);
-  m_uiVarGenMethod = pcAlfParam->alf_pcr_region_flag;
-  m_varImg         = m_varImgMethods[m_uiVarGenMethod];
-  calcVar(m_varImg, pRest, LumaStride, pcAlfParam->alf_pcr_region_flag);
-  if(!m_bUseNonCrossALF)
+  {
-    Bool bCUCtrlEnabled = false;
-    for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+    {
-      if(!pcPic->getValidSlice(s))
+      {
-        continue;
+      }
-      if( vAlfCUCtrlParam[s].cu_control_flag == 1)
+      {
-        bCUCtrlEnabled = true;
+      }
+    }
-    if(bCUCtrlEnabled)
+    {
-      xCUAdaptive(pcPic, pcAlfParam->filter_shape, pRest, pDec, LumaStride);
+    }
-    else
+    {
-      filterLuma(pRest, pDec, LumaStride, 0, m_img_height-1, 0, m_img_width-1,  pcAlfParam->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+    }
+  }
-  else
+  {
-    Pel* pTemp = m_pcSliceYuvTmp->getLumaAddr();
-    for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+    {
-      if(!pcPic->getValidSlice(s))
+      {
-        continue;
+      }
-      std::vector< std::vector<AlfLCUInfo*> > & vpSliceTileAlfLCU = m_pvpSliceTileAlfLCU[s];
-      for(Int t=0; t< (Int)vpSliceTileAlfLCU.size(); t++)
+      {
-        std::vector<AlfLCUInfo*> & vpAlfLCU = vpSliceTileAlfLCU[t];
-        copyRegion(vpAlfLCU, pTemp, pDec, LumaStride);
-        extendRegionBorder(vpAlfLCU, pTemp, LumaStride);
-        if(vAlfCUCtrlParam[s].cu_control_flag == 1)
+        {
-          xCUAdaptiveRegion(vpAlfLCU, pTemp, pRest, LumaStride, pcAlfParam->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+        }
-        else
+        {
-          filterLumaRegion(vpAlfLCU, pTemp, pRest, LumaStride, pcAlfParam->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+        }
+      }
+    }
+  }
+}
-Void TComAdaptiveLoopFilter::decodeFilterSet(ALFParam* pcAlfParam, Int* varIndTab, Int** filterCoeff)
+{
-  // reconstruct merge table
-  memset(m_varIndTab, 0, NO_VAR_BINS * sizeof(Int));
-  if(pcAlfParam->filters_per_group > 1)
+  {
-    for(Int i = 1; i < NO_VAR_BINS; ++i)
+    {
-      if(pcAlfParam->filterPattern[i])
+      {
-        varIndTab[i] = varIndTab[i-1] + 1;
+      }
-      else
+      {
-        varIndTab[i] = varIndTab[i-1];
+      }
+    }
+  }
-  predictALFCoeffLuma( pcAlfParam);
-  // reconstruct filter sets
-  reconstructFilterCoeffs( pcAlfParam, filterCoeff);
+}
-Void TComAdaptiveLoopFilter::filterLuma(Pel *pImgRes, Pel *pImgPad, Int stride,
-  Int ypos, Int yposEnd, Int xpos, Int xposEnd,
-  Int filtNo, Int** filterSet, Int* mergeTable, Pel** ppVarImg)
+{
-  static Int numBitsMinus1= (Int)ALF_NUM_BIT_SHIFT;
-  static Int offset       = (1<<( (Int)ALF_NUM_BIT_SHIFT-1));
-  static Int shiftHeight  = (Int)(log((double)VAR_SIZE_H)/log(2.0));
-  static Int shiftWidth   = (Int)(log((double)VAR_SIZE_W)/log(2.0));
-  Pel *pImgPad1,*pImgPad2,*pImgPad3,*pImgPad4;
-  Pel *pVar;
-  Int i, j, pixelInt;
-  Int *coef = NULL;
-  pImgPad    += (ypos*stride);
-  pImgRes    += (ypos*stride);
-  Int yLineInLCU;
-  Int paddingLine;
-#if !ALF_SINGLE_FILTER_SHAPE
-  Int varInd = 0;
-#endif
-  Int newCenterCoeff[4][NO_VAR_BINS];
-  for(i=0; i< 4; i++)
+  {
-    ::memset(&(newCenterCoeff[i][0]), 0, sizeof(Int)*NO_VAR_BINS);
+  }
-#if ALF_SINGLE_FILTER_SHAPE
-  if(filtNo == ALF_CROSS9x7_SQUARE3x3)
-#else
-  if(filtNo == ALF_CROSS9x9)
-#endif
+  {
-    for (i=0; i<NO_VAR_BINS; i++)
+    {
-      coef = filterSet[i];
-      //VB line 1
-      newCenterCoeff[0][i] = coef[8] + ((coef[0] + coef[1] + coef[2] + coef[3])<<1);
-      //VB line 2
-      newCenterCoeff[1][i] = coef[8] + ((coef[0] + coef[1] + coef[2])<<1);
-      //VB line 3
-      newCenterCoeff[2][i] = coef[8] + ((coef[0] + coef[1])<<1);
-      //VB line 4
-      newCenterCoeff[3][i] = coef[8] + ((coef[0])<<1);
+    }
+  }
-  switch(filtNo)
+  {
-#if !ALF_SINGLE_FILTER_SHAPE
-  case ALF_STAR5x5:
+    {
-      for(i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeight;
-        if (yLineInLCU<m_lineIdxPadBot || i-yLineInLCU+m_lcuHeight >= m_img_height)
+        {
-          pImgPad1 = pImgPad +   stride;
-          pImgPad2 = pImgPad -   stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - 2*stride;
+        }
-        else if (yLineInLCU<m_lineIdxPadTop)
+        {
-          paddingLine = - yLineInLCU + m_lineIdxPadTop - 1;
-          pImgPad1 = pImgPad + min(paddingLine, 1)*stride;
-          pImgPad2 = pImgPad -   stride;
-          pImgPad3 = pImgPad + min(paddingLine, 2)*stride;
-          pImgPad4 = pImgPad - 2*stride;
+        }
-        else
+        {
-          paddingLine = yLineInLCU - m_lineIdxPadTop ;
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - min(paddingLine, 1)*stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - min(paddingLine, 2)*stride;
+        }
-        pVar = ppVarImg[i>>shiftHeight] + (xpos>>shiftWidth);
-        if ( (yLineInLCU == m_lineIdxPadTop || yLineInLCU == m_lineIdxPadTop-1) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd; j++)
+          {
-            pImgRes[j] = pImgPad[j];
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTop+1 || yLineInLCU == m_lineIdxPadTop-2) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              coef = filterSet[mergeTable[*(pVar++)]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad3[j+2]+pImgPad4[j-2]);
-            pixelInt += coef[1]* (pImgPad3[j  ]+pImgPad4[j  ]);
-            pixelInt += coef[2]* (pImgPad3[j-2]+pImgPad4[j+2]);
-            pixelInt += coef[3]* (pImgPad1[j+1]+pImgPad2[j-1]);
-            pixelInt += coef[4]* (pImgPad1[j  ]+pImgPad2[j  ]);
-            pixelInt += coef[5]* (pImgPad1[j-1]+pImgPad2[j+1]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[8]* (pImgPad[j  ]);
-            pixelInt=(int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = ( Clip( pixelInt ) + pImgPad[j] ) >> 1;
+          }
+        }
-        else
+        {
-        for(j= xpos; j<= xposEnd ; j++)
+        {
-          if (j % VAR_SIZE_W==0)
+          {
-            coef = filterSet[mergeTable[*(pVar++)]];
+          }
-          pixelInt  = 0;
-          pixelInt += coef[0]* (pImgPad3[j+2]+pImgPad4[j-2]);
-          pixelInt += coef[1]* (pImgPad3[j  ]+pImgPad4[j  ]);
-          pixelInt += coef[2]* (pImgPad3[j-2]+pImgPad4[j+2]);
-          pixelInt += coef[3]* (pImgPad1[j+1]+pImgPad2[j-1]);
-          pixelInt += coef[4]* (pImgPad1[j  ]+pImgPad2[j  ]);
-          pixelInt += coef[5]* (pImgPad1[j-1]+pImgPad2[j+1]);
-          pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-          pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-          pixelInt += coef[8]* (pImgPad[j  ]);
-          pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-          pImgRes[j] = Clip( pixelInt );
+        }
+        }
-        pImgPad += stride;
-        pImgRes += stride;
+      }
+    }
-    break;
-  case ALF_CROSS9x9:
+    {
-      Pel *pImgPad5, *pImgPad6, *pImgPad7, *pImgPad8;
-#else
-  case ALF_CROSS9x7_SQUARE3x3:
+    {
-      Pel *pImgPad5, *pImgPad6;
-#endif
-      for(i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeight;
-        if (yLineInLCU<m_lineIdxPadBot || i-yLineInLCU+m_lcuHeight >= m_img_height)
+        {
-          pImgPad1 = pImgPad +   stride;
-          pImgPad2 = pImgPad -   stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - 2*stride;
-          pImgPad5 = pImgPad + 3*stride;
-          pImgPad6 = pImgPad - 3*stride;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = pImgPad + 4*stride;
-          pImgPad8 = pImgPad - 4*stride;
-#endif
+        }
-        else if (yLineInLCU<m_lineIdxPadTop)
+        {
-          paddingLine = - yLineInLCU + m_lineIdxPadTop - 1;
-#if ALF_SINGLE_FILTER_SHAPE
-          pImgPad1 = (paddingLine < 1) ? pImgPad : pImgPad + min(paddingLine, 1)*stride;
-          pImgPad2 = (paddingLine < 1) ? pImgPad : pImgPad -   stride;
-          pImgPad3 = (paddingLine < 2) ? pImgPad : pImgPad + min(paddingLine, 2)*stride;
-          pImgPad4 = (paddingLine < 2) ? pImgPad : pImgPad - 2*stride;
-          pImgPad5 = (paddingLine < 3) ? pImgPad : pImgPad + min(paddingLine, 3)*stride;
-          pImgPad6 = (paddingLine < 3) ? pImgPad : pImgPad - 3*stride;
-#else
-          pImgPad1 = pImgPad + min(paddingLine, 1)*stride;
-          pImgPad2 = pImgPad -   stride;
-          pImgPad3 = pImgPad + min(paddingLine, 2)*stride;
-          pImgPad4 = pImgPad - 2*stride;
-          pImgPad5 = pImgPad + min(paddingLine, 3)*stride;
-          pImgPad6 = pImgPad - 3*stride;
-          pImgPad7 = pImgPad + min(paddingLine, 4)*stride;
-          pImgPad8 = pImgPad - 4*stride;
-#endif
+        }
-        else
+        {
-          paddingLine = yLineInLCU - m_lineIdxPadTop ;
-#if ALF_SINGLE_FILTER_SHAPE
-          pImgPad1 = (paddingLine < 1) ? pImgPad : pImgPad +   stride;
-          pImgPad2 = (paddingLine < 1) ? pImgPad : pImgPad - min(paddingLine, 1)*stride;
-          pImgPad3 = (paddingLine < 2) ? pImgPad : pImgPad + 2*stride;
-          pImgPad4 = (paddingLine < 2) ? pImgPad : pImgPad - min(paddingLine, 2)*stride;
-          pImgPad5 = (paddingLine < 3) ? pImgPad : pImgPad + 3*stride;
-          pImgPad6 = (paddingLine < 3) ? pImgPad : pImgPad - min(paddingLine, 3)*stride;
-#else
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - min(paddingLine, 1)*stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - min(paddingLine, 2)*stride;
-          pImgPad5 = pImgPad + 3*stride;
-          pImgPad6 = pImgPad - min(paddingLine, 3)*stride;
-          pImgPad7 = pImgPad + 4*stride;
-          pImgPad8 = pImgPad - min(paddingLine, 4)*stride;
-#endif
+        }
-        pVar = ppVarImg[i>>shiftHeight] + (xpos>>shiftWidth);
-#if ALF_SINGLE_FILTER_SHAPE
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              coef = filterSet[mergeTable[*(pVar++)]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[1]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[2]* (pImgPad1[j-1]+pImgPad2[j+1]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad1[j+1]+pImgPad2[j-1]);
-            pixelInt += coef[5]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[6]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[7]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[8]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[9]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-#else
-        if ( (yLineInLCU == m_lineIdxPadTop || yLineInLCU == m_lineIdxPadTop-1) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              varInd = *(pVar++);
-              coef = filterSet[mergeTable[varInd]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[0][mergeTable[varInd]]* (pImgPad[j]);
-            pixelInt=(int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTop+1 || yLineInLCU == m_lineIdxPadTop-2) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              varInd = *(pVar++);
-              coef = filterSet[mergeTable[varInd]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[1][mergeTable[varInd]]* (pImgPad[j]);
-            pixelInt=(int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTop+2 || yLineInLCU == m_lineIdxPadTop-3) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              varInd = *(pVar++);
-              coef = filterSet[mergeTable[varInd]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[2][mergeTable[varInd]]* (pImgPad[j  ]);
-            pixelInt=(int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTop+3 || yLineInLCU == m_lineIdxPadTop-4) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              varInd = *(pVar++);
-              coef = filterSet[mergeTable[varInd]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[1]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[3][mergeTable[varInd]]* (pImgPad[j  ]);
-            pixelInt=(int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            if (j % VAR_SIZE_W==0)
+            {
-              coef = filterSet[mergeTable[*(pVar++)]];
+            }
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad7[j]+pImgPad8[j]);
-            pixelInt += coef[1]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[8]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-#endif
-        pImgPad += stride;
-        pImgRes += stride;
+      }
+    }
-    break;
-  default:
+    {
-      printf("Not a supported filter shape\n");
-      assert(0);
-      exit(1);
+    }
+  }
+}
-Void TComAdaptiveLoopFilter::xCUAdaptive(TComPic* pcPic, Int filtNo, Pel *imgYFilt, Pel *imgYRec, Int Stride)
+{
-  // for every CU, call CU-adaptive ALF process
-  for( UInt uiCUAddr = 0; uiCUAddr < pcPic->getNumCUsInFrame() ; uiCUAddr++ )
+  {
-    TComDataCU* pcCU = pcPic->getCU( uiCUAddr );
-    xSubCUAdaptive(pcCU, filtNo, imgYFilt, imgYRec, 0, 0, Stride);
+  }
+}
-Void TComAdaptiveLoopFilter::xSubCUAdaptive(TComDataCU* pcCU, Int filtNo, Pel *imgYFilt, Pel *imgYRec, UInt uiAbsPartIdx, UInt uiDepth, Int Stride)
+{
-  TComPic* pcPic = pcCU->getPic();
-  if(pcPic==NULL)
+  {
-    return;
+  }
-  Bool bBoundary = false;
-  UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
-  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
-  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
-  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
-  // check picture boundary
-  if ( ( uiRPelX >= m_img_width ) || ( uiBPelY >= m_img_height ) )
+  {
-    bBoundary = true;
+  }
-  if ( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < (g_uiMaxCUDepth-g_uiAddCUDepth) ) ) || bBoundary )
+  {
-    UInt uiQNumParts = ( pcPic->getNumPartInCU() >> (uiDepth<<1) )>>2;
-    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
+    {
-      uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
-      uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
-      if( ( uiLPelX < m_img_width ) && ( uiTPelY < m_img_height ) )
-        xSubCUAdaptive(pcCU, filtNo, imgYFilt, imgYRec, uiAbsPartIdx, uiDepth+1, Stride);
+    }
-    return;
+  }
-  if ( pcCU->getAlfCtrlFlag(uiAbsPartIdx) )
+  {
-    filterLuma(imgYFilt, imgYRec, Stride, uiTPelY, min(uiBPelY,(unsigned int)(m_img_height-1)), uiLPelX, min(uiRPelX,(unsigned int)(m_img_width-1))
-      ,filtNo, m_filterCoeffSym, m_varIndTab, m_varImg);
+  }
+}
-/** Predict ALF luma filter coefficients. Centre coefficient is always predicted. Left neighbour is predicted according to flag.
- */
-Void TComAdaptiveLoopFilter::predictALFCoeffLuma(ALFParam* pcAlfParam)
+{
-  Int sum, coeffPred, ind;
-  const Int* pFiltMag = NULL;
-  pFiltMag = weightsTabShapes[pcAlfParam->filter_shape];
-  for(ind = 0; ind < pcAlfParam->filters_per_group; ++ind)
+  {
-    sum = 0;
-    for(Int i = 0; i < pcAlfParam->num_coeff-2; i++)
+    {
-      sum +=  pFiltMag[i]*pcAlfParam->coeffmulti[ind][i];
+    }
-    if(pcAlfParam->nbSPred[ind]==0)
+    {
-      if((pcAlfParam->predMethod==0)|(ind==0))
+      {
-        coeffPred = ((1<<ALF_NUM_BIT_SHIFT)-sum) >> 2;
+      }
-      else
+      {
-        coeffPred = (0-sum) >> 2;
+      }
-      pcAlfParam->coeffmulti[ind][pcAlfParam->num_coeff-2] = coeffPred + pcAlfParam->coeffmulti[ind][pcAlfParam->num_coeff-2];
+    }
-    sum += pFiltMag[pcAlfParam->num_coeff-2]*pcAlfParam->coeffmulti[ind][pcAlfParam->num_coeff-2];
-    if((pcAlfParam->predMethod==0)|(ind==0))
+    {
-      coeffPred = (1<<ALF_NUM_BIT_SHIFT)-sum;
+    }
-    else
+    {
-      coeffPred = -sum;
+    }
-    pcAlfParam->coeffmulti[ind][pcAlfParam->num_coeff-1] = coeffPred + pcAlfParam->coeffmulti[ind][pcAlfParam->num_coeff-1];
+  }
+}
-Void TComAdaptiveLoopFilter::reconstructFilterCoeffs(ALFParam* pcAlfParam,int **pfilterCoeffSym)
+{
-  int i, ind;
-  // Copy non zero filters in filterCoeffTmp
-  for(ind = 0; ind < pcAlfParam->filters_per_group; ++ind)
+  {
-    for(i = 0; i < pcAlfParam->num_coeff; i++)
+    {
-      pfilterCoeffSym[ind][i] = pcAlfParam->coeffmulti[ind][i];
+    }
+  }
-  // Undo prediction
-  for(ind = 1; ind < pcAlfParam->filters_per_group; ++ind)
+  {
-    if(pcAlfParam->predMethod)
+    {
-      // Prediction
-      for(i = 0; i < pcAlfParam->num_coeff; ++i)
+      {
-        pfilterCoeffSym[ind][i] = (int)(pfilterCoeffSym[ind][i] + pfilterCoeffSym[ind - 1][i]);
+      }
+    }
+  }
-  for(ind = 0; ind < pcAlfParam->filters_per_group; ind++)
+  {
-    checkFilterCoeffValue(pfilterCoeffSym[ind], pcAlfParam->num_coeff, false );
+  }
+}
-#endif
 static Pel Clip_post(int high, int val)
 …
+}
-#if !LCU_SYNTAX_ALF
-/** Calculate ALF grouping indices for block-based (BA) mode
- * \param [out] imgYvar grouping indices buffer
- * \param [in] imgYpad picture buffer
- * \param [in] stride picture stride size
- * \param [in] adaptationMode  ALF_BA or ALF_RA mode
- */
-Void TComAdaptiveLoopFilter::calcVar(Pel **imgYvar, Pel *imgYpad, Int stride, Int adaptationMode)
+{
-  if(adaptationMode == ALF_RA)
+  {
-    return;
+  }
-  static Int shiftH = (Int)(log((double)VAR_SIZE_H)/log(2.0));
-  static Int shiftW = (Int)(log((double)VAR_SIZE_W)/log(2.0));
-  static Int varmax = (Int)NO_VAR_BINS-1;
-#if ALF_16_BA_GROUPS
-  static Int th[NO_VAR_BINS] = {0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
-  static Int avgVarTab[3][6] = { {0,  1,  2,  3,  4,  5,},
-  {0,  6,  7,  8,  9, 10,},
-  {0, 11, 12, 13, 14, 15}   };
-#else
-  static Int step1  = (Int)((Int)(NO_VAR_BINS)/3) - 1;
-  static Int th[NO_VAR_BINS] = {0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4};
-#endif
-  Int i, j, avgvar, vertical, horizontal,direction, yoffset;
-  Pel *pimgYpad, *pimgYpadup, *pimgYpaddown;
-  for(i = 0; i < m_img_height - 3; i=i+4)
+  {
-    yoffset      = ((i)*stride) + stride;
-    pimgYpad     = &imgYpad [yoffset];
-    pimgYpadup   = &imgYpad [yoffset + stride];
-    pimgYpaddown = &imgYpad [yoffset - stride];
-    for(j = 0; j < m_img_width - 3 ; j=j+4)
+    {
-      // Compute at sub-sample by 2
-      vertical   =  abs((pimgYpad[j+1]<<1  ) - pimgYpaddown[j+1]   - pimgYpadup[j+1]);
-      horizontal =  abs((pimgYpad[j+1]<<1  ) - pimgYpad    [j+2]   - pimgYpad  [j  ]);
-      vertical   += abs((pimgYpad[j+2]<<1  ) - pimgYpaddown[j+2]   - pimgYpadup[j+2]);
-      horizontal += abs((pimgYpad[j+2]<<1  ) - pimgYpad    [j+3]   - pimgYpad  [j+1]);
-      vertical   += abs((pimgYpad[j+1+stride]<<1) - pimgYpaddown[j+1+stride] - pimgYpadup[j+1+stride]);
-      horizontal += abs((pimgYpad[j+1+stride]<<1) - pimgYpad    [j+2+stride] - pimgYpad  [j+stride  ]);
-      vertical   += abs((pimgYpad[j+2+stride]<<1) - pimgYpaddown[j+2+stride] - pimgYpadup[j+2+stride]);
-      horizontal += abs((pimgYpad[j+2+stride]<<1) - pimgYpad    [j+3+stride] - pimgYpad  [j+1+stride]);
-      direction = 0;
-      if (vertical > 2*horizontal)
+      {
-        direction = 1; //vertical
+      }
-      if (horizontal > 2*vertical)
+      {
-        direction = 2; //horizontal
+      }
-      avgvar = (vertical + horizontal) >> 2;
-      avgvar = (Pel) Clip_post(varmax, avgvar >>(g_uiBitIncrement+1));
-      avgvar = th[avgvar];
-#if ALF_16_BA_GROUPS
-      avgvar = avgVarTab[direction][avgvar];
-#else
-      avgvar = Clip_post(step1, (Int) avgvar ) + (step1+1)*direction;
-#endif
-      imgYvar[(i )>>shiftH][(j)>>shiftW] = avgvar;
+    }
+  }
+}
-Void TComAdaptiveLoopFilter::createRegionIndexMap(Pel **imgYVar, Int imgWidth, Int imgHeight)
+{
-  int varStepSizeWidth = VAR_SIZE_W;
-  int varStepSizeHeight = VAR_SIZE_H;
-  int shiftHeight = (int)(log((double)varStepSizeHeight)/log(2.0));
-  int shiftWidth = (int)(log((double)varStepSizeWidth)/log(2.0));
-  int i, j;
-  int regionTable[NO_VAR_BINS] = {0, 1, 4, 5, 15, 2, 3, 6, 14, 11, 10, 7, 13, 12,  9,  8};
-  int xInterval;
-  int yInterval;
-  int yIndex;
-  int yIndexOffset;
-  int yStartLine;
-  int yEndLine;
-  xInterval = ((( (imgWidth+63)/64) + 1) / 4 * 64)>>shiftWidth;
-  yInterval = ((((imgHeight+63)/64) + 1) / 4 * 64)>>shiftHeight;
-  for (yIndex = 0; yIndex < 4 ; yIndex++)
+  {
-    yIndexOffset = yIndex * 4;
-    yStartLine = yIndex * yInterval;
-    yEndLine   = (yIndex == 3) ? imgHeight>>shiftHeight : (yStartLine+yInterval);
-    for(i = yStartLine; i < yEndLine ; i++)
+    {
-      for(j = 0; j < xInterval ; j++)
+      {
-        imgYVar[i][j] = regionTable[yIndexOffset+0];
+      }
-      for(j = xInterval; j < xInterval*2 ; j++)
+      {
-        imgYVar[i][j] = regionTable[yIndexOffset+1];
+      }
-      for(j = xInterval*2; j < xInterval*3 ; j++)
+      {
-        imgYVar[i][j] = regionTable[yIndexOffset+2];
+      }
-      for(j = xInterval*3; j < imgWidth>>shiftWidth ; j++)
+      {
-        imgYVar[i][j] = regionTable[yIndexOffset+3];
+      }
+    }
+  }
+}
-// --------------------------------------------------------------------------------------------------------------------
-// ALF for chroma
-// --------------------------------------------------------------------------------------------------------------------
-/**
- \param pcPicDec    picture before ALF
- \param pcPicRest   picture after  ALF
- \param qh          filter coefficient
- \param iTap        filter tap
- \param iColor      0 for Cb and 1 for Cr
- */
-Void TComAdaptiveLoopFilter::filterChroma(Pel *pImgRes, Pel *pImgPad, Int stride,
-                                          Int ypos, Int yposEnd, Int xpos, Int xposEnd,
-                                          Int filtNo, Int* coef)
+{
-  static Int numBitsMinus1= (Int)ALF_NUM_BIT_SHIFT;
-  static Int offset       = (1<<( (Int)ALF_NUM_BIT_SHIFT-1));
-  Pel *pImgPad1,*pImgPad2,*pImgPad3,*pImgPad4;
-  Int i, j, pixelInt;
-  pImgPad    += (ypos*stride);
-  pImgRes    += (ypos*stride);
-  Int imgHeightChroma = m_img_height>>1;
-  Int yLineInLCU;
-  Int paddingline;
-  Int newCenterCoeff[4];
-  ::memset(newCenterCoeff, 0, sizeof(Int)*4);
-#if ALF_SINGLE_FILTER_SHAPE
-  if(filtNo == ALF_CROSS9x7_SQUARE3x3)
-#else
-  if (filtNo == ALF_CROSS9x9)
-#endif
+  {
-    //VB line 1
-    newCenterCoeff[0] = coef[8] + ((coef[0] + coef[1] + coef[2] + coef[3])<<1);
-    //VB line 2
-    newCenterCoeff[1] = coef[8] + ((coef[0] + coef[1] + coef[2])<<1);
-    //VB line 3
-    newCenterCoeff[2] = coef[8] + ((coef[0] + coef[1])<<1);
-    //VB line 4
-    newCenterCoeff[3] = coef[8] + ((coef[0])<<1);
+  }
-  switch(filtNo)
+  {
-#if !ALF_SINGLE_FILTER_SHAPE
-  case ALF_STAR5x5:
+    {
-      for(i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeightChroma;
-        if (yLineInLCU < m_lineIdxPadBotChroma || i-yLineInLCU+m_lcuHeightChroma >= imgHeightChroma )
+        {
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - 2*stride;
+        }
-        else if (yLineInLCU < m_lineIdxPadTopChroma)
+        {
-          paddingline = - yLineInLCU + m_lineIdxPadTopChroma - 1;
-          pImgPad1 = pImgPad + min(paddingline, 1)*stride;
-          pImgPad2 = pImgPad - stride;
-          pImgPad3 = pImgPad + min(paddingline, 2)*stride;
-          pImgPad4 = pImgPad - 2*stride;
+        }
-        else
+        {
-          paddingline = yLineInLCU - m_lineIdxPadTopChroma ;
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - min(paddingline, 1)*stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - min(paddingline, 2)*stride;
+        }
-        if ( (yLineInLCU == m_lineIdxPadTopChroma || yLineInLCU == m_lineIdxPadTopChroma-1) && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pImgRes[j] = pImgPad[j];
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTopChroma+1 || yLineInLCU == m_lineIdxPadTopChroma-2) && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad3[j+2]+pImgPad4[j-2]);
-            pixelInt += coef[1]* (pImgPad3[j  ]+pImgPad4[j  ]);
-            pixelInt += coef[2]* (pImgPad3[j-2]+pImgPad4[j+2]);
-            pixelInt += coef[3]* (pImgPad1[j+1]+pImgPad2[j-1]);
-            pixelInt += coef[4]* (pImgPad1[j  ]+pImgPad2[j  ]);
-            pixelInt += coef[5]* (pImgPad1[j-1]+pImgPad2[j+1]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[8]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = (Clip( pixelInt ) + pImgPad[j]) >> 1;
+          }
+        }
-        else
+        {
-        for(j= xpos; j<= xposEnd ; j++)
+        {
-          pixelInt  = 0;
-          pixelInt += coef[0]* (pImgPad3[j+2]+pImgPad4[j-2]);
-          pixelInt += coef[1]* (pImgPad3[j  ]+pImgPad4[j  ]);
-          pixelInt += coef[2]* (pImgPad3[j-2]+pImgPad4[j+2]);
-          pixelInt += coef[3]* (pImgPad1[j+1]+pImgPad2[j-1]);
-          pixelInt += coef[4]* (pImgPad1[j  ]+pImgPad2[j  ]);
-          pixelInt += coef[5]* (pImgPad1[j-1]+pImgPad2[j+1]);
-          pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-          pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-          pixelInt += coef[8]* (pImgPad[j  ]);
-          pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-          pImgRes[j] = Clip( pixelInt );
+        }
+        }
-        pImgPad += stride;
-        pImgRes += stride;
+      }
+    }
-    break;
-  case ALF_CROSS9x9:
+    {
-      Pel *pImgPad5, *pImgPad6, *pImgPad7, *pImgPad8;
-#else
-  case ALF_CROSS9x7_SQUARE3x3:
+    {
-      Pel *pImgPad5, *pImgPad6;
-#endif
-      for(i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeightChroma;
-#if ALF_SINGLE_FILTER_SHAPE
-        if (yLineInLCU<2 && i> 2)
-#else
-        if (yLineInLCU<2)
-#endif
+        {
-          paddingline = yLineInLCU + 2 ;
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - 2*stride;
-#if ALF_SINGLE_FILTER_SHAPE
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + 3*stride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - min(paddingline, 3)*stride;
-#else
-          pImgPad5 = pImgPad + 3*stride;
-          pImgPad6 = pImgPad - min(paddingline, 3)*stride;
-          pImgPad7 = pImgPad + 4*stride;
-          pImgPad8 = pImgPad - min(paddingline, 4)*stride;
-#endif
+        }
-        else if (yLineInLCU < m_lineIdxPadBotChroma || i-yLineInLCU+m_lcuHeightChroma >= imgHeightChroma )
+        {
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - 2*stride;
-          pImgPad5 = pImgPad + 3*stride;
-          pImgPad6 = pImgPad - 3*stride;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = pImgPad + 4*stride;
-          pImgPad8 = pImgPad - 4*stride;
-#endif
+        }
-        else if (yLineInLCU < m_lineIdxPadTopChroma)
+        {
-          paddingline = - yLineInLCU + m_lineIdxPadTopChroma - 1;
-#if ALF_SINGLE_FILTER_SHAPE
-          pImgPad1 = (paddingline < 1) ? pImgPad : pImgPad + min(paddingline, 1)*stride;
-          pImgPad2 = (paddingline < 1) ? pImgPad : pImgPad -   stride;
-          pImgPad3 = (paddingline < 2) ? pImgPad : pImgPad + min(paddingline, 2)*stride;
-          pImgPad4 = (paddingline < 2) ? pImgPad : pImgPad - 2*stride;
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + min(paddingline, 3)*stride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - 3*stride;
-#else
-          pImgPad1 = pImgPad + min(paddingline, 1)*stride;
-          pImgPad2 = pImgPad - stride;
-          pImgPad3 = pImgPad + min(paddingline, 2)*stride;
-          pImgPad4 = pImgPad - 2*stride;
-          pImgPad5 = pImgPad + min(paddingline, 3)*stride;
-          pImgPad6 = pImgPad - 3*stride;
-          pImgPad7 = pImgPad + min(paddingline, 4)*stride;
-          pImgPad8 = pImgPad - 4*stride;
-#endif
+        }
-        else
+        {
-          paddingline = yLineInLCU - m_lineIdxPadTopChroma ;
-#if ALF_SINGLE_FILTER_SHAPE
-          pImgPad1 = (paddingline < 1) ? pImgPad : pImgPad +   stride;
-          pImgPad2 = (paddingline < 1) ? pImgPad : pImgPad - min(paddingline, 1)*stride;
-          pImgPad3 = (paddingline < 2) ? pImgPad : pImgPad + 2*stride;
-          pImgPad4 = (paddingline < 2) ? pImgPad : pImgPad - min(paddingline, 2)*stride;
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + 3*stride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - min(paddingline, 3)*stride;
-#else
-          pImgPad1 = pImgPad + stride;
-          pImgPad2 = pImgPad - min(paddingline, 1)*stride;
-          pImgPad3 = pImgPad + 2*stride;
-          pImgPad4 = pImgPad - min(paddingline, 2)*stride;
-          pImgPad5 = pImgPad + 3*stride;
-          pImgPad6 = pImgPad - min(paddingline, 3)*stride;
-          pImgPad7 = pImgPad + 4*stride;
-          pImgPad8 = pImgPad - min(paddingline, 4)*stride;
-#endif
+        }
-#if ALF_SINGLE_FILTER_SHAPE
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[1]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[2]* (pImgPad1[j-1]+pImgPad2[j+1]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad1[j+1]+pImgPad2[j-1]);
-            pixelInt += coef[5]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[6]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[7]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[8]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[9]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
-#else
-        if ( (yLineInLCU == m_lineIdxPadTopChroma || yLineInLCU == m_lineIdxPadTopChroma-1) && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[0]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == m_lineIdxPadTopChroma+1 || yLineInLCU == m_lineIdxPadTopChroma-2) && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[1]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == 0 && i>0) || (yLineInLCU == m_lineIdxPadTopChroma-3 && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma) )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[2]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else if ( (yLineInLCU == 1 && i>1) || (yLineInLCU == m_lineIdxPadTopChroma-4 && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma) )
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[1]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += newCenterCoeff[3]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-        else
+        {
-          for(j= xpos; j<= xposEnd ; j++)
+          {
-            pixelInt  = 0;
-            pixelInt += coef[0]* (pImgPad7[j]+pImgPad8[j]);
-            pixelInt += coef[1]* (pImgPad5[j]+pImgPad6[j]);
-            pixelInt += coef[2]* (pImgPad3[j]+pImgPad4[j]);
-            pixelInt += coef[3]* (pImgPad1[j]+pImgPad2[j]);
-            pixelInt += coef[4]* (pImgPad[j+4]+pImgPad[j-4]);
-            pixelInt += coef[5]* (pImgPad[j+3]+pImgPad[j-3]);
-            pixelInt += coef[6]* (pImgPad[j+2]+pImgPad[j-2]);
-            pixelInt += coef[7]* (pImgPad[j+1]+pImgPad[j-1]);
-            pixelInt += coef[8]* (pImgPad[j  ]);
-            pixelInt=(Int)((pixelInt+offset) >> numBitsMinus1);
-            pImgRes[j] = Clip( pixelInt );
+          }
+        }
-#endif
-        pImgPad += stride;
-        pImgRes += stride;
+      }
+    }
-    break;
-  default:
+    {
-      printf("Not a supported filter shape\n");
-      assert(0);
-      exit(1);
+    }
+  }
+}
-/** Chroma filtering for multi-slice picture
- * \param componentID slice parameters
- * \param pcPicDecYuv original picture
- * \param pcPicRestYuv picture before filtering
- * \param coeff filter coefficients
- * \param filtNo  filter shape
- * \param chromaFormatShift size adjustment for chroma (1 for 4:2:0 format)
- */
-Void TComAdaptiveLoopFilter::xFilterChromaSlices(Int componentID, TComPicYuv* pcPicDecYuv, TComPicYuv* pcPicRestYuv, Int *coeff, Int filtNo, Int chromaFormatShift)
+{
-  Pel* pPicDec   = (componentID == ALF_Cb)?(    pcPicDecYuv->getCbAddr()):(    pcPicDecYuv->getCrAddr());
-  Pel* pPicSlice = (componentID == ALF_Cb)?(m_pcSliceYuvTmp->getCbAddr()):(m_pcSliceYuvTmp->getCrAddr());
-  Pel* pRest     = (componentID == ALF_Cb)?(   pcPicRestYuv->getCbAddr()):(   pcPicRestYuv->getCrAddr());
-  Int  stride    = pcPicDecYuv->getCStride();
-  for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+  {
-    if(!m_pcPic->getValidSlice(s))
+    {
-      continue;
+    }
-    std::vector< std::vector<AlfLCUInfo*> > & vpSliceTileAlfLCU = m_pvpSliceTileAlfLCU[s];
-    for(Int t=0; t< (Int)vpSliceTileAlfLCU.size(); t++)
+    {
-      std::vector<AlfLCUInfo*> & vpAlfLCU = vpSliceTileAlfLCU[t];
-      copyRegion(vpAlfLCU, pPicSlice, pPicDec, stride, chromaFormatShift);
-      extendRegionBorder(vpAlfLCU, pPicSlice, stride, chromaFormatShift);
-      filterChromaRegion(vpAlfLCU, pPicSlice, pRest, stride, coeff, filtNo, chromaFormatShift);
+    }
+  }
+}
-/** Chroma filtering for one component in multi-slice picture
- * \param componentID slice parameters
- * \param pcPicDecYuv original picture
- * \param pcPicRestYuv picture before filtering
- * \param shape  filter shape
- * \param pCoeff filter coefficients
- */
-Void TComAdaptiveLoopFilter::xFilterChromaOneCmp(Int componentID, TComPicYuv *pDecYuv, TComPicYuv *pRestYuv, Int shape, Int *pCoeff)
+{
-  Int chromaFormatShift = 1;
-  if(!m_bUseNonCrossALF)
+  {
-    Pel* pDec    = (componentID == ALF_Cb)?(pDecYuv->getCbAddr()): (pDecYuv->getCrAddr());
-    Pel* pRest   = (componentID == ALF_Cb)?(pRestYuv->getCbAddr()):(pRestYuv->getCrAddr());
-    Int  iStride = pDecYuv->getCStride();
-    filterChroma(pRest, pDec, iStride, 0, (Int)(m_img_height>>1) -1, 0, (Int)(m_img_width>>1)-1, shape, pCoeff);
+  }
-  else
+  {
-    xFilterChromaSlices(componentID, pDecYuv, pRestYuv, pCoeff, shape, chromaFormatShift);
+  }
+}
-/** Chroma filtering for  multi-slice picture
- * \param pcAlfParam ALF parameters
- * \param pcPicDec to-be-filtered picture buffer
- * \param pcPicRest filtered picture buffer
- */
-Void TComAdaptiveLoopFilter::xALFChroma(ALFParam* pcAlfParam, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest)
+{
-  if((pcAlfParam->chroma_idc>>1)&0x01)
+  {
-    xFilterChromaOneCmp(ALF_Cb, pcPicDec, pcPicRest, pcAlfParam->filter_shape_chroma, pcAlfParam->coeff_chroma);
+  }
-  if(pcAlfParam->chroma_idc&0x01)
+  {
-    xFilterChromaOneCmp(ALF_Cr, pcPicDec, pcPicRest, pcAlfParam->filter_shape_chroma, pcAlfParam->coeff_chroma);
+  }
+}
-#endif
 Void TComAdaptiveLoopFilter::setAlfCtrlFlags(AlfCUCtrlInfo* pAlfParam, TComDataCU *pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt &idx)
 …
  * \param numSlicesInPic number of slices in picture
  */
-#if LCU_SYNTAX_ALF
 Void TComAdaptiveLoopFilter::createPicAlfInfo(TComPic* pcPic, Int numSlicesInPic, Int alfQP)
-#else
-Void TComAdaptiveLoopFilter::createPicAlfInfo(TComPic* pcPic, Int numSlicesInPic)
-#endif
+{
   m_uiNumSlicesInPic = numSlicesInPic;
 …
   m_pcPic = pcPic;
-#if LCU_SYNTAX_ALF
   m_isNonCrossSlice = pcPic->getIndependentSliceBoundaryForNDBFilter();
   m_suWidth = pcPic->getMinCUWidth();
   m_suHeight= pcPic->getMinCUHeight();
   m_alfQP = alfQP;
-#endif
-#if !LCU_SYNTAX_ALF
-  if(m_uiNumSlicesInPic > 1 || m_bUseNonCrossALF)
+  {
-#endif
     m_ppSliceAlfLCUs = new AlfLCUInfo*[m_uiNumSlicesInPic];
     m_pvpAlfLCU = new std::vector< AlfLCUInfo* >[m_uiNumSlicesInPic];
 …
       m_pcSliceYuvTmp = pcPic->getYuvPicBufferForIndependentBoundaryProcessing();
+    }
-#if !LCU_SYNTAX_ALF
+  }
-#endif
+}
 …
 Void TComAdaptiveLoopFilter::destroyPicAlfInfo()
+{
-#if !LCU_SYNTAX_ALF
-  if(m_bUseNonCrossALF)
+  {
-#endif
     for(Int s=0; s< m_uiNumSlicesInPic; s++)
+    {
 …
     delete[] m_pvpSliceTileAlfLCU;
     m_pvpSliceTileAlfLCU = NULL;
+#if !LCU_SYNTAX_ALF
+  }
+#endif
+}
+#if !LCU_SYNTAX_ALF
+/** ALF for cu-on/off-controlled region
+ * \param vpAlfLCU ALF LCU information container
+ * \param imgDec to-be-filtered picture buffer
+ * \param imgRest filtered picture buffer
+ * \param stride picture buffer stride size
+ * \param filtNo filter shape
+ * \param filterCoeff filter coefficients
+ * \param mergeTable merge table for filter set
+ * \param varImg BA index
+ */
+Void TComAdaptiveLoopFilter::xCUAdaptiveRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* imgDec, Pel* imgRest, Int stride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg)
+{
+  UInt SUWidth   = m_pcPic->getMinCUWidth();
+  UInt SUHeight  = m_pcPic->getMinCUHeight();
+  UInt idx, startSU, endSU, currSU, LCUX, LCUY, LPelX, TPelY;
+  TComDataCU* pcCU;
+  for(idx=0; idx< vpAlfLCU.size(); idx++)
+  {
+    AlfLCUInfo&    rAlfLCU = *(vpAlfLCU[idx]);
+    pcCU                   = rAlfLCU.pcCU;
+    startSU              = rAlfLCU.startSU;
+    endSU                = rAlfLCU.endSU;
+    LCUX                 = pcCU->getCUPelX();
+    LCUY                 = pcCU->getCUPelY();
+    for(currSU= startSU; currSU<= endSU; currSU++)
+    {
+      LPelX   = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[currSU] ];
+      TPelY   = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[currSU] ];
+      if( !( LPelX < m_img_width )  || !( TPelY < m_img_height )  )
+      {
+        continue;
+      }
+      if(pcCU->getAlfCtrlFlag(currSU))
+      {
+        filterLuma(imgRest, imgDec, stride, TPelY, TPelY+ SUHeight-1, LPelX, LPelX+ SUWidth-1,  filtNo, m_filterCoeffSym, m_varIndTab, m_varImg);
+      }
+    }
+  }
+}
+/** ALF for "non" cu-on/off-controlled region
+ * \param vpAlfLCU ALF LCU information container
+ * \param imgDec to-be-filtered picture buffer
+ * \param imgRest filtered picture buffer
+ * \param stride picture buffer stride size
+ * \param filtNo filter shape
+ * \param filterCoeff filter coefficients
+ * \param mergeTable merge table for filter set
+ * \param varImg BA index
+ */
+Void TComAdaptiveLoopFilter::filterLumaRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* imgDec, Pel* imgRest, Int stride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg)
+{
+  Int height, width;
+  Int ypos, xpos;
+  for(Int i=0; i< vpAlfLCU.size(); i++)
+  {
+    AlfLCUInfo& rAlfLCU = *(vpAlfLCU[i]);
+    for(UInt j=0; j< rAlfLCU.numSGU; j++)
+    {
+      ypos   = (Int)(rAlfLCU[j].posY  );
+      xpos   = (Int)(rAlfLCU[j].posX  );
+      height = (Int)(rAlfLCU[j].height);
+      width  = (Int)(rAlfLCU[j].width );
+      filterLuma(imgRest, imgDec, stride, ypos, ypos+ height-1, xpos, xpos+ width-1,  filtNo, filterCoeff, mergeTable, varImg);
+    }
+  }
+}
+/** Perform ALF for one chroma region
+ * \param vpAlfLCU ALF LCU data container
+ * \param pDec to-be-filtered picture buffer
+ * \param pRest filtered picture buffer
+ * \param stride picture buffer stride
+ * \param coeff  filter coefficients
+ * \param filtNo filter shape
+ * \param chromaFormatShift chroma component size adjustment (1 for 4:2:0)
+ */
+Void TComAdaptiveLoopFilter::filterChromaRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* pDec, Pel* pRest, Int stride, Int *coeff, Int filtNo, Int chromaFormatShift)
+{
+  Int height, width;
+  Int ypos, xpos;
+  for(Int i=0; i< vpAlfLCU.size(); i++)
+  {
+    AlfLCUInfo& cAlfLCU = *(vpAlfLCU[i]);
+    for(Int j=0; j< cAlfLCU.numSGU; j++)
+    {
+      ypos   = (Int)(cAlfLCU[j].posY   >> chromaFormatShift);
+      xpos   = (Int)(cAlfLCU[j].posX   >> chromaFormatShift);
+      height = (Int)(cAlfLCU[j].height >> chromaFormatShift);
+      width  = (Int)(cAlfLCU[j].width  >> chromaFormatShift);
+      filterChroma(pRest, pDec, stride, ypos, ypos+ height -1, xpos, xpos+ width-1, filtNo, coeff);
+    }
+  }
+}
+#endif
+}
 /** Copy ALF CU control flags from ALF parameters for slices
 …
+    {
       NDBFBlockInfo& rSGU = rAlfLCU[n];
-#if LCU_SYNTAX_ALF
       if(rSGU.allBordersAvailable)
+      {
         continue;
+      }
-#endif
       posX     = rSGU.posX >> formatShift;
       posY     = rSGU.posY >> formatShift;
 …
+}
-#if LCU_SYNTAX_ALF
 /** reconstruct ALF luma coefficient
  * \param [in] alfLCUParam ALF parameters
 …
   coeffPred = (1<<ALF_NUM_BIT_SHIFT) - sum;
 #endif
-#if ALF_CHROMA_COEF_PRED_HARMONIZATION
   filterCoeff[0][alfLCUParam->num_coeff-1] = coeffPred + alfLCUParam->coeffmulti[0][alfLCUParam->num_coeff-1];
-#else
-  filterCoeff[0][alfLCUParam->num_coeff-1] = coeffPred - alfLCUParam->coeffmulti[0][alfLCUParam->num_coeff-1];
-#endif
+}
 …
   Int pred = (1<<ALF_NUM_BIT_SHIFT) - (sum);
 #endif
-#if ALF_CHROMA_COEF_PRED_HARMONIZATION
   coeff[numCoef-1] = coeff[numCoef-1] - pred;
+#else
+  coeff[numCoef-1] = pred- coeff[numCoef-1];
+#endif
+}
+#if ALF_SINGLE_FILTER_SHAPE
+}
 /** filtering pixels
  * \param [out] imgRes filtered picture
 …
+  }
+}
-#endif
 #if LCUALF_QP_DEPENDENT_BITS
 …
   static Int shiftW = (Int)(log((double)VAR_SIZE_W)/log(2.0));
   static Int varMax = (Int)NO_VAR_BINS-1;
-#if ALF_16_BA_GROUPS
   static Int th[NO_VAR_BINS] = {0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
   static Int avgVarTab[3][6] = { {0,  1,  2,  3,  4,  5,},
   {0,  6,  7,  8,  9, 10,},
   {0, 11, 12, 13, 14, 15}   };
-#else
-  static Int step   = (Int)((Int)(NO_VAR_BINS)/3) - 1;
-  static Int th[NO_VAR_BINS] = {0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4};
-#endif
   Int i, j, avgVar, vertical, horizontal, direction, yOffset;
 …
       avgVar = (Pel) Clip_post( varMax, avgVar>>(g_uiBitIncrement+1) );
       avgVar = th[avgVar];
-#if ALF_16_BA_GROUPS
       avgVar = avgVarTab[direction][avgVar];
-#else
-      avgVar = Clip_post(step, (Int)avgVar) + (step+1)*direction;
-#endif
       imgYvar[i>>shiftH][j>>shiftW] = avgVar;
+    }
 …
   return pBuf;
+}
-#endif

trunk/source/Lib/TLibCommon/TComAdaptiveLoopFilter.h

-                      r56
+                      r296
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
   #define LCUALF_QP_DEPENDENT_BITS    1
+#endif
+#if ALF_SINGLE_FILTER_SHAPE
 #define ALF_FILTER_LEN       10
 #define ALF_MAX_NUM_COEF     ALF_FILTER_LEN    //!< maximum number of filter coefficients
-#else
-#define ALF_MAX_NUM_COEF      9                                       //!< maximum number of filter coefficients
-#endif
 #define MAX_SQR_FILT_LENGTH   41                                      //!< ((max_horizontal_tap * max_vertical_tap) / 2 + 1) = ((11 * 5) / 2 + 1)
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
 #define ALF_QP1               28
 #define ALF_QP2               34
 …
-#if LCU_SYNTAX_ALF
 /// Luma/Chroma component ID
 enum ALFComponentID
 …
   NUM_ALF_MERGE_TYPE
 };
-#else
-///
-/// Chroma component ID
-///
-enum AlfChromaID
+{
-  ALF_Cb = 0,
-  ALF_Cr = 1
-};
-///
-/// Adaptation mode ID
-///
-enum ALFClassficationMethod
+{
-  ALF_BA =0,
-  ALF_RA,
-  NUM_ALF_CLASS_METHOD
-};
-#endif
 ///
 /// Filter shape
 …
 enum ALFFilterShape
+{
-#if ALF_SINGLE_FILTER_SHAPE
   ALF_CROSS9x7_SQUARE3x3 = 0,
-#else
-  ALF_STAR5x5 = 0,
-  ALF_CROSS9x9,
-#endif
   NUM_ALF_FILTER_SHAPE
 };
-#if LCU_SYNTAX_ALF
 extern Int* kTableTabShapes[NUM_ALF_FILTER_SHAPE];
-#endif
-#if ALF_SINGLE_FILTER_SHAPE
 extern Int depthIntShape1Sym[ALF_MAX_NUM_COEF+1];
-#else
-extern Int depthIntShape0Sym[10];
-extern Int depthIntShape1Sym[10];
-#endif
 extern Int *pDepthIntTabShapes[NUM_ALF_FILTER_SHAPE];
 …
   const AlfCUCtrlInfo& operator= (const AlfCUCtrlInfo& src);  //!< "=" operator
   AlfCUCtrlInfo():cu_control_flag(0), num_alf_cu_flag(0), alf_max_depth(0) {} //!< constructor
-#if LCU_SYNTAX_ALF
   Void reset();
-#endif
 };
 …
   // filter shape information
-#if ALF_SINGLE_FILTER_SHAPE
   static Int weightsShape1Sym[ALF_MAX_NUM_COEF+1];
-#else
-  static Int weightsShape0Sym[10];
-  static Int weightsShape1Sym[10];
-#endif
   static Int *weightsTabShapes[NUM_ALF_FILTER_SHAPE];
   static Int m_sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE];
 …
   //classification
   Int      m_varIndTab[NO_VAR_BINS];
-#if !LCU_SYNTAX_ALF
-  UInt     m_uiVarGenMethod;
-  Pel** m_varImgMethods[NUM_ALF_CLASS_METHOD];
-#endif
   Pel** m_varImg;
 …
   std::vector< std::vector< AlfLCUInfo* > > *m_pvpSliceTileAlfLCU;
-#if LCU_SYNTAX_ALF
   Int m_suWidth;
   Int m_suHeight;
 …
   Bool m_isNonCrossSlice;
   Int m_alfQP;
-#endif
 private: //private member variables
 …
 protected: //protected methods
-#if LCU_SYNTAX_ALF
   Void createLCUAlfInfo();
   Void destroyLCUAlfInfo();
 …
   Bool isEnabledComponent(ALFParam** alfLCUParam);
   Int  getAlfPrecisionBit(Int qp);
-#if ALF_SINGLE_FILTER_SHAPE
   Void filterOneCompRegion(Pel *imgRes, Pel *imgPad, Int stride, Bool isChroma, Int yPos, Int yPosEnd, Int xPos, Int xPosEnd, Int** filterSet, Int* mergeTable, Pel** varImg);
-#endif
   Void calcOneRegionVar(Pel **imgYvar, Pel *imgYpad, Int stride, Bool isOnlyOneGroup, Int yPos, Int yPosEnd, Int xPos, Int xPosEnd);
-#endif
   Void InitAlfLCUInfo(AlfLCUInfo& rAlfLCU, Int sliceID, Int tileID, TComDataCU* pcCU, UInt maxNumSUInLCU);
-#if !LCU_SYNTAX_ALF
-  Void createRegionIndexMap(Pel **imgY_var, Int img_width, Int img_height); //!< create RA index for regions
-  Void calcVar(Pel **imgYvar, Pel *imgYpad, Int stride, Int adaptationMode); //!< Calculate ALF grouping indices for block-based (BA) mode
-  Void filterLuma(Pel *pImgYRes, Pel *pImgYPad, Int stride, Int ypos, Int yposEnd, Int xpos, Int xposEnd, Int filtNo, Int** filterSet, Int* mergeTable, Pel** ppVarImg); //!< filtering operation for luma region
-  Void filterChroma(Pel *pImgRes, Pel *pImgPad, Int stride, Int ypos, Int yposEnd, Int xpos, Int xposEnd, Int filtNo, Int* coef);
-  Void filterChromaRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* pDec, Pel* pRest, Int stride, Int *coeff, Int filtNo, Int chromaFormatShift); //!< filtering operation for chroma region
-  Void xCUAdaptive   (TComPic* pcPic, Int filtNo, Pel *imgYFilt, Pel *imgYRec, Int Stride);
-  Void xSubCUAdaptive(TComDataCU* pcCU, Int filtNo, Pel *imgYFilt, Pel *imgYRec, UInt uiAbsPartIdx, UInt uiDepth, Int Stride);
-  Void reconstructFilterCoeffs(ALFParam* pcAlfParam,int **pfilterCoeffSym);
-  Void predictALFCoeffLuma  ( ALFParam* pAlfParam );                    //!< prediction of luma ALF coefficients
-#endif
   Void checkFilterCoeffValue( Int *filter, Int filterLength, Bool isChroma );
-#if !LCU_SYNTAX_ALF
-  Void decodeFilterSet(ALFParam* pcAlfParam, Int* varIndTab, Int** filterCoeff);
-  Void xALFChroma   ( ALFParam* pcAlfParam, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest );
-  Void xFilterChromaSlices(Int componentID, TComPicYuv* pcPicDecYuv, TComPicYuv* pcPicRestYuv, Int *coeff, Int filtNo, Int chromaFormatShift);
-  Void xFilterChromaOneCmp(Int componentID, TComPicYuv *pDecYuv, TComPicYuv *pRestYuv, Int shape, Int *pCoeff);
-  Void xALFLuma( TComPic* pcPic, ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest );
-#endif
   Void setAlfCtrlFlags(AlfCUCtrlInfo* pAlfParam, TComDataCU *pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt &idx);
   Void transferCtrlFlagsFromAlfParam(std::vector<AlfCUCtrlInfo>& vAlfParamSlices); //!< Copy ALF CU control flags from ALF parameters for slices
 …
   Void copyRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* pPicDst, Pel* pPicSrc, Int stride, Int formatShift = 0);
   Void extendRegionBorder(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* pPelSrc, Int stride, Int formatShift = 0);
-#if !LCU_SYNTAX_ALF
-  Void filterLumaRegion (std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* imgDec, Pel* imgRest, Int stride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg);
-  Void xCUAdaptiveRegion(std::vector<AlfLCUInfo*> &vpAlfLCU, Pel* imgDec, Pel* imgRest, Int stride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg);
-#endif
   Int  getCtrlFlagsFromAlfParam(AlfLCUInfo* pcAlfLCU, Int iAlfDepth, UInt* puiFlags);
 …
   Void destroy ();
-#if LCU_SYNTAX_ALF
   Void ALFProcess          (TComPic* pcPic, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam, Bool isAlfCoefInSlice);
   Void resetLCUAlfInfo     ();
 …
   ALFParam*** getAlfLCUParam() {return m_alfFiltInfo;}
-#else
-  Void predictALFCoeffChroma  ( ALFParam* pAlfParam );                  //!< prediction of chroma ALF coefficients
-#if ALF_CHROMA_COEF_PRED_HARMONIZATION
-  Void reconstructALFCoeffChroma( ALFParam* pAlfParam );
-#endif
-  Void ALFProcess             ( TComPic* pcPic, ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam ); ///< interface function for ALF process
-  Void allocALFParam  ( ALFParam* pAlfParam ); //!< allocate ALF parameters
-  Void freeALFParam   ( ALFParam* pAlfParam ); //!< free ALF parameters
-  Void copyALFParam   ( ALFParam* pDesAlfParam, ALFParam* pSrcAlfParam ); //!< copy ALF parameters
-#endif
   Int  getNumCUsInPic()  {return m_uiNumCUsInFrame;} //!< get number of LCU in picture for ALF process
-#if LCU_SYNTAX_ALF
   Void createPicAlfInfo (TComPic* pcPic, Int uiNumSlicesInPic = 1, Int alfQP = 26);
-#else
-  Void createPicAlfInfo (TComPic* pcPic, Int numSlicesInPic = 1);
-#endif
   Void destroyPicAlfInfo();

trunk/source/Lib/TLibCommon/TComBitStream.cpp

-                      r56
+                      r296
   m_puiTileMarkerLocation     = new UInt[MAX_MARKER_PER_NALU];
   m_uiTileMarkerLocationCount = 0;
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   m_numBitsRead = 0;
-#endif
+}
 …
   assert( uiNumberOfBits <= 32 );
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   m_numBitsRead += uiNumberOfBits;
-#endif
   /* NB, bits are extracted from the MSB of each byte. */
 …
     buf->push_back(uiByte);
+  }
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
   buf->push_back(0); // The final chunk might not start byte aligned.
 #endif

trunk/source/Lib/TLibCommon/TComBitStream.h

-                      r56
+                      r296
   UInt m_uiTileMarkerLocationCount;
   UInt *m_puiTileMarkerLocation;
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   UInt  m_numBitsRead;
-#endif
 public:
 …
   Void        pseudoRead      ( UInt uiNumberOfBits, UInt& ruiBits );
   Void        read            ( UInt uiNumberOfBits, UInt& ruiBits );
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
   Void        readByte        ( UInt &ruiBits )
+  {
 …
   Void                backupByte() { m_fifo_idx--; }
 #endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   UInt  getNumBitsRead() { return m_numBitsRead; }
+};
+//! \}
 #endif
-};
-//! \}
-#endif

trunk/source/Lib/TLibCommon/TComDataCU.cpp

-                      r210
+                      r296
 #endif
+#if MERL_VSP_C0152
+#define CHECK_ADD_YET(pcCURef,uiIdx,vspIdx) && !( (pcCURef)->getVSPIndex(uiIdx) == vspIdx && bVspMvZeroDone[vspIdx-1] )
+inline Void TComDataCU::xInheritVspMode( TComDataCU* pcCURef, UInt uiIdx, Bool* bVspMvZeroDone, Int iCount, Int* iVSPIndexTrue, TComMvField* pcMvFieldNeighbours, DisInfo* pDInfo )
+{
+  Int vspIdx = (Int) pcCURef->getVSPIndex(uiIdx);
+  if( vspIdx != 0 )
+  {
+    Int idx = vspIdx - 1;
+    bVspMvZeroDone[idx] = true;
+    iVSPIndexTrue [idx] = iCount;
+    // no need to reset Inter Dir
+    // set MV using checked disparity
+    if (vspIdx < 4)
+    {
+      pcMvFieldNeighbours[ iCount<<1].setMvField ( pDInfo->m_acMvCand[0],  NOT_VALID );
+      if ( pcCURef->getSlice()->isInterB() )
+      {
+         pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField ( pDInfo->m_acMvCand[0],  NOT_VALID );
+      }
+    }
+  }
+}
+inline Bool TComDataCU::xAddVspMergeCand( UChar ucVspMergePos, Int vspIdx, Bool* bVspMvZeroDone, UInt uiDepth, Bool* abCandIsInter, Int& iCount,
+                                          UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, Int* iVSPIndexTrue, Int mrgCandIdx, DisInfo* pDInfo )
+{
+  if( ucVspMergePos == VSP_MERGE_POS )
+  {
+    Int idx = vspIdx - 1;
+    {
+      if( getSlice()->getSPS()->getViewId() != 0 && bVspMvZeroDone[idx] == false )
+      {
+        {
+          abCandIsInter [iCount] = true;
+          bVspMvZeroDone[idx] = true;
+          // get Inter Dir
+          Int iInterDir = ((getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 && getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 0) ? 3 :
+            (getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 ? 1 : 2));
+          puhInterDirNeighbours[iCount] = iInterDir; // The direction information does not matter
+          // get Mv using checked disparity vector
+          if (vspIdx < 4) // spatial
+          {
+            pcMvFieldNeighbours[iCount<<1].setMvField(pDInfo->m_acMvCand[0], NOT_VALID );
+            if ( getSlice()->isInterB() )
+            {
+              pcMvFieldNeighbours[(iCount<<1)+1].setMvField( pDInfo->m_acMvCand[0], NOT_VALID );
+            }
+          }
+          iVSPIndexTrue[idx] = iCount;
+          if ( mrgCandIdx == iCount )
+          {
+            return false;
+          }
+          iCount ++;
+        }
+      }
+    }
+  }
+  return true;
+}
+#endif
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 …
 #endif
   m_puhMergeIndex      = NULL;
+#if MERL_VSP_C0152
+  m_piVSPIndex         = NULL;
+#endif
   m_puhLumaIntraDir    = NULL;
   m_puhChromaIntraDir  = NULL;
 …
 #if HHI_DMM_PRED_TEX
   m_puiWedgePredTexTabIdx    = NULL;
+#if LGE_DMM3_SIMP_C0044
+  m_puiWedgePredTexIntraTabIdx = NULL;
+#endif
   m_piWedgePredTexDeltaDC1   = NULL;
   m_piWedgePredTexDeltaDC2   = NULL;
 …
   m_piContourPredTexDeltaDC2 = NULL;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_pbResPredAvailable = NULL;
   m_pbResPredFlag      = NULL;
 …
   if ( !bDecSubCu )
+  {
-#if H0736_AVC_STYLE_QP_RANGE
     m_phQP               = (Char*     )xMalloc(Char,     uiNumPartition);
-#else
-    m_phQP               = (UChar*    )xMalloc(UChar,    uiNumPartition);
-#endif
     m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
 #if HHI_MPI
 …
 #endif
     m_puhMergeIndex      = (UChar* )xMalloc(UChar,  uiNumPartition);
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+    m_piVSPIndex         = (Char*  )xMalloc(Char,   uiNumPartition);
+#endif
+#if H3D_IVRP
     m_pbResPredAvailable = (Bool*  )xMalloc(Bool,   uiNumPartition);
     m_pbResPredFlag      = (Bool*  )xMalloc(Bool,   uiNumPartition);
 …
 #if HHI_DMM_PRED_TEX
     m_puiWedgePredTexTabIdx    = (UInt*)xMalloc(UInt, uiNumPartition);
+#if LGE_DMM3_SIMP_C0044
+    m_puiWedgePredTexIntraTabIdx    = (UInt*)xMalloc(UInt, uiNumPartition);
+#endif
     m_piWedgePredTexDeltaDC1   = (Int* )xMalloc(Int,  uiNumPartition);
     m_piWedgePredTexDeltaDC2   = (Int* )xMalloc(Int,  uiNumPartition);
 …
     if ( m_pbICFlag           ) { xFree(m_pbICFlag);            m_pbICFlag          = NULL; }
 #endif
+#if MERL_VSP_C0152
+    if ( m_piVSPIndex         ) { xFree(m_piVSPIndex);          m_piVSPIndex        = NULL; }
+#endif
     if ( m_puhMergeIndex      ) { xFree(m_puhMergeIndex);       m_puhMergeIndex     = NULL; }
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     if ( m_pbResPredAvailable ) { xFree(m_pbResPredAvailable);  m_pbResPredAvailable= NULL; }
     if ( m_pbResPredFlag      ) { xFree(m_pbResPredFlag);       m_pbResPredFlag     = NULL; }
 …
 #if HHI_DMM_PRED_TEX
     if ( m_puiWedgePredTexTabIdx    ) { xFree(m_puiWedgePredTexTabIdx   ); m_puiWedgePredTexTabIdx    = NULL; }
+#if LGE_DMM3_SIMP_C0044
+    if ( m_puiWedgePredTexIntraTabIdx ) { xFree(m_puiWedgePredTexIntraTabIdx); m_puiWedgePredTexIntraTabIdx    = NULL; }
+#endif
     if ( m_piWedgePredTexDeltaDC1   ) { xFree(m_piWedgePredTexDeltaDC1  ); m_piWedgePredTexDeltaDC1   = NULL; }
     if ( m_piWedgePredTexDeltaDC2   ) { xFree(m_piWedgePredTexDeltaDC2  ); m_piWedgePredTexDeltaDC2   = NULL; }
 …
   this->height = src.height;
   ::memcpy(this->isBorderAvailable, src.isBorderAvailable, sizeof(Bool)*((Int)NUM_SGU_BORDER));
-#if LCU_SYNTAX_ALF
   this->allBordersAvailable = src.allBordersAvailable;
-#endif
   return *this;
 …
   m_uiTotalBins        = 0;
   m_uiNumPartition     = pcPic->getNumPartInCU();
-#if BURST_IPCM
   m_numSucIPCM       = 0;
   m_lastCUSucIPCMFlag   = false;
-#endif
   for(int i=0; i<pcPic->getNumPartInCU(); i++)
 …
 #endif
     m_puhMergeIndex[ui]=pcFrom->m_puhMergeIndex[ui];
+#if MERL_VSP_C0152
+    m_piVSPIndex[ui] = pcFrom->m_piVSPIndex[ui];
+#endif
     m_puhLumaIntraDir[ui]=pcFrom->m_puhLumaIntraDir[ui];
     m_puhChromaIntraDir[ui]=pcFrom->m_puhChromaIntraDir[ui];
 …
 #endif
     memset( m_puhMergeIndex     + firstElement, 0,                        numElements * sizeof( *m_puhMergeIndex ) );
+#if MERL_VSP_C0152
+    memset( m_piVSPIndex        + firstElement, 0,                        numElements * sizeof( *m_piVSPIndex ) );
+#endif
     memset( m_puhLumaIntraDir   + firstElement, 2,                        numElements * sizeof( *m_puhLumaIntraDir ) );
     memset( m_puhChromaIntraDir + firstElement, 0,                        numElements * sizeof( *m_puhChromaIntraDir ) );
 …
 #if HHI_DMM_PRED_TEX
     memset( m_puiWedgePredTexTabIdx    + firstElement, 0, sizeof( UInt ) * numElements );
+#if LGE_DMM3_SIMP_C0044
+    memset( m_puiWedgePredTexIntraTabIdx + firstElement, 0, sizeof( UInt ) * numElements );
+#endif
     memset( m_piWedgePredTexDeltaDC1   + firstElement, 0, sizeof( Int  ) * numElements );
     memset( m_piWedgePredTexDeltaDC2   + firstElement, 0, sizeof( Int  ) * numElements );
 …
     memset (m_pbRenderable             + firstElement, false, sizeof( Bool ) * numElements) ;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     memset( m_pbResPredAvailable       + firstElement, 0    , sizeof( Bool ) * numElements );
     memset( m_pbResPredFlag            + firstElement, 0    , sizeof( Bool ) * numElements );
 …
+}
-#if H0736_AVC_STYLE_QP_RANGE
 /** initialize prediction data with enabling sub-LCU-level delta QP
 *\param  uiDepth  depth of the current CU
 …
 */
 Void TComDataCU::initEstData( UInt uiDepth, Int qp )
-#else
-/** initialize prediction data with enabling sub-LCU-level delta QP
-*\param  uiDepth  depth of the current CU
-*\param  uiQP     QP for the current CU
-*- set CU width and CU height according to depth
-*- set QP value according to input QP
-*- set last-coded QP value according to input last-coded QP
-*/
-Void TComDataCU::initEstData( UInt uiDepth, UInt uiQP )
-#endif
+{
   m_dTotalCost         = MAX_DOUBLE;
 …
       m_pePredMode[ui] = MODE_NONE;
       m_pbIPCMFlag[ui] = 0;
-#if H0736_AVC_STYLE_QP_RANGE
       m_phQP[ui] = qp;
-#else
-      m_phQP[ui] = uiQP;
-#endif
       m_puiAlfCtrlFlag[ui]= false;
       m_pbMergeFlag[ui] = 0;
 …
 #endif
       m_puhMergeIndex[ui] = 0;
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+      m_piVSPIndex[ui] = 0;
+#endif
+#if H3D_IVRP
       m_pbResPredAvailable[ui] = 0;
       m_pbResPredFlag[ui]      = 0;
 …
 #if HHI_DMM_PRED_TEX
     m_puiWedgePredTexTabIdx   [ui] = 0;
+#if LGE_DMM3_SIMP_C0044
+    m_puiWedgePredTexIntraTabIdx [ui] = 0;
+#endif
     m_piWedgePredTexDeltaDC1  [ui] = 0;
     m_piWedgePredTexDeltaDC2  [ui] = 0;
 …
 // initialize Sub partition
-#if H0736_AVC_STYLE_QP_RANGE
 Void TComDataCU::initSubCU( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp )
-#else
-Void TComDataCU::initSubCU( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, UInt uiQP )
-#endif
+{
   assert( uiPartUnitIdx<4 );
 …
   m_uiNumPartition     = pcCU->getTotalNumPart() >> 2;
-#if BURST_IPCM
   m_numSucIPCM       = 0;
   m_lastCUSucIPCMFlag   = false;
-#endif
   Int iSizeInUchar = sizeof( UChar  ) * m_uiNumPartition;
   Int iSizeInBool  = sizeof( Bool   ) * m_uiNumPartition;
+#if H0736_AVC_STYLE_QP_RANGE
+#if MERL_VSP_C0152
+  Int iSizeInChar  = sizeof( Char   ) * m_uiNumPartition;
+#endif
   Int sizeInChar = sizeof( Char  ) * m_uiNumPartition;
   memset( m_phQP,              qp,  sizeInChar );
-#else
-  memset( m_phQP,              uiQP, iSizeInUchar );
-#endif
   memset( m_puiAlfCtrlFlag,     0, iSizeInBool );
 …
 #endif
   memset( m_puhMergeIndex,      0, iSizeInUchar );
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  memset( m_piVSPIndex,         0, iSizeInChar );
+#endif
+#if H3D_IVRP
   memset( m_pbResPredAvailable, 0, iSizeInBool  );
   memset( m_pbResPredFlag,      0, iSizeInBool  );
 …
 #if HHI_DMM_PRED_TEX
   memset( m_puiWedgePredTexTabIdx,    0, sizeof( UInt ) * m_uiNumPartition );
+#if LGE_DMM3_SIMP_C0044
+  memset( m_puiWedgePredTexIntraTabIdx, 0, sizeof( UInt ) * m_uiNumPartition );
+#endif
   memset( m_piWedgePredTexDeltaDC1,   0, sizeof( Int  ) * m_uiNumPartition );
   memset( m_piWedgePredTexDeltaDC2,   0, sizeof( Int  ) * m_uiNumPartition );
 …
 #endif
       m_puhMergeIndex[ui]=pcCU->m_puhMergeIndex[uiPartOffset+ui];
+#if MERL_VSP_C0152
+      m_piVSPIndex[ui]=pcCU->m_piVSPIndex[uiPartOffset+ui];
+#endif
       m_puhLumaIntraDir[ui]=pcCU->m_puhLumaIntraDir[uiPartOffset+ui];
       m_puhChromaIntraDir[ui]=pcCU->m_puhChromaIntraDir[uiPartOffset+ui];
 …
 #if HHI_DMM_PRED_TEX
       m_puiWedgePredTexTabIdx   [ui]=pcCU->getWedgePredTexTabIdx    (uiPartOffset+ui);
+#if LGE_DMM3_SIMP_C0044
+      m_puiWedgePredTexIntraTabIdx [ui]=pcCU->getWedgePredTexIntraTabIdx (uiPartOffset+ui);
+#endif
       m_piWedgePredTexDeltaDC1  [ui]=pcCU->getWedgePredTexDeltaDC1  (uiPartOffset+ui);
       m_piWedgePredTexDeltaDC2  [ui]=pcCU->getWedgePredTexDeltaDC2  (uiPartOffset+ui);
 …
       m_piContourPredTexDeltaDC2[ui]=pcCU->getContourPredTexDeltaDC2(uiPartOffset+ui);
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       m_pbResPredAvailable[ui] = pcCU->m_pbResPredAvailable[ uiPartOffset + ui ];
       m_pbResPredFlag     [ui] = pcCU->m_pbResPredFlag     [ uiPartOffset + ui ];
 …
 #endif
   m_puhMergeIndex       = pcCU->getMergeIndex()       + uiPart;
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  m_piVSPIndex          = pcCU->getVSPIndex()         + uiPart;
+#endif
+#if H3D_IVRP
   m_pbResPredAvailable  = pcCU->getResPredAvail()     + uiPart;
   m_pbResPredFlag       = pcCU->getResPredFlag ()     + uiPart;
 …
 #if HHI_DMM_PRED_TEX
   m_puiWedgePredTexTabIdx    = pcCU->getWedgePredTexTabIdx()     + uiPart;
+#if LGE_DMM3_SIMP_C0044
+  m_puiWedgePredTexIntraTabIdx = pcCU->getWedgePredTexIntraTabIdx() + uiPart;
+#endif
   m_piWedgePredTexDeltaDC1   = pcCU->getWedgePredTexDeltaDC1()   + uiPart;
   m_piWedgePredTexDeltaDC2   = pcCU->getWedgePredTexDeltaDC2()   + uiPart;
 …
   m_uiCUAddr           = pcCU->getAddr();
   m_uiAbsIdxInLCU      = uiAbsPartIdx;
   Int iRastPartIdx     = g_auiZscanToRaster[uiAbsPartIdx];
   m_uiCUPelX           = pcCU->getCUPelX() + m_pcPic->getMinCUWidth ()*( iRastPartIdx % m_pcPic->getNumPartInWidth() );
 …
 #endif
   m_puhMergeIndex      = pcCU->getMergeIndex()            + uiAbsPartIdx;
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  m_piVSPIndex         = pcCU->getVSPIndex()              + uiAbsPartIdx;
+#endif
+#if H3D_IVRP
   m_pbResPredAvailable = pcCU->getResPredAvail()          + uiAbsPartIdx;
   m_pbResPredFlag      = pcCU->getResPredFlag ()          + uiAbsPartIdx;
 …
   Int iSizeInUchar  = sizeof( UChar ) * uiNumPartition;
   Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
+#if H0736_AVC_STYLE_QP_RANGE
+#if MERL_VSP_C0152
+  Int iSizeInChar   = sizeof( Char )  * uiNumPartition;
+#endif
   Int sizeInChar  = sizeof( Char ) * uiNumPartition;
   memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
-#else
-  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             iSizeInUchar                        );
-#endif
   memcpy( m_pePartSize + uiOffset, pcCU->getPartitionSize(),  sizeof( *m_pePartSize ) * uiNumPartition );
   memcpy( m_pePredMode + uiOffset, pcCU->getPredictionMode(), sizeof( *m_pePredMode ) * uiNumPartition );
 …
 #endif
   memcpy( m_puhMergeIndex       + uiOffset, pcCU->getMergeIndex(),        iSizeInUchar );
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  memcpy( m_piVSPIndex          + uiOffset, pcCU->getVSPIndex(),          iSizeInChar );
+#endif
+#if H3D_IVRP
   memcpy( m_pbResPredAvailable  + uiOffset, pcCU->getResPredAvail(),      iSizeInBool  );
   memcpy( m_pbResPredFlag       + uiOffset, pcCU->getResPredFlag(),       iSizeInBool  );
 …
 #if HHI_DMM_PRED_TEX
   memcpy( m_puiWedgePredTexTabIdx    + uiOffset, pcCU->getWedgePredTexTabIdx(),     sizeof( UInt ) * uiNumPartition );
+#if LGE_DMM3_SIMP_C0044
+  memcpy( m_puiWedgePredTexIntraTabIdx + uiOffset, pcCU->getWedgePredTexIntraTabIdx(), sizeof( UInt ) * uiNumPartition );
+#endif
   memcpy( m_piWedgePredTexDeltaDC1   + uiOffset, pcCU->getWedgePredTexDeltaDC1(),   sizeof( Int  ) * uiNumPartition );
   memcpy( m_piWedgePredTexDeltaDC2   + uiOffset, pcCU->getWedgePredTexDeltaDC2(),   sizeof( Int  ) * uiNumPartition );
 …
   Int iSizeInUchar  = sizeof( UChar ) * m_uiNumPartition;
   Int iSizeInBool   = sizeof( Bool  ) * m_uiNumPartition;
+#if H0736_AVC_STYLE_QP_RANGE
+#if MERL_VSP_C0152
+  Int iSizeInChar   = sizeof( Char  ) * m_uiNumPartition;
+#endif
   Int sizeInChar  = sizeof( Char ) * m_uiNumPartition;
   memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, sizeInChar  );
-#else
-  memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, iSizeInUchar );
-#endif
   memcpy( rpcCU->getPartitionSize()  + m_uiAbsIdxInLCU, m_pePartSize, sizeof( *m_pePartSize ) * m_uiNumPartition );
 …
 #endif
   memcpy( rpcCU->getMergeIndex()        + m_uiAbsIdxInLCU, m_puhMergeIndex,       iSizeInUchar );
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  memcpy( rpcCU->getVSPIndex()          + m_uiAbsIdxInLCU, m_piVSPIndex,         iSizeInChar );
+#endif
+#if H3D_IVRP
   memcpy( rpcCU->getResPredAvail()      + m_uiAbsIdxInLCU, m_pbResPredAvailable,  iSizeInBool  );
   memcpy( rpcCU->getResPredFlag()       + m_uiAbsIdxInLCU, m_pbResPredFlag,       iSizeInBool  );
 …
 #if HHI_DMM_PRED_TEX
   memcpy( rpcCU->getWedgePredTexTabIdx()     + m_uiAbsIdxInLCU, m_puiWedgePredTexTabIdx,    sizeof( UInt ) * m_uiNumPartition );
+#if LGE_DMM3_SIMP_C0044
+  memcpy( rpcCU->getWedgePredTexIntraTabIdx() + m_uiAbsIdxInLCU, m_puiWedgePredTexIntraTabIdx,    sizeof( UInt ) * m_uiNumPartition );
+#endif
   memcpy( rpcCU->getWedgePredTexDeltaDC1()   + m_uiAbsIdxInLCU, m_piWedgePredTexDeltaDC1,   sizeof( Int  ) * m_uiNumPartition );
   memcpy( rpcCU->getWedgePredTexDeltaDC2()   + m_uiAbsIdxInLCU, m_piWedgePredTexDeltaDC2,   sizeof( Int  ) * m_uiNumPartition );
 …
   Int iSizeInUchar  = sizeof( UChar  ) * uiQNumPart;
   Int iSizeInBool   = sizeof( Bool   ) * uiQNumPart;
+#if H0736_AVC_STYLE_QP_RANGE
+#if MERL_VSP_C0152
+  Int iSizeInChar   = sizeof( Char   ) * uiQNumPart;
+#endif
   Int sizeInChar  = sizeof( Char ) * uiQNumPart;
   memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, sizeInChar );
-#else
-  memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, iSizeInUchar );
-#endif
   memcpy( rpcCU->getPartitionSize()  + uiPartOffset, m_pePartSize, sizeof( *m_pePartSize ) * uiQNumPart );
 #if HHI_INTERVIEW_SKIP
 …
 #endif
   memcpy( rpcCU->getMergeIndex()        + uiPartOffset, m_puhMergeIndex,       iSizeInUchar );
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+  memcpy( rpcCU->getVSPIndex()          + uiPartOffset, m_piVSPIndex,         iSizeInChar );
+#endif
+#if H3D_IVRP
   memcpy( rpcCU->getResPredAvail()      + uiPartOffset, m_pbResPredAvailable,  iSizeInBool  );
   memcpy( rpcCU->getResPredFlag()       + uiPartOffset, m_pbResPredFlag,       iSizeInBool  );
 …
 #if HHI_DMM_PRED_TEX
   memcpy( rpcCU->getWedgePredTexTabIdx()     + uiPartOffset, m_puiWedgePredTexTabIdx,    sizeof( UInt ) * uiQNumPart );
+#if LGE_DMM3_SIMP_C0044
+  memcpy( rpcCU->getWedgePredTexIntraTabIdx() + uiPartOffset, m_puiWedgePredTexIntraTabIdx, sizeof( UInt ) * uiQNumPart );
+#endif
   memcpy( rpcCU->getWedgePredTexDeltaDC1()   + uiPartOffset, m_piWedgePredTexDeltaDC1,   sizeof( Int  ) * uiQNumPart );
   memcpy( rpcCU->getWedgePredTexDeltaDC2()   + uiPartOffset, m_piWedgePredTexDeltaDC2,   sizeof( Int  ) * uiQNumPart );
 …
        (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)))
       ||
-#if !REMOVE_TILE_DEPENDENCE
-       (bEnforceTileRestriction && ( m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))  )  )
-#else
        (bEnforceTileRestriction && ( m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))  )  )
-#endif
+      )
+  {
 …
        (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || m_pcCUAbove->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)))
       ||
-#if !REMOVE_TILE_DEPENDENCE
-       (bEnforceTileRestriction &&(m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))))
-#else
        (bEnforceTileRestriction &&(m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))))
-#endif
+      )
+  {
 …
   if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCUAboveLeft==NULL || m_pcCUAboveLeft->getSlice()==NULL ||
        m_pcCUAboveLeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAboveLeft==NULL || m_pcCUAboveLeft->getSlice()==NULL ||
        m_pcCUAboveLeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
        m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
        m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL ||
        m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
        m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
        m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
        m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL ||
        m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
        m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiAbsZorderQpMinCUIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL ||
        m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiAbsZorderQpMinCUIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
+  }
-#if H0204_QP_PREDICTION
   if ( m_pcCULeft && m_pcCULeft->getAddr() != getAddr() )
+  {
     return NULL;
+  }
-#endif
   return m_pcCULeft;
+}
-#if H0204_QP_PREDICTION
 /** Get Above QpMinCu
 *\param   aPartUnitIdx
 …
   if ( (enforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(absZorderQpMinCUIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))||
        (enforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL ||
        m_pcCUAbove->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(absZorderQpMinCUIdx)||
-#if !REMOVE_TILE_DEPENDENCE
-       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#else
        (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
-#endif
        ))
+     )
 …
   return m_pcCUAbove;
+}
+#endif
+#if H0736_AVC_STYLE_QP_RANGE
 /** Get reference QP from left QpMinCu or latest coded QP
 *\param   uiCurrAbsIdxInLCU
 …
 */
 Char TComDataCU::getRefQP( UInt uiCurrAbsIdxInLCU )
+#else
+/** Get reference QP from left QpMinCu or latest coded QP
+*\param   uiCurrAbsIdxInLCU
+*\returns UChar   reference QP value
+*/
+UChar TComDataCU::getRefQP( UInt uiCurrAbsIdxInLCU )
+#endif
+{
+#if H0204_QP_PREDICTION
+{
   UInt        lPartIdx, aPartIdx;
   lPartIdx = 0;
 …
   TComDataCU* cUAbove = getQpMinCuAbove( aPartIdx, m_uiAbsIdxInLCU + uiCurrAbsIdxInLCU );
   return (((cULeft? cULeft->getQP( lPartIdx ): getLastCodedQP( uiCurrAbsIdxInLCU )) + (cUAbove? cUAbove->getQP( aPartIdx ): getLastCodedQP( uiCurrAbsIdxInLCU )) + 1) >> 1);
-#else
-  // Left CU
-  TComDataCU* pcCULeft;
-  UInt        uiLPartIdx;
-  pcCULeft = getQpMinCuLeft( uiLPartIdx, m_uiAbsIdxInLCU + uiCurrAbsIdxInLCU );
-  if ( pcCULeft )
+  {
-    return pcCULeft->getQP(uiLPartIdx);
+  }
-  // Last QP
-  return getLastCodedQP( uiCurrAbsIdxInLCU );
-#endif
+}
 …
+}
-#if H0736_AVC_STYLE_QP_RANGE
 Char TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
-#else
-UChar TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
-#endif
+{
   UInt uiQUPartIdxMask = ~((1<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))-1);
 …
 Bool TComDataCU::isLosslessCoded(UInt absPartIdx)
+{
-#if H0736_AVC_STYLE_QP_RANGE
   return ( getSlice()->getSPS()->getUseLossless() && ((getQP(absPartIdx) + getSlice()->getSPS()->getQpBDOffsetY()) == 0) );
-#else
-  return ( getSlice()->getSPS()->getUseLossless() && (getQP(absPartPIdx)  == 0) );
-#endif
+}
 #endif
 …
+{
   uiModeList[0] = PLANAR_IDX;
-#if LOGI_INTRA_NAME_3MPM
   uiModeList[1] = VER_IDX;
   uiModeList[2] = HOR_IDX;
-#else
-  uiModeList[1] = 1;
-  uiModeList[2] = 2;
-#endif
   uiModeList[3] = DC_IDX;
   uiModeList[4] = LM_CHROMA_IDX;
 …
     if( uiLumaMode == uiModeList[i] )
+    {
-#if LOGI_INTRA_NAME_3MPM
       uiModeList[i] = 34; // VER+8 mode
-#else
-      uiModeList[i] = 7; // VER+8 mode
-#endif
       break;
+    }
 …
   pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
-#if DEFAULT_DC
   iLeftIntraDir  = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
-#else
-  iLeftIntraDir  = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : PLANAR_IDX ) : PLANAR_IDX;
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
   mapDMMtoIntraMode( iLeftIntraDir );
 …
   pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx, true, true, false, true );
-#if DEFAULT_DC
   iAboveIntraDir = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
-#else
-  iAboveIntraDir = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : PLANAR_IDX ) : PLANAR_IDX;
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
   mapDMMtoIntraMode( iAboveIntraDir );
 …
 #endif
-#if LOGI_INTRA_NAME_3MPM
   uiPredNum = 3;
   if(iLeftIntraDir == iAboveIntraDir)
 …
+    }
+  }
-#else
-  Int iIdx  = getIntraSizeIdx(uiAbsPartIdx);
-  if ( iLeftIntraDir >= g_aucIntraModeNumAng[iIdx] )
+  {
-    iLeftIntraDir = PLANAR_IDX;
+  }
-  if ( iAboveIntraDir >= g_aucIntraModeNumAng[iIdx] )
+  {
-    iAboveIntraDir = PLANAR_IDX;
+  }
-  if(iLeftIntraDir == iAboveIntraDir)
+  {
-    uiPredNum = 2;
-    if( piMode )
+    {
-      *piMode = iLeftIntraDir;
+    }
-    iAboveIntraDir = iLeftIntraDir == PLANAR_IDX ? DC_IDX : PLANAR_IDX; // DC or Planar
-    assert( iLeftIntraDir != iAboveIntraDir );
-    uiIntraDirPred[0] = min(iLeftIntraDir, iAboveIntraDir);
-    uiIntraDirPred[1] = max(iLeftIntraDir, iAboveIntraDir);
+  }
-  else
+  {
-    uiPredNum = 2;
-    uiIntraDirPred[0] = min(iLeftIntraDir, iAboveIntraDir);
-    uiIntraDirPred[1] = max(iLeftIntraDir, iAboveIntraDir);
+  }
-#endif
   return uiPredNum;
 …
   UInt quadtreeTUMaxDepth = getPredictionMode( absPartIdx ) == MODE_INTRA ? m_pcSlice->getSPS()->getQuadtreeTUMaxDepthIntra() : m_pcSlice->getSPS()->getQuadtreeTUMaxDepthInter();
   Int intraSplitFlag = ( getPredictionMode( absPartIdx ) == MODE_INTRA && partSize == SIZE_NxN ) ? 1 : 0;
-#if G519_TU_AMP_NSQT_HARMONIZATION
   Int interSplitFlag = ((quadtreeTUMaxDepth == 1) && (getPredictionMode( absPartIdx ) == MODE_INTER) && (partSize != SIZE_2Nx2N) );
-#else
-  Int interSplitFlag = ((quadtreeTUMaxDepth == 1) && (getPredictionMode( absPartIdx ) == MODE_INTER) && (partSize == SIZE_Nx2N || partSize == SIZE_2NxN) );
-#endif
   UInt log2MinTUSizeInCU = 0;
 …
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 UInt
 TComDataCU::getCtxResPredFlag( UInt uiAbsPartIdx )
 …
+}
-#if H0736_AVC_STYLE_QP_RANGE
 Void TComDataCU::setQPSubParts( Int qp, UInt uiAbsPartIdx, UInt uiDepth )
-#else
-Void TComDataCU::setQPSubParts( UInt uiQP, UInt uiAbsPartIdx, UInt uiDepth )
-#endif
+{
   UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
 …
     if( m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiSCUIdx+getZorderIdxInCU()) == pcSlice->getEntropySliceCurStartCUAddr() )
+    {
-#if H0736_AVC_STYLE_QP_RANGE
       m_phQP[uiSCUIdx] = qp;
-#else
-      m_phQP[uiSCUIdx] = uiQP;
-#endif
+    }
+  }
 …
+}
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if MERL_VSP_C0152
+Void TComDataCU::setVSPIndexSubParts ( Char iVSPIdx, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
+{
+  setSubPart<Char>( iVSPIdx, m_piVSPIndex, uiAbsPartIdx, uiDepth, uiPartIdx );
+}
+#endif
+#if H3D_IVRP
 Void TComDataCU::setResPredAvailSubParts( Bool bResPredAvailable, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
+{
 …
+}
+#if LGE_ILLUCOMP_DEPTH_C0046
+//This modification is not needed after integrating JCT3V-C0137
+Bool TComDataCU::isICFlagRequired(UInt uiAbsPartIdx, UInt uiDepth)
+{
+  UInt uiPartAddr;
+  UInt iNumbPart;
+  if(!getSlice()->getIsDepth())
+  {
+    Int iWidth, iHeight;
+    iNumbPart = ( getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N ? 1 : (getPartitionSize(uiAbsPartIdx) == SIZE_NxN ? 4 : 2) );
+    for(UInt i = 0; i < iNumbPart; i++)
+    {
+      getPartIndexAndSize(i, uiPartAddr, iWidth, iHeight, uiAbsPartIdx, true);
+      uiPartAddr += uiAbsPartIdx;
+      for(UInt uiRefIdx = 0; uiRefIdx < 2; uiRefIdx++)
+      {
+        RefPicList eRefList = uiRefIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
+        Int iBestRefIdx = getCUMvField(eRefList)->getRefIdx(uiPartAddr);
+        if((getInterDir(uiPartAddr) & (uiRefIdx+1)) && iBestRefIdx >= 0 && getSlice()->getViewId() != getSlice()->getRefViewId(eRefList, iBestRefIdx))
+        {
+          return true;
+        }
+      }
+    }
+  }
+  else
+  {
+    iNumbPart = getPic()->getNumPartInCU() >> (uiDepth << 1);
+    for(UInt i = 0; i < iNumbPart; i++)
+    {
+      uiPartAddr = uiAbsPartIdx + i;
+      for(UInt uiRefIdx = 0; uiRefIdx < 2; uiRefIdx++)
+      {
+        RefPicList eRefList = uiRefIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
+        Int iBestRefIdx = getCUMvField(eRefList)->getRefIdx(uiPartAddr);
+        if((getInterDir(uiPartAddr) & (uiRefIdx+1)) && iBestRefIdx >= 0 && getSlice()->getViewId() != getSlice()->getRefViewId(eRefList, iBestRefIdx))
+        {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+#else
 Bool TComDataCU::isICFlagRequired(UInt uiAbsPartIdx)
+{
 …
+      {
         return true;
+      }
+    }
+    }
+  }
+  }
   return false;
+}
+#endif
 #endif
 …
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Int TComDataCU::getResiPredMode(UInt uiPartAddr)
+{
 …
  * \param numValidMergeCand
  */
+#if SIMP_MRG_PRUN
+#if MERL_VSP_C0152
+Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int* iVSPIndexTrue, Int mrgCandIdx )
+#else
 Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
+#endif
+{
+#if H3D_IVMP
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  const Int extraMergeCand = ( ( getSlice()->getIsDepth() || getSlice()->getSPS()->getMultiviewMvPredMode() )? 1 : 0 );
 #else
-Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand )
-#endif
+{
-#if HHI_INTER_VIEW_MOTION_PRED
   const Int extraMergeCand = ( getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
+#endif
 #endif
   UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx;
   UInt uiIdx = 1;
 #if HHI_INTER_VIEW_MOTION_PRED
   bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ];
+#if H3D_IVMP
+  Bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ];
   for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
 #else
   bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
+  Bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
   for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
 #endif
 …
+  }
   // compute the location of the current PU
-#if PARALLEL_MERGE
   Int xP, yP, nPSW, nPSH;
   this->getPartPosition(uiPUIdx, xP, yP, nPSW, nPSH);
+#endif
+#if MERL_VSP_C0152
+  Bool bVspMvZeroDone[3] = {false, false, false};
+#endif
   Int iCount = 0;
 …
   deriveLeftBottomIdxGeneral( cCurPS, uiAbsPartIdx, uiPUIdx, uiPartIdxLB );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Bool bNoPdmMerge   = ( m_pcSlice->getSPS()->getViewId() == 0 || ( m_pcSlice->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) != PDM_USE_FOR_MERGE );
   //===== add merge with predicted depth maps =====
-#if QC_MRG_CANS_B0048
   TComMv  acPdmMv       [4];
   Int     aiPdmRefIdx   [4] = {-1, -1, -1, -1};
   Bool    bLeftAvai         = false;
-#if OL_DISMV_POS_B0069
   Int     iPosLeftAbove[2]  = {-1, -1};
+#endif
+#else
+  TComMv  acPdmMv       [2];
+  Int     aiPdmRefIdx   [2] = {-1, -1};
+#endif
+#if LGE_DVMCP_A0126
+#if QC_MRG_CANS_B0048
+#if H3D_NBDV
   acPdmMv[0].m_bDvMcp = acPdmMv[1].m_bDvMcp = acPdmMv[2].m_bDvMcp = acPdmMv[3].m_bDvMcp = false;
+#else
+  acPdmMv[0].m_bDvMcp = acPdmMv[1].m_bDvMcp = false;
+#endif
+#endif
+#if QC_MULTI_DIS_CAN_A0097
+#endif //H3D_NBDV
+#if MTK_MDIVRP_C0138
+  Bool bDVAvail = true;
+#endif
+#if H3D_NBDV
   DisInfo cDisInfo;
   cDisInfo.iN = 0;
   if(!bNoPdmMerge)
+  {
+#if LGE_DVMCP_A0126
+#if LGE_IVMP_PARALLEL_MERGE_B0136 && !QC_SIMPLE_NBDV_B0047
+    getDisMvpCand2(uiPUIdx, uiAbsPartIdx, &cDisInfo, true, REF_PIC_LIST_X, -1, true );
+#else
+    getDisMvpCand2(uiPUIdx, uiAbsPartIdx, &cDisInfo
+#if LGE_IVMP_PARALLEL_MERGE_B0136==QC_SIMPLE_NBDV_B0047
+,
+true
+    getDisMvpCandNBDV(uiPUIdx, uiAbsPartIdx, &cDisInfo , true
+#if MERL_VSP_C0152
+            , true
 #endif
 );
-#endif
-#else
-    getDisMvpCand (uiPUIdx, uiAbsPartIdx, &cDisInfo );
-#endif
+  }
   if(cDisInfo.iN==0)
 …
     cDisInfo.m_acMvCand[0].setVer(0);
     cDisInfo.m_aVIdxCan[0] = 0;
+  }
+#if QC_MRG_CANS_B0048
+#if MTK_MDIVRP_C0138
+    bDVAvail = false;
+#endif
+  }
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  if( m_pcSlice->getIsDepth())
+  {
+    UInt uiPartIdxCenter;
+    xDeriveCenterIdx( cCurPS, uiPUIdx, uiPartIdxCenter );
+    TComDataCU *pcTextureCU = m_pcSlice->getTexturePic()->getCU( getAddr() );
+    if ( pcTextureCU && !pcTextureCU->isIntra( uiPartIdxCenter ) )
+    {
+      abCandIsInter[iCount] = true;
+      puhInterDirNeighbours[iCount] = pcTextureCU->getInterDir( uiPartIdxCenter );
+      if( ( puhInterDirNeighbours[iCount] & 1 ) == 1 )
+      {
+        pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
+        TComMv cMvPred = pcMvFieldNeighbours[iCount<<1].getMv();
+        const TComMv cAdd( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
+        cMvPred+=cAdd;
+        cMvPred>>=2;
+        clipMv(cMvPred);
+        pcMvFieldNeighbours[iCount<<1].setMvField(cMvPred,pcMvFieldNeighbours[iCount<<1].getRefIdx());
+      }
+      if ( getSlice()->isInterB() )
+      {
+        if( ( puhInterDirNeighbours[iCount] & 2 ) == 2 )
+        {
+          pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+          TComMv cMvPred = pcMvFieldNeighbours[(iCount<<1)+1].getMv();
+          const TComMv cAdd( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
+          cMvPred+=cAdd;
+          cMvPred>>=2;
+          clipMv(cMvPred);
+          pcMvFieldNeighbours[(iCount<<1)+1].setMvField(cMvPred,pcMvFieldNeighbours[(iCount<<1)+1].getRefIdx());
+        }
+      }
+#if MERL_VSP_C0152
+      xInheritVspMode( pcTextureCU, uiPartIdxCenter, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
+      if ( mrgCandIdx == iCount )
+      {
+        return;
+      }
+      iCount ++;
+    }
+  }
+#endif
   Int iPdmDir[2] = {0, 0};
+#endif
+  Int     iPdmInterDir      = cDisInfo.iN==0? 0:getPdmMergeCandidateDisCan ( uiPUIdx, aiPdmRefIdx, acPdmMv, &cDisInfo
+#if QC_MRG_CANS_B0048
+    , iPdmDir
+#endif
+    );
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+  getUnifiedMvPredCan(uiPUIdx, REF_PIC_LIST_0, 0, aiPdmRefIdx, acPdmMv, &cDisInfo, iPdmDir, true);
+  Int iPdmInterDir;
 #else
+  Int     iPdmInterDir      = cDisInfo.iN==0? 0:getPdmMergeCandidateDisCan ( uiPUIdx, aiPdmRefIdx, acPdmMv, &cDisInfo, iPdmDir );
+#endif
+#else // H3D_NBDV
+  Int iPdmDir[2] = {0, 0};
   Int     iPdmInterDir      = getPdmMergeCandidate( uiPUIdx, aiPdmRefIdx, acPdmMv );
+#endif
+#if QC_MRG_CANS_B0048
+  iPdmDir[0] = iPdmInterDir;
+  iPdmDir[1] = iPdmInterDir;
+#endif // H3D_NBDV
+#if MTK_MDIVRP_C0138
+  if (m_pcSlice->getSPS()->getMultiviewResPredMode()==1 && iPdmDir[0] && !bNoPdmMerge && cCurPS == SIZE_2Nx2N && bDVAvail)
+  {
+    setResPredAvailSubParts(true, 0, 0, uiDepth);
+  }
+#endif
   if( iPdmDir[0] && !bNoPdmMerge && PDM_MERGE_POS == 0 )
-#else
-  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 0 )
-#endif
+  {
     abCandIsInter        [ iCount ] = true;
-#if QC_MRG_CANS_B0048
     puhInterDirNeighbours[ iCount ] = iPdmDir[0];
     iPdmInterDir                    = iPdmDir[0];
+#else
+    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
+#endif
     if( ( iPdmInterDir & 1 ) == 1 )
+    {
 …
+    }
 #endif
-#if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#endif
+#if QC_MRG_CANS_B0048
   if(extraMergeCand)
+  {
 …
         pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 3 ], aiPdmRefIdx[ 3 ] );
+      }
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
       pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
       pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
-#if SIMP_MRG_PRUN
       if ( mrgCandIdx == iCount )
           return;
-#endif
       iCount ++;
+    }
+  }
+#endif
+#endif //  H3D_IVMP
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 0 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(0, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
+      return;
+#endif
   //left
   UInt uiLeftPartIdx = 0;
   TComDataCU* pcCULeft = 0;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
   pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB, true, false );
-#else
-  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB );
-#endif
-#if PARALLEL_MERGE
   if (pcCULeft)
+  {
 …
+    }
+  }
-#endif
   PartSize partSize = getPartitionSize( uiAbsPartIdx );
   if (!(uiPUIdx == 1 && (partSize == SIZE_Nx2N || partSize == SIZE_nLx2N || partSize == SIZE_nRx2N)))
+  {
+  if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx ) )
+    if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx )
+#if MERL_VSP_C0152
+      CHECK_ADD_YET(pcCULeft, uiLeftPartIdx, 1)
+#endif
+      )
+    {
+      abCandIsInter[iCount] = true;
+      // get Inter Dir
+      puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx );
+      // get Mv from Left
+      pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
+      if ( getSlice()->isInterB() )
+      {
+        pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+      }
+#if FIX_CU_BASED_MRG_CAND_LIST_B0136
+      else
+      {
+        pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( TComMv(0,0), NOT_VALID );
+      }
+#endif
+#if H3D_IVMP
+      Bool bRemoveSpa = false; //pruning to inter-view candidates
+      Int  iCnloop    = iCount - 1;
+      for(; iCnloop >= 0; iCnloop --)
+      {
+        if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[iCnloop] && pcMvFieldNeighbours[iCnloop<<1]==pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[(iCnloop<<1)+1]==pcMvFieldNeighbours[(iCount<<1)+1])
+        {
+          bRemoveSpa                      = true;
+          abCandIsInter        [ iCount ] = false;
+          //reset to the default value for IC, MC
+          puhInterDirNeighbours[iCount]   = 0;
+          TComMv  cZeroMv;
+          pcMvFieldNeighbours[iCount<<1].setMvField( cZeroMv, NOT_VALID );
+          pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
+          break;
+        }
+      }
+      if(!bRemoveSpa)
+      {
+        bLeftAvai = true;
+        iPosLeftAbove[0] = iCount;
+#endif  // H3D_IVMP
+#if H3D_NBDV
+        pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
+        pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
+#endif
+#if MERL_VSP_C0152
+        xInheritVspMode( pcCULeft, uiLeftPartIdx, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
+        if ( mrgCandIdx == iCount )
+        {
+          return;
+        }
+        iCount ++;
+#if H3D_IVMP
+      }
+#endif
+    }
+  }
+#if H3D_IVMP
+  if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 1 )
+  {
+    abCandIsInter        [ iCount ] = true;
+    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
+    if( ( iPdmInterDir & 1 ) == 1 )
+    {
+      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
+    }
+#if FIX_CU_BASED_MRG_CAND_LIST_B0136
+    else
+    {
+      pcMvFieldNeighbours[ iCount<<1 ].setMvField( TComMv(0,0), NOT_VALID );
+    }
+#endif
+    if( ( iPdmInterDir & 2 ) == 2 )
+    {
+      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
+    }
+#if FIX_CU_BASED_MRG_CAND_LIST_B0136
+    else
+    {
+      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( TComMv(0,0), NOT_VALID );
+    }
+#endif
+    if ( mrgCandIdx == iCount )
+    {
+      return;
+    }
+    iCount ++;
+  }
+#endif //  H3D_IVMP
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 1 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(1, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
+      return;
+#endif
+  // above
+  UInt uiAbovePartIdx = 0;
+  TComDataCU* pcCUAbove = 0;
+  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, false, true );
+    if (pcCUAbove)
+    {
+      if (!pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
+      {
+        pcCUAbove = NULL;
+      }
+    }
+  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx )
+#if MERL_VSP_C0152
+    CHECK_ADD_YET(pcCUAbove, uiAbovePartIdx, 1)
+#endif
+    && !(uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD))
+    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
+  {
     abCandIsInter[iCount] = true;
     // get Inter Dir
     puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx );
+    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
     // get Mv from Left
     pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
+    pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     if ( getSlice()->isInterB() )
+    {
       pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+      pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+    }
 #if FIX_CU_BASED_MRG_CAND_LIST_B0136
 …
+    }
 #endif
 #if QC_MRG_CANS_B0048
     Bool bRemoveSpa = false; //prunign to inter-view candidates
     Int  iCnloop    = iCount - 1;
+#if H3D_IVMP
+    Bool bRemoveSpa = false; //pruning to inter-view candidates
+    Int  iCnloop    = bLeftAvai? (iCount-2): (iCount-1);
     for(; iCnloop >= 0; iCnloop --)
+    {
 …
         bRemoveSpa                      = true;
         abCandIsInter        [ iCount ] = false;
+#if FIX_MISUSE_REFINDEX
         //reset to the default value for IC, MC
         puhInterDirNeighbours[iCount]   = 0;
 …
         pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
         break;
-#endif
+      }
+    }
     if(!bRemoveSpa)
+    {
+      bLeftAvai = true;
+#if OL_DISMV_POS_B0069
+      iPosLeftAbove[0] = iCount;
+#endif
+#endif
+#if LGE_DVMCP_A0126
+      iPosLeftAbove[1] = iCount;
+#endif //  H3D_IVMP
+#if H3D_NBDV
     pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if SIMP_MRG_PRUN
+#if MERL_VSP_C0152
+     xInheritVspMode( pcCUAbove, uiAbovePartIdx, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+#if QC_MRG_CANS_B0048
+      }
+#endif
+  }
+  }
+#if HHI_INTER_VIEW_MOTION_PRED
+#if QC_MRG_CANS_B0048
+  if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 1 )
+#else
+  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 1 )
+#endif
+#if H3D_IVMP
+    }
+#endif
+  }
+#if H3D_IVMP
+  if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 2 )
+  {
     abCandIsInter        [ iCount ] = true;
 …
+    }
 #endif
-#if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#endif
+  // above
+#if !SIMP_MRG_PRUN
+  partSize = getPartitionSize( uiAbsPartIdx );
+  if (!(uiPUIdx == 1 && (partSize == SIZE_2NxN || partSize == SIZE_2NxnU || partSize == SIZE_2NxnD)))
+  {
+#endif
+  UInt uiAbovePartIdx = 0;
+  TComDataCU* pcCUAbove = 0;
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, false, true );
+#else
+  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, true, true );
+#endif
+#if PARALLEL_MERGE
+    if (pcCUAbove)
+    {
+      if (!pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
+      {
+        pcCUAbove = NULL;
+      }
+    }
+#endif
+#if SIMP_MRG_PRUN
+  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx )
+    && !(uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD))
+    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
+#else
+  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx ) )
+#endif
+  {
+    abCandIsInter[iCount] = true;
+    // get Inter Dir
+    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
+    // get Mv from Left
+    pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
+    if ( getSlice()->isInterB() )
+    {
+      pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+    }
+#if FIX_CU_BASED_MRG_CAND_LIST_B0136
+    else
+    {
+      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( TComMv(0,0), NOT_VALID );
+    }
+#endif
+#if QC_MRG_CANS_B0048
+    Bool bRemoveSpa = false; //prunign to inter-view candidates
+    Int  iCnloop    = bLeftAvai? (iCount-2): (iCount-1);
+    for(; iCnloop >= 0; iCnloop --)
+    {
+      if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[iCnloop] && pcMvFieldNeighbours[iCnloop<<1]==pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[(iCnloop<<1)+1]==pcMvFieldNeighbours[(iCount<<1)+1])
+      {
+        bRemoveSpa                      = true;
+        abCandIsInter        [ iCount ] = false;
+#if FIX_MISUSE_REFINDEX
+        //reset to the default value for IC, MC
+        puhInterDirNeighbours[iCount]   = 0;
+        TComMv  cZeroMv;
+        pcMvFieldNeighbours[iCount<<1].setMvField( cZeroMv, NOT_VALID );
+        pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
+        break;
+#endif
+      }
+    }
+    if(!bRemoveSpa)
+    {
+#if OL_DISMV_POS_B0069
+      iPosLeftAbove[1] = iCount;
+#endif
+#endif
+#if LGE_DVMCP_A0126
+    pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
+    pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
+#endif
+#if SIMP_MRG_PRUN
+    if ( mrgCandIdx == iCount )
+    {
+#endif //  H3D_IVMP
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 2 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(2, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
       return;
+    }
-#endif
-    iCount ++;
-#if QC_MRG_CANS_B0048
+    }
-#endif
+  }
-#if !SIMP_MRG_PRUN
+  }
-#endif
-#if HHI_INTER_VIEW_MOTION_PRED
-#if QC_MRG_CANS_B0048
-  if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 2 )
-#else
-  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 2 )
-#endif
+  {
-    abCandIsInter        [ iCount ] = true;
-    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
-    if( ( iPdmInterDir & 1 ) == 1 )
+    {
-      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
+    }
-#if FIX_CU_BASED_MRG_CAND_LIST_B0136
-    else
+    {
-      pcMvFieldNeighbours[ iCount<<1 ].setMvField( TComMv(0,0), NOT_VALID );
+    }
-#endif
-    if( ( iPdmInterDir & 2 ) == 2 )
+    {
-      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
+    }
-#if FIX_CU_BASED_MRG_CAND_LIST_B0136
-    else
+    {
-      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( TComMv(0,0), NOT_VALID );
+    }
-#endif
-#if SIMP_MRG_PRUN
-    if ( mrgCandIdx == iCount )
+    {
-      return;
+    }
-#endif
-    iCount ++;
+  }
 #endif
 …
   UInt uiAboveRightPartIdx = 0;
   TComDataCU* pcCUAboveRight = 0;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
   pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, false, true );
-#else
-  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, true, true);
-#endif
-#if PARALLEL_MERGE
   if (pcCUAboveRight)
+  {
 …
+    }
+  }
+#endif
+#if SIMP_MRG_PRUN
+  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
+#else
+  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) )
+#endif
+  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx )
+#if MERL_VSP_C0152
+    CHECK_ADD_YET(pcCUAboveRight, uiAboveRightPartIdx, 1)
+#endif
+    && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
+  {
     abCandIsInter[iCount] = true;
 …
+    }
 #endif
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
     pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if SIMP_MRG_PRUN
+#if MERL_VSP_C0152
+    xInheritVspMode( pcCUAboveRight, uiAboveRightPartIdx, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#if HHI_INTER_VIEW_MOTION_PRED
+#if QC_MRG_CANS_B0048
+#if H3D_IVMP
   if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 3 )
-#else
-  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 3 )
-#endif
+  {
     abCandIsInter        [ iCount ] = true;
 …
+    }
 #endif
-#if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#endif
+#if OL_DISMV_POS_B0069
   if(extraMergeCand)
+  {
 …
+    {
       assert(iCount < MRG_MAX_NUM_CANDS_MEM);
       Bool bRemoveSpa = false; //prunign to A1, B1
+      Bool bRemoveSpa = false; //pruning to A1, B1
       abCandIsInter        [ iCount ] = true;
       puhInterDirNeighbours[ iCount ] = iPdmDir[1];
 …
           bRemoveSpa                      = true;
           abCandIsInter        [ iCount ] = false;
-#if FIX_MISUSE_REFINDEX
           //reset to the default value for IC, MC
           puhInterDirNeighbours[iCount]   = 0;
 …
           pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
           break;
-#endif
+        }
+      }
       if(!bRemoveSpa)
+      {
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
         pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
         pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
-#if SIMP_MRG_PRUN
         if ( mrgCandIdx == iCount )
           return;
-#endif
         iCount ++;
+      }
+    }
+  }
+#endif
+#endif // H3D_IVMP
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 3 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(3, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
+      return;
+#endif
+#if MERL_VSP_C0152
+#if VSP_MERGE_POS < 4
+#if H3D_IVMP
+  if( iCount < 4 + extraMergeCand )
+#else
+  if( iCount < 4 )
+#endif
+  {
+#endif
+#endif
   //left bottom
   UInt uiLeftBottomPartIdx = 0;
   TComDataCU* pcCULeftBottom = 0;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
   pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB, true, false );
-#else
-  pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB );
-#endif
-#if PARALLEL_MERGE
   if (pcCULeftBottom)
+  {
 …
+    }
+  }
+#endif
+#if SIMP_MRG_PRUN
+  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
+#else
+  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) )
+#endif
+  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx )
+#if MERL_VSP_C0152
+    CHECK_ADD_YET(pcCULeftBottom, uiLeftBottomPartIdx, 1)
+#endif
+    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
+  {
     abCandIsInter[iCount] = true;
 …
+    }
 #endif
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
     pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if SIMP_MRG_PRUN
+#if MERL_VSP_C0152
+     xInheritVspMode( pcCULeftBottom, uiLeftBottomPartIdx, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#if HHI_INTER_VIEW_MOTION_PRED
+#if QC_MRG_CANS_B0048
+#if MERL_VSP_C0152
+#if VSP_MERGE_POS < 4
+  }
+#endif
+#endif
+#if H3D_IVMP
   if( iPdmDir[0]   && !bNoPdmMerge && PDM_MERGE_POS == 4 )
-#else
-  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 4 )
-#endif
+  {
     abCandIsInter        [ iCount ] = true;
 …
+    }
 #endif
-#if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
+    {
       return;
+    }
-#endif
     iCount ++;
+  }
+#endif
+  // above left
+#if HHI_INTER_VIEW_MOTION_PRED
+#endif //  H3D_IVMP
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 4 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(4, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
+      return;
+#endif
+  // above left
+#if H3D_IVMP
   if( iCount < 4 + extraMergeCand )
 #else
 …
     UInt uiAboveLeftPartIdx = 0;
     TComDataCU* pcCUAboveLeft = 0;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
     pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, false, true );
-#else
-    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, true, true );
-#endif
-#if PARALLEL_MERGE
     if (pcCUAboveLeft)
+    {
 …
+      }
+    }
-#endif
-#if SIMP_MRG_PRUN
     if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx )
+#if MERL_VSP_C0152
+     CHECK_ADD_YET(pcCUAboveLeft, uiAboveLeftPartIdx, 1)
+#endif
      && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
      && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
+     )
-#else
-    if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx ) )
-#endif
+    {
       abCandIsInter[iCount] = true;
 …
+      }
 #endif
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
       pcMvFieldNeighbours[iCount<<1    ].getMv().m_bDvMcp = false;
       pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if SIMP_MRG_PRUN
+#if MERL_VSP_C0152
+     xInheritVspMode( pcCUAboveLeft, uiAboveLeftPartIdx, bVspMvZeroDone, iCount, iVSPIndexTrue, pcMvFieldNeighbours, &cDisInfo ) ;
+#endif
       if ( mrgCandIdx == iCount )
+      {
         return;
+      }
-#endif
       iCount ++;
+    }
+  }
+#if MERL_VSP_COMPENSATION_C0152
+  //===== vsp 5 =====
+  if( iCount < 4 + extraMergeCand )
+    if ( !xAddVspMergeCand(5, 1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, iVSPIndexTrue, mrgCandIdx, &cDisInfo) )
+      return;
+#endif
   if ( getSlice()->getPPS()->getEnableTMVPFlag()
 #if QC_MRG_CANS_B0048
+#if H3D_IVMP
        && iCount < (MRG_MAX_NUM_CANDS_SIGNALED + extraMergeCand)
 #endif
 …
+    {
       RefPicList  eRefPicList = ( i==1 ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
-#if SET_MERGE_TMVP_REFIDX
       Int iRefIdxTmp;
       if ( uiPUIdx != 0 )
 …
         iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList)->getRefIdx(uiLeftPartIdx) : -1;
+      }
-#else
-      Int iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList)->getRefIdx(uiLeftPartIdx) : -1;
-#endif
       iRefIdxSkip[i] = (iRefIdxTmp != -1) ? iRefIdxTmp : 0;
+    }
 …
     Int uiLCUIdx = getAddr();
     PartSize eCUMode = getPartitionSize( 0 );
+#if MERL_VSP_C0152 // Potential bug, not related to BW_VSP
+    if (eCUMode==SIZE_NxN)
+    {
+      printf("Size NxN ???");
+      assert(0);
+    }
+#endif
     deriveRightBottomIdx( eCUMode, uiPUIdx, uiPartIdxRB );
 …
     UInt uiCurLCUIdx = getAddr();
     xDeriveCenterIdx( eCUMode, uiPUIdx, uiPartIdxCenter );
+    bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_0, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx );
+    bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_0, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+    , 1
+#endif
+    );
     if( bExistMV == false )
+    {
+      bExistMV = xGetColMVP( REF_PIC_LIST_0, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
+      bExistMV = xGetColMVP( REF_PIC_LIST_0, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+    , 1
+#endif
+    );
+    }
     if( bExistMV )
 …
         iRefIdx = 0;
 #endif
+        bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_1, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx);
+        bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_1, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+        , 1
+#endif
+        );
         if( bExistMV == false )
+        {
+          bExistMV = xGetColMVP( REF_PIC_LIST_1, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
+          bExistMV = xGetColMVP( REF_PIC_LIST_1, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+        , 1
+#endif
+        );
+        }
         if( bExistMV )
 …
 #endif
+      }
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
       pcMvFieldNeighbours[uiArrayAddr<<1    ].getMv().m_bDvMcp = false;
       pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getMv().m_bDvMcp = false;
 #endif
-#if SIMP_MRG_PRUN
       if ( mrgCandIdx == iCount )
+      {
 …
+      }
       iCount++;
-#endif
+    }
     uiIdx++;
 …
+  }
-#if SIMP_MRG_PRUN
   UInt uiArrayAddr = iCount;
-#else
-#if HHI_INTER_VIEW_MOTION_PRED
-  for( UInt uiOuter = 0; uiOuter < MRG_MAX_NUM_CANDS_MEM; uiOuter++ )
-#else
-  for( UInt uiOuter = 0; uiOuter < MRG_MAX_NUM_CANDS; uiOuter++ )
-#endif
+  {
-    if( abCandIsInter[ uiOuter ] )
+    {
-#if HHI_INTER_VIEW_MOTION_PRED
-      for( UInt uiIter = uiOuter + 1; uiIter < MRG_MAX_NUM_CANDS_MEM; uiIter++ )
-#else
-      for( UInt uiIter = uiOuter + 1; uiIter < MRG_MAX_NUM_CANDS; uiIter++ )
-#endif
+      {
-        UInt uiMvFieldNeighIdxCurr = uiOuter << 1;
-        UInt uiMvFieldNeighIdxComp = uiIter << 1;
-        if( getSlice()->isInterB() )
+        {
-          if( puhInterDirNeighbours[ uiOuter ] == 3 )
+          {
-            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() && pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getRefIdx() &&
-              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() && pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getMv() &&
-              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
+            {
-              abCandIsInter[ uiIter ] = false;
+            }
+          }
-          else if( puhInterDirNeighbours[ uiOuter ] == 2 )
+          {
-            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getRefIdx() &&
-              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getMv() &&
-              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
+            {
-              abCandIsInter[ uiIter ] = false;
+            }
+          }
-          else
+          {
-            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() &&
-              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() &&
-              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
+            {
-              abCandIsInter[ uiIter ] = false;
+            }
+          }
+        }
-        else
+        {
-          if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() &&
-              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() )
+          {
-            assert( puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] );
-            abCandIsInter[ uiIter ] = false;
+          }
+        }
+      }
+    }
+  }
-#if HHI_INTER_VIEW_MOTION_PRED
-  bool abCandIsInterFlag[MRG_MAX_NUM_CANDS_MEM];
-  for (int i=0; i<MRG_MAX_NUM_CANDS_MEM; i++)
-#else
-  bool abCandIsInterFlag[MRG_MAX_NUM_CANDS];
-  for (int i=0; i<MRG_MAX_NUM_CANDS; i++)
-#endif
+  {
-    abCandIsInterFlag[i] = abCandIsInter[ i ];
-    abCandIsInter[ i ] = false;
+  }
-  UInt uiArrayAddr = 0;
-#if HHI_INTER_VIEW_MOTION_PRED
-  for (int i=0; i<MRG_MAX_NUM_CANDS_MEM; i++)
-#else
-  for (int i=0; i<MRG_MAX_NUM_CANDS; i++)
-#endif
+  {
-    if (abCandIsInterFlag[i])
+    {
-      abCandIsInter[uiArrayAddr] = true;
-      puhInterDirNeighbours[uiArrayAddr] = puhInterDirNeighbours[i];
-      pcMvFieldNeighbours[uiArrayAddr<<1].setMvField(pcMvFieldNeighbours[i<<1].getMv(), pcMvFieldNeighbours[i<<1].getRefIdx());
-      pcMvFieldNeighbours[(uiArrayAddr<<1)+1].setMvField(pcMvFieldNeighbours[(i<<1)+1].getMv(), pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
-      ++uiArrayAddr;
+    }
+  }
-#if HHI_INTER_VIEW_MOTION_PRED
-  for (int i=uiArrayAddr; i<MRG_MAX_NUM_CANDS_MEM; i++)
-#else
-  for (int i=uiArrayAddr; i<MRG_MAX_NUM_CANDS; i++)
-#endif
+  {
-    puhInterDirNeighbours[i] = (getSlice()->isInterB()) ? 3 : 1;
-    abCandIsInter[i] = false;
-    TComMv tmpMv;
-    tmpMv.set(0,0);
-    pcMvFieldNeighbours[i<<1].setMvField(tmpMv, 0);
-    if ( getSlice()->isInterB() )
+    {
-      pcMvFieldNeighbours[(i<<1)+1].setMvField(tmpMv, 0);
+    }
+  }
-#endif
   UInt uiCutoff = uiArrayAddr;
   if ( getSlice()->isInterB() )
+  {
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     Int iCombinedCount = 0;
     Int iMaxCombCount  = ( extraMergeCand ?  6 :  5 );
 …
+    {
       Int i = uiPriorityList0[idx]; Int j = uiPriorityList1[idx];
+      if (abCandIsInter[i] && abCandIsInter[j]&& (puhInterDirNeighbours[i]&0x1)&&(puhInterDirNeighbours[j]&0x2))
+#if MERL_VSP_C0152
+      Bool bValid = true;
+      if (pcMvFieldNeighbours[i<<1].getRefIdx() < 0 || pcMvFieldNeighbours[(j<<1)+1].getRefIdx() < 0) // NOT_VALID
+        bValid = false;
+#endif
+      if (abCandIsInter[i] && abCandIsInter[j]&& (puhInterDirNeighbours[i]&0x1)&&(puhInterDirNeighbours[j]&0x2)
+#if MERL_VSP_C0152
+       && bValid
+#endif
+         )
+      {
         abCandIsInter[uiArrayAddr] = true;
 …
+      }
+    }
-#if !REMOVE_NON_SCALED
-    Int iScaledCount = 0;
-#if HHI_INTER_VIEW_MOTION_PRED
-    for (int i=0; i<uiCutoff && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM && iScaledCount<1; i++)
-#else
-    for (int i=0; i<uiCutoff && uiArrayAddr!=MRG_MAX_NUM_CANDS && iScaledCount<1; i++)
-#endif
+    {
-#if HHI_INTER_VIEW_MOTION_PRED
-      for (int j=0; j<2 && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM && iScaledCount<1; j++)
-#else
-      for (int j=0; j<2 && uiArrayAddr!=MRG_MAX_NUM_CANDS && iScaledCount<1; j++)
-#endif
+      {
-        if (abCandIsInter[i] && pcMvFieldNeighbours[(i<<1)+j].getRefIdx()>=0 && pcMvFieldNeighbours[(i<<1)+j].getRefIdx() < m_pcSlice->getNumRefIdx((j==0)?REF_PIC_LIST_1:REF_PIC_LIST_0))
+        {
-          Int iCurrPOC = m_pcSlice->getPOC();
-          Int iCurrRefPOC1 = m_pcSlice->getRefPOC( (j==0)?REF_PIC_LIST_1:REF_PIC_LIST_0, pcMvFieldNeighbours[(i<<1)+j].getRefIdx() );
-          Int iCurrRefPOC2 = m_pcSlice->getRefPOC( (j==0)?REF_PIC_LIST_0:REF_PIC_LIST_1, pcMvFieldNeighbours[(i<<1)+j].getRefIdx() );
-          if (iCurrRefPOC1 != iCurrRefPOC2 && abs(iCurrPOC-iCurrRefPOC1) == abs(iCurrPOC-iCurrRefPOC2))
+          {
-            abCandIsInter[uiArrayAddr] = true;
-            puhInterDirNeighbours[uiArrayAddr] = 3;
-            TComMv cMvPred = pcMvFieldNeighbours[(i<<1)+j].getMv();
-            TComMv rcMv;
-            rcMv.set(-1*cMvPred.getHor(), -1*cMvPred.getVer());
-            if (j==0)
+            {
-              pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(pcMvFieldNeighbours[(i<<1)].getMv(), pcMvFieldNeighbours[(i<<1)].getRefIdx());
-              pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(rcMv, pcMvFieldNeighbours[(i<<1)].getRefIdx());
+            }
-            else
+            {
-              pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(rcMv, pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
-              pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(pcMvFieldNeighbours[(i<<1)+1].getMv(), pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
+            }
-            uiArrayAddr++;
-            iScaledCount++;
+          }
+        }
+      }
+    }
-#endif
+  }
   Int iNumRefIdx = (getSlice()->isInterB()) ? min(m_pcSlice->getNumRefIdx(REF_PIC_LIST_0), m_pcSlice->getNumRefIdx(REF_PIC_LIST_1)) : m_pcSlice->getNumRefIdx(REF_PIC_LIST_0);
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   for (int r=0; r<iNumRefIdx && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM; r++)
 #else
 …
     uiArrayAddr++;
+  }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   if (uiArrayAddr > MRG_MAX_NUM_CANDS_SIGNALED + extraMergeCand )
+  {
 …
   if( uiIter == 0 )
+  {
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx )
+#if MERL_VSP_C0152
+     && !pcCorner->getVSPIndex( uiCornerPUIdx )
+#endif
+    )
+    {
       rbValidCand = true;
 …
   else
+  {
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx )
+#if MERL_VSP_C0152
+     && !pcCorner->getVSPIndex( uiCornerPUIdx )
+#endif
+    )
+    {
       rbValidCand = true;
 …
+  }
+}
-#if PARALLEL_MERGE
 /** Check whether the current PU and a spatial neighboring PU are in a same ME region.
  * \param xN, xN   location of the upper-left corner pixel of a neighboring PU
 …
+}
-#endif
 AMVP_MODE TComDataCU::getAMVPMode(UInt uiIdx)
+{
   return m_pcSlice->getSPS()->getAMVPMode(m_puhDepth[uiIdx]);
+}
 #if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
 /** construct a list of disparity motion vectors from the neighbouring PUs **/
 Void TComDataCU::getDisMvpCand ( UInt uiPartIdx, UInt uiPartAddr,DisInfo* pDInfo )
 …
   UInt uiIdx = 0;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
     pcTmpCU = getPULeft(uiIdx, uiPartIdxLB, true, false);
-#else
-    pcTmpCU = getPULeft(uiIdx, uiPartIdxLB);
-#endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if MERL_VSP_C0152
+  if(! pcTmpCU->getVSPIndex(uiIdx))
+#endif
+  {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
+    }
+  }
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT, true, false, true);
-#else
-    pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT);
-#endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if MERL_VSP_C0152
+  if(! pcTmpCU->getVSPIndex(uiIdx))
+#endif
+  {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
+  }
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveRight(uiIdx, uiPartIdxRT, true, false, true);
-#else
-      pcTmpCU = getPUAboveRight(uiIdx, uiPartIdxRT, true, true, true);
-#endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if MERL_VSP_C0152
+  if(! pcTmpCU->getVSPIndex(uiIdx))
+#endif
+  {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
+    }
+  }
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUBelowLeft(uiIdx, uiPartIdxLB, true, false);
-#else
-      pcTmpCU = getPUBelowLeft(uiIdx, uiPartIdxLB);
-#endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if MERL_VSP_C0152
+  if(! pcTmpCU->getVSPIndex(uiIdx))
+#endif
+  {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
   // Above predictor search
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveLeft(uiIdx, (m_uiAbsIdxInLCU + uiPartAddr), true, false, true);
     assert(uiPartIdxLT == (m_uiAbsIdxInLCU + uiPartAddr));
-#else
-      pcTmpCU = getPUAboveLeft(uiIdx, uiPartIdxLT, true, true, true);
-#endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if MERL_VSP_C0152
+  if(! pcTmpCU->getVSPIndex(uiIdx))
+#endif
+  {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
+}
+#if LGE_DVMCP_A0126
+#if QC_SIMPLE_NBDV_B0047
+Void TComDataCU::getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr,DisInfo* pDInfo
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+                                , Bool bParMerge
+#endif
+#if MERL_VSP_C0152
+#if LGE_SIMP_DVP_REFINE_C0112
+Pel TComDataCU::getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iWidth, Int iHeight, Int* aiShiftLUT, Int iShiftPrec, Bool bSimpleDvpRefine)
 #else
+Void TComDataCU::getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr,DisInfo* pDInfo, Bool bMerge, RefPicList eRefPicList0, Int iRefIdx0
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+                                , Bool bParMerge
+#endif
+Pel TComDataCU::getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iWidth, Int iHeight, Int* aiShiftLUT, Int iShiftPrec)
+#endif
+{
+  Int depStride =  pcBaseViewDepthPicYuv->getStride();
+  Int width  = pcBaseViewDepthPicYuv->getWidth();
+  Int height = pcBaseViewDepthPicYuv->getHeight();
+  Int depthPosX = Clip3(0,   width - iWidth  - 1,  iBlkX + (mv->getHor()>>2));
+  Int depthPosY = Clip3(0,   height- iHeight - 1,  iBlkY + (mv->getVer()>>2));
+  Pel *depth  = pcBaseViewDepthPicYuv->getLumaAddr() + depthPosX + depthPosY * depStride;
+  Pel  maxDepth = 0;
+#if LGE_SIMP_DVP_REFINE_C0112
+  if ( bSimpleDvpRefine )
+  {
+    Int depthStartPosX = Clip3(0,   width - iWidth  - 1,  iBlkX + (mv->getHor()>>2));
+    Int depthStartPosY = Clip3(0,   height- iHeight - 1,  iBlkY + (mv->getVer()>>2));
+    Int depthEndPosX = Clip3(0,   width - iWidth  - 1,  iBlkX + iWidth  + (mv->getHor()>>2));
+    Int depthEndPosY = Clip3(0,   height- iHeight - 1,  iBlkY + iHeight + (mv->getVer()>>2));
+    Int iCenterX = (depthStartPosX + depthEndPosX) >> 1;
+    Int iCenterY = (depthStartPosY + depthEndPosY) >> 1;
+    Pel *depthTL  = pcBaseViewDepthPicYuv->getLumaAddr();
+    Int aiDepth[5];
+    aiDepth[0] = depthTL[ (depthStartPosY) * depStride + depthStartPosX ];      // Left Top
+    aiDepth[1] = depthTL[ (depthEndPosY)   * depStride + depthStartPosX ];      // Left Bottom
+    aiDepth[2] = depthTL[ (depthStartPosY) * depStride + depthEndPosX   ];      // Right Top
+    aiDepth[3] = depthTL[ (depthEndPosY)   * depStride + depthEndPosX   ];      // Right Bottom
+    aiDepth[4] = depthTL[ (iCenterY)       * depStride + iCenterX       ];      // Center
+    for (Int i = 0; i < 5; i++)
+    {
+      if (maxDepth < aiDepth[i])
+        maxDepth = aiDepth[i];
+    }
+  }
+  else
+  {
+    for (Int j = 0; j < iHeight; j++)
+    {
+      for (Int i = 0; i < iWidth; i++)
+      {
+        if (maxDepth < depth[i])
+          maxDepth = depth[i];
+      }
+      depth += depStride;
+    }
+  }
+#else
+  for (Int j = 0; j < iHeight; j++)
+  {
+    for (Int i = 0; i < iWidth; i++)
+    {
+      if (maxDepth < depth[i])
+        maxDepth = depth[i];
+    }
+    depth += depStride;
+  }
+#endif
+  Int disparity = aiShiftLUT[ maxDepth ] << iShiftPrec;
+  return disparity;
+}
+#if LGE_SIMP_DVP_REFINE_C0112
+Void TComDataCU::estimateDVFromDM(UInt uiPartIdx, TComPic* picDepth, UInt uiPartAddr, TComMv* cMvPred, Bool bSimpleDvpRefine)
+#else
+Void TComDataCU::estimateDVFromDM(UInt uiPartIdx, TComPic* picDepth, UInt uiPartAddr, TComMv* cMvPred)
+#endif
+{
+  if (picDepth)
+  {
+    UInt uiAbsPartAddrCurrCU = m_uiAbsIdxInLCU + uiPartAddr;
+    Int iWidth, iHeight;
+    getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight ); // The modified value of uiPartAddr won't be used any more
+    TComPicYuv* pcBaseViewDepthPicYuv = picDepth->getPicYuvRec();
+    Int iBlkX = ( getAddr() % picDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartAddrCurrCU ] ];
+    Int iBlkY = ( getAddr() / picDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartAddrCurrCU ] ];
+    Int* aiShiftLUT;
+    Int  iShiftPrec;
+    getSlice()->getBWVSPLUTParam(aiShiftLUT, iShiftPrec);
+#if LGE_SIMP_DVP_REFINE_C0112
+    Pel x = getMcpFromDM( pcBaseViewDepthPicYuv, cMvPred, iBlkX, iBlkY, iWidth, iHeight, aiShiftLUT, iShiftPrec, bSimpleDvpRefine );
+#else
+    Pel x = getMcpFromDM( pcBaseViewDepthPicYuv, cMvPred, iBlkX, iBlkY, iWidth, iHeight, aiShiftLUT, iShiftPrec);
+#endif
+    cMvPred->setHor(x);
+    clipMv(*cMvPred);
+  }
+}
+#endif
+#if H3D_NBDV
+Void TComDataCU::getDisMvpCandNBDV( UInt uiPartIdx, UInt uiPartAddr,DisInfo* pDInfo , Bool bParMerge
+#if MERL_VSP_C0152
+                                , Bool bDepthRefine
 #endif
+                                )
 …
   PartSize eCUMode = getPartitionSize( uiPartAddr );
   TComDataCU* pcTmpCU = NULL;
-#if !QC_SIMPLE_NBDV_B0047
-  TComDataCU* pcCULeft = NULL;
-#endif
   pDInfo->iN = 0;
 …
   UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
-#if QC_SIMPLE_NBDV_B0047
   const Int iNumofDvMCP = 7;
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Int   aiDvMcpDvCandX[2][iNumofDvMCP] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal
+  Int   aiDvMcpDvCandY[2][iNumofDvMCP] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal
+#else
   Int   aiDvMcpDvCand[2][iNumofDvMCP] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal
+#endif
   Bool  abDvMcpFlag  [2][iNumofDvMCP] = {{false,},{false,}};
-#else
-  Int   aiDvMcpDvCand[2][7] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal
-  Bool  abDvMcpFlag  [2][7] = {{false,},{false,}};
-  //Int   aiRefPOC     [2][7] = {{-1,},{-1}}; // debug
-#endif
   TComMv cTmpMvPred, cMv;
   Bool  bTmpIsSkipped = false;
   Bool  bDvMcpIsFound = false;
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+  Int iLCUAddrDiff = 0;
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  Int   iLCUAddrDiff = 0;
   Int xP, yP, nPSW, nPSH;
   if( bParMerge)
     this->getPartPosition(uiPartIdx, xP, yP, nPSW, nPSH);
-#endif
   deriveLeftRightTopIdxGeneral( eCUMode, uiPartAddr, uiPartIdx, uiPartIdxLT, uiPartIdxRT );
   deriveLeftBottomIdxGeneral( eCUMode, uiPartAddr, uiPartIdx, uiPartIdxLB );
+  UInt uiIdx = 0;
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcTmpCU = getPULeft(uiIdx, uiPartIdxLB, true, false);
+#else
+  pcTmpCU = getPULeft(uiIdx, uiPartIdxLB);
+#endif
+#if DV_DERIVATION_PARALLEL_B0096
+  if ( uiPartIdx == 1 && (eCUMode == SIZE_Nx2N || eCUMode == SIZE_nLx2N || eCUMode == SIZE_nRx2N) )
+  {
+    pcTmpCU = NULL;
+  }
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP -1, yP+nPSH-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+#endif
+#if !QC_SIMPLE_NBDV_B0047
+  pcCULeft = pcTmpCU;
+  UInt uiLeftPartIdx = uiIdx;
+#endif
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+  {
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId()) // DCP
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          return;
+        }
+        else // MCP
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+            aiDvMcpDvCand[iList][DVFROM_LEFT] = cTmpMvPred.m_iDvMcpDispX;
+            abDvMcpFlag  [iList][DVFROM_LEFT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+    }
+  }
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT, true, false, true);
+#else
+  pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT);
+#endif
+#if DV_DERIVATION_PARALLEL_B0096
+  if ( uiPartIdx == 1 && (eCUMode == SIZE_2NxN || eCUMode == SIZE_2NxnU || eCUMode == SIZE_2NxnD) )
+  {
+    pcTmpCU = NULL;
+  }
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+#endif
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+#endif
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          return;
+        }
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+        else if(iLCUAddrDiff == 0) //MCP, within same LCU
+#else
+        else // MCP
+#endif
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp  && bTmpIsSkipped )
+          {
+            aiDvMcpDvCand[iList][DVFROM_ABOVE] = cTmpMvPred.m_iDvMcpDispX;
+            abDvMcpFlag  [iList][DVFROM_ABOVE] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+    }
+  }
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcTmpCU = getPUAboveRight(uiIdx, uiPartIdxRT, true, false, true);
+#else
+  pcTmpCU = getPUAboveRight(uiIdx, uiPartIdxRT, true, true, true);
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP+nPSW, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+#endif
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+  {
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+#endif
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          return;
+        }
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+        else if(iLCUAddrDiff == 0)
+#else
+        else  // MCP
+#endif
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+            aiDvMcpDvCand[iList][DVFROM_ABOVERIGHT] = cTmpMvPred.m_iDvMcpDispX;
+            abDvMcpFlag  [iList][DVFROM_ABOVERIGHT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+    }
+  }
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcTmpCU = getPUBelowLeft(uiIdx, uiPartIdxLB, true, false);
+#else
+  pcTmpCU = getPUBelowLeft(uiIdx, uiPartIdxLB);
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP-1, yP+nPSH, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+#endif
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          return;
+        }
+        else // MCP
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+            aiDvMcpDvCand[iList][DVFROM_LEFTBELOW] = cTmpMvPred.m_iDvMcpDispX;
+            abDvMcpFlag  [iList][DVFROM_LEFTBELOW] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+    }
+  }
+  // Above predictor search
+#if MVP_AT_ENTROPYSLICE_BOUNDARY
+  pcTmpCU = getPUAboveLeft(uiIdx, (m_uiAbsIdxInLCU + uiPartAddr), true, false, true);
+  assert(uiPartIdxLT == (m_uiAbsIdxInLCU + uiPartAddr));
+#else
+  pcTmpCU = getPUAboveLeft(uiIdx, uiPartIdxLT, true, true, true);
+#endif
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP-1, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+#endif
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+#endif
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          return;
+        }
+#if LGE_DVMCP_MEM_REDUCTION_B0135
+        else if(iLCUAddrDiff <= 1)
+#else
+        else // MCP
+#endif
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+            aiDvMcpDvCand[iList][DVFROM_ABOVELEFT] = cTmpMvPred.m_iDvMcpDispX;
+            abDvMcpFlag  [iList][DVFROM_ABOVELEFT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+    }
+  }
+#if MTK_SAIT_TEMPORAL_FIRST_ORDER_C0141_C0097
   // copied from getInterMergeCand()
   if ( getSlice()->getPPS()->getEnableTMVPFlag() )
+  {
-#if !QC_SIMPLE_NBDV_B0047
-    UInt uiPUIdx = uiPartIdx;
-    UInt uiAbsPartAddr = uiPartAddr;
-    // col [2]
-    Int iRefIdxSkip[2] = {-1, -1};
-    if( !bMerge )
+    {
-      iRefIdxSkip[ eRefPicList0 ] = iRefIdx0;
+    }
-    else
+    {
-      for (Int i=0; i<2; i++)
+      {
-        RefPicList  eRefPicList1 = ( i==1 ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
-#if SET_MERGE_TMVP_REFIDX
-        Int iRefIdxTmp;
-        if ( uiPUIdx != 0 )
+        {
-          iRefIdxTmp = 0;
+        }
-        else
+        {
-          iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList1)->getRefIdx(uiLeftPartIdx) : -1;
+        }
-#else
-        Int iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList1)->getRefIdx(uiLeftPartIdx) : -1;
-#endif
-        iRefIdxSkip[i] = (iRefIdxTmp != -1) ? iRefIdxTmp : 0;
+      }
+    }
-    //>> MTK colocated-RightBottom
-    UInt uiPartIdxRB;
-    Int uiLCUIdx = getAddr();
-    eCUMode = getPartitionSize( 0 );
-    deriveRightBottomIdx( eCUMode, uiPUIdx, uiPartIdxRB );
-    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
-    //UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
-    TComMv cColMv;
-    Int iRefIdx;
-    if      ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
+    {
-      uiLCUIdx = -1;
+    }
-    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
+    {
-      uiLCUIdx = -1;
+    }
-    else
+    {
-      if ( ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU
-        ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) ) // is not at the last row    of LCU
+      {
-        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + uiNumPartInCUWidth + 1 ];
-        uiLCUIdx = getAddr();
+      }
-      else if ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 )           // is not at the last column of LCU But is last row of LCU
+      {
-        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
-        uiLCUIdx = -1 ;
+      }
-      else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
+      {
-        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
-        uiLCUIdx = getAddr() + 1;
+      }
-      else //is the right bottom corner of LCU
+      {
-        uiAbsPartAddr = 0;
-        uiLCUIdx = -1 ;
+      }
+    }
-    Bool bExistMV = false;
-    UInt uiPartIdxCenter;
-    UInt uiCurLCUIdx = getAddr();
-    xDeriveCenterIdx( eCUMode, uiPUIdx, uiPartIdxCenter );
-    Int iTargetView, iStartView;
-    if( !bMerge ) // AMVP
+    {
-      bExistMV = uiLCUIdx >= 0 && xGetColDisMV( eRefPicList0, iRefIdx0, uiLCUIdx, uiAbsPartAddr, cColMv, iTargetView, iStartView );
-      if( bExistMV == false )
+      {
-        bExistMV = xGetColDisMV( eRefPicList0, iRefIdx0, uiCurLCUIdx, uiPartIdxCenter, cColMv, iTargetView, iStartView );
+      }
-      if( bExistMV ) // DV is found
+      {
-        if( cColMv.m_bDvMcp == false ) //=> DCP, if true => DV-MCP
+        {
-          clipMv(cColMv);
-          pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
-          pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetView;
-          return;
+        }
-        else // DV-MCP
+        {
-          aiDvMcpDvCand[eRefPicList0][DVFROM_COL] = cColMv.getHor();
-          abDvMcpFlag  [eRefPicList0][DVFROM_COL] = true;
-          bDvMcpIsFound = true;
+        }
+      }
+    }
-    else // MERGE
+    {
-      iRefIdx = iRefIdxSkip[0];
-      bExistMV = uiLCUIdx >= 0 && xGetColDisMV( REF_PIC_LIST_0, iRefIdx, uiLCUIdx, uiAbsPartAddr, cColMv, iTargetView, iStartView );
-      if( bExistMV == false )
+      {
-        bExistMV = xGetColDisMV( REF_PIC_LIST_0, iRefIdx, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iTargetView, iStartView );
+      }
-      if( bExistMV )
+      {
-        if( cColMv.m_bDvMcp == false ) // DCP
+        {
-          clipMv(cColMv);
-          pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
-          pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetView;
-          return;
+        }
-        else { // // DV-MCP
-          aiDvMcpDvCand[0][DVFROM_COL] = cColMv.getHor();
-          abDvMcpFlag  [0][DVFROM_COL] = true;
-          bDvMcpIsFound = true;
-        };
-        if ( getSlice()->isInterB() )
+        {
-          iRefIdx = iRefIdxSkip[1];
-          bExistMV = uiLCUIdx >= 0 && xGetColDisMV( REF_PIC_LIST_1, iRefIdx, uiLCUIdx, uiAbsPartAddr, cColMv, iTargetView, iStartView );
-          if( bExistMV == false )
+          {
-            bExistMV = xGetColDisMV( REF_PIC_LIST_1, iRefIdx, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iTargetView, iStartView );
+          }
-          if( bExistMV )
+          {
-            if( cColMv.m_bDvMcp == false ) // DCP
+            {
-              clipMv(cColMv);
-              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
-              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetView;
-              return;
+            }
-            else // DV-MCP
+            {
-              aiDvMcpDvCand[1][DVFROM_COL] = cColMv.getHor();
-              abDvMcpFlag  [1][DVFROM_COL] = true;
-              bDvMcpIsFound = true;
-            };
+          }
+        }
+      }
+    }
-#else
     TComMv cColMv;
     Int iTargetViewIdx = 0;
     Int iTStartViewIdx = 0;
     UInt uiPartIdxRB, uiBRIdx;
+#if !MTK_SIMPLIFY_DVTC_C0135
     Int uiViewIdxCurr= getSlice()->getViewId();
+#endif
     UInt uiPartIdxCenter;
     xDeriveCenterIdx( eCUMode, uiPartIdx, uiPartIdxCenter );
 …
     uiBRIdx = uiPartIdxLT;
     UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
+#if MTK_SIMPLIFY_DVTC_C0135
+    if (( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() )>= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )
+    {
+      uiLCUnew = -1;
+    }
+    else if(( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() )>= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
+    {
+      uiLCUnew = -1;
+    }
+    else
+#else
     if ( (( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples() ) &&(( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ))  // image boundary check
+#endif
+    {
       if ( ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU
 …
+      {
         uiBRIdx = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
+#if MTK_SIMPLIFY_DVTC_C0135
+        uiLCUnew = -1;
+#else
         uiLCUnew = uiLCUIdx + m_pcPic->getFrameWidthInCU();
+#endif
+      }
       else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
 …
+      {
         uiBRIdx = 0;
+#if MTK_SIMPLIFY_DVTC_C0135
+        uiLCUnew = -1;
+#else
         uiLCUnew = uiLCUIdx + m_pcPic->getFrameWidthInCU() + 1;
+#endif
+      }
+    }
 …
       if( m_pcSlice->getViewId() == getSlice()->getRefPic( eRefPicList, lpRef)->getViewId() )
+      {
+#if !MTK_SIMPLIFY_DVTC_C0135
         if (uiViewIdxCurr > 1)
+        {
+#endif
           if( (uiLCUnew >= 0 && xGetColDisMV( eRefPicList, lpRef, uiLCUnew, uiBRIdx, cColMv, iTargetViewIdx, iTStartViewIdx)) )
+          {
             clipMv(cColMv);
+            pDInfo->m_acMvCand[pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[pDInfo->iN++] = iTargetViewIdx;
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
             return ;
+          }
+#if !MTK_SIMPLIFY_DVTC_C0135
+        }
+#endif
         if(xGetColDisMV( eRefPicList, lpRef, uiLCUIdx, uiPartIdxCenter,  cColMv, iTargetViewIdx, iTStartViewIdx ))
+        {
           clipMv(cColMv);
+          pDInfo->m_acMvCand[pDInfo->iN] = cColMv;
+          pDInfo->m_aVIdxCan[pDInfo->iN++] = iTargetViewIdx;
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
           return ;
+        }
+#if !MTK_SIMPLIFY_DVTC_C0135
         if(uiViewIdxCurr == 1)
+        {
 …
+          {
             clipMv(cColMv);
+            pDInfo->m_acMvCand[pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[pDInfo->iN++] = iTargetViewIdx;
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
             return ;
+          }
+        }
+      }
+    }
+#endif
+#endif
+      }
+    }
   } // if TMVP Flag
+#endif
+  UInt uiIdx = 0;
+  pcTmpCU = getPULeft(uiIdx, uiPartIdxLB, true, false);
+  if ( uiPartIdx == 1 && (eCUMode == SIZE_Nx2N || eCUMode == SIZE_nLx2N || eCUMode == SIZE_nRx2N) )
+  {
+    pcTmpCU = NULL;
+  }
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP -1, yP+nPSH-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+  {
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx != m_pcSlice->getViewId()) // DCP
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          }
+#endif
+          return;
+        }
+        else // MCP
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+            aiDvMcpDvCandX[iList][DVFROM_LEFT] = cTmpMvPred.m_iDvMcpDispX;
+            aiDvMcpDvCandY[iList][DVFROM_LEFT] = cTmpMvPred.m_iDvMcpDispY;
+#else
+            aiDvMcpDvCand[iList][DVFROM_LEFT] = cTmpMvPred.m_iDvMcpDispX;
+#endif
+            abDvMcpFlag  [iList][DVFROM_LEFT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+#if MERL_VSP_C0152
+      else if (pcTmpCU->getVSPIndex(uiIdx) != 0) // is VSP
+      {
+        TComPic* picDepth = NULL;
+        TComMv myMv = pcTmpCU->getCUMvField( eRefPicList )->getMv( uiIdx );
+        picDepth = pcTmpCU->getSlice()->getRefPicBaseDepth();
+        if (picDepth && bDepthRefine)
+          estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &myMv);
+        myMv.setVer(0);
+        pDInfo->m_acMvCand[ pDInfo->iN] = myMv;
+        pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0; // refViewIdx;
+        return;
+      }
+#endif
+    }
+  }
+  pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT, true, false, true);
+  if ( uiPartIdx == 1 && (eCUMode == SIZE_2NxN || eCUMode == SIZE_2NxnU || eCUMode == SIZE_2NxnD) )
+  {
+    pcTmpCU = NULL;
+  }
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          }
+#endif
+          return;
+        }
+        else if(iLCUAddrDiff == 0) //MCP, within same LCU
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp  && bTmpIsSkipped )
+          {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+            aiDvMcpDvCandX[iList][DVFROM_ABOVE] = cTmpMvPred.m_iDvMcpDispX;
+            aiDvMcpDvCandY[iList][DVFROM_ABOVE] = cTmpMvPred.m_iDvMcpDispY;
+#else
+            aiDvMcpDvCand[iList][DVFROM_ABOVE] = cTmpMvPred.m_iDvMcpDispX;
+#endif
+            abDvMcpFlag  [iList][DVFROM_ABOVE] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+#if MERL_VSP_C0152
+      else if (pcTmpCU->getVSPIndex(uiIdx) != 0) // is VSP
+      {
+        TComPic* picDepth = NULL;
+        TComMv myMv = pcTmpCU->getCUMvField( eRefPicList )->getMv( uiIdx );
+        picDepth = pcTmpCU->getSlice()->getRefPicBaseDepth();
+        if (picDepth && bDepthRefine)
+          estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &myMv);
+        myMv.setVer(0);
+        pDInfo->m_acMvCand[ pDInfo->iN] = myMv;
+        pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0; // refViewIdx;
+        return;
+      }
+#endif
+    }
+  }
+  pcTmpCU = getPUAboveRight(uiIdx, uiPartIdxRT, true, false, true);
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP+nPSW, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+  {
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          }
+#endif
+          return;
+        }
+        else if(iLCUAddrDiff == 0)
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+            aiDvMcpDvCandX[iList][DVFROM_ABOVERIGHT] = cTmpMvPred.m_iDvMcpDispX;
+            aiDvMcpDvCandY[iList][DVFROM_ABOVERIGHT] = cTmpMvPred.m_iDvMcpDispY;
+#else
+            aiDvMcpDvCand[iList][DVFROM_ABOVERIGHT] = cTmpMvPred.m_iDvMcpDispX;
+#endif
+            abDvMcpFlag  [iList][DVFROM_ABOVERIGHT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+#if MERL_VSP_C0152
+      else if (pcTmpCU->getVSPIndex(uiIdx) != 0) // is VSP
+      {
+        TComPic* picDepth = NULL;
+        TComMv myMv = pcTmpCU->getCUMvField( eRefPicList )->getMv( uiIdx );
+        picDepth = pcTmpCU->getSlice()->getRefPicBaseDepth();
+        if (picDepth && bDepthRefine)
+          estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &myMv);
+        myMv.setVer(0);
+        pDInfo->m_acMvCand[ pDInfo->iN] = myMv;
+        pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0; // refViewIdx;
+        return;
+      }
+#endif
+    }
+  }
+  pcTmpCU = getPUBelowLeft(uiIdx, uiPartIdxLB, true, false);
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP-1, yP+nPSH, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          }
+#endif
+          return;
+        }
+        else // MCP
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+            aiDvMcpDvCandX[iList][DVFROM_LEFTBELOW] = cTmpMvPred.m_iDvMcpDispX;
+            aiDvMcpDvCandY[iList][DVFROM_LEFTBELOW] = cTmpMvPred.m_iDvMcpDispY;
+#else
+            aiDvMcpDvCand[iList][DVFROM_LEFTBELOW] = cTmpMvPred.m_iDvMcpDispX;
+#endif
+            abDvMcpFlag  [iList][DVFROM_LEFTBELOW] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+#if MERL_VSP_C0152
+      else if (pcTmpCU->getVSPIndex(uiIdx) != 0) // is VSP
+      {
+        TComPic* picDepth = NULL;
+        TComMv myMv = pcTmpCU->getCUMvField( eRefPicList )->getMv( uiIdx );
+        picDepth = pcTmpCU->getSlice()->getRefPicBaseDepth();
+        if (picDepth && bDepthRefine)
+          estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &myMv);
+        myMv.setVer(0);
+        pDInfo->m_acMvCand[ pDInfo->iN] = myMv;
+        pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0; // refViewIdx;
+        return;
+      }
+#endif
+    }
+  }
+  // Above predictor search
+  pcTmpCU = getPUAboveLeft(uiIdx, (m_uiAbsIdxInLCU + uiPartAddr), true, false, true);
+  assert(uiPartIdxLT == (m_uiAbsIdxInLCU + uiPartAddr));
+  if (pcTmpCU && bParMerge)
+  {
+    if (!pcTmpCU->isDiffMER(xP-1, yP-1, xP, yP))
+    {
+      pcTmpCU = NULL;
+    }
+  }
+  if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+  {
+    iLCUAddrDiff = getAddr() - pcTmpCU->getAddr();
+    bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
+    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
+    {
+      eRefPicList = RefPicList(iList);
+      Int refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
+      if( refId >= 0)
+      {
+        Int refViewIdx  = pcTmpCU->getSlice()->getRefViewId( eRefPicList, refId);
+        if (refViewIdx!= m_pcSlice->getViewId())
+        {
+          TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          clipMv(cMvPred);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cMvPred);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = cMvPred;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = refViewIdx;
+          }
+#endif
+          return;
+        }
+        else if(iLCUAddrDiff <= 1)
+        {
+          cTmpMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
+          if( cTmpMvPred.m_bDvMcp && bTmpIsSkipped )
+          {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+            aiDvMcpDvCandX[iList][DVFROM_ABOVELEFT] = cTmpMvPred.m_iDvMcpDispX;
+            aiDvMcpDvCandY[iList][DVFROM_ABOVELEFT] = cTmpMvPred.m_iDvMcpDispY;
+#else
+            aiDvMcpDvCand[iList][DVFROM_ABOVELEFT] = cTmpMvPred.m_iDvMcpDispX;
+#endif
+            abDvMcpFlag  [iList][DVFROM_ABOVELEFT] = true;
+            bDvMcpIsFound = true;
+          }
+        }
+      }
+#if MERL_VSP_C0152
+      else if (pcTmpCU->getVSPIndex(uiIdx) != 0) // is VSP
+      {
+        TComPic* picDepth = NULL;
+        TComMv myMv = pcTmpCU->getCUMvField( eRefPicList )->getMv( uiIdx );
+        picDepth = pcTmpCU->getSlice()->getRefPicBaseDepth();
+        if (picDepth && bDepthRefine)
+          estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &myMv);
+        myMv.setVer(0);
+        pDInfo->m_acMvCand[ pDInfo->iN] = myMv;
+        pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0; // refViewIdx;
+        return;
+      }
+#endif
+    }
+  }
+#if !MTK_SAIT_TEMPORAL_FIRST_ORDER_C0141_C0097
+  // copied from getInterMergeCand()
+  if ( getSlice()->getPPS()->getEnableTMVPFlag() )
+  {
+    TComMv cColMv;
+    Int iTargetViewIdx = 0;
+    Int iTStartViewIdx = 0;
+    UInt uiPartIdxRB, uiBRIdx;
+#if !MTK_SIMPLIFY_DVTC_C0135
+    Int uiViewIdxCurr= getSlice()->getViewId();
+#endif
+    UInt uiPartIdxCenter;
+    xDeriveCenterIdx( eCUMode, uiPartIdx, uiPartIdxCenter );
+    Int uiLCUIdx = getAddr();
+    Int uiLCUnew = uiLCUIdx;
+    eCUMode = getPartitionSize( 0 );
+    deriveRightBottomIdx( eCUMode, uiPartIdx, uiPartIdxRB );
+    uiBRIdx = uiPartIdxLT;
+    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
+#if MTK_SIMPLIFY_DVTC_C0135
+    if (( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() )>= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )
+    {
+      uiLCUnew = -1;
+    }
+    else if(( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() )>= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
+    {
+      uiLCUnew = -1;
+    }
+    else
+#else
+    if ( (( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples() ) &&(( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ))  // image boundary check
+#endif
+    {
+      if ( ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU
+      ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) ) // is not at the last row    of LCU
+      {
+        uiBRIdx = g_auiRasterToZscan[ uiAbsPartIdxTmp + uiNumPartInCUWidth + 1 ];
+      }
+      else if ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 )           // is not at the last column of LCU But is last row of LCU
+      {
+        uiBRIdx = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
+#if MTK_SIMPLIFY_DVTC_C0135
+        uiLCUnew = -1;
+#else
+        uiLCUnew = uiLCUIdx + m_pcPic->getFrameWidthInCU();
+#endif
+      }
+      else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
+      {
+        uiBRIdx = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
+        uiLCUnew = uiLCUIdx + 1;
+      }
+      else //is the right bottom corner of LCU
+      {
+        uiBRIdx = 0;
+#if MTK_SIMPLIFY_DVTC_C0135
+        uiLCUnew = -1;
+#else
+        uiLCUnew = uiLCUIdx + m_pcPic->getFrameWidthInCU() + 1;
+#endif
+      }
+    }
+    const Int iNumofCandPic = 2;
+    for(Int i =0; i < iNumofCandPic; i++)
+    {
+      Int lpRef=0;
+      if(i == 0)
+      {   //check the col-located picture
+        eRefPicList = RefPicList(getSlice()->isInterB() ? getSlice()->getColDir() : 0);
+#if COLLOCATED_REF_IDX
+        lpRef = getSlice()->getColRefIdx();
+#else
+        Int lpRef = 0;
+#endif
+      }
+      else
+      {
+        if(!(getPic()->getRapbCheck()))
+          break;
+        eRefPicList=getPic()->getRapRefList();
+        lpRef=getPic()->getRapRefIdx();
+      }
+      if( m_pcSlice->getViewId() == getSlice()->getRefPic( eRefPicList, lpRef)->getViewId() )
+      {
+#if !MTK_SIMPLIFY_DVTC_C0135
+        if (uiViewIdxCurr > 1)
+        {
+#endif
+          if( (uiLCUnew >= 0 && xGetColDisMV( eRefPicList, lpRef, uiLCUnew, uiBRIdx, cColMv, iTargetViewIdx, iTStartViewIdx)) )
+          {
+            clipMv(cColMv);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
+            return ;
+          }
+#if !MTK_SIMPLIFY_DVTC_C0135
+        }
+#endif
+        if(xGetColDisMV( eRefPicList, lpRef, uiLCUIdx, uiPartIdxCenter,  cColMv, iTargetViewIdx, iTStartViewIdx ))
+        {
+          clipMv(cColMv);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
+          return ;
+        }
+#if !MTK_SIMPLIFY_DVTC_C0135
+        if(uiViewIdxCurr == 1)
+        {
+          if( (uiLCUnew >= 0 && xGetColDisMV( eRefPicList, lpRef, uiLCUnew, uiBRIdx, cColMv, iTargetViewIdx, iTStartViewIdx)) )
+          {
+            clipMv(cColMv);
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+            pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+#else
+            {
+              TComPic* picDepth = NULL;
+              picDepth = getSlice()->getRefPicBaseDepth();
+              if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv, true);
+#else
+                estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &cColMv);
+#endif
+              pDInfo->m_acMvCand[ pDInfo->iN] = cColMv;
+              pDInfo->m_aVIdxCan[ pDInfo->iN++] = iTargetViewIdx;
+            }
+#endif
+            return ;
+          }
+        }
+#endif
+      }
+    }
+  } // if TMVP Flag
+#endif
   if( bDvMcpIsFound ) // skip dvmcp
+  {
-#if QC_SIMPLE_NBDV_B0047
     for( Int i=1 ; i<iNumofDvMCP-1 ; i++ ) // 5 spatial
-#else
-    for( Int i=1 ; i<7 ; i++ ) // 5 spatial + 1 temporal
-#endif
+    {
       for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
 …
         if( abDvMcpFlag[iList][i]==true )
+        {
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+          TComMv dv( aiDvMcpDvCandX[iList][ i ], aiDvMcpDvCandY[iList][ i ] );
+#else
           TComMv dv( aiDvMcpDvCand[iList][ i ], 0 );
+#endif
           clipMv( dv );
+          pDInfo->m_acMvCand[ pDInfo->iN  ] = dv;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0;
+#if !MERL_MTK_VSP_DVP_REFINE_C0152_C0131
+          pDInfo->m_acMvCand[ pDInfo->iN] = dv;
+          pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0;
+#else
+          {
+            TComPic* picDepth = NULL;
+            picDepth = getSlice()->getRefPicBaseDepth();
+            if (picDepth && bDepthRefine)
+#if LGE_SIMP_DVP_REFINE_C0112
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &dv, true);
+#else
+              estimateDVFromDM(uiPartIdx, picDepth, uiPartAddr, &dv);
+#endif
+            pDInfo->m_acMvCand[ pDInfo->iN] = dv;
+            pDInfo->m_aVIdxCan[ pDInfo->iN++] = 0;
+          }
+#endif
           return;
+        }
 …
+}
 #endif
 #endif
 …
  * \param pInfo
  */
 #if SHARP_INTERVIEW_DECOUPLE_B0111
+#if H3D_IVMP
 Void TComDataCU::fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo, Int iMVPIdx)
+{
 …
     if (iMVPIdx<=0)
+    {
+      // extention part
+#if H3D_NBDV
+      // Extension part
       DisInfo cDisInfo;
       cDisInfo.iN = 0;
+#if LGE_DVMCP_A0126
+#if QC_SIMPLE_NBDV_B0047
+#if FIX_LGE_IVMP_PARALLEL_MERGE_B0136
+      getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo, false);
+#else
+      getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo);
+#endif
+#else
+      getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo, false, eRefPicList, iRefIdx );
+#endif
+#else
+      getDisMvpCand (uiPartIdx, uiPartAddr, &cDisInfo );
+#endif
+      getDisMvpCandNBDV(uiPartIdx, uiPartAddr, &cDisInfo, false
+#if MERL_VSP_C0152
+            , true
+#endif
+              );
       if(cDisInfo.iN==0)
+      {
 …
         cDisInfo.m_aVIdxCan[0] = 0;
+      }
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+      Int paiPdmRefIdx[4] = {-1, -1, -1, -1};
+      Int iPdmDir[4]      = {-1, -1, -1, -1};
+#if QC_C0051_FIXED_BY_MTK
+      TComMv cPdmMvPred[4];
+#else
+      TComMv cPdmMvPred[2];
+#endif
+      cPdmMvPred[0].m_bDvMcp = cPdmMvPred[1].m_bDvMcp = false;
+      if(getUnifiedMvPredCan(uiPartIdx, eRefPicList, iRefIdx, paiPdmRefIdx, cPdmMvPred, &cDisInfo, iPdmDir, false))
+#else // QC_AMVP_MRG_UNIFY_IVCAN_C0051
       TComMv  cPdmMvPred;
-#if QC_MULTI_DIS_CAN_A0097
       if( getPdmMvPredDisCan( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred, &cDisInfo ) )
+#endif // QC_AMVP_MRG_UNIFY_IVCAN_C0051
+#else // H3D_NBDV
+      if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
+#endif
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+      {
+        clipMv( cPdmMvPred[0] );
+        pInfo->m_acMvCand[0] = cPdmMvPred[0];
+      }
+      else
+      {
+        pInfo->m_acMvCand[0].set(0,0);
+      }
 #else
-      if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
-#endif
+      {
         clipMv( cPdmMvPred );
 …
         pInfo->m_acMvCand[0].set(0,0);
+      }
+#endif
+    }
+  }
 …
 Void TComDataCU::fillMvpCandBase( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo )
 #else
+#else //  H3D_IVMP
 Void TComDataCU::fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo )
 #endif
+#endif //  H3D_IVMP
+{
   PartSize eCUMode = getPartitionSize( 0 );
 …
     return;
+  }
-#if QC_MULTI_DIS_CAN_A0097 && !SHARP_INTERVIEW_DECOUPLE_B0111
-  DisInfo cDisInfo;
-  cDisInfo.iN = 0;
-  if(m_pcSlice->getSPS()->getViewId() && m_pcSlice->getSPS()->getMultiviewMvPredMode())
+  {
-#if LGE_DVMCP_A0126
-#if QC_SIMPLE_NBDV_B0047
-#if FIX_LGE_IVMP_PARALLEL_MERGE_B0136
-    getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo, false);
-#else
-    getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo);
-#endif
-#else
-    getDisMvpCand2(uiPartIdx, uiPartAddr, &cDisInfo, false, eRefPicList, iRefIdx );
-#endif
-#else
-    getDisMvpCand (uiPartIdx, uiPartAddr, &cDisInfo );
-#endif
+  }
-  if(cDisInfo.iN==0)
+  {
-    cDisInfo.iN = 1;
-    cDisInfo.m_acMvCand[0].setHor(0);
-    cDisInfo.m_acMvCand[0].setVer(0);
-    cDisInfo.m_aVIdxCan[0] = 0;
+  }
-#endif
-#if HHI_INTER_VIEW_MOTION_PRED && !SHARP_INTERVIEW_DECOUPLE_B0111
-#if ( PDM_AMVP_POS == 0 )
-  // get inter-view mv predictor (at position 0)
-  TComMv  cPdmMvPred;
-#if QC_MULTI_DIS_CAN_A0097
-  if( getPdmMvPredDisCan( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred, &cDisInfo ) )
-#else
-  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
-#endif
+  {
-    clipMv( cPdmMvPred );
-    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
+  }
-#endif
-#endif
   //-- Get Spatial MV
 …
   TComDataCU* tmpCU = NULL;
   UInt idx;
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
   tmpCU = getPUBelowLeft(idx, uiPartIdxLB, true, false);
-#else
-  tmpCU = getPUBelowLeft(idx, uiPartIdxLB);
-#endif
   bAddedSmvp = (tmpCU != NULL) && (tmpCU->getPredictionMode(idx) != MODE_INTRA);
   if (!bAddedSmvp)
+  {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
     tmpCU = getPULeft(idx, uiPartIdxLB, true, false);
-#else
-    tmpCU = getPULeft(idx, uiPartIdxLB);
-#endif
     bAddedSmvp = (tmpCU != NULL) && (tmpCU->getPredictionMode(idx) != MODE_INTRA);
+  }
 …
+  }
-#if HHI_INTER_VIEW_MOTION_PRED && !SHARP_INTERVIEW_DECOUPLE_B0111
-#if ( PDM_AMVP_POS == 1 )
-  // get inter-view mv predictor (at position 1)
-  TComMv  cPdmMvPred;
-#if QC_MULTI_DIS_CAN_A0097
-  if( getPdmMvPredDisCan( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred, &cDisInfo ) )
-#else
-  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
-#endif
+  {
-    clipMv( cPdmMvPred );
-    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
+  }
-#endif
-#endif
   // Above predictor search
   bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
 …
+  }
+#if HHI_INTER_VIEW_MOTION_PRED && !SHARP_INTERVIEW_DECOUPLE_B0111
+#if ( PDM_AMVP_POS == 2 )
+  // get inter-view mv predictor (at position 2)
+  TComMv  cPdmMvPred;
+#if QC_MULTI_DIS_CAN_A0097
+  if( getPdmMvPredDisCan( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred, &cDisInfo ) )
+#else
+  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
+#endif
+  {
+    clipMv( cPdmMvPred );
+    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
+  }
+#endif
+#endif
+#if AMVP_PRUNING_SIMPLIFICATION
   if ( pInfo->iN == 2 )
+  {
 …
+    {
       pInfo->iN = 1;
 #if FIX_MISUSE_REFINDEX
+#if QC_MRG_CANS_B0048
       pInfo->m_acMvCand[ 1 ].set(0, 0);
 #endif
+    }
+  }
-#if QC_MULTI_DIS_CAN_A0097 && !SHARP_INTERVIEW_DECOUPLE_B0111
-  if ( getSlice()->getViewId()!=0 && pInfo->iN == 3 )
+  {
-    if ( pInfo->m_acMvCand[ 1 ] == pInfo->m_acMvCand[ 2 ] )
+    {
-      pInfo->iN = 2;
-      if( pInfo->m_acMvCand[ 0 ] == pInfo->m_acMvCand[ 1 ] )
-        pInfo->iN = 1;
+    }
-    else
+    {
-      if( pInfo->m_acMvCand[ 0 ] == pInfo->m_acMvCand[ 1 ] )
+      {
-        pInfo->m_acMvCand[1 ] = pInfo->m_acMvCand[ 2 ];
-        pInfo->iN = 2;
+      }
-      else if (pInfo->m_acMvCand[ 0 ] == pInfo->m_acMvCand[ 2 ])
+      {
-         pInfo->iN = 2;
+      }
+    }
+  }
-#endif
-#endif
   if ( getSlice()->getPPS()->getEnableTMVPFlag() )
 …
     if ( uiLCUIdx >= 0 && xGetColMVP( eRefPicList, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx_Col ) )
+    {
 #if FIX_LGE_DVMCP_B0133
+#if H3D_NBDV
       cColMv.m_bDvMcp = false;
 #endif
 …
       if (xGetColMVP( eRefPicList, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx_Col ))
+      {
 #if FIX_LGE_DVMCP_B0133
+#if H3D_NBDV
         cColMv.m_bDvMcp = false;
 #endif
 …
+  }
+#if HHI_INTER_VIEW_MOTION_PRED && !SHARP_INTERVIEW_DECOUPLE_B0111
+#if ( PDM_AMVP_POS == 3 )
+  // get inter-view mv predictor (at position 3)
+  TComMv  cPdmMvPred;
+#if QC_MULTI_DIS_CAN_A0097
+  if( getPdmMvPredDisCan( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred, &cDisInfo ) )
+#else
+  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
+#endif
+  {
+    clipMv( cPdmMvPred );
+    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
+  }
+#endif
+#endif
+#if !AMVP_PRUNING_SIMPLIFICATION
+  // Check No MV Candidate
+  xUniqueMVPCand( pInfo );
+#endif
+#if HHI_INTER_VIEW_MOTION_PRED && !SHARP_INTERVIEW_DECOUPLE_B0111
+  const Int iNumAMVPCands = AMVP_MAX_NUM_CANDS + ( getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
+  if (pInfo->iN > iNumAMVPCands)
+  {
+    pInfo->iN = iNumAMVPCands;
+  }
+  else if (pInfo->iN < iNumAMVPCands)
+#else
   if (pInfo->iN > AMVP_MAX_NUM_CANDS)
+  {
 …
+  }
   else if (pInfo->iN < AMVP_MAX_NUM_CANDS)
+#endif
+  {
+#if !AMVP_ZERO_CHECKING_REMOVAL
+    int j;
+    for (j=0; j<pInfo->iN; j++)
+    {
+      if (pInfo->m_acMvCand[j].getHor() == 0 && pInfo->m_acMvCand[j].getVer() == 0)
+      {
+        break;
+      }
+    }
+    if (j == pInfo->iN)
+    {
+#endif
+  {
       pInfo->m_acMvCand[pInfo->iN].set(0,0);
       pInfo->iN++;
-#if !AMVP_ZERO_CHECKING_REMOVAL
+    }
-#endif
+  }
   return ;
 …
     case MD_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx, true, false);
-#else
-      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
-#endif
       break;
+    }
     case MD_ABOVE:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
     case MD_ABOVE_RIGHT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
     case MD_BELOW_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx, true, false);
-#else
-      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
-#endif
       break;
+    }
     case MD_ABOVE_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
 …
+  }
+#if MERL_VSP_C0152
+  if(pcTmpCU != NULL && pcTmpCU->getVSPIndex(uiIdx))
+  {
+    return false;
+  }
+#endif
   if ( pcTmpCU != NULL && m_pcSlice->isEqualRef(eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx), iRefIdx) )
+  {
     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
     cMvPred.m_bDvMcp = false;
 #endif
 …
+    {
       TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
       cMvPred.m_bDvMcp = false;
 #endif
 …
+}
-#if !AMVP_PRUNING_SIMPLIFICATION
-/**
- * Reduce list of motion vector predictors to a set of unique predictors
- * \param pInfo list of motion vector predictors
- */
-Void TComDataCU::xUniqueMVPCand(AMVPInfo* pInfo)
+{
-  Int n = 1;
-  if ( pInfo->iN == 0 )
+  {
-#if AMVP_ZERO_CHECKING_REMOVAL
-    return;
-#else
-    // Add a zero candidate is none is available
-    pInfo->m_acMvCand[ 0 ].setZero();
-#endif
+  }
-  else
+  {
-    for (Int i = 1; i < pInfo->iN; i++)
+    {
-      Int j;
-      for (j = n - 1; j >= 0; j--)
+      {
-        if ( pInfo->m_acMvCand[ i ] == pInfo->m_acMvCand[ j ] )
+        {
-          break;
+        }
+      }
-      if ( j < 0 )
+      {
-        pInfo->m_acMvCand[ n++ ] = pInfo->m_acMvCand[ i ];
+      }
+    }
+  }
-  pInfo->iN = n;
+}
-#endif
 /**
 …
   TComDataCU* pcTmpCU = NULL;
   UInt uiIdx;
   switch( eDir )
+  {
   case MD_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx, true, false);
-#else
-      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
-#endif
       break;
+    }
   case MD_ABOVE:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
   case MD_ABOVE_RIGHT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
   case MD_BELOW_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx, true, false);
-#else
-      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
-#endif
       break;
+    }
   case MD_ABOVE_LEFT:
+    {
-#if MVP_AT_ENTROPYSLICE_BOUNDARY
       pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, false, true);
-#else
-      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, true, true);
-#endif
       break;
+    }
 …
     return false;
+  }
+#if MERL_VSP_C0152
+  if(pcTmpCU->getVSPIndex(uiIdx))
+  {
+    return false;
+  }
+#endif
   RefPicList eRefPicList2nd = REF_PIC_LIST_0;
   if(       eRefPicList == REF_PIC_LIST_0 )
 …
   Int iNeibPOC = iCurrPOC;
   Int iNeibRefPOC;
+#if INTER_VIEW_VECTOR_SCALING_C0116
+  Int iCurrViewId = m_pcSlice->getViewOrderIdx(); // will be changed to view_id
+  Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, iRefIdx)->getViewOrderIdx(); // will be changed to view_id
+  Int iNeibViewId = iCurrViewId;
+  Int iNeibRefViewId;
+#endif
 #if QC_IV_AS_LT_B0046
   Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getIsLongTerm();
 …
+  {
     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    iNeibRefViewId = pcTmpCU->getSlice()->getRefPic(eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx))->getViewOrderIdx(); // will be changed to view_id
+#endif
 #if QC_IV_AS_LT_B0046
     bIsNeibRefLongTerm = m_pcSlice->getRefPic( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx))->getIsLongTerm() ;
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    if ( (bIsCurrRefLongTerm == bIsNeibRefLongTerm) && ((iNeibRefPOC == iCurrRefPOC) && (iNeibRefViewId == iCurrRefViewId)))
+#else
     if ( (bIsCurrRefLongTerm == bIsNeibRefLongTerm) && (iNeibRefPOC == iCurrRefPOC) )
+#endif
 #else
     if( pcTmpCU->getSlice()->getRefViewId( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) ) != m_pcSlice->getRefViewId( eRefPicList, iRefIdx ) )
 …
+    {
       TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
       cMvPred.m_bDvMcp = false;
 #endif
 …
+  {
     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) );
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    iNeibRefViewId = pcTmpCU->getSlice()->getRefPic(eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx))->getViewOrderIdx(); // will be changed to view_id
+#endif
     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
     TComMv rcMv;
 …
+    }
 #endif
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    Int iScale = 4096;
+    if((iCurrRefPOC != iNeibRefPOC)  )    // inter & inter
+        iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+    else if(m_pcSlice->getIVScalingFlag())    // inter-view & inter-view
+        iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iNeibViewId, iNeibRefViewId );
+#else
     Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#endif
     if ( iScale == 4096 )
+    {
 …
       rcMv = cMvPred.scaleMv( iScale );
+    }
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
     rcMv.m_bDvMcp = false;
 #endif
 …
+  {
     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    iNeibRefViewId = pcTmpCU->getSlice()->getRefPic(eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx))->getViewOrderIdx(); // will be changed to view_id
+#endif
     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
     TComMv rcMv;
 …
+    }
 #endif
+#if INTER_VIEW_VECTOR_SCALING_C0116
+    Int iScale = 4096;
+    if((iCurrRefPOC != iNeibRefPOC))    // inter & inter
+        iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+    else if(m_pcSlice->getIVScalingFlag())    // inter-view & inter-view
+        iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iNeibViewId, iNeibRefViewId );
+#else
     Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#endif
     if ( iScale == 4096 )
+    {
 …
       rcMv = cMvPred.scaleMv( iScale );
+    }
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
     rcMv.m_bDvMcp = false;
 #endif
 …
+}
 #if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
 Bool TComDataCU::xGetColDisMV( RefPicList eRefPicList, Int refidx, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv , Int & iTargetViewIdx, Int & iStartViewIdx )
+{
-#if LGE_DVMCP_A0126 && !QC_SIMPLE_NBDV_B0047
-  Int  iDvMcpDispX[2] = {-1,};
-  Bool bDvMcpFlag [2] = { false, };
-  Int iCurrViewIdx = m_pcSlice->getViewId();
-#endif
   UInt uiAbsPartAddr = uiPartUnitIdx;
 …
   TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
   iColViewIdx = pColCU->getSlice()->getViewId();
+#if MERL_VSP_C0152
+  //TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
+  if( pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr) < 0)
+  {
+    return false;
+  }
+#endif
   if (pColCU->getPic()==0||pColCU->getPartitionSize(uiPartUnitIdx)==SIZE_NONE||pColCU->isIntra(uiAbsPartAddr))
 …
     return false;
+  }
-#if LGE_DVMCP_A0126 && !QC_SIMPLE_NBDV_B0047
-  Bool bColIsSkipped = pColCU->isSkipped( uiAbsPartAddr );
-#endif
   for (Int ilist = 0; ilist < (pColCU->getSlice()->isInterB()? 2:1); ilist++)
+  {
     if(pColCU->getSlice()->isInterB())
+    {
+#if !QC_NBDV_LDB_FIX_C0055
       if(ilist == 0 )
         eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList(1-getSlice()->getColDir());
       else
         eColRefPicList = getSlice()->getCheckLDC() ? (eRefPicList== REF_PIC_LIST_0? REF_PIC_LIST_1:REF_PIC_LIST_0 ): RefPicList(getSlice()->getColDir());
+#else
+        eColRefPicList = RefPicList(ilist);
+#endif
+    }
 …
     if ( iColViewIdx    == iColRefViewIdx ) // temporal vector
+    {
-#if LGE_DVMCP_A0126 && !QC_SIMPLE_NBDV_B0047
-      if( iColViewIdx >0 )
+      {
-        TComMv tmpMv = pColCU->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
-        if( tmpMv.m_bDvMcp && bColIsSkipped ) // DV-MCP SKIP
+        {
-          iDvMcpDispX[ilist] = tmpMv.m_iDvMcpDispX;
-          bDvMcpFlag [ilist] = true;
-          iTargetViewIdx  = 0; //iColRefViewIdx ;
-          iStartViewIdx   = 0; //iCurrViewIdx; //iColViewIdx   ;
+        }
+      }
-#endif
       continue;
+    }
 …
+    {
       rcMv = pColCU->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
-#if LGE_DVMCP_A0126
       rcMv.m_bDvMcp = false;
-#endif
       iTargetViewIdx  = iColRefViewIdx ;
       iStartViewIdx   = iColViewIdx   ;
 …
+    }
+  }
-#if LGE_DVMCP_A0126 && !QC_SIMPLE_NBDV_B0047
-  for( Int ilist=0 ; ilist<2 ; ilist++ )
+  {
-    if( bDvMcpFlag[ilist] )
+    {
-      rcMv.setHor( iDvMcpDispX[ilist] );
-      rcMv.setVer( 0 );
-      rcMv.m_bDvMcp = true;
-      iTargetViewIdx  = 0; //iColRefViewIdx ;
-      iStartViewIdx   = iCurrViewIdx; //iColViewIdx   ;
-      return true;
+    }
+  }
-#endif
   return false;
 …
  * \returns Bool
  */
+Bool TComDataCU::xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx )
+Bool TComDataCU::xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+  ,
+  Bool bMRG
+#endif
+)
+{
   UInt uiAbsPartAddr = uiPartUnitIdx;
 …
   RefPicList  eColRefPicList;
   Int iColPOC, iColRefPOC, iCurrPOC, iCurrRefPOC, iScale;
-#if SONY_COLPIC_AVAILABILITY
-#if QC_IV_AS_LT_B0046
-  Int iColViewOrderIdx, iCurrViewOrderIdx, iCurrRefViewOrderIdx;
-#else
-  Int iColViewOrderIdx, iColRefViewOrderIdx, iCurrViewOrderIdx, iCurrRefViewOrderIdx;
-#endif
-#endif
   TComMv cColMv;
+#if SONY_COLPIC_AVAILABILITY
+  iCurrViewOrderIdx    = m_pcSlice->getViewOrderIdx();
+  iCurrRefViewOrderIdx = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx();
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Int iColViewId, iColRefViewId, iCurrViewId, iCurrRefViewId;
+#endif
   // use coldir.
 #if COLLOCATED_REF_IDX
 …
   iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
   iColPOC = pColCU->getSlice()->getPOC();
+#if SONY_COLPIC_AVAILABILITY
+  iColViewOrderIdx = pColCU->getSlice()->getViewOrderIdx();
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  iCurrViewId = m_pcSlice->getViewOrderIdx(); // will be changed to view_id
+  iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx(); // will be changed to view_id
+  iColViewId = pColCU->getSlice()->getViewOrderIdx(); // will be changed to view_id
 #endif
 …
+  }
 #if !SONY_COLPIC_AVAILABILITY&!QC_IV_AS_LT_B0046
+#if !INTER_VIEW_VECTOR_SCALING_C0115&!QC_IV_AS_LT_B0046
   if( m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId() != m_pcSlice->getViewId() )
     return false;
 …
   // Scale the vector.
   iColRefPOC = pColCU->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  iColRefViewId = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewOrderIdx(); // will be changed to view_id
+#endif
 #if !QC_IV_AS_LT_B0046
-#if SONY_COLPIC_AVAILABILITY
-  iColRefViewOrderIdx = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewOrderIdx();
-#else
   if( pColCU->getSlice()->getRefViewId( eColRefPicList, iColRefIdx ) != pColCU->getSlice()->getViewId() )
+  {
     return false;
+  }
-#endif
 #else
   Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
 …
   if(bIsCurrRefLongTerm != bIsColRefLongTerm)
+  {
+#if QC_TMVP_MRG_REFIDX_C0047
+    cColMv = pColCU->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
+    iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
+    if(bMRG )
+    {
+      Int iUpdRefIdx  = m_pcSlice->getNewRefIdx(eRefPicList);
+      if(iUpdRefIdx > 0 )
+      {
+        riRefIdx = iUpdRefIdx;
+        bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
+        iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
+#if INTER_VIEW_VECTOR_SCALING_C0115
+        iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx(); // will be changed to view_id
+#endif
+      }
+      else
+        return false;
+    }else
+    {
+#endif
     assert( ((iColPOC == iColRefPOC)&&(iCurrPOC != iCurrRefPOC))||((iColPOC != iColRefPOC)&&(iCurrPOC == iCurrRefPOC)));
     return false;
+#if QC_TMVP_MRG_REFIDX_C0047
+    }
+#endif
+  }
 #endif
 …
+      }
     }else
+#if QC_MVHEVC_B0046
+      rcMv = cColMv; //inter-view
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    {
+        if((iCurrPOC == iCurrRefPOC) && m_pcSlice->getIVScalingFlag())    // inter-view & inter-view
+            iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
+        else
+            iScale = 4096;            // inter & inter
+      if ( iScale == 4096 )
+      {
+        rcMv = cColMv;
+      }
+      else
+      {
+        rcMv = cColMv.scaleMv( iScale );
+      }
+  }
 #else
+    {
+#if SONY_COLPIC_AVAILABILITY
+      Int iColRefViewOrderIdx = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewOrderIdx();
+      iScale = xGetDistScaleFactor(iCurrViewOrderIdx, iCurrRefViewOrderIdx, iColViewOrderIdx, iColRefViewOrderIdx);
+      if ( iScale == 4096 )
+      {
+        rcMv = cColMv;
+      }
+      else
+      {
+        rcMv = cColMv.scaleMv( iScale );
+      }
+#else
+      return false;
+#endif
+    }
+#endif
+  }
+#else
+#if SONY_COLPIC_AVAILABILITY
+  iScale = 0;
+  iCurrRefViewOrderIdx = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx();
+  if((iColPOC != iColRefPOC)&&(iCurrPOC != iCurrRefPOC))
+    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
+  else if((iColPOC == iColRefPOC)&&(iCurrPOC == iCurrRefPOC))
+    iScale = xGetDistScaleFactor(iCurrViewOrderIdx, iCurrRefViewOrderIdx, iColViewOrderIdx, iColRefViewOrderIdx);
+  else
+    return false;
+#else
+  iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
+#endif
+  if ( iScale == 4096 )
+  {
+    rcMv = cColMv;
+  }
+  else
+  {
+    rcMv = cColMv.scaleMv( iScale );
+  }
+#endif
+    rcMv = cColMv; //inter-view
+#endif
+  }
+#endif
   return true;
+}
 …
     return false;
+  }
   if( m_pcSlice->getRefPic( eRefPicList, iRefIdx )->getViewId() != m_pcSlice->getViewId() )
+  {
 …
+    }
+  }
+#if MERL_VSP_C0152 // Preventive
+  if (pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiPartIdxCenter) < 0) // NOT_VALID
+    return false;
+#endif
   // Scale the vector.
 …
 UInt TComDataCU::getCoefScanIdx(UInt uiAbsPartIdx, UInt uiWidth, Bool bIsLuma, Bool bIsIntra)
+{
-#if !LOGI_INTRA_NAME_3MPM
-  static const UChar aucIntraDirToScanIdx[MAX_CU_DEPTH][NUM_INTRA_MODE] =
+  {
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    },
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    },
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    },
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    },
-    {0, 1, 2, 0, 0, 1, 1, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0
-    },
-    {0, 1, 2, 0, 0, 1, 1, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0
-    },
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    },
-  };
-#endif
   UInt uiCTXIdx;
 …
 #endif
-#if LOGI_INTRA_NAME_3MPM
     uiScanIdx = SCAN_ZIGZAG;
     if (uiCTXIdx >3 && uiCTXIdx < 6) //if multiple scans supported for PU size
 …
       uiScanIdx = abs((Int) uiDirMode - VER_IDX) < 5 ? 1 : (abs((Int)uiDirMode - HOR_IDX) < 5 ? 2 : 0);
+    }
-#else
-    uiScanIdx = aucIntraDirToScanIdx[uiCTXIdx][uiDirMode];
-#endif
+  }
   else
 …
 #endif
+    }
-#if LOGI_INTRA_NAME_3MPM
     uiScanIdx = SCAN_ZIGZAG;
     if (uiCTXIdx >4 && uiCTXIdx < 7) //if multiple scans supported for PU size
 …
       uiScanIdx = abs((Int) uiDirMode - VER_IDX) < 5 ? 1 : (abs((Int)uiDirMode - HOR_IDX) < 5 ? 2 : 0);
+    }
-#else
-    uiScanIdx = aucIntraDirToScanIdx[max<Int>(uiCTXIdx-1,0)][uiDirMode];
-#endif
+  }
 …
+      }
+    }
-#if LCU_SYNTAX_ALF
     rSGU.allBordersAvailable = true;
     for(Int b=0; b< NUM_SGU_BORDER; b++)
 …
+      }
+    }
-#endif
+  }
 …
+}
+#if LGE_DMM3_SIMP_C0044
+Void TComDataCU::setWedgePredTexIntraTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
+  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
+  {
+    m_puiWedgePredTexIntraTabIdx[uiAbsPartIdx+ui] = uiTIdx;
+  }
+}
+#endif
 Void TComDataCU::setWedgePredTexDeltaDC1SubParts( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth )
+{
 …
   memcpy( m_pePredMode + uiAbsPartIdxDst,  pcCU->getPredictionMode() + uiAbsPartIdxSrc, sizeof( m_pePredMode[0] ) * uiNumPartition );
   memcpy( m_puhInterDir + uiAbsPartIdxDst, pcCU->getInterDir() + uiAbsPartIdxSrc,       sizeof( m_puhInterDir[0] ) * uiNumPartition );
+#if MERL_VSP_C0152 && MTK_UNCONSTRAINED_MVI_B0083
+  memcpy( m_piVSPIndex + uiAbsPartIdxDst,  pcCU->getVSPIndex() + uiAbsPartIdxSrc, sizeof( m_piVSPIndex[0] ) * uiNumPartition );
+#endif
 #if !MTK_UNCONSTRAINED_MVI_B0083
 …
 // public functions for Multi-view tools
 // -------------------------------------------------------------------------------------------------------------------
 #if HHI_INTER_VIEW_MOTION_PRED
 #if !QC_MULTI_DIS_CAN_A0097
+#if H3D_IVMP
+#if !H3D_NBDV
 Int
 TComDataCU::getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
 …
   return pcDepthMapGenerator->getPdmMvPred( this, uiPartIdx, eRefPicList, iRefIdx, rcMv, bMerge );
+}
+#else //H3D_NBDV
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+Bool
+TComDataCU::getUnifiedMvPredCan(UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm, Bool bMerge )
+{
+  TComDepthMapGenerator* pcDepthMapGenerator = m_pcSlice->getSPS()->getDepthMapGenerator();
+  ROFRS( pcDepthMapGenerator, false );
+  if (pDInfo->iN > 0 && pcDepthMapGenerator->getPdmCandidate(this, uiPartIdx, eRefPicList, iRefIdx, paiPdmRefIdx, pacPdmMv, pDInfo, iPdm, bMerge))
+    return true;
+  return false;
+}
 #else
 Int
+TComDataCU::getPdmMergeCandidateDisCan( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
+#if QC_MRG_CANS_B0048
+  , Int* iPdm
+#endif
+)
+TComDataCU::getPdmMergeCandidateDisCan( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm )
+{
   TComDepthMapGenerator* pcDepthMapGenerator = m_pcSlice->getSPS()->getDepthMapGenerator();
   ROFRS( pcDepthMapGenerator, 0 );
+  return pcDepthMapGenerator->getPdmMergeCandidate( this, uiPartIdx, paiPdmRefIdx, pacPdmMv, pDInfo
+#if QC_MRG_CANS_B0048
+    , iPdm
+#endif
+    );
+  return pcDepthMapGenerator->getPdmMergeCandidate( this, uiPartIdx, paiPdmRefIdx, pacPdmMv, pDInfo, iPdm );
+}
 Bool
 …
+}
 #endif
+#endif //H3D_NBDV
 Bool
 …
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Bool
+TComDataCU::getResidualSamples( UInt uiPartIdx,
+#if QC_SIMPLIFIEDIVRP_M24938
+  Bool bRecon ,
+#endif
+  TComYuv* pcYuv )
+TComDataCU::getResidualSamples( UInt uiPartIdx, Bool bRecon, TComYuv* pcYuv )
+{
   TComResidualGenerator*  pcResidualGenerator = m_pcSlice->getSPS()->getResidualGenerator();
   ROFRS( pcResidualGenerator, false );
 #if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
   DisInfo cDisInfo;
   cDisInfo.iN = 0;
   PartSize m_peSaved =  getPartitionSize( 0 );
   m_pePartSize[0] =  SIZE_2Nx2N;
+#if LGE_DVMCP_A0126
+#if QC_SIMPLE_NBDV_B0047
+#if FIX_LGE_IVMP_PARALLEL_MERGE_B0136
+  getDisMvpCand2( 0, 0,  &cDisInfo, false);
+#else
+  getDisMvpCand2( 0, 0,  &cDisInfo);
+#endif
+#else
+  getDisMvpCand2( 0, 0,  &cDisInfo, true );
+#endif
+#else
+  getDisMvpCand        ( 0, 0,  &cDisInfo );
+#endif
+  getDisMvpCandNBDV( 0, 0,  &cDisInfo, false );
   if( cDisInfo.iN == 0)
+  {
 …
   else
+  {
+    Bool bAvailable = pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv, cDisInfo.m_acMvCand[0].getHor()
+#if QC_SIMPLIFIEDIVRP_M24938
+      , bRecon
+#endif
+      );
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+    Bool bAvailable = pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv, cDisInfo.m_acMvCand[0], bRecon );
+#else
+    Bool bAvailable = pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv, cDisInfo.m_acMvCand[0].getHor(), bRecon );
+#endif
     m_pePartSize[0] = m_peSaved;
     return bAvailable;
+  }
 #else
+  return pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , bRecon
+#endif
+    );
+  return pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv, bRecon );
 #endif
+}

trunk/source/Lib/TLibCommon/TComDataCU.h

-                      r189
+                      r296
 #include "TComPattern.h"
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 #include "TComYuv.h"
 #endif
 …
   UInt  height;   //!< number of pixels in height
   Bool  isBorderAvailable[NUM_SGU_BORDER];  //!< the border availabilities
-#if LCU_SYNTAX_ALF
   Bool  allBordersAvailable;
-#endif
   NDBFBlockInfo():tileID(0), sliceID(0), startSU(0), endSU(0) {} //!< constructor
 …
 #endif
   Char*         m_pePredMode;         ///< array of prediction modes
-#if H0736_AVC_STYLE_QP_RANGE
   Char*         m_phQP;               ///< array of QP values
-#else
-  UChar*        m_phQP;               ///< array of QP values
-#endif
   UChar*        m_puhTrIdx;           ///< array of transform indices
   UChar*        m_nsqtPartIdx;        ///< array of absPartIdx mapping table, map zigzag to NSQT
 …
 #endif
   UChar*        m_puhMergeIndex;      ///< array of merge candidate indices
+#if MERL_VSP_C0152
+  Char*         m_piVSPIndex;         ///< array of VSP flags to indicate the current block uses synthetic predictor or not
+                                      ///< value 0: non-VSP, value 1: VSP
+#endif
 #if AMP_MRG
   Bool          m_bIsMergeAMP;
 …
   Bool*         m_pbIPCMFlag;         ///< array of intra_pcm flags
-#if BURST_IPCM
   Int           m_numSucIPCM;         ///< the number of succesive IPCM blocks associated with the current log2CUSize
   Bool          m_lastCUSucIPCMFlag;  ///< True indicates that the last CU is IPCM and shares the same root as the current CU.
+#endif
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Bool*         m_pbResPredAvailable; ///< array of residual prediction available flags
   Bool*         m_pbResPredFlag;      ///< array of residual prediction flags
 …
   Bool          m_bDecSubCu;          ///< indicates decoder-mode
   Double        m_dTotalCost;         ///< sum of partition RD costs
-#if FIX_RDO_NEGDIST
   Dist          m_uiTotalDistortion;  ///< sum of partition distortion
-#else
-  UInt          m_uiTotalDistortion;  ///< sum of partition distortion
-#endif
   UInt          m_uiTotalBits;        ///< sum of partition bits
   UInt          m_uiTotalBins;       ///< sum of partition bins
 …
 #if HHI_DMM_PRED_TEX
   UInt*         m_puiWedgePredTexTabIdx;
+#if LGE_DMM3_SIMP_C0044
+  UInt*         m_puiWedgePredTexIntraTabIdx;
+#endif
   Int*          m_piWedgePredTexDeltaDC1;
   Int*          m_piWedgePredTexDeltaDC2;
 …
   Bool          xAddMVPCand           ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
   Bool          xAddMVPCandOrder      ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
+#if MERL_VSP_C0152
+  inline Bool   xAddVspMergeCand      ( UChar ucVspMergePos, Int vspIdx, Bool* bVspMvZeroDone, UInt uiDepth, Bool* abCandIsInter, Int& iCount,
+                                        UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, Int* iVSPIndexTrue, Int mrgCandIdx, DisInfo* pDisInfo );
+  inline Void   xInheritVspMode       ( TComDataCU* pcCURef, UInt uiIdx, Bool* bVspMvZeroDone, Int iCount, Int* iVSPIndexTrue, TComMvField* pcMvFieldNeighbours, DisInfo* pDInfo ) ;
+#endif
   Void          deriveRightBottomIdx        ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxRB );
+  Bool          xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx );
+#if QC_MULTI_DIS_CAN_A0097
+  Bool          xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
+#if QC_TMVP_MRG_REFIDX_C0047
+  ,
+  Bool bMRG = 0
+#endif
+  );
+#if H3D_NBDV
   Bool          xGetColDisMV( RefPicList eRefPicList, Int refidx, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int & iTargetViewIdx, Int & iStartViewIdx );
 #endif
-#if !AMVP_PRUNING_SIMPLIFICATION
-  /// remove redundant candidates
-  Void          xUniqueMVPCand        ( AMVPInfo* pInfo );
-#endif
   Void xCheckCornerCand( TComDataCU* pcCorner, UInt uiCornerIdx, UInt uiIter, Bool& rbValidCand );
 …
   Void xCheckDuplicateCand(TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, bool* pbCandIsInter, UInt& ruiArrayAddr);
-#if !BURST_IPCM
-  Int           getLastValidPartIdx   ( Int iAbsPartIdx );
-#endif
 public:
 …
   Void          initCU                ( TComPic* pcPic, UInt uiCUAddr );
-#if H0736_AVC_STYLE_QP_RANGE
   Void          initEstData           ( UInt uiDepth, Int qp );
   Void          initSubCU             ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp );
-#else
-  Void          initEstData           ( UInt uiDepth, UInt uiQP );
-  Void          initSubCU             ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, UInt uiQP );
-#endif
   Void          setOutsideCUPart      ( UInt uiAbsPartIdx, UInt uiDepth );
 …
   Void          copyTextureMotionDataFrom( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdxSrc, UInt uiAbsPartIdxDst = 0 );
 #endif
   // -------------------------------------------------------------------------------------------------------------------
+   // -------------------------------------------------------------------------------------------------------------------
   // member functions for CU data
   // -------------------------------------------------------------------------------------------------------------------
 …
   Void          setSizeSubParts       ( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth );
-#if H0736_AVC_STYLE_QP_RANGE
   Char*         getQP                 ()                        { return m_phQP;              }
   Char          getQP                 ( UInt uiIdx )            { return m_phQP[uiIdx];       }
   Void          setQP                 ( UInt uiIdx, Char value ){ m_phQP[uiIdx] =  value;     }
   Void          setQPSubParts         ( Int qp,   UInt uiAbsPartIdx, UInt uiDepth );
-#if BURST_IPCM
   Int           getLastValidPartIdx   ( Int iAbsPartIdx );
-#endif
   Char          getLastCodedQP        ( UInt uiAbsPartIdx );
-#else
-  UChar*        getQP                 ()                        { return m_phQP;              }
-  UChar         getQP                 ( UInt uiIdx )            { return m_phQP[uiIdx];       }
-  Void          setQP                 ( UInt uiIdx, UChar  uh ) { m_phQP[uiIdx] = uh;         }
-  Void          setQPSubParts         ( UInt uiQP,   UInt uiAbsPartIdx, UInt uiDepth );
-#if BURST_IPCM
-  Int           getLastValidPartIdx   ( Int iAbsPartIdx );
-#endif
-  UChar         getLastCodedQP        ( UInt uiAbsPartIdx );
-#endif
 #if LOSSLESS_CODING
 …
   Void          setMergeIndex         ( UInt uiIdx, UInt uiMergeIndex ) { m_puhMergeIndex[uiIdx] = uiMergeIndex;  }
   Void          setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
+#if MERL_VSP_C0152
+  Char*         getVSPIndex        ()                        { return m_piVSPIndex;        }
+  Char          getVSPIndex        ( UInt uiIdx )            { return m_piVSPIndex[uiIdx]; }
+  Void          setVSPIndex        ( UInt uiIdx, Int n )     { m_piVSPIndex[uiIdx] = n;    }
+  Void          setVSPIndexSubParts( Char bVSPIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
+#endif
   template <typename T>
   Void          setSubPart            ( T bParameter, T* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );
 …
   Void          setICFlag             ( UInt uiIdx, Bool  uh )  { m_pbICFlag[uiIdx] = uh;          }
   Void          setICFlagSubParts     ( Bool bICFlag,  UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
+#if LGE_ILLUCOMP_DEPTH_C0046
+  Bool          isICFlagRequired      (UInt uiAbsPartIdx, UInt uiDepth); //This modification is not needed after integrating JCT3V-C0137
+#else
   Bool          isICFlagRequired      (UInt uiAbsPartIdx);
+#endif
 #endif
 …
   Void          setIPCMFlagSubParts   (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth);
-#if BURST_IPCM
   Int           getNumSucIPCM         ()                        { return m_numSucIPCM;             }
   Void          setNumSucIPCM         ( Int num )               { m_numSucIPCM = num;              }
   Bool          getLastCUSucIPCMFlag  ()                        { return m_lastCUSucIPCMFlag;        }
   Void          setLastCUSucIPCMFlag  ( Bool flg )              { m_lastCUSucIPCMFlag = flg;         }
-#endif
   /// get slice ID for SU
 …
                                           ,Bool bIndependentTileBoundaryEnabled );
+#if HHI_INTER_VIEW_MOTION_PRED
+#if !QC_MULTI_DIS_CAN_A0097
+  Int           getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
+  Bool          getPdmMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge = false );
+#if H3D_IVMP
+#if !H3D_NBDV
+  Int           getPdmMergeCandidate      ( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
+  Bool          getPdmMvPred              ( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge = false );
+#else //!H3D_NBDV
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+  Bool          getUnifiedMvPredCan       ( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm, Bool bMerge );
+#else //QC_AMVP_MRG_UNIFY_IVCAN_C0051
+  Bool          getPdmMvPredDisCan        ( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge = false );
+  Int           getPdmMergeCandidateDisCan( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm );
+#endif //QC_AMVP_MRG_UNIFY_IVCAN_C0051
+  Void          getDisMvpCand        ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo );
+  Void          getDisMvpCandNBDV( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo , Bool bParMerg = false
+#if MERL_VSP_C0152
+                              , Bool bDepthRefine = false
+#endif //MERL_VSP_C0152
+    );
+#endif // !H3D_NBDV
+#if MERL_VSP_C0152
+#if LGE_SIMP_DVP_REFINE_C0112
+  Pel           getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iWidth, Int iHeight, Int* aiShiftLUT, Int iShiftPrec, Bool bSimpleDvpRefine = false);
+  Void          estimateDVFromDM(UInt uiPartIdx, TComPic* picDepth, UInt uiPartAddr, TComMv* cMvPred, Bool bSimpleDvpRefine = false);
 #else
+  Bool          getPdmMvPredDisCan( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge = false );
+  Int           getPdmMergeCandidateDisCan( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
+#if QC_MRG_CANS_B0048
+    , Int* iPdm
+#endif
+  );
+  Void          getDisMvpCand        ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo );
+#if LGE_DVMCP_A0126
+#if QC_SIMPLE_NBDV_B0047
+  Void          getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+    , Bool bParMerg = false
+#endif
+    );
+#else
+  Void          getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo, Bool bMerge=false, RefPicList eRefPicList=REF_PIC_LIST_X, Int iRefIdx=-1
+#if LGE_IVMP_PARALLEL_MERGE_B0136
+    , Bool bParMerg = false
+#endif
+    );
+#endif
+#endif
+  Pel           getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iWidth, Int iHeight, Int* aiShiftLUT, Int iShiftPrec);
+  Void          estimateDVFromDM(UInt uiPartIdx, TComPic* picDepth, UInt uiPartAddr, TComMv* cMvPred);
+#endif
 #endif
   Bool          getIViewOrgDepthMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#endif //  H3D_IVMP
+#if H3D_IVRP
   Bool*         getResPredAvail         ()                        { return m_pbResPredAvailable;        }
   Bool          getResPredAvail         ( UInt uiIdx )            { return m_pbResPredAvailable[uiIdx]; }
 …
   Void          setResPredIndicator     ( Bool bAv, Bool bRP )    { m_pbResPredAvailable[0] = bAv; m_pbResPredFlag[0] = bRP; }
 #endif
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+  Bool          getResidualSamples( UInt uiPartIdx,
+#if QC_SIMPLIFIEDIVRP_M24938
+    Bool bRecon ,
+#endif
+    TComYuv* pcYuv = 0 );
+#if H3D_IVRP
+  Bool          getResidualSamples( UInt uiPartIdx, Bool bRecon, TComYuv* pcYuv = 0 );
 #endif
   // -------------------------------------------------------------------------------------------------------------------
 …
   Void          getPartIndexAndSize   ( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight );
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Int           getResiPredMode(UInt uiPartAddr);
   Void          getPUResiPredShift (Int *iPUPredResiShift, UInt uiAbsPartIndex);
 …
   AMVP_MODE     getAMVPMode           ( UInt uiIdx );
 #if SHARP_INTERVIEW_DECOUPLE_B0111
+#if H3D_IVMP
   Void          fillMvpCandBase       ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo );
   Void          fillMvpCand           ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo , Int iMVPIdx=-1);
+#else
+  Void          fillMvpCand           ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo );
+#endif
+#if PARALLEL_MERGE
+#endif
   Bool          isDiffMER             ( Int xN, Int yN, Int xP, Int yP);
   Void          getPartPosition       ( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH);
-#endif
   Void          setMVPIdx             ( RefPicList eRefPicList, UInt uiIdx, Int iMVPIdx)  { m_apiMVPIdx[eRefPicList][uiIdx] = iMVPIdx;  }
   Int           getMVPIdx             ( RefPicList eRefPicList, UInt uiIdx)               { return m_apiMVPIdx[eRefPicList][uiIdx];     }
 …
   TComDataCU*   getQpMinCuLeft              ( UInt&  uiLPartUnitIdx , UInt uiCurrAbsIdxInLCU, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
-#if H0204_QP_PREDICTION
   TComDataCU*   getQpMinCuAbove             ( UInt&  aPartUnitIdx , UInt currAbsIdxInLCU, Bool enforceSliceRestriction=true, Bool enforceEntropySliceRestriction=true );
-#endif
-#if H0736_AVC_STYLE_QP_RANGE
   Char          getRefQP                    ( UInt   uiCurrAbsIdxInLCU                       );
-#else
-  UChar         getRefQP                    ( UInt   uiCurrAbsIdxInLCU                       );
-#endif
   TComDataCU*   getPUAboveRightAdi          ( UInt&  uiARPartUnitIdx, UInt uiPuWidth, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
 …
   Bool          hasEqualMotion              ( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx );
 #if SIMP_MRG_PRUN
   Void          getInterMergeCandidates       ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 );
+#if MERL_VSP_C0152
+  Void          getInterMergeCandidates     ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int* uiVSPIndexTrue, Int mrgCandIdx = -1 );
 #else
   Void          getInterMergeCandidates       ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand );
 #endif
   Void          deriveLeftRightTopIdxGeneral  ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
   Void          deriveLeftBottomIdxGeneral    ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB );
+  Void          getInterMergeCandidates     ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 );
+#endif
+  Void          deriveLeftRightTopIdxGeneral( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
+  Void          deriveLeftBottomIdxGeneral  ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB );
 …
   UInt          getCtxInterDir                  ( UInt   uiAbsPartIdx                                 );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt          getCtxResPredFlag               ( UInt   uiAbsPartIdx                                 );
 #endif
 …
   Double&       getTotalCost()                  { return m_dTotalCost;        }
-#if FIX_RDO_NEGDIST
   Dist&         getTotalDistortion()            { return m_uiTotalDistortion; }
-#else
-  UInt&         getTotalDistortion()            { return m_uiTotalDistortion; }
-#endif
   UInt&         getTotalBits()                  { return m_uiTotalBits;       }
   UInt&         getTotalNumPart()               { return m_uiNumPartition;    }
 …
   Void  setWedgePredTexTabIdx             ( UInt uiIdx, UInt uh ) { m_puiWedgePredTexTabIdx[uiIdx] = uh;      }
   Void  setWedgePredTexTabIdxSubParts     ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
+#if LGE_DMM3_SIMP_C0044
+  UInt* getWedgePredTexIntraTabIdx             ()                      { return m_puiWedgePredTexIntraTabIdx;           }
+  UInt  getWedgePredTexIntraTabIdx             ( UInt uiIdx )          { return m_puiWedgePredTexIntraTabIdx[uiIdx];    }
+  Void  setWedgePredTexIntraTabIdx             ( UInt uiIdx, UInt uh ) { m_puiWedgePredTexIntraTabIdx[uiIdx] = uh;      }
+  Void  setWedgePredTexIntraTabIdxSubParts     ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
+#endif
   Int*  getWedgePredTexDeltaDC1           ()                      { return m_piWedgePredTexDeltaDC1;          }
   Int   getWedgePredTexDeltaDC1           ( UInt uiIdx )          { return m_piWedgePredTexDeltaDC1[uiIdx];   }

trunk/source/Lib/TLibCommon/TComDepthMapGenerator.cpp

-                      r189
+                      r296
 #if DEPTH_MAP_GENERATION
 TComDepthMapGenerator::TComDepthMapGenerator()
+{
 …
   m_uiSubSampExpX       = uiSubSampExpX;
   m_uiSubSampExpY       = uiSubSampExpY;
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
   m_ppcYuv              = new TComYuv*    [ m_uiMaxDepth ];
   m_ppcCU               = new TComDataCU* [ m_uiMaxDepth ];
 …
   m_cTmpPic.create( uiPicWidth >> m_uiSubSampExpX, uiPicHeight >> m_uiSubSampExpY, uiMaxCUWidth >> m_uiSubSampExpX, uiMaxCUHeight >> m_uiSubSampExpY, uiMaxCUDepth );
   xSetChroma( &m_cTmpPic, ( 1 << uiOrgBitDepth ) >> 1 );
 #endif
+#endif //!H3D_NBDV
   m_bCreated    = true;
+}
 …
+  {
     m_bCreated    = false;
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
     for( UInt uiDepth = 0; uiDepth < m_uiMaxDepth; uiDepth++ )
+    {
 …
     delete [] m_ppcCU;  m_ppcCU  = 0;
     m_cTmpPic.destroy();
 #endif
+#endif //!H3D_NBDV
     m_uiMaxDepth          = 0;
     m_uiOrgDepthBitDepth  = 0;
 …
+}
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
 Bool
 TComDepthMapGenerator::predictDepthMap( TComPic* pcPic )
 …
   m_cTmpPic.dump( acFilename, ( pcPic->getPOC() != 0 )  );
+}
+#endif
+#if HHI_INTER_VIEW_MOTION_PRED
+#endif //!H3D_NBDV
+#if H3D_IVMP
 Void
 TComDepthMapGenerator::covertOrgDepthMap( TComPic* pcPic )
 …
+#if HHI_INTER_VIEW_MOTION_PRED
+#if QC_MULTI_DIS_CAN_A0097
+Int
+TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
+#if QC_MRG_CANS_B0048
+  , Int* iPdm
+#endif
+)
+#else
+Int
+TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
+#endif
+{
+#if MTK_INTERVIEW_MERGE_A0049
+#if H3D_IVMP
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+Bool
+TComDepthMapGenerator::getPdmCandidate(TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm, Bool bMerge )
+{
   AOF  ( m_bCreated && m_bInit );
-#if !QC_MULTI_DIS_CAN_A0097
-  ROFRS( m_bPDMAvailable, 0 );
-#endif
   TComSlice*    pcSlice     = pcCU->getSlice ();
   TComSPS*      pcSPS       = pcSlice->getSPS();
   AOF  ( pcSPS->getViewId() == m_uiCurrViewId );
+  TComPic*      pcRefPic    = pcSlice->getRefPic( eRefPicList, iRefIdx );
+  UInt          uiRefViewId = pcRefPic->getSPS()->getViewId();
+  Bool          bInterview  = ( uiRefViewId < m_uiCurrViewId );
+  Bool          bPdmIView   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
+  Bool          bPdmInter   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
   Bool          bPdmMerge   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
+  ROTRS( !bPdmMerge, 0 );
+#if QC_MRG_CANS_B0048
+  if(!bMerge)
+  {
+    ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
+    ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
+    ROTRS(                  bMerge   && !bPdmMerge, false );
+  }
+  else
+    ROTRS( !bPdmMerge, 0 );
   Bool abPdmAvailable[4] = {false, false, false, false};
-#else
-  Bool abPdmAvailable[2] = {false,false};
-#endif
   Int iValid = 0;
 …
   for( UInt uiBId = 0; uiBId < m_uiCurrViewId && iValid==0; uiBId++ )
+  {
+#if MTK_C0138_FIXED
+    UInt        uiBaseId    = uiBId;
+#else
     UInt        uiBaseId    = m_auiBaseIdList[ uiBId ];
+#endif
     TComPic*    pcBasePic   = m_pcAUPicAccess->getPic( uiBaseId );
     for( Int iRefListId = 0; iRefListId < 2 && iValid==0; iRefListId++ )
 …
+  }
   if (iValid == 0)
     return 0;
+    return false;
   //--- get base CU/PU and check prediction mode ---
   TComPic*    pcBasePic   = m_pcAUPicAccess->getPic( iViewId );
   TComPicYuv* pcBaseRec   = pcBasePic->getPicYuvRec   ();
+#if QC_MULTI_DIS_CAN_A0097
+  if(bMerge || !bInterview)
+  {
+#if H3D_NBDV
+    Int  iCurrPosX, iCurrPosY;
+    UInt          uiPartAddr;
+    Int           iWidth;
+    Int           iHeight;
+    pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
+    pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
+    iCurrPosX  += ( ( iWidth  - 1 ) >> 1 );
+    iCurrPosY  += ( ( iHeight - 1 ) >> 1 );
+    Int         iBasePosX   = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
+    Int         iBasePosY   = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
+    Int         iBaseCUAddr;
+    Int         iBaseAbsPartIdx;
+    pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
+#else //H3D_NBDV
+    Int  iPrdDepth, iCurrPosX, iCurrPosY;
+    Bool bAvailable  = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
+    AOF( bAvailable );
+    TComPicYuv* pcBasePdm   = pcBasePic->getPredDepthMap();
+    Int         iDisparity  = xGetDisparityFromVirtDepth( iViewId, iPrdDepth );
+    Int         iShiftX     = m_uiSubSampExpX + 2;
+    Int         iAddX       = ( 1 << iShiftX ) >> 1;
+    Int         iBasePosX   = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
+    Int         iBasePosY   = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY                               );
+    Int         iBaseCUAddr;
+    Int         iBaseAbsPartIdx;
+    pcBaseRec->getCUAddrAndPartIdx( iBasePosX<< m_uiSubSampExpX , iBasePosY<< m_uiSubSampExpY , iBaseCUAddr, iBaseAbsPartIdx );
+#endif // H3D_NBDV
+    TComDataCU* pcBaseCU    = pcBasePic->getCU( iBaseCUAddr );
+    if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTER || pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_SKIP )
+    {
+      for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )
+      {
+        RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
+        if(!bMerge && eCurrRefPicList != eRefPicList)
+          continue;
+        Bool bLoop_stop = false;
+        for(Int iLoop = 0; iLoop < 2 && !bLoop_stop; ++iLoop)
+        {
+          RefPicList eBaseRefPicList = (iLoop ==1)? RefPicList( 1 -  uiCurrRefListId ) : RefPicList( uiCurrRefListId );
+          TComMvField cBaseMvField;
+          pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
+          Int         iBaseRefIdx     = cBaseMvField.getRefIdx();
+          if (iBaseRefIdx >= 0)
+          {
+            Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
+            if (iBaseRefPOC != pcSlice->getPOC())
+            {
+              for (Int iPdmRefIdx = (bMerge?0: iRefIdx); iPdmRefIdx < (bMerge? pcSlice->getNumRefIdx( eCurrRefPicList ): (iRefIdx+1)); iPdmRefIdx++)
+              {
+                if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx))
+                {
+                  abPdmAvailable[ uiCurrRefListId ] = true;
+                  TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
+#if H3D_NBDV
+                  if( bMerge )
+                  {
+                    cMv.m_bDvMcp = true;
+                    cMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
+                  }
+#endif
+                  pcCU->clipMv( cMv );
+                  if(bMerge)
+                  {
+                    paiPdmRefIdx  [ uiCurrRefListId ] = iPdmRefIdx;
+                    pacPdmMv      [ uiCurrRefListId ] = cMv;
+                    bLoop_stop = true;
+                    break;
+                  }else
+                  {
+                    pacPdmMv  [0] = cMv;
+                    return true;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if( bMerge )
+      iPdm[0] = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
+  }
+  if(bMerge || bInterview)
+  {
+    for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
+    {
+      RefPicList  eRefPicListDMV       = RefPicList( iRefListId );
+      Int         iNumRefPics       = pcSlice->getNumRefIdx( eRefPicListDMV );
+      for( Int iPdmRefIdx = (bMerge ? 0: iRefIdx); iPdmRefIdx < (bMerge ? iNumRefPics: (iRefIdx+1) ); iPdmRefIdx++ )
+      {
+        if( pcSlice->getRefPOC( eRefPicListDMV, iPdmRefIdx ) == pcSlice->getPOC())
+        {
+          abPdmAvailable[ iRefListId+2 ] = true;
+          paiPdmRefIdx  [ iRefListId+2 ] = iPdmRefIdx;
+#if H3D_NBDV
+          TComMv cMv = pDInfo->m_acMvCand[0];
+          cMv.setVer(0);
+#else
+          TComMv cMv(iDisparity, 0);
+#endif
+          pcCU->clipMv( cMv );
+          pacPdmMv      [ iRefListId + 2] = cMv;
+          if(bMerge)
+            break;
+          else
+          {
+            pacPdmMv [0] = cMv;
+            return true;
+          }
+        }
+      }
+    }
+    iPdm[1] = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 );
+  }
+  return false;
+}
+#else // QC_AMVP_MRG_UNIFY_IVCAN_C0051
+#if H3D_NBDV
+Int
+TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm )
+#else
+Int
+TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
+#endif
+{
+  AOF  ( m_bCreated && m_bInit );
+#if !H3D_NBDV
+  ROFRS( m_bPDMAvailable, 0 );
+#endif
+  TComSlice*    pcSlice     = pcCU->getSlice ();
+  TComSPS*      pcSPS       = pcSlice->getSPS();
+  AOF  ( pcSPS->getViewId() == m_uiCurrViewId );
+  Bool          bPdmMerge   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
+  ROTRS( !bPdmMerge, 0 );
+  Bool abPdmAvailable[4] = {false, false, false, false};
+  Int iValid = 0;
+  Int iViewId = 0;
+  for( UInt uiBId = 0; uiBId < m_uiCurrViewId && iValid==0; uiBId++ )
+  {
+    UInt        uiBaseId    = m_auiBaseIdList[ uiBId ];
+    TComPic*    pcBasePic   = m_pcAUPicAccess->getPic( uiBaseId );
+    for( Int iRefListId = 0; iRefListId < 2 && iValid==0; iRefListId++ )
+    {
+      RefPicList  eRefPicListTest = RefPicList( iRefListId );
+      Int         iNumRefPics = pcSlice->getNumRefIdx( eRefPicListTest ) ;
+      for( Int iRefIndex = 0; iRefIndex < iNumRefPics; iRefIndex++ )
+      {
+        if(pcBasePic->getPOC() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getPOC()
+          && pcBasePic->getViewId() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getViewId())
+        {
+          iValid=1;
+          iViewId = uiBaseId;
+          break;
+        }
+      }
+    }
+  }
+  if (iValid == 0)
+    return 0;
+  //--- get base CU/PU and check prediction mode ---
+  TComPic*    pcBasePic   = m_pcAUPicAccess->getPic( iViewId );
+  TComPicYuv* pcBaseRec   = pcBasePic->getPicYuvRec   ();
+#if H3D_NBDV
   Int  iCurrPosX, iCurrPosY;
   UInt          uiPartAddr;
 …
               paiPdmRefIdx  [ uiBaseRefListId ] = iPdmRefIdx;
               TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
               cMv.m_bDvMcp = true;
               cMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
+#endif
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+              cMv.m_iDvMcpDispY = pDInfo->m_acMvCand[0].getVer();
+#endif
+#endif //H3D_NBDV
               pcCU->clipMv( cMv );
               pacPdmMv      [ uiBaseRefListId ] = cMv;
 …
+  }
   Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
+#if QC_MRG_CANS_B0048
   iPdm[0] = iPdmInterDir;
-#else
-  if (iPdmInterDir == 0)
+  {
-#endif
     for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
+    {
 …
       Int         iNumRefPics       = pcSlice->getNumRefIdx( eRefPicList );
       for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
+{
+      {
         if( pcSlice->getRefPOC( eRefPicList, iPdmRefIdx ) == pcSlice->getPOC())
+        {
-#if QC_MRG_CANS_B0048
           abPdmAvailable[ iRefListId+2 ] = true;
           paiPdmRefIdx  [ iRefListId+2 ] = iPdmRefIdx;
+#else
+          abPdmAvailable[ iRefListId ] = true;
+          paiPdmRefIdx  [ iRefListId ] = iPdmRefIdx;
+#endif
+#if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
           TComMv cMv = pDInfo->m_acMvCand[0];
           cMv.setVer(0);
 …
 #endif
           pcCU->clipMv( cMv );
-#if QC_MRG_CANS_B0048
           pacPdmMv      [ iRefListId + 2] = cMv;
-#else
-          pacPdmMv      [ iRefListId ] = cMv;
-#endif
           break;
+        }
+      }
+    }
-#if QC_MRG_CANS_B0048
     iPdmInterDir = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 ) ;
     iPdm[1] = iPdmInterDir;
-#else
-    iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 ) ;
+  }
-#endif
   return iPdmInterDir;
+#else
+  Int  iMaxNumInterPics  = 1;
+  Int  iMaxNumAllPics    = 2;
+  // inter-only
+  Bool abPdmAvailable[2] = {false,false};
+  for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
+  {
+    RefPicList  eRefPicList       = RefPicList( iRefListId );
+    Int         iNumRefPics       = pcCU->getSlice()->getNumRefIdx( eRefPicList );
+    TComMv      cMv;
+    for( Int iPdmRefIdx = 0, iInterPics = 0; iPdmRefIdx < iNumRefPics && iInterPics < iMaxNumInterPics; iPdmRefIdx++ )
+    {
+      if( pcCU->getSlice()->getRefPOC( eRefPicList, iPdmRefIdx ) != pcCU->getSlice()->getPOC() )
+      {
+#if QC_MULTI_DIS_CAN_A0097
+        if( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
+#else
+        if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
+#endif
+        {
+          pcCU->clipMv( cMv );
+          abPdmAvailable[ iRefListId ] = true;
+          paiPdmRefIdx  [ iRefListId ] = iPdmRefIdx;
+          pacPdmMv      [ iRefListId ] = cMv;
+          break;
+        }
+        iInterPics++;
+      }
+    }
+  }
+  Int    iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
+  if( 0==iPdmInterDir )
+  { // check all, including inter view references
+    for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
+    {
+      RefPicList  eRefPicList = RefPicList( iRefListId );
+      Int         iNumRefPics = Min( iMaxNumAllPics, pcCU->getSlice()->getNumRefIdx( eRefPicList ) );
+      TComMv      cMv;
+      for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
+      {
+#if QC_MULTI_DIS_CAN_A0097
+        if ( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
+#else
+        if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
+#endif
+        {
+          pcCU->clipMv( cMv );
+          abPdmAvailable[ iRefListId ] = true;
+          paiPdmRefIdx  [ iRefListId ] = iPdmRefIdx;
+          pacPdmMv      [ iRefListId ] = cMv;
+          break;
+        }
+      }
+    }
+    iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
+  }
+  return iPdmInterDir;
+#endif
+}
+#if QC_MULTI_DIS_CAN_A0097
+}
+#if H3D_NBDV
 Bool
 TComDepthMapGenerator::getDisCanPdmMvPred    ( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge )
+{
-#if LGE_DVMCP_A0126
   rcMv.m_bDvMcp = false;
-#endif
   AOF  ( m_bCreated && m_bInit );
   AOF  ( iRefIdx >= 0 );
   AOF  ( pcCU );
-  //ROFRS( m_bPDMAvailable, false );
   TComSlice*    pcSlice     = pcCU->getSlice ();
   TComSPS*      pcSPS       = pcSlice->getSPS();
 …
   for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
+  {
     UInt        uiBaseId    = uiBId;  //m_auiBaseIdList[ uiBId ];
+    UInt        uiBaseId    = uiBId;
     if (m_uiCurrViewId >1 && uiBaseId ==1 )
 …
+      {
         rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
-#if LGE_DVMCP_A0126
         // save disparity vector when a merge candidate for IVMP is set as DV-MCP
         if( bMerge )
 …
           rcMv.m_bDvMcp = true;
           rcMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+          rcMv.m_iDvMcpDispY = pDInfo->m_acMvCand[0].getVer();
+#endif
+        }
         else { // AMVP ?
           rcMv.m_bDvMcp = false;
+        }
-#endif
         return true;
+      }
 …
   return false;
+}
 #else
+#else // H3D_NBDV
 Bool
 TComDepthMapGenerator::getPdmMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge )
 …
   return false;
+}
+#endif
+#endif // H3D_NBDV
+#endif // QC_AMVP_MRG_UNIFY_IVCAN_C0051
 …
   return        true;
+}
 #endif
 #if !QC_MULTI_DIS_CAN_A0097
+#endif //  H3D_IVMP
+#if !H3D_NBDV
 /*=======================================================*
  *=====                                             =====*
 …
   Int           iCurrPosY;
   pcPredDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
 #if SAIT_IMPROV_MOTION_PRED_M24829 // max disparity within PU
+#if H3D_IVMP // max disparity within PU
   Int DiWidth  = iCurrPosX+(iWidth  >> m_uiSubSampExpX);
   Int DiHeight = iCurrPosY+(iHeight >> m_uiSubSampExpY);
 …
   return        true;
+}
 #endif
+#endif // H3D_NBDV
 #endif // DEPTH_MAP_GENERATION

trunk/source/Lib/TLibCommon/TComDepthMapGenerator.h

-                      r210
+                      r296
   UInt      getPdm  ()                            { if( m_aacActiveSPS[0][1] ) { return m_aacActiveSPS[0][1]->getPredDepthMapGeneration(); } return 0; }
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt      getResPrd ()                          { if( m_aacActiveSPS[0][1] ) { return m_aacActiveSPS[0][1]->getMultiviewResPredMode  (); } return 0; }
 #endif
 …
   Void  initViewComponent     ( TComPic*      pcPic );
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
   Bool  predictDepthMap       ( TComPic*      pcPic );
   Void  updateDepthMap        ( TComPic*      pcPic );
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void  covertOrgDepthMap     ( TComPic*      pcPic );
 #endif
 …
   UInt  getSubSampExpY        ()                      { return m_uiSubSampExpY; }
   Int   getDisparity          ( TComPic*      pcPic, Int iPosX, Int iPosY, UInt uiRefViewId );
+#if HHI_INTER_VIEW_MOTION_PRED
+#if QC_MULTI_DIS_CAN_A0097
+  Int   getPdmMergeCandidate ( TComDataCU*   pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
+#if QC_MRG_CANS_B0048
+    , Int* iPdm
+#endif
+    );
+#if H3D_IVMP
+#if H3D_NBDV
+#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
+  Bool  getPdmCandidate       ( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm, Bool bMerge );
+#else
+  Int   getPdmMergeCandidate  ( TComDataCU*   pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm );
   Bool  getPdmMvPredDisCan    ( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge );
   Bool  getDisCanPdmMvPred    ( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge );
+#endif
 #else
   Int   getPdmMergeCandidate  ( TComDataCU*   pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
 …
 private:
   // picture operations
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
   Bool  xConvertDepthMapCurr2Ref  ( TComPic*    pcRef, TComPic* pcCur );
   Bool  xConvertDepthMapRef2Curr  ( TComPic*    pcCur, TComPic* pcRef );

trunk/source/Lib/TLibCommon/TComLoopFilter.cpp

-                      r56
+                      r296
 // Public member functions
 // ====================================================================================================================
-#if DBL_CONTROL
 Void TComLoopFilter::setCfg( Bool DeblockingFilterControlPresent, UInt uiDisableDblkIdc, Int iBetaOffset_div2, Int iTcOffset_div2, Bool bLFCrossTileBoundary)
+#else
+Void TComLoopFilter::setCfg( UInt uiDisableDblkIdc, Int iBetaOffset_div2, Int iTcOffset_div2, Bool bLFCrossTileBoundary)
+#endif
+{
+#if !DBL_CONTROL
+  m_uiDisableDeblockingFilterIdc  = uiDisableDblkIdc;
+#endif
+{
   m_bLFCrossTileBoundary = bLFCrossTileBoundary;
-#if DBL_CONTROL
   if (DeblockingFilterControlPresent)
+  {
 …
     m_tcOffsetDiv2 = 0;
+  }
-#else
-  m_betaOffsetDiv2 = iBetaOffset_div2;
-  m_tcOffsetDiv2 = iTcOffset_div2;
-#endif
+}
 …
   //-- Set BS for Intra MB : BS = 4 or 3
+  if ( pcCUP->isIntra(uiPartP) || pcCUQ->isIntra(uiPartQ) )
+  if ( pcCUP->isIntra(uiPartP) || pcCUQ->isIntra(uiPartQ)
+#if MERL_VSP_C0152
+    || pcCUP->getVSPIndex(uiPartP) || pcCUQ->getVSPIndex(uiPartQ)
+#endif
+     )
+  {
     uiBs = 2;
 …
   //-- Set BS for not Intra MB : BS = 2 or 1 or 0
+  if ( !pcCUP->isIntra(uiPartP) && !pcCUQ->isIntra(uiPartQ) )
+  {
+#if NSQT_LFFIX
+  if ( !pcCUP->isIntra(uiPartP) && !pcCUQ->isIntra(uiPartQ)
+#if MERL_VSP_C0152
+    && !pcCUP->getVSPIndex(uiPartP) && !pcCUQ->getVSPIndex(uiPartQ)
+#endif
+  )
+  {
     UInt nsPartQ = uiPartQ;
     UInt nsPartP = uiPartP;
 …
     if ( m_aapucBS[iDir][uiAbsPartIdx] && (pcCUQ->getCbf( nsPartQ, TEXT_LUMA, pcCUQ->getTransformIdx(nsPartQ)) != 0 || pcCUP->getCbf( nsPartP, TEXT_LUMA, pcCUP->getTransformIdx(nsPartP) ) != 0) )
-#else
-    if ( m_aapucBS[iDir][uiAbsPartIdx] && (pcCUQ->getCbf( uiPartQ, TEXT_LUMA, pcCUQ->getTransformIdx(uiPartQ)) != 0 || pcCUP->getCbf( uiPartP, TEXT_LUMA, pcCUP->getTransformIdx(uiPartP) ) != 0) )
-#endif
+    {
       uiBs = 1;
 …
   }   // enf of "if( not Intra )"
+#if MERL_VSP_C0152
+  if ( pcCUP->getVSPIndex(uiPartP) || pcCUQ->getVSPIndex(uiPartQ))
+  {
+    uiBs = 0;
+  }
+#endif
   m_aapucBS[iDir][uiAbsPartIdx] = uiBs;
+}
 …
   UInt  uiPelsInPart = g_uiMaxCUWidth >> g_uiMaxCUDepth;
-#if !DBL_H0473_PART_1
-  UInt  PartIdxIncr = DEBLOCK_SMALLEST_BLOCK / uiPelsInPart ? DEBLOCK_SMALLEST_BLOCK / uiPelsInPart : 1;
-  UInt  uiBlocksInPart = uiPelsInPart / DEBLOCK_SMALLEST_BLOCK ? uiPelsInPart / DEBLOCK_SMALLEST_BLOCK : 1;
-#endif
   UInt  uiBsAbsIdx = 0, uiBs = 0;
   Int   iOffset, iSrcStep;
 …
+  }
-#if !DBL_H0473_PART_1
-  for ( UInt iIdx = 0; iIdx < uiNumParts; iIdx+=PartIdxIncr )
+  {
-    uiBs = 0;
-    for (UInt iIdxInside = 0; iIdxInside<PartIdxIncr; iIdxInside++)
+    {
-      uiBsAbsIdx = xCalcBsIdx( pcCU, uiAbsZorderIdx, iDir, iEdge, iIdx+iIdxInside);
-      if (uiBs < m_aapucBS[iDir][uiBsAbsIdx])
+      {
-        uiBs = m_aapucBS[iDir][uiBsAbsIdx];
+      }
+    }
-#else
   for ( UInt iIdx = 0; iIdx < uiNumParts; iIdx++ )
+  {
     uiBsAbsIdx = xCalcBsIdx( pcCU, uiAbsZorderIdx, iDir, iEdge, iIdx);
     uiBs = m_aapucBS[iDir][uiBsAbsIdx];
-#endif
     if ( uiBs )
+    {
 …
-#if !DBL_H0473_PART_1
-      for (UInt iBlkIdx = 0; iBlkIdx< uiBlocksInPart; iBlkIdx ++)
+      {
-        Int dp0 = xCalcDP( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+0), iOffset);
-        Int dq0 = xCalcDQ( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+0), iOffset);
-        Int dp3 = xCalcDP( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+3), iOffset);
-        Int dq3 = xCalcDQ( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+3), iOffset);
-        Int d0 = dp0 + dq0;
-        Int d3 = dp3 + dq3;
-        Int dp4 = xCalcDP( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+4), iOffset);
-        Int dq4 = xCalcDQ( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+4), iOffset);
-        Int dp7 = xCalcDP( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+7), iOffset);
-        Int dq7 = xCalcDQ( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+7), iOffset);
-        Int d4 = dp4 + dq4;
-        Int d7 = dp7 + dq7;
-#else
         Int dp0 = xCalcDP( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+0), iOffset);
         Int dq0 = xCalcDQ( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+0), iOffset);
 …
         Int dq = dq0 + dq3;
         Int d =  d0 + d3;
-#endif
         if (bPCMFilter)
 …
         bPartQNoFilter = bPartQNoFilter || (pcCU->isLosslessCoded(uiAbsZorderIdx) );
 #endif
-#if !DBL_H0473_PART_1
-        if (d0+d3 < iBeta)
+        {
-          Bool bFilterP = (dp0+dp3 < iSideThreshold);
-          Bool bFilterQ = (dq0+dq3 < iSideThreshold);
-          Bool sw =  xUseStrongFiltering( iOffset, 2*d0, iBeta, iTc , piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+0))
-          && xUseStrongFiltering( iOffset, 2*d3, iBeta, iTc , piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+3));
-#else
         if (d < iBeta)
+        {
 …
           Bool sw =  xUseStrongFiltering( iOffset, 2*d0, iBeta, iTc, piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+0))
                   && xUseStrongFiltering( iOffset, 2*d3, iBeta, iTc, piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+3));
-#endif
           for ( Int i = 0; i < DEBLOCK_SMALLEST_BLOCK/2; i++)
+          {
-#if !DBL_H0473_PART_1
-            xPelFilterLuma( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+i), iOffset, d0+d3, iBeta, iTc, sw, bPartPNoFilter, bPartQNoFilter, iThrCut, bFilterP, bFilterQ);
-#else
             xPelFilterLuma( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+i), iOffset, d, iBeta, iTc, sw, bPartPNoFilter, bPartQNoFilter, iThrCut, bFilterP, bFilterQ);
-#endif
+          }
+        }
-#if !DBL_H0473_PART_1
-        if (d4+d7 < iBeta)
+        {
-          Bool bFilterP = (dp4+dp7 < iSideThreshold);
-          Bool bFilterQ = (dq4+dq7 < iSideThreshold);
-          Bool sw =  xUseStrongFiltering( iOffset, 2*d4, iBeta, iTc , piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+4))
-          && xUseStrongFiltering( iOffset, 2*d7, iBeta, iTc , piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+7));
-          for ( Int i = DEBLOCK_SMALLEST_BLOCK/2; i < DEBLOCK_SMALLEST_BLOCK; i++)
+          {
-            xPelFilterLuma( piTmpSrc+iSrcStep*(iIdx*uiPelsInPart+iBlkIdx*DEBLOCK_SMALLEST_BLOCK+i), iOffset, d4+d7, iBeta, iTc, sw, bPartPNoFilter, bPartQNoFilter, iThrCut, bFilterP, bFilterQ);
+          }
+        }
+      }
-#endif
+    }
+  }
 …
   if (sw)
+  {
-#if DBL_STRONG_FILTER_CLIP
     piSrc[-iOffset]   = Clip3(m3-2*tc, m3+2*tc, ((m1 + 2*m2 + 2*m3 + 2*m4 + m5 + 4) >> 3));
     piSrc[0]          = Clip3(m4-2*tc, m4+2*tc, ((m2 + 2*m3 + 2*m4 + 2*m5 + m6 + 4) >> 3));
 …
     piSrc[-iOffset*3] = Clip3(m1-2*tc, m1+2*tc, ((2*m0 + 3*m1 + m2 + m3 + m4 + 4 )>>3));
     piSrc[ iOffset*2] = Clip3(m6-2*tc, m6+2*tc, ((m3 + m4 + m5 + 3*m6 + 2*m7 +4 )>>3));
-#else
-    piSrc[-iOffset] = ( m1 + 2*m2 + 2*m3 + 2*m4 + m5 + 4) >> 3;
-    piSrc[0] = ( m2 + 2*m3 + 2*m4 + 2*m5 + m6 + 4) >> 3;
-    piSrc[-iOffset*2] = ( m1 + m2 + m3 + m4 + 2)>>2;
-    piSrc[ iOffset] = ( m3 + m4 + m5 + m6 + 2)>>2;
-    piSrc[-iOffset*3] = ( 2*m0 + 3*m1 + m2 + m3 + m4 + 4 )>>3;
-    piSrc[ iOffset*2] = ( m3 + m4 + m5 + 3*m6 + 2*m7 +4 )>>3;
-#endif
+  }
   else

trunk/source/Lib/TLibCommon/TComLoopFilter.h

-                      r56
+                      r296
   /// set configuration
-#if DBL_CONTROL
   Void setCfg( Bool DeblockingFilterControlPresent, UInt uiDisableDblkIdc, Int betaOffsetDiv2, Int tcOffsetDiv2, Bool bLFCrossTileBoundary);
-#else
-  Void setCfg( UInt uiDisableDblkIdc, Int betaOffsetDiv2, Int tcOffsetDiv2, Bool bLFCrossTileBoundary);
-#endif
   /// picture-level deblocking filter

trunk/source/Lib/TLibCommon/TComMotionInfo.cpp

r189	r296
378	378
379	379	#if MTK_UNCONSTRAINED_MVI_B0083
380		Void TComCUMvField::setUndefinedMv( Int iPartAddr, Int iNumPart, Char* pePredMode, UChar* puhInterDir, Int refIdx, Int InterDir )
	380	Void TComCUMvField::setUndefinedMv( Int iPartAddr, Int iNumPart, Char* pePredMode, UChar* puhInterDir, Int refIdx, Int InterDir
	381	)
381	382	{
382	383	PredMode predMode = MODE_INTRA;
…	…
386	387	{
387	388	predMode = static_cast<PredMode>( pePredMode[ iPartAddr+i ] );
388		if( predMode~~==MODE_INTRA~~ )
	389	if( predMode == MODE_INTRA )
389	390	{
390	391	m_pcMv[iPartAddr+i] = cMv;

trunk/source/Lib/TLibCommon/TComMotionInfo.h

-                      r189
+                      r296
 // ====================================================================================================================
 #if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
 typedef struct _DisCand
+{
 …
   Int getHor   () const { return  m_acMv.getHor(); }
   Int getVer   () const { return  m_acMv.getVer(); }
 #if QC_MRG_CANS_B0048
+#if H3D_IVMP
   Bool operator== ( const TComMvField& rcMv ) const
+  {

trunk/source/Lib/TLibCommon/TComMv.h

-                      r189
+                      r296
 public:
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
   Bool  m_bDvMcp;       // is dv-mcp ?
   Int   m_iDvMcpDispX;  // disparity for dv-mcp
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Int   m_iDvMcpDispY;  // disparity for dv-mcp
+#endif
 #endif
 …
   m_iHor(0),
   m_iVer(0)
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
   , m_bDvMcp(false)
   , m_iDvMcpDispX(0)
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  , m_iDvMcpDispY(0)
+#endif
 #endif
+  {
 …
   m_iHor(iHor),
   m_iVer(iVer)
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
   , m_bDvMcp(false)
   , m_iDvMcpDispX(0)
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  , m_iDvMcpDispY(0)
+#endif
 #endif
+  {
 …
   const TComMv scaleMv( Int iScale ) const
+  {
-#if CLIPSCALEDMVP
     Int mvx = Clip3( -32768, 32767, (iScale * getHor() + 127 + (iScale * getHor() < 0)) >> 8 );
     Int mvy = Clip3( -32768, 32767, (iScale * getVer() + 127 + (iScale * getVer() < 0)) >> 8 );
     return TComMv( mvx, mvy );
-#else
-    return TComMv( (iScale * getHor() + 127 + (iScale * getHor() < 0)) >> 8, (iScale * getVer() + 127 + (iScale * getVer() < 0)) >> 8);
-#endif
+  }
 };// END CLASS DEFINITION TComMV

trunk/source/Lib/TLibCommon/TComPattern.cpp

-                      r189
+                      r296
 // ====================================================================================================================
-#if LOGI_INTRA_NAME_3MPM
 const UChar TComPattern::m_aucIntraFilter[5] =
+{
 …
 , //64x64
 };
-#else
-const UChar TComPattern::m_aucIntraFilter[5][NUM_INTRA_MODE] =
+{
-  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-  }, //4x4
-  {1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-  }, //8x8
-  {1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0
-  }, //16x16
-  {1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
-  }, //32x32
-  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-  }, //64x64
-};
-#endif
 // ====================================================================================================================
 …
   mapDMMtoIntraMode( uiDirMode );
 #endif
-#if LOGI_INTRA_NAME_3MPM
   Int diff = min<Int>(abs((Int) uiDirMode - HOR_IDX), abs((Int)uiDirMode - VER_IDX));
   UChar ucFiltIdx = diff > m_aucIntraFilter[log2BlkSize - 2] ? 1 : 0;
 …
     ucFiltIdx = 0; //no smoothing for DC or LM chroma
+  }
-#else
-  UChar ucFiltIdx = m_aucIntraFilter[log2BlkSize - 2][uiDirMode];
-#endif
   assert( ucFiltIdx <= 1 );

trunk/source/Lib/TLibCommon/TComPattern.h

-                      r189
+                      r296
 #endif
-#if LOGI_INTRA_NAME_3MPM
   static const UChar m_aucIntraFilter[5];
-#else
-  static const UChar m_aucIntraFilter[5][NUM_INTRA_MODE];
-#endif
 public:

trunk/source/Lib/TLibCommon/TComPic.cpp

-                      r210
+                      r296
 #endif
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   m_pcOrgDepthMap     = NULL;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_pcResidual        = NULL;
 #endif
 …
   m_pcUsedPelsMap     = NULL;
 #endif
 #if SONY_COLPIC_AVAILABILITY
   m_iViewOrderIdx     = 0;
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  m_iViewOrderIdx     = 0;    // will be changed to view_id
 #endif
   m_aaiCodedScale     = 0;
 …
   m_bReduceBitsQTL    = 0;
 #endif
 #if QC_SIMPLE_NBDV_B0047
+#if H3D_NBDV
   m_bRapCheck = false;
   m_eRapRefList = REF_PIC_LIST_0;
 …
 #endif
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   if( m_pcOrgDepthMap )
+  {
 …
+  }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   if( m_pcResidual )
+  {
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 Void
 TComPic::addOrgDepthMapBuffer()
 …
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TComPic::addResidualBuffer()
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 Void
 TComPic::removeOrgDepthMapBuffer()
 …
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TComPic::removeResidualBuffer()
 …
     m_pbValidSlice[s] = true;
+  }
-#if !LCU_SYNTAX_ALF
-  if( pSliceStartAddress == NULL || (numSlices == 1 && numTiles == 1) )
+  {
-    return;
+  }
-#endif
   m_pSliceSUMap = new Int[maxNumSUInLCU * numLCUInPic];
 …
+  }
+}
 #if QC_SIMPLE_NBDV_B0047
+#if H3D_NBDV
 Bool TComPic::getDisCandRefPictures(Int iColPOC)
+{

trunk/source/Lib/TLibCommon/TComPic.h

-                      r210
+                      r296
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   TComPicYuv*           m_pcOrgDepthMap;          //  original depth map
+#if QC_MULTI_DIS_CAN_A0097
+  Bool          m_checked;
+#endif
+#if QC_SIMPLE_NBDV_B0047
+#if H3D_NBDV
+  Bool        m_checked;
   UInt        m_uiRapRefIdx;
   RefPicList  m_eRapRefList;
 …
 #endif
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComPicYuv*           m_pcResidual;             //  residual buffer (coded or inter-view predicted residual)
 #endif
 …
   TComPicYuv*           m_pcUsedPelsMap;
 #endif
 #if SONY_COLPIC_AVAILABILITY
   Int                   m_iViewOrderIdx;
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Int                   m_iViewOrderIdx;    // will be changed to view_id
 #endif
   Int**                 m_aaiCodedScale;
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   TComPicYuv*   getOrgDepthMap()      { return  m_pcOrgDepthMap; }
 #if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
   Void          setCandPicCheckedFlag (Bool bchecked)   { m_checked = bchecked; }
   Bool          getCandPicCheckedFlag ()                { return m_checked;}
 …
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComPicYuv*   getResidual()         { return  m_pcResidual; }
 #endif
 #if QC_SIMPLE_NBDV_B0047
+#if H3D_NBDV
   UInt          getRapRefIdx()                         {return m_uiRapRefIdx;}
   RefPicList    getRapRefList()                        {return m_eRapRefList;}
 …
 #endif
 #if SONY_COLPIC_AVAILABILITY
   Void          setViewOrderIdx(Int i)                        { m_iViewOrderIdx = i; }
   Int           getViewOrderIdx()                             { return m_iViewOrderIdx; }
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Void          setViewOrderIdx(Int i)                        { m_iViewOrderIdx = i; }        // will be changed to view_id
+  Int           getViewOrderIdx()                             { return m_iViewOrderIdx; }    // will be changed to view_id
 #endif
 …
   Void          addPrdDepthMapBuffer    ( UInt uiSubSampExpX, UInt uiSubSampExpY );
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void          addOrgDepthMapBuffer    ();
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void          addResidualBuffer       ();
 #endif
 …
   Void          removePrdDepthMapBuffer ();
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void          removeOrgDepthMapBuffer ();
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void          removeResidualBuffer    ();
 #endif

trunk/source/Lib/TLibCommon/TComPicSym.h

-                      r56
+                      r296
   UInt        getNumPartInWidth()       { return m_uiNumPartInWidth;            }
   UInt        getNumPartInHeight()      { return m_uiNumPartInHeight;           }
-#if !REMOVE_TILE_DEPENDENCE
-  Void         setTileBoundaryIndependenceIdr( Int i )               { m_iTileBoundaryIndependenceIdr = i; }
-  Int          getTileBoundaryIndependenceIdr()                      { return m_iTileBoundaryIndependenceIdr; }
-#endif
   Void         setNumColumnsMinus1( Int i )                          { m_iNumColumnsMinus1 = i; }
   Int          getNumColumnsMinus1()                                 { return m_iNumColumnsMinus1; }

trunk/source/Lib/TLibCommon/TComPrediction.cpp

-                      r210
+                      r296
+{
   m_piYuvExt = NULL;
+#if MERL_VSP_C0152
+  m_pDepth = (Int*) malloc(64*64*sizeof(Int)); // TODO: Use a smart way to determine the size of the array
+  if (m_pDepth == NULL)
+  {
+      printf("ERROR: UKTGHU, No memory allocated.\n");
+  }
+#endif
+}
 …
+{
+#if MERL_VSP_C0152
+  if (m_pDepth != NULL)
+  {
+      free(m_pDepth);
+  }
+#endif
   delete[] m_piYuvExt;
 …
   // Map the mode index to main prediction direction and angle
-#if LOGI_INTRA_NAME_3MPM
   assert( dirMode > 0 ); //no planar
   Bool modeDC        = dirMode < 2;
 …
   Bool modeVer       = !modeDC && !modeHor;
   Int intraPredAngle = modeVer ? (Int)dirMode - VER_IDX : modeHor ? -((Int)dirMode - HOR_IDX) : 0;
-#else
-  Bool modeDC        = dirMode == 0;
-  Bool modeVer       = !modeDC && (dirMode < 18);
-  Bool modeHor       = !modeDC && !modeVer;
-  Int intraPredAngle = modeVer ? dirMode - 9 : modeHor ? dirMode - 25 : 0;
-#endif
   Int absAng         = abs(intraPredAngle);
   Int signAng        = intraPredAngle < 0 ? -1 : 1;
 …
         for (k=0;k<blkSize;k++)
+        {
-#if REMOVE_DIV_OPERATION
           pDst[k*dstStride] = Clip ( pDst[k*dstStride] + (( refSide[k+1] - refSide[0] ) >> 1) );
-#else
-          pDst[k*dstStride] = Clip ( pDst[k*dstStride] + ( refSide[k+1] - refSide[0] ) / 2 );
-#endif
+        }
+      }
 …
   else
+  {
-#if LOGI_INTRA_NAME_3MPM
     xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );
-#else
-    xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, g_aucAngIntraModeOrder[ uiDirMode ], bAbove, bLeft, true );
-#endif
     if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
 …
+  {
     // Create the prediction
-#if LOGI_INTRA_NAME_3MPM
     xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
-#else
-    xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, g_aucAngIntraModeOrder[ uiDirMode ], bAbove, bLeft, false );
-#endif
+  }
+}
 …
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
+#else
 Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
+#endif
+#else
+#if MERL_VSP_C0152
+Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx )
 #else
 Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx )
+#endif
 #endif
+{
 …
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
 #endif
+#endif
+      }
       else
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
+#endif
 #endif
+      }
 …
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
 #endif
+#endif
+      }
       else
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
+#else
         xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
 #else
         xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
+#endif
 #endif
+      }
 …
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
+#endif
+      }
+      else
+      {
+#endif
+#endif
+  }
+  else
+  {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
+#endif
+#endif
+#endif
+      }
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+      xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
       xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+      xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
 #else
       xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
+#endif
+#endif
+#endif
 #if LGE_ILLUCOMP_B0045
       if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
 #else
       if ( pcCU->getSlice()->getPPS()->getUseWP() )
+      if( pcCU->getSlice()->getPPS()->getUseWP())
 #endif
+      {
 …
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
 #else
         xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
+#endif
+#endif
+      }
+      else
+      {
+#if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
+#else
+        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
+#else
+        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
 #endif
+      }
+      else
+      {
+#endif
+      }
+    }
+  }
+  return;
+}
+#if MTK_MDIVRP_C0138
+Void TComPrediction::residualPrediction(TComDataCU* pcCU, TComYuv* pcYuvPred, TComYuv* pcYuvResPred)
+{
+  Int         iWidth;
+  Int         iHeight;
+  UInt        uiPartAddr;
+  pcCU->getPartIndexAndSize( 0, uiPartAddr, iWidth, iHeight );
+  Bool bResAvail = false;
+  bResAvail = pcCU->getResidualSamples( 0, true, pcYuvResPred );
+  assert (bResAvail);
+  pcYuvPred->add(pcYuvResPred, iWidth, iHeight);
+}
+#endif
 #if DEPTH_MAP_GENERATION
+        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
+#else
+        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
+#endif
+      }
+    }
+  }
+  return;
+}
+#if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
+#else
 Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
+#endif
+#else
+#if MERL_VSP_C0152
+Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi )
 #else
 Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi )
 #endif
+{
+#endif
+{
+#if MERL_VSP_C0152
+  Int  iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
+  Int  vspIdx  = pcCU->getVSPIndex(uiPartAddr);
+  if (vspIdx != 0)
+  {
+    if (iRefIdx >= 0)
+    {
+      printf("vspIdx = %d, iRefIdx = %d\n", vspIdx, iRefIdx);
+    }
+    assert (iRefIdx < 0); // assert (iRefIdx == NOT_VALID);
+  }
+  else
+  {
+    assert (iRefIdx >= 0);
+  }
+#else
   Int         iRefIdx     = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           assert (iRefIdx >= 0);
+  TComMv      cMv         = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
+#endif
+  TComMv cMv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
   pcCU->clipMv(cMv);
 …
   if( pcCU->getSlice()->getSPS()->isDepth() )
+  {
+    UInt uiRShift = ( bi ? 14-g_uiBitDepth-g_uiBitIncrement : 0 );
+    UInt uiOffset = bi ? IF_INTERNAL_OFFS : 0;
+#if MERL_VSP_C0152
+    if (vspIdx != 0)
+    { // depth, vsp
+      // get depth estimator here
+      TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
+      TComPicYuv* pcBaseViewDepthPicYuv = NULL;
+      if (vspIdx < 4) // spatial
+      {
+        pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
+      }
+      Int iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
+      Int iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
+      Int* pShiftLUT;
+      Int iShiftPrec;
+      pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
+      //using disparity to find the depth block of the base view as the depth block estimator of the current block
+      //using depth block estimator and base view texture to get Backward warping
+      xPredInterLumaBlkFromDM  ( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,     pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
+      xPredInterChromaBlkFromDM( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1,  pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
+    }
+    else
+    {
+#endif
+      UInt uiRShift = ( bi ? 14-g_uiBitDepth-g_uiBitIncrement : 0 );
+      UInt uiOffset = bi ? IF_INTERNAL_OFFS : 0;
+#if LGE_ILLUCOMP_DEPTH_C0046
+    Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
+#endif
 #if DEPTH_MAP_GENERATION
+    xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, 0, 0, rpcYuvPred, uiRShift, uiOffset );
+#else
+    xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, uiOffset );
+#endif
+    xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, 0, 0, rpcYuvPred, uiRShift, uiOffset
+#if LGE_ILLUCOMP_DEPTH_C0046
+        , bICFlag
+#endif
+        );
+#else
+      xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, uiOffset );
+#endif
+#if MERL_VSP_C0152
+    }
+#endif// MERL_VSP_C0152 //else
+  }
   else
+  {
 #endif
+#if MERL_VSP_C0152
+    if ( vspIdx != 0 )
+    { // texture, vsp
+      TComPic*    pRefPicBaseTxt        = pcCU->getSlice()->getRefPicBaseTxt();
+      TComPicYuv* pcBaseViewTxtPicYuv   = pRefPicBaseTxt->getPicYuvRec();
+      TComPicYuv* pcBaseViewDepthPicYuv = NULL;
+      if (vspIdx < 4) // spatial
+      {
+        TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
+        pcBaseViewDepthPicYuv     = pRefPicBaseDepth->getPicYuvRec();
+      }
+      Int iBlkX = ( pcCU->getAddr() % pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
+      Int iBlkY = ( pcCU->getAddr() / pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
+      Int* pShiftLUT;
+      Int iShiftPrec;
+      pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
+      //using disparity to find the depth block of the base view as the depth block estimator of the current block
+      //using depth block estimator and base view texture to get Backward warping
+      xPredInterLumaBlkFromDM  ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,    pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
+      xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
+    }
+    else//texture not VSP
+    {
+#endif //MERL_VSP_C0152
 #if LGE_ILLUCOMP_B0045
+    Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
+    xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag);
+#else
+  xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
+#endif
+      Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
+      xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag);
+#else
+      xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
+#endif
+#if MERL_VSP_C0152
+     } //texture not VSP
+#endif
 #if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
+  }
+#endif
+#if MERL_VSP_C0152
+  if ( vspIdx == 0 )//Not VSP
+  {
 #endif
 #if LGE_ILLUCOMP_B0045
 …
   xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
 #endif
+#if MERL_VSP_C0152
+   }
+#endif
+}
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
+#else
 Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
+#endif
+#else
+#if MERL_VSP_C0152
+Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred, Int iPartIdx )
 #else
 Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred, Int iPartIdx )
+#endif
 #endif
+{
 …
     iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
+#if MERL_VSP_C0152
+    if(!pcCU->getVSPIndex(uiPartAddr))
+    {
+      if ( iRefIdx[iRefList] < 0 )
+      {
+        continue;
+      }
+    }
+    else
+    {
+      if ( iRefList== REF_PIC_LIST_1 && iRefIdx[iRefList] < 0 ) // iRefIdx[iRefList] ==NOT_VALID
+      {
+        continue;
+      }
+    }
+#else
     if ( iRefIdx[iRefList] < 0 )
+    {
       continue;
+    }
+#endif
     assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
 …
+    {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+      xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#else
       xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#endif
+#else
+#if MERL_VSP_C0152
+      xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
 #else
       xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
 #endif
+#endif
+    }
     else
 …
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#else
         xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
 #else
         xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
 #endif
+#endif
+      }
       else
+      {
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#else
         xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
+#endif
+#else
+#if MERL_VSP_C0152
+        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, false );
 #else
         xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, false );
 #endif
+#endif
+      }
+    }
 …
   if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() )
+  {
+#if MERL_VSP_C0152
+    if(pcCU->getVSPIndex(uiPartAddr))
+      m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
+    else
+#endif
     xWeightedPredictionBi( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
+  }
 …
     else
+    {
+#if MERL_VSP_C0152
+      if(pcCU->getVSPIndex(uiPartAddr))
+        m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
+      else
+#endif
+      xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
+    }
+#else
     xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
+  }
+#else
+    xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
+#endif
+  }
+}
+#endif
+  }
+}
 Void
 #if DEPTH_MAP_GENERATION
+TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset )
+TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset
+#if LGE_ILLUCOMP_DEPTH_C0046
+, Bool bICFlag
+#endif
+)
 #else
 TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset )
 …
+    }
+  }
+#if LGE_ILLUCOMP_DEPTH_C0046
+  if(bICFlag)
+  {
+    Int a, b, iShift;
+    TComMv tTmpMV(pcMv->getHor()<<2, pcMv->getVer()<<2);
+    piRefY      = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr ) + iRefOffset;
+    piDstY      = rpcYuv->getLumaAddr( uiPartAddr );
+    xGetLLSICPrediction(pcCU, &tTmpMV, pcPicYuvRef, a, b, iShift);
+    for( Int y = 0; y < iHeight; y++, piDstY += iDstStride, piRefY += iRefStride )
+    {
+      for( Int x = 0; x < iWidth; x++ )
+      {
+        if(uiOffset)
+        {
+          Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
+          piDstY[ x ] = ( (a*piDstY[ x ]+a*IF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
+        }
+        else
+          piDstY[ x ] = Clip( ( (a*piDstY[ x ]) >> iShift ) + b );
+      }
+    }
+  }
+#endif
+}
 …
+}
+#if MERL_VSP_C0152
+// Input:
+// refPic: Ref picture. Full picture, with padding
+// posX, posY:     PU position, texture
+// size_x, size_y: PU size
+// partAddr: z-order index
+// mv: disparity vector. derived from neighboring blocks
+//
+// Output: dstPic, PU predictor 64x64
+Void TComPrediction::xPredInterLumaBlkFromDM( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv* mv, UInt partAddr,Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
+                                            , TComYuv *&dstPic )
+{
+  Int widthLuma;
+  Int heightLuma;
+  if (isDepth)
+  {
+    widthLuma   =  pPicBaseDepth->getWidth();
+    heightLuma  =  pPicBaseDepth->getHeight();
+  }
+  else
+  {
+    widthLuma   =  refPic->getWidth();
+    heightLuma  =  refPic->getHeight();
+  }
+#if MERL_VSP_BLOCKSIZE_C0152 != 1
+  Int widthDepth  = pPicBaseDepth->getWidth();
+  Int heightDepth = pPicBaseDepth->getHeight();
+#endif
+  Int nTxtPerDepthX = widthLuma  / ( pPicBaseDepth->getWidth() );  // texture pixel # per depth pixel
+  Int nTxtPerDepthY = heightLuma / ( pPicBaseDepth->getHeight() );
+  Int refStride = refPic->getStride();
+  Int dstStride = dstPic->getStride();
+  Int depStride =  pPicBaseDepth->getStride();
+  Int depthPosX = Clip3(0,   widthLuma - size_x - 1,  (posX/nTxtPerDepthX) + (mv->getHor()>>2));
+  Int depthPosY = Clip3(0,   heightLuma- size_y - 1,  (posY/nTxtPerDepthY) + (mv->getVer()>>2));
+  Pel *ref    = refPic->getLumaAddr() + posX + posY * refStride;
+  Pel *dst    = dstPic->getLumaAddr(partAddr);
+  Pel *depth  = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY * depStride;
+#if MERL_VSP_BLOCKSIZE_C0152 != 1
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+  Int  dW = size_x>>1;
+  Int  dH = size_y>>1;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+  Int  dW = size_x>>2;
+  Int  dH = size_y>>2;
+#endif
+  {
+    Pel* depthi = depth;
+    for (Int j = 0; j < dH; j++)
+    {
+      for (Int i = 0; i < dW; i++)
+      {
+        Pel* depthTmp;
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+        if (depthPosX + (i<<1) < widthDepth)
+          depthTmp = depthi + (i << 1);
+        else
+          depthTmp = depthi + (widthDepth - depthPosX - 1);
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+        if (depthPosX + (i<<2) < widthDepth)
+          depthTmp = depthi + (i << 2);
+        else
+          depthTmp = depthi + (widthDepth - depthPosX - 1);
+#endif
+        Int maxV = 0;
+        for (Int blockj = 0; blockj < MERL_VSP_BLOCKSIZE_C0152; blockj++)
+        {
+          Int iX = 0;
+          for (Int blocki = 0; blocki < MERL_VSP_BLOCKSIZE_C0152; blocki++)
+          {
+            if (maxV < depthTmp[iX])
+              maxV = depthTmp[iX];
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+            if (depthPosX + (i<<1) + blocki < widthDepth - 1)
+#else // MERL_VSP_BLOCKSIZE_C0152 == 4
+            if (depthPosX + (i<<2) + blocki < widthDepth - 1)
+#endif
+              iX++;
+          }
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+          if (depthPosY + (j<<1) + blockj < heightDepth - 1)
+#else // MERL_VSP_BLOCKSIZE_C0152 == 4
+          if (depthPosY + (j<<2) + blockj < heightDepth - 1)
+#endif
+            depthTmp += depStride;
+        }
+        m_pDepth[i+j*dW] = maxV;
+      } // end of i < dW
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+      if (depthPosY + ((j+1)<<1) < heightDepth)
+        depthi += (depStride << 1);
+      else
+        depthi  = depth + (heightDepth-depthPosY-1)*depStride;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+      if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
+        depthi += (depStride << 2);
+      else
+        depthi  = depth + (heightDepth-depthPosY-1)*depStride; // the last line
+#endif
+    }
+  }
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 != 1
+  Int yDepth = 0;
+#endif
+  for ( Int yTxt = 0; yTxt < size_y; yTxt += nTxtPerDepthY )
+  {
+    for ( Int xTxt = 0, xDepth = 0; xTxt < size_x; xTxt += nTxtPerDepthX, xDepth++ )
+    {
+      Pel rep_depth = 0; // to store the depth value used for warping
+#if MERL_VSP_BLOCKSIZE_C0152 == 1
+      rep_depth = depth[xDepth];
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+      rep_depth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+      rep_depth = m_pDepth[(xTxt>>2) + (yTxt>>2)*dW];
+#endif
+      assert( rep_depth >= 0 && rep_depth <= 255 );
+      Int disparity = pShiftLUT[ rep_depth ] << iShiftPrec;
+      Int refOffset = xTxt + (disparity >> 2);
+      Int xFrac = disparity & 0x3;
+      Int absX  = posX + refOffset;
+      if (xFrac == 0)
+        absX = Clip3(0, widthLuma-1, absX);
+      else
+        absX = Clip3(4, widthLuma-5, absX);
+      refOffset = absX - posX;
+      assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
+      m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true );
+    }
+    ref   += refStride*nTxtPerDepthY;
+    dst   += dstStride*nTxtPerDepthY;
+    depth += depStride;
+#if MERL_VSP_BLOCKSIZE_C0152 != 1
+    yDepth++;
+#endif
+  }
+}
+Void TComPrediction::xPredInterChromaBlkFromDM ( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv*mv, UInt partAddr, Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
+                                               , TComYuv *&dstPic )
+{
+  Int refStride = refPic->getCStride();
+  Int dstStride = dstPic->getCStride();
+  Int depStride = pPicBaseDepth->getStride();
+  Int widthChroma, heightChroma;
+  if( isDepth)
+  {
+     widthChroma   = pPicBaseDepth->getWidth()>>1;
+     heightChroma  = pPicBaseDepth->getHeight()>>1;
+  }
+  else
+  {
+     widthChroma   = refPic->getWidth()>>1;
+     heightChroma  = refPic->getHeight()>>1;
+  }
+  // Below is only for Texture chroma component
+  Int widthDepth  = pPicBaseDepth->getWidth();
+  Int heightDepth = pPicBaseDepth->getHeight();
+  Int nTxtPerDepthX, nTxtPerDepthY;  // Number of texture samples per one depth sample
+  Int nDepthPerTxtX, nDepthPerTxtY;  // Number of depth samples per one texture sample
+  Int depthPosX;  // Starting position in depth image
+  Int depthPosY;
+  if ( widthChroma > widthDepth )
+  {
+    nTxtPerDepthX = widthChroma / widthDepth;
+    nDepthPerTxtX = 1;
+    depthPosX = posX / nTxtPerDepthX + (mv->getHor()>>2);        //mv denotes the disparity for VSP
+  }
+  else
+  {
+    nTxtPerDepthX = 1;
+    nDepthPerTxtX = widthDepth / widthChroma;
+    depthPosX = posX * nDepthPerTxtX + (mv->getHor()>>2);        //mv denotes the disparity for VSP
+  }
+  depthPosX = Clip3(0, widthDepth - (size_x<<1) - 1, depthPosX);
+  if ( heightChroma > heightDepth )
+  {
+    nTxtPerDepthY = heightChroma / heightDepth;
+    nDepthPerTxtY = 1;
+    depthPosY = posY / nTxtPerDepthY + (mv->getVer()>>2);     //mv denotes the disparity for VSP
+  }
+  else
+  {
+    nTxtPerDepthY = 1;
+    nDepthPerTxtY = heightDepth / heightChroma;
+    depthPosY = posY * nDepthPerTxtY + (mv->getVer()>>2);     //mv denotes the disparity for VSP
+  }
+  depthPosY = Clip3(0, heightDepth - (size_y<<1) - 1, depthPosY);
+  Pel *refCb  = refPic->getCbAddr() + posX + posY * refStride;
+  Pel *refCr  = refPic->getCrAddr() + posX + posY * refStride;
+  Pel *dstCb  = dstPic->getCbAddr(partAddr);
+  Pel *dstCr  = dstPic->getCrAddr(partAddr);
+  Pel *depth  = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY * depStride;  // move the pointer to the current depth pixel position
+  Int refStrideBlock = refStride * nTxtPerDepthY;
+  Int dstStrideBlock = dstStride * nTxtPerDepthY;
+  Int depStrideBlock = depStride * nDepthPerTxtY;
+  if (isDepth)
+  {
+     // DT: Since the call for this function is redundant, ..
+     for (Int y = 0; y < size_y; y++)
+     {
+       for (Int x = 0; x < size_x; x++)
+       {
+         dstCb[x] = 128;
+         dstCr[x] = 128;
+       }
+       dstCb += dstStride;
+       dstCr += dstStride;
+     }
+     return;
+  }
+  if ( widthChroma > widthDepth ) // We assume
+  {
+    assert( heightChroma > heightDepth );
+    printf("This branch should never been reached.\n");
+    exit(0);
+  }
+  else
+  {
+#if MERL_VSP_BLOCKSIZE_C0152 == 1
+  Int  dW = size_x;
+  Int  dH = size_y;
+  Int  sW = 2; // search window size
+  Int  sH = 2;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+  Int  dW = size_x;
+  Int  dH = size_y;
+  Int  sW = 2; // search window size
+  Int  sH = 2;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+  Int  dW = size_x>>1;
+  Int  dH = size_y>>1;
+  Int  sW = 4; // search window size
+  Int  sH = 4;
+#endif
+  {
+    Pel* depthi = depth;
+    for (Int j = 0; j < dH; j++)
+    {
+      for (Int i = 0; i < dW; i++)
+      {
+        Pel* depthTmp;
+#if MERL_VSP_BLOCKSIZE_C0152 == 1
+        depthTmp = depthi + (i << 1);
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+        if (depthPosX + (i<<1) < widthDepth)
+          depthTmp = depthi + (i << 1);
+        else
+          depthTmp = depthi + (widthDepth - depthPosX - 1);
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+        if (depthPosX + (i<<2) < widthDepth)
+          depthTmp = depthi + (i << 2);
+        else
+          depthTmp = depthi + (widthDepth - depthPosX - 1);
+#endif
+        Int maxV = 0;
+        for (Int blockj = 0; blockj < sH; blockj++)
+        {
+          Int iX = 0;
+          for (Int blocki = 0; blocki < sW; blocki++)
+          {
+            if (maxV < depthTmp[iX])
+              maxV = depthTmp[iX];
+            if (depthPosX + i*sW + blocki < widthDepth - 1)
+              iX++;
+          }
+          if (depthPosY + j*sH + blockj < heightDepth - 1)
+            depthTmp += depStride;
+        }
+        m_pDepth[i+j*dW] = maxV;
+      } // end of i < dW
+#if MERL_VSP_BLOCKSIZE_C0152 == 1
+      if (depthPosY + ((j+1)<<1) < heightDepth)
+        depthi += (depStride << 1);
+      else
+        depthi  = depth + (heightDepth-1)*depStride;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+      if (depthPosY + ((j+1)<<1) < heightDepth)
+        depthi += (depStride << 1);
+      else
+        depthi  = depth + (heightDepth-depthPosY-1)*depStride;
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+      if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
+        depthi += (depStride << 2);
+      else
+        depthi  = depth + (heightDepth-depthPosY-1)*depStride; // the last line
+#endif
+    }
+  }
+    // (size_x, size_y) is Chroma block size
+    for ( Int yTxt = 0, yDepth = 0; yTxt < size_y; yTxt += nTxtPerDepthY, yDepth += nDepthPerTxtY )
+    {
+      for ( Int xTxt = 0, xDepth = 0; xTxt < size_x; xTxt += nTxtPerDepthX, xDepth += nDepthPerTxtX )
+      {
+        Pel rep_depth = 0; // to store the depth value used for warping
+#if MERL_VSP_BLOCKSIZE_C0152 == 1
+        rep_depth = m_pDepth[(xTxt) + (yTxt)*dW];
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 2
+        rep_depth = m_pDepth[(xTxt) + (yTxt)*dW];
+#endif
+#if MERL_VSP_BLOCKSIZE_C0152 == 4
+        rep_depth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
+#endif
+      // calculate the offset in the reference picture
+        Int disparity = pShiftLUT[ rep_depth ] << iShiftPrec;
+        Int refOffset = xTxt + (disparity >> 3); // in integer pixel in chroma image
+        Int xFrac = disparity & 0x7;
+        Int absX  = posX + refOffset;
+        if (xFrac == 0)
+          absX = Clip3(0, widthChroma-1, absX);
+        else
+          absX = Clip3(4, widthChroma-5, absX);
+        refOffset = absX - posX;
+        assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
+        assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
+        m_if.filterHorChroma(&refCb[refOffset], refStride, &dstCb[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
+        m_if.filterHorChroma(&refCr[refOffset], refStride, &dstCr[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
+      }
+      refCb += refStrideBlock;
+      refCr += refStrideBlock;
+      dstCb += dstStrideBlock;
+      dstCr += dstStrideBlock;
+      depth += depStrideBlock;
+    }
+  }
+}
+#endif // MERL_VSP_C0152
 #if DEPTH_MAP_GENERATION
 Void TComPrediction::xWeightedAveragePdm( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst, UInt uiSubSampExpX, UInt uiSubSampExpY )
 …
   iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
   iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
+#if FIX_LGE_ILLUCOMP_B0045
+  iRefX   = iCUPelX + (pMv->getHor() >> 2);
+  iRefY   = iCUPelY + (pMv->getVer() >> 2);
+#else
   iRefX   = iCUPelX + (pMv->getHor() >> 3);
   iRefY   = iCUPelY + (pMv->getVer() >> 3);
+#endif
   uiWidth = pcCU->getWidth(0) >> 1;
   uiHeight = pcCU->getHeight(0) >> 1;
 …
   UInt  uiWedgeStride   = pcWedgelet->getStride();
+#if HS_REFERENCE_SUBSAMPLE_C0154
+  Int subSamplePix;
+  if ( pcWedgelet->getWidth() == 32 )
+  {
+    subSamplePix = 2;
+  }
+  else
+  {
+    subSamplePix = 1;
+  }
+#endif
   if( bAbove )
+  {
+#if HS_REFERENCE_SUBSAMPLE_C0154
+    for( Int k = 0; k < pcWedgelet->getWidth(); k+=subSamplePix )
+#else
     for( Int k = 0; k < pcWedgelet->getWidth(); k++ )
+#endif
+    {
       if( true == pabWedgePattern[k] )
 …
   if( bLeft )
+  {
+#if HS_REFERENCE_SUBSAMPLE_C0154
+    for( Int k = 0; k < pcWedgelet->getHeight(); k+=subSamplePix )
+#else
     for( Int k = 0; k < pcWedgelet->getHeight(); k++ )
+#endif
+    {
       if( true == pabWedgePattern[k*uiWedgeStride] )
 …
+}
+#if LGE_DMM3_SIMP_C0044
+/**
+ - fetch best Wedgelet pattern at decoder
+ */
+UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt IntraTabIdx)
+{
+  assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
+  UInt          uiBestTabIdx = 0;
+  TComPic*      pcPicTex = pcCU->getSlice()->getTexturePic();
+  TComDataCU*   pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
+  UInt          uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
+  Int           uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
+  std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
+  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
+  {
+    std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
+    uiBestTabIdx    =   pauiWdgLst->at(IntraTabIdx);
+  }
+  else
+  {
+    WedgeNodeList* pacWedgeNodeList = &g_aacWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
+    uiBestTabIdx = pacWedgeNodeList->at(IntraTabIdx).getPatternIdx();
+  }
+  return uiBestTabIdx;
+}
+#endif
+#if LGE_DMM3_SIMP_C0044
+/**
+ - calculate best Wedgelet pattern at encoder
+ */
+UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Pel* piOrigi, UInt uiStride, UInt & ruiIntraTabIdx)
+#else
 UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight )
+#endif
+{
   assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
 …
   Int  iDC2 = 0;
   WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiWidth])];
+#if HHIQC_DMMFASTSEARCH_B0039
+#if LGE_DMM3_SIMP_C0044
+  ruiIntraTabIdx  = 0;
+#endif
   TComPic*      pcPicTex = pcCU->getSlice()->getTexturePic();
   TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
 …
+    {
       UInt uiIdx     =   pauiWdgLst->at(uiIdxW);
+#if LGE_DMM3_SIMP_C0044
+      calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piOrigi,   uiWidth,      iDC1, iDC2 );
+#else
       calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piRefBlkY, uiWidth,      iDC1, iDC2 );
+#endif
       assignWedgeDCs2Pred( &(pacWedgeList->at(uiIdx)), piPred,    uiPredStride, iDC1, iDC2 );
+#if LGE_DMM3_SIMP_C0044
+      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
+#else
       UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
+#endif
       if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
 …
         uiBestDist   = uiActDist;
         uiBestTabIdx = uiIdx;
+#if LGE_DMM3_SIMP_C0044
+        ruiIntraTabIdx = uiIdxW;
+#endif
+      }
+    }
 …
     for( UInt uiNodeId = 0; uiNodeId < pacWedgeNodeList->size(); uiNodeId++ )
+    {
+#if LGE_DMM3_SIMP_C0044
+      calcWedgeDCs       ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piOrigi, uiWidth,      iDC1, iDC2 );
+#else
       calcWedgeDCs       ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piRefBlkY, uiWidth,      iDC1, iDC2 );
+#endif
       assignWedgeDCs2Pred( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piPred,    uiPredStride, iDC1, iDC2 );
+#if LGE_DMM3_SIMP_C0044
+      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
+#else
       UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
+#endif
       if( uiActDist < uiBestNodeDist || uiBestNodeDist == MAX_UINT )
 …
         uiBestNodeDist = uiActDist;
         uiBestNodeId   = uiNodeId;
+      }
+    }
+#if LGE_DMM3_SIMP_C0044
+        ruiIntraTabIdx = uiNodeId;
+#endif
+      }
+    }
+#if LGE_DMM3_SIMP_C0044
+    uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
+#else
     // refinement
     uiBestDist   = uiBestNodeDist;
 …
+      }
+    }
+  }
+#else
+  for( UInt uiIdx = 0; uiIdx < pacWedgeList->size(); uiIdx++ )
+  {
+    calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piRefBlkY, uiWidth,      iDC1, iDC2 );
+    assignWedgeDCs2Pred( &(pacWedgeList->at(uiIdx)), piPred,    uiPredStride, iDC1, iDC2 );
+    UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
+    if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
+    {
+      uiBestDist   = uiActDist;
+      uiBestTabIdx = uiIdx;
+    }
+  }
+#endif
+#endif
+  }
   cPredYuv.destroy();
 …
+  {
     // decoder: get and store wedge pattern in CU
+      // decoder: get and store wedge pattern in CU
+#if LGE_DMM3_SIMP_C0044
+    UInt uiIntraTabIdx   = pcCU->getWedgePredTexIntraTabIdx ( uiAbsPartIdx );
+    uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, uiIntraTabIdx );
+#else
     uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight );
+#endif
     UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
 …
   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
+#if HHI_DMM_DELTADC_Q1_C0034
+#else
   if( bDelta )
+  {
 …
     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
+  }
+#endif
   // assign wedge pred DCs to prediction
 …
   getWedgePredDCs( pcContourWedge, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
+#if HHI_DMM_DELTADC_Q1_C0034
+#else
   if( bDelta )
+  {
 …
     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
+  }
+#endif
   // assign wedge pred DCs to prediction
 …
   delete pcContourWedge;
+}
 #endif
+#endif // HHI_DMM_PRED_TEX
 #if HHI_DMM_WEDGE_INTRA
 …
   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
+#if HHI_DMM_DELTADC_Q1_C0034
+#else
   if( bDelta )
+  {
 …
     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
+  }
+#endif
   // assign wedge pred DCs to prediction
 …
   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
+#if HHI_DMM_DELTADC_Q1_C0034
+#else
   if( bDelta )
+  {
 …
     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
+  }
+#endif
   // assign wedge pred DCs to prediction
 …
   // 2nd step: derive wedge direction
-#if LOGI_INTRA_NAME_3MPM
   Int uiPreds[3] = {-1, -1, -1};
-#else
-  Int uiPreds[2] = {-1, -1};
-#endif
   Int iMode = -1;
   Int iPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds, &iMode );
   UInt uiDirMode = 0;
-#if LOGI_INTRA_NAME_3MPM
   if( iMode >= 0 ) { iPredNum = iMode; }
   if( iPredNum == 1 ) { uiDirMode = uiPreds[0]; }
 …
   Bool modeVer       = !modeHor;
   Int intraPredAngle = modeVer ? (Int)uiDirMode - VER_IDX : modeHor ? -((Int)uiDirMode - HOR_IDX) : 0;
-#else
-  if( iPredNum == 1 ) { uiDirMode = g_aucAngIntraModeOrder[uiPreds[0]]; }
-  if( iPredNum == 2 ) { uiDirMode = g_aucAngIntraModeOrder[uiPreds[1]]; }
-  if( uiDirMode == 0 ) {  return false; } // no DC
-  Bool modeVer       = (uiDirMode < 18);
-  Bool modeHor       = !modeVer;
-  Int intraPredAngle = modeVer ? uiDirMode - 9 : modeHor ? uiDirMode - 25 : 0;
-#endif
   Int absAng         = abs(intraPredAngle);
   Int signAng        = intraPredAngle < 0 ? -1 : 1;
 …
   Int*  ptrSrc  = pcTComPattern->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
   Int   sw      = ( iWidth<<1 ) + 1;
-#if !LOGI_INTRA_NAME_3MPM
-  uiDirMode     = g_aucAngIntraModeOrder[ uiDirMode ];
-#endif
   xPredIntraAngDepth( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode );
+}

trunk/source/Lib/TLibCommon/TComPrediction.h

-                      r210
+                      r296
   UInt   m_uiaShift[ 63 ];       // Table for multiplication to substitue of division operation
+#if MERL_VSP_C0152
+  Int*   m_pDepth; ///< Local variable, to store a depth block, just to prevent allocate memory every time
+#endif
   Void xPredIntraAng            ( Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, UInt width, UInt height, UInt dirMode, Bool blkAboveAvailable, Bool blkLeftAvailable, Bool bFilter );
   Void xPredIntraPlanar         ( Int* pSrc, Int srcStride, Pel* rpDst, Int dstStride, UInt width, UInt height );
 …
   // motion compensation functions
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,       UInt uiAbsPartIdx,        Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX = 0, UInt uiSubSampExpY = 0, Bool bi=false );
+#else
   Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX = 0, UInt uiSubSampExpY = 0, Bool bi=false );
+#endif
+#else
+#if MERL_VSP_C0152
+  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,       UInt uiAbsPartIdx,        Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi=false          );
 #else
   Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi=false          );
 #endif
+#if DEPTH_MAP_GENERATION
+#endif
+#if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+  Void xPredInterBi             ( TComDataCU* pcCU,                          UInt uiPartAddr,       UInt uiAbsPartIdx,   Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap );
+#else
   Void xPredInterBi             ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap );
+  Void xPredInterPrdDepthMap    ( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset );
+#endif
+  Void xPredInterPrdDepthMap    ( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset
+#if LGE_ILLUCOMP_DEPTH_C0046
+      , Bool bICFlag = false
+#endif
+      );
+#else
+#if MERL_VSP_C0152
+  Void xPredInterBi             ( TComDataCU* pcCU,                          UInt uiPartAddr,     UInt uiAbsPartIdx,     Int iWidth, Int iHeight,                         TComYuv*& rpcYuvPred, Int iPartIdx          );
 #else
   Void xPredInterBi             ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight,                         TComYuv*& rpcYuvPred, Int iPartIdx          );
+#endif
   Void xPredInterPrdDepthMap    ( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight,                         TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset );
+#endif
+#if MERL_VSP_C0152
+  Void xPredInterUniBWVSP         ( TComDataCU* pcCU,                          UInt uiPartAddr, UInt uiAbsPartIdx,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi=false );
+  Void xPredInterBiBWVSP          ( TComDataCU* pcCU,                          UInt uiPartAddr, UInt uiAbsPartIdx,               Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap );
 #endif
 …
 #endif
   Void xWeightedAverage         ( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst );
+#if MERL_VSP_C0152
+  Void xPredInterLumaBlkFromDM    ( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv *mv, UInt partAddr,Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
+                                  , TComYuv *&dstPic );
+  Void xPredInterChromaBlkFromDM  ( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv *mv, UInt partAddr,Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
+                                  , TComYuv *&dstPic );
+#endif
   Void xGetLLSPrediction ( TComPattern* pcPattern, Int* pSrc0, Int iSrcStride, Pel* pDst0, Int iDstStride, UInt uiWidth, UInt uiHeight, UInt uiExt0 );
 #if LGE_ILLUCOMP_B0045
 …
   // inter
 #if DEPTH_MAP_GENERATION
+#if MERL_VSP_C0152
+  Void motionCompensation         ( TComDataCU*  pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList = REF_PIC_LIST_X, Int iPartIdx = -1, Bool bPrdDepthMap = false, UInt uiSubSampExpX = 0, UInt uiSubSampExpY = 0 );
+#else
   Void motionCompensation         ( TComDataCU*  pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList = REF_PIC_LIST_X, Int iPartIdx = -1, Bool bPrdDepthMap = false, UInt uiSubSampExpX = 0, UInt uiSubSampExpY = 0 );
+#endif
+#else
+#if MERL_VSP_C0152
+  Void motionCompensation         ( TComDataCU*  pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx,, RefPicList eRefPicList = REF_PIC_LIST_X, Int iPartIdx = -1 );
 #else
   Void motionCompensation         ( TComDataCU*  pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList = REF_PIC_LIST_X, Int iPartIdx = -1 );
 #endif
+#endif
+#if MTK_MDIVRP_C0138
+  Void residualPrediction         (TComDataCU* pcCU, TComYuv* pcYuvPred, TComYuv* pcYuvResPred);
+#endif
   // motion vector prediction
   Void getMvPredAMVP              ( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred );
 …
 #if HHI_DMM_PRED_TEX
   Void  getBestContourFromTex   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge );
+#if LGE_DMM3_SIMP_C0044
+  UInt  getBestWedgeFromTex     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Pel * piOrgi, UInt uiStride, UInt &ruiIntraTabIdx);//encoder
+  UInt  getBestWedgeFromTex     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt IntraTabIdx);//decoder
+#else
   UInt  getBestWedgeFromTex     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight );
+#endif
   Void  copyTextureLumaBlock    ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight );
 #endif

trunk/source/Lib/TLibCommon/TComRdCost.cpp

r189	r296
181	181	}
182	182
183		#if H~~HI_INTER_VIEW_MOTION_PRED~~
	183	#if H3D_IVMP
184	184	Void
185	185	TComRdCost::setLambdaMVReg( Double dLambda )

trunk/source/Lib/TLibCommon/TComRdCost.h

r189	r296
203	203	#endif
204	204	Void setLambda ( Double dLambda );
205		#if H~~HI_INTER_VIEW_MOTION_PRED~~
	205	#if H3D_IVMP
206	206	Void setLambdaMVReg ( Double dLambda );
207	207	#endif

trunk/source/Lib/TLibCommon/TComResidualGenerator.cpp

-                      r189
+                      r296
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 …
   AOF  ( pcPic );
+#if MTK_MDIVRP_C0138
+  if (pcPic->getSPS()->getViewId() != 0)
+  {
+    return;
+  }
+#endif
   if( pcPic->getPOC() == 0 )
+  {
 …
+}
+#if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
 Bool
+TComResidualGenerator::getResidualSamples( TComDataCU* pcCU, UInt uiPUIdx, TComYuv* pcYuv, Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+  , Bool bRecon
+#endif
+ )
+TComResidualGenerator::getResidualSamples( TComDataCU* pcCU, UInt uiPUIdx, TComYuv* pcYuv, TComMv iDisp, Bool bRecon  )
 #else
 Bool
 TComResidualGenerator::getResidualSamples( TComDataCU* pcCU, UInt uiPUIdx, TComYuv* pcYuv
 #if QC_SIMPLIFIEDIVRP_M24938
+  , Bool bRecon
+#endif
+  )
 #endif
+TComResidualGenerator::getResidualSamples( TComDataCU* pcCU, UInt uiPUIdx, TComYuv* pcYuv, Int iDisp, Bool bRecon  )
+#endif
+#else
+Bool
+TComResidualGenerator::getResidualSamples( TComDataCU* pcCU, UInt uiPUIdx, TComYuv* pcYuv, Bool bRecon )
+#endif //H3D_NBDV
+{
   AOF(  pcCU );
 …
   iBlkHeight  = pcCU->getHeight ( 0 );
   pcCU->getPic()->getPicYuvRec()->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iXPos, iYPos );
+#if QC_MULTI_DIS_CAN_A0097
+  return getResidualSamples( pcCU->getPic(), (UInt)iXPos, (UInt)iYPos, (UInt)iBlkWidth, (UInt)iBlkHeight, pcYuv, iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+    , bRecon
+#endif
+  );
+#else
+  return getResidualSamples( pcCU->getPic(), (UInt)iXPos, (UInt)iYPos, (UInt)iBlkWidth, (UInt)iBlkHeight, pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , bRecon
+#endif
+    );
+#endif
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  return getResidualSamples( pcCU->getPic(), (UInt)iXPos, (UInt)iYPos, (UInt)iBlkWidth, (UInt)iBlkHeight, pcYuv, iDisp, bRecon);
+#else
+  return getResidualSamples( pcCU->getPic(), (UInt)iXPos, (UInt)iYPos, (UInt)iBlkWidth, (UInt)iBlkHeight, pcYuv, iDisp, bRecon);
+#endif
+#else
+  return getResidualSamples( pcCU->getPic(), (UInt)iXPos, (UInt)iYPos, (UInt)iBlkWidth, (UInt)iBlkHeight, pcYuv, bRecon);
+#endif // H3D_NBDV
+}
+#if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
 Bool
+TComResidualGenerator::getResidualSamples( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+  , Bool bRecon
+#endif
+)
+TComResidualGenerator::getResidualSamples( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, TComMv iDisp, Bool bRecon)
 #else
 Bool
+TComResidualGenerator::getResidualSamples( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+  , Bool bRecon
+#endif
+  )
+#endif
+{
+TComResidualGenerator::getResidualSamples( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Int iDisp, Bool bRecon)
+#endif
+#else
+Bool
+TComResidualGenerator::getResidualSamples( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Bool bRecon)
+#endif
+{
+#if MTK_C0138_FIXED
+  UInt  uiBaseViewId  = 0;
+#else
   UInt  uiBaseViewId  = m_pcDepthMapGenerator->getBaseViewId( 0 );
+#endif
   if( !pcYuv )
+  {
     pcYuv = m_ppcYuvTmp[1];
+  }
-#if QC_SIMPLIFIEDIVRP_M24938
   UInt uiXPosInRefView = uiXPos , uiYPosInRefView = uiYPos;
+#endif
+#if QC_MULTI_DIS_CAN_A0097
+  xSetPredResidualBlock( pcPic, uiBaseViewId, uiXPos, uiYPos, uiBlkWidth, uiBlkHeight, pcYuv, iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+    , &uiXPosInRefView , &uiYPosInRefView , bRecon
+#endif
+  );
+#else
+  xSetPredResidualBlock( pcPic, uiBaseViewId, uiXPos, uiYPos, uiBlkWidth, uiBlkHeight, pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , &uiXPosInRefView , &uiYPosInRefView , bRecon
+#endif
+    );
+#endif
+#if QC_SIMPLIFIEDIVRP_M24938
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  xSetPredResidualBlock( pcPic, uiBaseViewId, uiXPos, uiYPos, uiBlkWidth, uiBlkHeight, pcYuv, iDisp, &uiXPosInRefView , &uiYPosInRefView , bRecon  );
+#else
+  xSetPredResidualBlock( pcPic, uiBaseViewId, uiXPos, uiYPos, uiBlkWidth, uiBlkHeight, pcYuv, iDisp, &uiXPosInRefView , &uiYPosInRefView , bRecon  );
+#endif
+#else
+  xSetPredResidualBlock( pcPic, uiBaseViewId, uiXPos, uiYPos, uiBlkWidth, uiBlkHeight, pcYuv, &uiXPosInRefView , &uiYPosInRefView , bRecon    );
+#endif
+#if MTK_MDIVRP_C0138
+  return true;
+#else
   return xIsNonZeroByCBF( uiBaseViewId , uiXPosInRefView , uiYPosInRefView , uiBlkWidth , uiBlkHeight );
+#else
+  return xIsNonZero( pcYuv, uiBlkWidth, uiBlkHeight );
+#endif
+}
+#if QC_SIMPLIFIEDIVRP_M24938
+#endif
+}
 Bool TComResidualGenerator::xIsNonZeroByCBF( UInt uiBaseViewId , UInt uiXPos , UInt uiYPos, UInt uiBlkWidth , UInt uiBlkHeight )
+{
 …
   return( false );
+}
-#endif
 …
   Pel*    pRes      = pcCUResidual->getLumaAddr();
   UInt    uiLumaTrMode, uiChromaTrMode;
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766  && !MTK_MDIVRP_C0138
   Int     iPUPredResiShift[4];
 #endif
   pcCU->convertTransIdx             ( 0, pcCU->getTransformIdx( 0 ), uiLumaTrMode, uiChromaTrMode );
-#if H0736_AVC_STYLE_QP_RANGE
     m_pcTrQuant->setQPforQuant      ( pcCU->getQP( 0 ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
-#else
-    m_pcTrQuant->setQPforQuant      ( pcCU->getQP( 0 ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
-#endif
   m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_LUMA, pRes, 0, pcCUResidual->getStride(), uiWidth, uiHeight, uiLumaTrMode, 0, piCoeff );
   // chroma Cb
 …
   piCoeff     = pcCU->getCoeffCb();
   pRes        = pcCUResidual->getCbAddr();
-#if H0736_AVC_STYLE_QP_RANGE
     m_pcTrQuant->setQPforQuant      ( pcCU->getQP( 0 ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
-#else
-    m_pcTrQuant->setQPforQuant      ( pcCU->getQP( 0 ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC() );
-#endif
   m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_U, pRes, 0, pcCUResidual->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
   // chroma Cr
 …
   m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_V, pRes, 0, pcCUResidual->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
+#if !MTK_MDIVRP_C0138
   if( pcCU->getResPredFlag( 0 ) )
+  {
     AOF( pcCU->getResPredAvail( 0 ) );
+    Bool bOK = pcCU->getResidualSamples( 0,
+#if QC_SIMPLIFIEDIVRP_M24938
+      true,
+#endif
+      m_ppcYuvTmp[0] );
+    Bool bOK = pcCU->getResidualSamples( 0, true, m_ppcYuvTmp[0] );
     AOF( bOK );
 #if LG_RESTRICTEDRESPRED_M24766
 …
 #endif
+  }
+#endif
   //===== clear inter-view predicted parts =====
 …
+#if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+Void
+TComResidualGenerator::xSetPredResidualBlock( TComPic* pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, TComMv iDisp
+                                             ,UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon )
+#else // MTK_RELEASE_DV_CONSTRAINT_C0129
 Void
 TComResidualGenerator::xSetPredResidualBlock( TComPic* pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+  , UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon
+#endif
+)
+#else
+                                             ,UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon)
+#endif // MTK_RELEASE_DV_CONSTRAINT_C0129
+#else // H3D_NBDV
 Void
 TComResidualGenerator::xSetPredResidualBlock( TComPic* pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+  , UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon
+#endif
+  )
+#endif
+                                             , UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon  )
+#endif // H3D_NBDV
+{
   //===== set and check some basic variables =====
 …
   //===== get disparity =====
+#if QC_MULTI_DIS_CAN_A0097
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Int iDisparity_y = iDisp.getVer();
+  Int iDisparity   = iDisp.getHor();
+#else
   Int iDisparity = iDisp;
+#else
+#endif
+#else //H3D_NBDV
   Int           iMidPosX    = Int( uiXPos + ( ( uiBlkWidth  - 1 ) >> 1 ) ) >> m_pcDepthMapGenerator->getSubSampExpX();
   Int           iMidPosY    = Int( uiYPos + ( ( uiBlkHeight - 1 ) >> 1 ) ) >> m_pcDepthMapGenerator->getSubSampExpY();
   Int           iDisparity  = m_pcDepthMapGenerator->getDisparity( pcPic, iMidPosX, iMidPosY, uiBaseViewId );
 #endif
+#endif //H3D_NBDV
   //===== compensate luma =====
   Int           iYWidth     = Int( uiBlkWidth  );
 …
   Int           iYRefPosX0  = Int( uiXPos )     + ( iDisparity >> 2 );
   Int           iYRefPosX1  = iYRefPosX0        + 1;
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Int           iYMaxPosY   = Int( uiPicHeight ) - 1;
+  Int           iYWeight3   = ( iDisparity_y & 3 );
+  Int           iYWeight2   = 4 - iYWeight3;
+  Int           iYRefPosY0  = Max( 0, Min( iYMaxPosY, Int( uiYPos )     + ( iDisparity_y >> 2 )) );
+  Int           iYRefPosY1  = Max( 0, Min( iYMaxPosY, iYRefPosY0 + 1 ));
+#endif
   Int           iYMaxPosX   = Int( uiPicWidth ) - 1;
   Int           iSrcStrideY = pcBaseRes->getStride   ();
   Int           iDesStrideY = pcYuv    ->getStride   ();
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Pel*          pSrcSamplesY0= pcBaseRes->getLumaAddr ( 0 ) + iYRefPosY0 * iSrcStrideY;
+  Pel*          pSrcSamplesY1= pcBaseRes->getLumaAddr ( 0 ) + iYRefPosY1 * iSrcStrideY;
+#else
   Pel*          pSrcSamplesY= pcBaseRes->getLumaAddr ( 0 ) + uiYPos * iSrcStrideY;
+#endif
   Pel*          pDesSamplesY= pcYuv    ->getLumaAddr ();
+#if QC_SIMPLIFIEDIVRP_M24938
   if( puiXPosInRefView != NULL )
     *puiXPosInRefView = Max( 0, Min( iYMaxPosX, iYRefPosX0 ) );
 …
   if( bRecon == false )
     return;
+#endif
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  for(   Int iY = 0; iY < iYHeight; iY++, pSrcSamplesY0 += iSrcStrideY, pSrcSamplesY1 += iSrcStrideY, pDesSamplesY += iDesStrideY )
+#else
   for(   Int iY = 0; iY < iYHeight; iY++, pSrcSamplesY += iSrcStrideY, pDesSamplesY += iDesStrideY )
+#endif
+  {
     for( Int iX = 0; iX < iYWidth; iX++ )
 …
       Int iXPic0        = Max( 0, Min( iYMaxPosX, iYRefPosX0 + iX ) );
       Int iXPic1        = Max( 0, Min( iYMaxPosX, iYRefPosX1 + iX ) );
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+      Pel Temp1,Temp2;
+      Temp1 =( iYWeight0 * pSrcSamplesY0[iXPic0] + iYWeight1 * pSrcSamplesY0[iXPic1] + 2 ) >> 2;
+      Temp2 =( iYWeight0 * pSrcSamplesY1[iXPic0] + iYWeight1 * pSrcSamplesY1[iXPic1] + 2 ) >> 2;
+      pDesSamplesY[iX]  = ( iYWeight2 * Temp1 + iYWeight3 * Temp2 + 2 ) >> 2;
+#else
       pDesSamplesY[iX]  = ( iYWeight0 * pSrcSamplesY[iXPic0] + iYWeight1 * pSrcSamplesY[iXPic1] + 2 ) >> 2;
+#endif
+    }
+  }
 …
   Int           iCRefPosX0  = Int( uiXPos     >> 1 ) + ( iDisparity >> 3 );
   Int           iCRefPosX1  = iCRefPosX0             + 1;
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Int           iCMaxPosY   = Int( uiPicHeight >> 1 ) - 1;
+  Int           iCWeight3   = ( iDisparity_y & 7 );
+  Int           iCWeight2   = 8 - iCWeight3;
+  Int           iCRefPosY0  = Max( 0, Min( iCMaxPosY, Int( uiYPos >> 1 )     + ( iDisparity_y >> 3 )) );
+  Int           iCRefPosY1  = Max( 0, Min( iCMaxPosY, iCRefPosY0 + 1 ));
+#endif
   Int           iCMaxPosX   = Int( uiPicWidth >> 1 ) - 1;
   Int           iSrcStrideC = pcBaseRes->getCStride();
   Int           iDesStrideC = pcYuv    ->getCStride();
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Pel*          pSrcSamplesU0= pcBaseRes->getCbAddr ( 0 ) + ( iCRefPosY0 >> 1 ) * iSrcStrideC;
+  Pel*          pSrcSamplesU1= pcBaseRes->getCbAddr ( 0 ) + ( iCRefPosY1 >> 1 ) * iSrcStrideC;
+  Pel*          pSrcSamplesV0= pcBaseRes->getCrAddr ( 0 ) + ( iCRefPosY0 >> 1 ) * iSrcStrideC;
+  Pel*          pSrcSamplesV1= pcBaseRes->getCrAddr ( 0 ) + ( iCRefPosY1 >> 1 ) * iSrcStrideC;
+#else
   Pel*          pSrcSamplesU= pcBaseRes->getCbAddr ( 0 ) + ( uiYPos >> 1 ) * iSrcStrideC;
   Pel*          pSrcSamplesV= pcBaseRes->getCrAddr ( 0 ) + ( uiYPos >> 1 ) * iSrcStrideC;
+#endif
   Pel*          pDesSamplesU= pcYuv    ->getCbAddr ();
   Pel*          pDesSamplesV= pcYuv    ->getCrAddr ();
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  for(   Int iY = 0; iY < iCHeight; iY++, pSrcSamplesU0 += iSrcStrideC, pSrcSamplesU1 += iSrcStrideC, pDesSamplesU += iDesStrideC,
+                                          pSrcSamplesV0 += iSrcStrideC, pSrcSamplesV1 += iSrcStrideC, pDesSamplesV += iDesStrideC )
+#else
   for(   Int iY = 0; iY < iCHeight; iY++, pSrcSamplesU += iSrcStrideC, pDesSamplesU += iDesStrideC,
                                           pSrcSamplesV += iSrcStrideC, pDesSamplesV += iDesStrideC )
+#endif
+  {
     for( Int iX = 0; iX < iCWidth; iX++ )
 …
       Int iXPic0        = Max( 0, Min( iCMaxPosX, iCRefPosX0 + iX ) );
       Int iXPic1        = Max( 0, Min( iCMaxPosX, iCRefPosX1 + iX ) );
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+      Pel Temp1,Temp2;
+      Temp1 =( iCWeight0 * pSrcSamplesU0[iXPic0] + iCWeight1 * pSrcSamplesU0[iXPic1] + 4 ) >> 3;
+      Temp2 =( iCWeight0 * pSrcSamplesU1[iXPic0] + iCWeight1 * pSrcSamplesU1[iXPic1] + 4 ) >> 3;
+      pDesSamplesU[iX]  = ( iCWeight2 * Temp1 + iCWeight3 * Temp2 + 4 ) >> 3;
+      Temp1 =( iCWeight0 * pSrcSamplesV0[iXPic0] + iCWeight1 * pSrcSamplesV0[iXPic1] + 4 ) >> 3;
+      Temp2 =( iCWeight0 * pSrcSamplesV1[iXPic0] + iCWeight1 * pSrcSamplesV1[iXPic1] + 4 ) >> 3;
+      pDesSamplesV[iX]  = ( iCWeight2 * Temp1 + iCWeight3 * Temp2 + 4 ) >> 3;
+#else
       pDesSamplesU[iX]  = ( iCWeight0 * pSrcSamplesU[iXPic0] + iCWeight1 * pSrcSamplesU[iXPic1] + 4 ) >> 3;
       pDesSamplesV[iX]  = ( iCWeight0 * pSrcSamplesV[iXPic0] + iCWeight1 * pSrcSamplesV[iXPic1] + 4 ) >> 3;
+#endif
+    }
+  }
 …
 #endif // HHI_INTER_VIEW_RESIDUAL_PRED
+#endif // H3D_IVRP

trunk/source/Lib/TLibCommon/TComResidualGenerator.h

-                      r189
+                      r296
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 class TComResidualGenerator
 …
   Void  setRecResidualPic     ( TComPic*      pcPic );
+#if QC_MULTI_DIS_CAN_A0097
+  Bool  getResidualSamples    ( TComDataCU*   pcCU,  UInt uiPUIdx, TComYuv* pcYuv, Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+    , Bool bRecon
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Bool  getResidualSamples    ( TComDataCU*   pcCU,  UInt uiPUIdx, TComYuv* pcYuv, TComMv iDisp_x, Bool bRecon );
+  Bool  getResidualSamples    ( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv , TComMv iDisp_x, Bool bRecon );
+#else
+  Bool  getResidualSamples    ( TComDataCU*   pcCU,  UInt uiPUIdx, TComYuv* pcYuv, Int iDisp, Bool bRecon );
+  Bool  getResidualSamples    ( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv , Int iDisp, Bool bRecon );
 #endif
+);
+  Bool  getResidualSamples    ( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv , Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+    , Bool bRecon
+#endif
+  );
+#else
+  Bool  getResidualSamples    ( TComDataCU*   pcCU,  UInt uiPUIdx, TComYuv* pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , Bool bRecon
+#endif
+    );
+  Bool  getResidualSamples    ( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , Bool bRecon
+#endif
+    );
+#endif
+#else // H3D_NBDV
+  Bool  getResidualSamples    ( TComDataCU*   pcCU,  UInt uiPUIdx, TComYuv* pcYuv, Bool bRecon );
+  Bool  getResidualSamples    ( TComPic* pcPic, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Bool bRecon );
+#endif // H3D_NBDV
 private:
 …
   Void  xClearIntViewResidual ( TComDataCU*   pcCU,  TComYuv* pcCUResidual, UInt uiPartIdx    );
   Void  xClearResidual        (                      TComYuv* pcCUResidual, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight );
+#if QC_MULTI_DIS_CAN_A0097
+  Void  xSetPredResidualBlock ( TComPic*      pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Int iDisp
+#if QC_SIMPLIFIEDIVRP_M24938
+    , UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon
+#if H3D_NBDV
+#if MTK_RELEASE_DV_CONSTRAINT_C0129
+  Void  xSetPredResidualBlock ( TComPic*      pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, TComMv iDisp, UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon  );
+#else
+  Void  xSetPredResidualBlock ( TComPic*      pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, Int iDisp, UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon  );
 #endif
-  );
 #else
+  Void  xSetPredResidualBlock ( TComPic*      pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv
+#if QC_SIMPLIFIEDIVRP_M24938
+    , UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon
+#endif
+    );
+  Void  xSetPredResidualBlock ( TComPic*      pcPic, UInt uiBaseViewId, UInt uiXPos, UInt uiYPos, UInt uiBlkWidth, UInt uiBlkHeight, TComYuv* pcYuv, UInt * puiXPosInRefView , UInt * puiYPosInRefView , Bool bRecon  );
 #endif
   Bool  xIsNonZero            ( TComYuv*      pcYuv, UInt uiBlkWidth, UInt uiBlkHeight );
-#if QC_SIMPLIFIEDIVRP_M24938
   Bool  xIsNonZeroByCBF       ( UInt uiBaseViewId , UInt uiXPos , UInt uiYPos, UInt uiBlkWidth , UInt uiBlkHeight );
-#endif
   Void  xDumpResidual         ( TComPic*      pcPic, char* pFilenameBase );
 private:
   // general parameters
 …
 #endif // __TCOM_RESIDUAL_GENERATOR__
 #endif // HHI_INTER_VIEW_RESIDUAL_PRED
+#endif // H3D_IVRP

trunk/source/Lib/TLibCommon/TComRom.cpp

-                      r189
+                      r296
     g_aacWedgeRefLists.clear();
+  }
+#if HHIQC_DMMFASTSEARCH_B0039
   if ( !g_aacWedgeNodeLists.empty() )
+  {
 …
     g_aacWedgeNodeLists.clear();
+  }
+#endif
 #endif
+}
 …
 #if RWTH_SDC_DLT_B0036
+#if SAIT_SDC_C0096
+UInt g_auiSDCPredModes[RWTH_SDC_NUM_PRED_MODES] = { DC_IDX, DMM_WEDGE_FULL_IDX, PLANAR_IDX };
+#else
 UInt g_auiSDCPredModes[RWTH_SDC_NUM_PRED_MODES] = { DC_IDX, DMM_WEDGE_FULL_IDX, DMM_WEDGE_PREDDIR_IDX, PLANAR_IDX };
+#endif
 #endif
 …
 };
-#if !LOGI_INTRA_NAME_3MPM
-// Mapping each Unified Directional Intra prediction direction to DCT/DST transform
-// 0 implies use DCT, 1 implies DST
-#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
-const UChar g_aucDCTDSTMode_Vert[NUM_INTRA_MODE+NUM_DMM_MODE] =
-#else
-const UChar g_aucDCTDSTMode_Vert[NUM_INTRA_MODE] =
-#endif
-{ //0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
-, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
-#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
-  , 0, 0, 0, 0, 0, 0, 0, 0
-#elif HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
-  , 0, 0, 0, 0
-#endif
-};
-#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
-const UChar g_aucDCTDSTMode_Hor[NUM_INTRA_MODE+NUM_DMM_MODE] =
-#else
-const UChar g_aucDCTDSTMode_Hor[NUM_INTRA_MODE] =
-#endif
-{ //0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
-, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0
-#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
-  , 0, 0, 0, 0, 0, 0, 0, 0
-#elif HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
-  , 0, 0, 0, 0
-#endif
-};
-#endif
 …
 const UChar g_aucConvertTxtTypeToIdx[4] = { 0, 1, 1, 2 };
-#if !LOGI_INTRA_NAME_3MPM
-// ====================================================================================================================
-// Angular Intra prediction
-// ====================================================================================================================
-// g_aucAngIntraModeOrder
-//   Indexing this array with the mode indicated in the bitstream
-//   gives a logical index used in the prediction functions.
-const UChar g_aucAngIntraModeOrder[NUM_INTRA_MODE] =
-{     //  ModeOrder LogicalOrderInPredFunctions
-, //  PLANAR_IDX PLANAR PLANAR
-,  //  0 VER     DC
-, //  1 HOR     VER-8 (diagonal from top-left to bottom-right = HOR-8)
-,  //  2 DC      VER-7
-,  //  4 VER-8   VER-6
-,  //  5 VER-4   VER-5
-, //  6 VER+4   VER-4
-, //  7 VER+8   VER-3
-, //  8 HOR-4   VER-2
-, //  9 HOR+4   VER-1
-, // 10 HOR+8   VER
-,  // 11 VER-6   VER+1
-,  // 12 VER-2   VER+2
-, // 13 VER+2   VER+3
-, // 14 VER+6   VER+4
-, // 15 HOR-6   VER+5
-, // 16 HOR-2   VER+6
-, // 17 HOR+2   VER+7
-, // 18 HOR+6   VER+8
-,  // 19 VER-7   HOR-7
-,  // 20 VER-5   HOR-6
-,  // 21 VER-3   HOR-5
-,  // 22 VER-1   HOR-4
-, // 23 VER+1   HOR-3
-, // 24 VER+3   HOR-2
-, // 25 VER+5   HOR-1
-, // 26 VER+7   HOR
-, // 27 HOR-7   HOR+1
-, // 28 HOR-5   HOR+2
-, // 29 HOR-3   HOR+3
-, // 30 HOR-1   HOR+4
-, // 31 HOR+1   HOR+5
-, // 32 HOR+3   HOR+6
-, // 33 HOR+5   HOR+7
-, // 34 HOR+7   HOR+8
-, // LM_CHROMA_IDX
-};
-const UChar g_aucIntraModeNumAng[7] =
+{
-,  //   2x2
-,  //   4x4
-,  //   8x8
-,  //  16x16
-,  //  32x32
-,  //  64x64
-   // 128x128
-};
-const UChar g_aucIntraModeBitsAng[7] =
+{
-,  //   2x2     3   1+1
-,  //   4x4    17   4+1
-,  //   8x8    34   5+esc
-,  //  16x16   34   5+esc
-,  //  32x32   34   5+esc
-,  //  64x64   34   5+esc
-   // 128x128   5   2+1
-};
-#endif
 // ====================================================================================================================
 …
 };
+#if LGE_DMM3_SIMP_C0044
+const UChar g_aucWedgeTexPredBitsListIdx[7] =
+{
+,   //   2x2
+,   //   4x4
+,  //   8x8
+,  //  16x16
+,  //  32x32
+,  //  64x64
+    // 128x128
+};
+#endif
 const UChar g_aucIntraSizeIdxToWedgeSize[7] =
+{
 …
 };
-#if MULTILEVEL_SIGMAP_EXT
 const UInt g_sigLastScan8x8[ 4 ][ 4 ] =
+{
 …
 };
 UInt g_sigLastScanCG32x32[ 64 ];
-#endif
 UInt* g_auiNonSquareSigLastScan[ 4 ];
 …
 const UInt g_uiMinInGroup[ 10 ] = {0,1,2,3,4,6,8,12,16,24};
 const UInt g_uiGroupIdx[ 32 ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
-#if LAST_CTX_REDUCTION
 const UInt g_uiLastCtx[ 28 ]    =
+{
 …
 , 11, 12, 12, 13, 13, 14, 14, 2, 2    // 32x32  10
 };
-#else
-const UInt g_uiLastCtx[ 28 ]    =
+{
-,   1,  2,  2,                         // 4x4    4
-,   4,  5,  5, 6,  6,                  // 8x8    6
-,   8,  9,  9, 10, 10, 11, 11,         // 16x16  8
-, 13, 14, 14, 15, 15, 16, 16, 17, 17  // 32x32  10
-};
-#endif
 // Rice parameters for absolute transform levels
-#if EIGHT_BITS_RICE_CODE
 const UInt g_auiGoRiceRange[5] =
+{
 …
 , 7, 6, 5, 4
 };
+#else
+const UInt g_auiGoRiceRange[4] =
+{
+, 20, 42, 70
+};
+const UInt g_auiGoRicePrefixLen[4] =
+{
+, 10, 10, 8
+};
+#endif
+#if EIGHT_BITS_RICE_CODE
 const UInt g_aauiGoRiceUpdate[5][24] =
+{
-#if RESTRICT_GR1GR2FLAG_NUMBER
+  {
 , 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
 …
 , 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
+  }
+#else
+  {
+, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
+  },
+  {
+, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
+  },
+  {
+, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
+  },
+  {
+, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
+  },
+  {
+, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
+  }
+#endif
+};
+#else
+const UInt g_aauiGoRiceUpdate[4][16] =
+{
+#if RESTRICT_GR1GR2FLAG_NUMBER
+  {
+, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
+  },
+  {
+, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
+  },
+  {
+, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
+  },
+  {
+, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+  }
+#else
+  {
+, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3
+  },
+  {
+, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3
+  },
+  {
+, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3
+  },
+  {
+, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
+  }
+#endif
+};
+#endif
+};
 // initialize g_auiFrameScanXY
 …
   if( iWidth < 16 )
+  {
-#if MULTILEVEL_SIGMAP_EXT
   UInt* pBuffTemp = pBuffD;
   if( iWidth == 8 )
 …
     pBuffTemp = g_sigLastScanCG32x32;
+  }
-#endif
   for( UInt uiScanLine = 0; uiNextScanPos < uiNumScanPos; uiScanLine++ )
+  {
 …
     while( iPrimDim >= 0 && iScndDim < iWidth )
+    {
-#if MULTILEVEL_SIGMAP_EXT
       pBuffTemp[ uiNextScanPos ] = iPrimDim * iWidth + iScndDim ;
-#else
-      pBuffD[ uiNextScanPos ] = iPrimDim * iWidth + iScndDim ;
-#endif
       uiNextScanPos++;
       iScndDim++;
 …
+  }
+  }
-#if MULTILEVEL_SIGMAP_EXT
   if( iWidth > 4 )
-#else
-  else
-#endif
+  {
     UInt uiNumBlkSide = iWidth >> 2;
 …
       uiNextScanPos   = 0;
       UInt initBlkPos = g_auiSigLastScan[ SCAN_DIAG ][ log2Blk ][ uiBlk ];
-#if MULTILEVEL_SIGMAP_EXT
       if( iWidth == 32 )
+      {
         initBlkPos = g_sigLastScanCG32x32[ uiBlk ];
+      }
-#endif
       UInt offsetY    = initBlkPos / uiNumBlkSide;
       UInt offsetX    = initBlkPos - offsetY * uiNumBlkSide;
 …
+}
-#if SCALING_LIST
 Int g_quantIntraDefault4x4[16] =
+{
 …
 ,25,28,33,41,54,71,91
 };
-#else
-Int g_quantIntraDefault4x4[16] =
+{
-,13,20,28,
-,20,28,32,
-,28,32,37,
-,32,37,42
-};
-Int g_quantInterDefault4x4[16] =
+{
-,14,20,24,
-,20,24,27,
-,24,27,30,
-,27,30,34
-};
-Int g_quantIntraDefault8x8[64] =
+{
-,10,13,16,18,23,25,27,
-,11,16,18,23,25,27,29,
-,16,18,23,25,27,29,31,
-,18,23,25,27,29,31,33,
-,23,25,27,29,31,33,36,
-,25,27,29,31,33,36,38,
-,27,29,31,33,36,38,40,
-,29,31,33,36,38,40,42
-};
-Int g_quantInterDefault8x8[64] =
+{
-,13,15,17,19,21,22,24,
-,13,17,19,21,22,24,25,
-,17,19,21,22,24,25,27,
-,19,21,22,24,25,27,28,
-,21,22,24,25,27,28,30,
-,22,24,25,27,28,30,32,
-,24,25,27,28,30,32,33,
-,25,27,28,30,32,33,35
-};
-Int g_quantIntraDefault16x16[256] =
+{
-,16,16,16,16,16,16,16,17,17,18,19,21,22,24,27,
-,16,16,16,16,16,16,16,17,18,18,20,21,23,25,27,
-,16,16,16,16,16,16,17,17,18,19,20,22,23,25,28,
-,16,16,16,16,16,17,17,18,19,20,21,23,25,27,29,
-,16,16,16,17,17,18,19,20,21,22,23,25,27,29,31,
-,16,16,16,17,18,19,20,22,23,24,26,27,29,32,34,
-,16,16,17,18,19,21,23,24,25,27,29,31,33,36,39,
-,16,17,17,19,20,23,25,27,29,31,33,35,38,41,44,
-,17,17,18,20,22,24,27,30,32,35,38,41,44,47,51,
-,18,18,19,21,23,25,29,32,36,40,43,47,51,55,60,
-,18,19,20,22,24,27,31,35,40,44,49,54,59,65,70,
-,20,20,21,23,26,29,33,38,43,49,56,62,69,75,82,
-,21,22,23,25,27,31,35,41,47,54,62,70,79,88,97,
-,23,23,25,27,29,33,38,44,51,59,69,79,90,101,113,
-,25,25,27,29,32,36,41,47,55,65,75,88,101,115,130,
-,27,28,29,31,34,39,44,51,60,70,82,97,113,130,149
-};
-Int g_quantInterDefault16x16[256] =
+{
-,16,16,16,16,16,16,16,17,17,18,19,20,21,22,27,
-,16,16,16,16,16,16,17,17,18,19,20,21,22,27,27,
-,16,16,16,16,16,17,17,18,19,20,21,22,27,27,28,
-,16,16,16,16,17,17,18,19,20,21,22,27,27,28,29,
-,16,16,16,17,17,18,19,20,21,22,27,27,28,29,30,
-,16,16,17,17,18,19,20,21,22,27,27,28,29,30,32,
-,16,17,17,18,19,20,21,22,27,27,28,29,30,32,36,
-,17,17,18,19,20,21,22,27,27,28,29,30,32,36,40,
-,17,18,19,20,21,22,27,27,28,29,30,32,36,40,45,
-,18,19,20,21,22,27,27,28,29,30,32,36,40,45,52,
-,19,20,21,22,27,27,28,29,30,32,36,40,45,52,59,
-,20,21,22,27,27,28,29,30,32,36,40,45,52,59,68,
-,21,22,27,27,28,29,30,32,36,40,45,52,59,68,79,
-,22,27,27,28,29,30,32,36,40,45,52,59,68,79,91,
-,27,27,28,29,30,32,36,40,45,52,59,68,79,91,103,
-,27,28,29,30,32,36,40,45,52,59,68,79,91,103,117
-};
-Int g_quantIntraDefault32x32[1024] =
+{
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,27,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,23,23,24,25,27,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,18,19,20,20,21,22,23,24,25,26,27,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,21,22,23,24,25,26,27,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,20,21,22,23,23,24,25,26,28,29,
-,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,18,19,19,20,21,21,22,23,24,25,26,27,28,30,
-,16,16,16,16,16,16,16,16,16,16,17,17,17,17,18,18,19,19,20,20,21,21,22,23,24,25,26,27,28,29,30,
-,16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,19,19,20,20,21,21,22,23,24,25,26,27,28,29,30,31,
-,16,16,16,16,16,16,16,17,17,17,18,18,18,19,19,20,20,21,21,22,22,23,24,25,26,27,28,29,30,31,33,
-,16,16,16,16,16,16,17,17,17,18,18,19,19,20,20,20,21,22,22,23,23,24,25,26,27,28,29,30,31,33,34,
-,16,16,16,16,16,16,17,17,18,18,19,19,20,20,21,22,22,23,23,24,25,26,26,27,28,29,30,32,33,34,36,
-,16,16,16,16,16,17,17,18,18,19,20,20,21,21,22,23,23,24,25,25,26,27,28,29,30,31,32,33,35,36,38,
-,16,16,16,16,16,17,17,18,19,19,20,21,22,23,23,24,25,25,26,27,28,29,30,31,32,33,34,36,37,39,40,
-,16,16,16,16,17,17,18,18,19,20,21,22,23,24,24,25,26,27,28,29,30,31,32,33,34,35,37,38,39,41,43,
-,16,16,16,17,17,17,18,19,20,20,21,23,24,25,26,27,28,29,30,31,32,33,34,35,36,38,39,41,42,44,46,
-,16,17,17,17,17,18,18,19,20,21,22,23,24,26,27,28,29,31,32,33,34,35,37,38,39,41,42,44,45,47,49,
-,17,17,17,17,18,18,19,20,20,22,23,24,25,27,28,30,31,32,34,35,36,38,39,41,42,44,45,47,49,51,53,
-,17,17,17,18,18,19,19,20,21,22,23,25,26,28,29,31,33,34,36,37,39,41,42,44,45,47,49,51,53,55,57,
-,17,18,18,18,18,19,20,21,22,23,24,25,27,29,31,32,34,36,38,40,42,43,45,47,49,51,53,55,57,60,62,
-,18,18,18,19,19,20,20,21,22,23,25,26,28,30,32,34,36,38,40,42,44,46,48,51,53,55,57,60,62,65,67,
-,18,18,19,19,19,20,21,22,23,24,25,27,29,31,33,35,37,40,42,44,47,49,52,54,57,59,62,65,67,70,73,
-,19,19,19,20,20,21,21,22,23,25,26,28,30,32,34,36,39,42,44,47,50,52,55,58,61,64,67,70,73,76,79,
-,19,20,20,20,21,21,22,23,24,26,27,29,31,33,35,38,41,43,46,49,52,56,59,62,65,69,72,75,79,82,86,
-,20,20,21,21,21,22,23,24,25,26,28,30,32,34,37,39,42,45,48,52,55,59,62,66,70,74,77,81,85,89,93,
-,21,21,21,22,22,23,24,25,26,27,29,31,33,35,38,41,44,47,51,54,58,62,66,70,74,79,83,88,92,97,101,
-,22,22,22,23,23,24,25,26,27,28,30,32,34,36,39,42,45,49,53,57,61,65,70,74,79,84,89,94,99,104,110,
-,23,23,23,23,24,25,26,27,28,29,31,33,35,38,41,44,47,51,55,59,64,69,74,79,84,90,95,101,107,113,119,
-,23,24,24,24,25,26,27,28,29,30,32,34,37,39,42,45,49,53,57,62,67,72,77,83,89,95,101,108,114,121,128,
-,24,25,25,25,26,27,28,29,30,32,33,36,38,41,44,47,51,55,60,65,70,75,81,88,94,101,108,115,122,130,138,
-,25,26,26,26,27,28,29,30,31,33,35,37,39,42,45,49,53,57,62,67,73,79,85,92,99,107,114,122,131,139,148,
-,27,27,27,28,28,29,30,31,33,34,36,39,41,44,47,51,55,60,65,70,76,82,89,97,104,113,121,130,139,149,159,
-,28,28,28,29,30,30,31,33,34,36,38,40,43,46,49,53,57,62,67,73,79,86,93,101,110,119,128,138,148,159,170
-};
-Int g_quantInterDefault32x32[1024] =
+{
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,
-,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,
-,16,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,
-,16,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,
-,16,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,
-,16,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,
-,16,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,
-,16,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,
-,16,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,
-,16,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,
-,16,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,
-,16,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,
-,16,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,
-,17,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,
-,17,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,
-,17,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,
-,18,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,
-,18,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,
-,19,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,
-,19,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,
-,20,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,
-,21,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,
-,22,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,
-,22,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,
-,23,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,
-,24,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,101,
-,25,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,101,108,
-,26,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,101,108,115,
-,28,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,101,108,115,123,
-,28,28,28,29,30,30,31,32,33,34,35,36,38,40,42,45,48,52,56,60,64,69,74,80,87,94,101,108,115,123,131
-};
-#endif
 UInt g_scalingListSize   [4] = {16,64,256,1024};
 UInt g_scalingListSizeX  [4] = { 4, 8, 16,  32};
 …
 std::vector< std::vector<TComWedgeRef> > g_aacWedgeRefLists;
-#if HHIQC_DMMFASTSEARCH_B0039
 std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
 std::vector< std::vector< TComWedgeNode> >      g_aacWedgeNodeLists;
-#endif
 Void initWedgeLists()
 …
     g_aacWedgeRefLists.push_back( acWedgeRefList );
-#if HHIQC_DMMFASTSEARCH_B0039
     // create WedgeNodeList
     std::vector<TComWedgeNode> acWedgeNodeList;
 …
+    }
     g_aacWedgeNodeLists.push_back( acWedgeNodeList );
+#endif
+  }
   return;
 …
       for( Int iL = 0; iL < uiBlockSize; iL++ )
+      {
-#if HHIQC_DMMFASTSEARCH_B0039
         cTempWedgelet.setWedgelet( uhStartX + (iK*iStepStartX) , uhStartY + (iK*iStepStartY), uhEndX + (iL*iStepEndX), uhEndY + (iL*iStepEndY), (UChar)uiOri, eWedgeRes, ((iL%2)==0 && (iK%2)==0) );
-#else
-        cTempWedgelet.setWedgelet( uhStartX + (iK*iStepStartX) , uhStartY + (iK*iStepStartY), uhEndX + (iL*iStepEndX), uhEndY + (iL*iStepEndY), (UChar)uiOri, eWedgeRes );
-#endif
         addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
+      }
+    }
+  }
-#if HHIQC_DMMFASTSEARCH_B0039
   UInt uiThrSz = DMM3_SIMPLIFY_TR;
 …
+  }
   g_aauiWdgLstM3.push_back(auiWdgListSz);
-#endif
+}
 …
   if( bValid )
+  {
+#if HHIQC_DMMFASTSEARCH_B0039
+  cWedgelet.findClosetAngle();
+#endif
+    cWedgelet.findClosetAngle();
     racWedgeList.push_back( cWedgelet );
     TComWedgeRef cWedgeRef;
 …
+  }
+}
 #endif
+#endif //HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 //! \}

trunk/source/Lib/TLibCommon/TComRom.h

-                      r189
+                      r296
 extern const UInt   g_uiLastCtx[ 28 ];
-#if EIGHT_BITS_RICE_CODE
 extern const UInt   g_auiGoRiceRange[5];                  //!< maximum value coded with Rice codes
 extern const UInt   g_auiGoRicePrefixLen[5];              //!< prefix length for each maximum value
 extern const UInt   g_aauiGoRiceUpdate[5][24];            //!< parameter update rules for Rice codes
-#else
-extern const UInt   g_auiGoRiceRange[4];                  //!< maximum value coded with Rice codes
-extern const UInt   g_auiGoRicePrefixLen[4];              //!< prefix length for each maximum value
-extern const UInt   g_aauiGoRiceUpdate[4][16];            //!< parameter update rules for Rice codes
-#endif
-#if MULTILEVEL_SIGMAP_EXT
 extern const UInt   g_sigLastScan8x8[ 4 ][ 4 ];           //!< coefficient group scan order for 8x8 TUs
 extern       UInt   g_sigLastScanCG32x32[ 64 ];
-#endif
 // ====================================================================================================================
 …
 extern const WedgeResolution g_aeWedgeResolutionList[5];
 extern const UChar           g_aucWedgeFullBitsListIdx[7];
+#if LGE_DMM3_SIMP_C0044
+extern const UChar           g_aucWedgeTexPredBitsListIdx[7];
+#endif
 extern const UChar           g_aucIntraSizeIdxToWedgeSize[7];
 …
 extern       std::vector< std::vector<TComWedgeRef> >  g_aacWedgeRefLists;
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 extern       std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
 extern       std::vector< std::vector<TComWedgeNode> >       g_aacWedgeNodeLists;
 …
 #if RWTH_SDC_DLT_B0036
+#if SAIT_SDC_C0096
+#define RWTH_SDC_NUM_PRED_MODES 3
+#else
 #define RWTH_SDC_NUM_PRED_MODES 4
+#endif
 extern      UInt g_auiSDCPredModes[RWTH_SDC_NUM_PRED_MODES];
 #endif
 …
 Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList );
-#if DEFAULT_DC
 __inline Void mapDMMtoIntraMode(  UInt& dirMode ) { dirMode = (dirMode >= NUM_INTRA_MODE) ? DC_IDX : dirMode; }
 __inline Void mapDMMtoIntraMode(   Int& dirMode ) { dirMode = (dirMode >= NUM_INTRA_MODE) ? DC_IDX : dirMode; }
-#else
-__inline Void mapDMMtoIntraMode(  UInt& dirMode ) { dirMode = (dirMode >= NUM_INTRA_MODE) ? PLANAR_IDX : dirMode; }
-__inline Void mapDMMtoIntraMode(   Int& dirMode ) { dirMode = (dirMode >= NUM_INTRA_MODE) ? PLANAR_IDX : dirMode; }
-#endif
 #endif
 …
 #define MAX_MATRIX_COEF_NUM 64     ///< max coefficient number for quantization matrix
 #define MAX_MATRIX_SIZE_NUM 8      ///< max size number for quantization matrix
-#if SCALING_LIST
 #define SCALING_LIST_DC 16         ///< default DC value
-#endif
 enum ScalingListDIR
+{
 …
   },
 };
-#if SCALING_LIST
 static const char MatrixType_DC[4][12][22] =
+{
 …
   },
 };
-#endif
 extern Int g_quantIntraDefault4x4[16];
 extern Int g_quantIntraDefault8x8[64];

trunk/source/Lib/TLibCommon/TComSampleAdaptiveOffset.cpp

-                      r56
+                      r296
   m_pClipTable = NULL;
   m_pClipTableBase = NULL;
-#if SAO_UNIT_INTERLEAVING
   m_lumaTableBo = NULL;
-#else
-  m_ppLumaTableBo0 = NULL;
-  m_ppLumaTableBo1 = NULL;
-#endif
   m_iUpBuff1 = NULL;
   m_iUpBuff2 = NULL;
 …
 ,
 ,
-#if !SAO_UNIT_INTERLEAVING
-,
-#endif
 };
 …
   SAO_EO_LEN,
   SAO_EO_LEN,
-#if !SAO_UNIT_INTERLEAVING
-  SAO_BO_LEN,
-#endif
   SAO_BO_LEN
 };
 …
    * m_iNumTotalParts must allow for sufficient storage in any allocated arrays */
   m_iNumTotalParts  = max(3,m_aiNumCulPartsLevel[m_uiMaxSplitLevel]);
-#if !SAO_UNIT_INTERLEAVING
-  UInt auiTable[2][LUMA_GROUP_NUM] =
-  {{0, 0, 0, 0, 0, 0, 0, 0,
-, 2, 3, 4, 5, 6, 7, 8,
-,10,11,12,13,14,15,16,
-, 0, 0, 0, 0, 0, 0, 0},
-  {1, 2, 3, 4, 5, 6, 7, 8,
-, 0, 0, 0, 0, 0, 0, 0,
-, 0, 0, 0, 0, 0, 0, 0,
-,10,11,12,13,14,15,16}};
-#endif
   UInt uiInternalBitDepth = g_uiBitDepth+g_uiBitIncrement;
 …
   UInt uiBoRangeShift = uiInternalBitDepth - SAO_BO_BITS;
-#if SAO_UNIT_INTERLEAVING
   m_lumaTableBo = new Pel [uiPixelRange];
   for (Int k2=0; k2<uiPixelRange; k2++)
 …
     m_lumaTableBo[k2] = 1 + (k2>>uiBoRangeShift);
+  }
-#else
-  m_ppLumaTableBo0 = new Pel [uiPixelRange];
-  m_ppLumaTableBo1 = new Pel [uiPixelRange];
-  for (Int k2=0; k2<uiPixelRange; k2++)
+  {
-    m_ppLumaTableBo0[k2] = auiTable[0][k2>>uiBoRangeShift];
-    m_ppLumaTableBo1[k2] = auiTable[1][k2>>uiBoRangeShift];
+  }
-#endif
   m_iUpBuff1 = new Int[m_iPicWidth+2];
   m_iUpBuff2 = new Int[m_iPicWidth+2];
 …
     delete [] m_iOffsetBo; m_iOffsetBo = NULL;
+  }
-#if SAO_UNIT_INTERLEAVING
   if (m_lumaTableBo)
+  {
     delete[] m_lumaTableBo; m_lumaTableBo = NULL;
+  }
-#else
-  if (m_ppLumaTableBo0)
+  {
-    delete[] m_ppLumaTableBo0; m_ppLumaTableBo0 = NULL;
+  }
-  if (m_ppLumaTableBo1)
+  {
-    delete[] m_ppLumaTableBo1; m_ppLumaTableBo1 = NULL;
+  }
-#endif
 …
     pcSaoParam->iNumClass[j] = m_iNumClass[j];
+  }
-#if SAO_UNIT_INTERLEAVING
   pcSaoParam->numCuInWidth  = m_iNumCuInWidth;
   pcSaoParam->numCuInHeight = m_iNumCuInHeight;
 …
   pcSaoParam->saoLcuParam[1] = new SaoLcuParam [m_iNumCuInHeight*m_iNumCuInWidth];
   pcSaoParam->saoLcuParam[2] = new SaoLcuParam [m_iNumCuInHeight*m_iNumCuInWidth];
-#endif
+}
 …
   pSaoPart->UpPartIdx = iParentPartIdx;
-#if !SAO_UNIT_INTERLEAVING
-  pSaoPart->bEnableFlag =  0;
-#endif
   pSaoPart->iBestType   = -1;
   pSaoPart->iLength     =  0;
-#if SAO_UNIT_INTERLEAVING
   pSaoPart->bandPosition = 0;
   for (j=0;j<MAX_NUM_SAO_OFFSETS;j++)
-#else
-  for (j=0;j<MAX_NUM_SAO_CLASS;j++)
-#endif
+  {
     pSaoPart->iOffset[j] = 0;
 …
   pcSaoParam->psSaoPart[1] = 0;
   pcSaoParam->psSaoPart[2] = 0;
-#if SAO_UNIT_INTERLEAVING
   if( pcSaoParam->saoLcuParam[0])
+  {
 …
     delete [] pcSaoParam->saoLcuParam[2]; pcSaoParam->saoLcuParam[2] = NULL;
+  }
-#endif
+}
 …
     for(Int i=0; i< m_aiNumCulPartsLevel[m_uiMaxSplitLevel]; i++)
+    {
-#if !SAO_UNIT_INTERLEAVING
-      pcSaoParam->psSaoPart[c][i].bEnableFlag   =  0;
-#endif
       pcSaoParam->psSaoPart[c][i].iBestType     = -1;
       pcSaoParam->psSaoPart[c][i].iLength       =  0;
 …
       pcSaoParam->psSaoPart[c][i].iMinDist      = MAX_INT;
       pcSaoParam->psSaoPart[c][i].iMinRate      = MAX_INT;
-#if SAO_UNIT_INTERLEAVING
       pcSaoParam->psSaoPart[c][i].bandPosition = 0;
       for (Int j=0;j<MAX_NUM_SAO_OFFSETS;j++)
-#else
-      for (Int j=0;j<MAX_NUM_SAO_CLASS;j++)
-#endif
+      {
         pcSaoParam->psSaoPart[c][i].iOffset[j] = 0;
 …
+      }
+    }
-#if SAO_UNIT_INTERLEAVING
     pcSaoParam->oneUnitFlag[0]   = 0;
     pcSaoParam->oneUnitFlag[1]   = 0;
 …
     resetLcuPart(pcSaoParam->saoLcuParam[1]);
     resetLcuPart(pcSaoParam->saoLcuParam[2]);
-#endif
+  }
+}
 …
       break;
+    }
-#if SAO_UNIT_INTERLEAVING
   case SAO_BO:
-#else
-  case SAO_BO_0:
-  case SAO_BO_1:
-#endif
+    {
       for (y=0; y< height; y++)
 …
       break;
+    }
-#if SAO_UNIT_INTERLEAVING
   case SAO_BO:
-#else
-  case SAO_BO_0:
-  case SAO_BO_1:
-#endif
+    {
       for (y=0; y<iLcuHeight; y++)
 …
+  }
+}
-#if !SAO_UNIT_INTERLEAVING
-/** sample adaptive offset process for one partition
- * \param   *psQTPart,  uiPartIdx,  iYCbCr
- */
-Void TComSampleAdaptiveOffset::processSaoOnePart(SAOQTPart *psQTPart, UInt uiPartIdx, Int iYCbCr)
+{
-  int  i;
-  UInt uiEdgeType, uiTypeIdx;
-  Pel* ppLumaTable = NULL;
-  SAOQTPart*  pOnePart= &(psQTPart[uiPartIdx]);
-  static Int iOffset[LUMA_GROUP_NUM];
-  Int LcuIdxX;
-  Int LcuIdxY;
-  Int iAddr;
-  Int iFrameWidthInCU = m_pcPic->getFrameWidthInCU();
-  if(pOnePart->bEnableFlag)
+  {
-    uiTypeIdx = pOnePart->iBestType;
-    if (uiTypeIdx == SAO_BO_0 || uiTypeIdx == SAO_BO_1)
+    {
-      for (i=0;i<pOnePart->iLength;i++)
-        iOffset[i+1] = pOnePart->iOffset[i] << m_uiSaoBitIncrease;
-      if (uiTypeIdx == SAO_BO_0 )
+      {
-        ppLumaTable = m_ppLumaTableBo0;
+      }
-      if (uiTypeIdx == SAO_BO_1 )
+      {
-        ppLumaTable = m_ppLumaTableBo1;
+      }
-#if FULL_NBIT
-      for (i=0;i<(1<<(g_uiBitDepth));i++)
-#else
-      for (i=0;i<(1<<(g_uiBitIncrement+8));i++)
-#endif
+      {
-        m_iOffsetBo[i] = m_pClipTable[i + iOffset[ppLumaTable[i]]];
+      }
+    }
-    if (uiTypeIdx == SAO_EO_0 || uiTypeIdx == SAO_EO_1 || uiTypeIdx == SAO_EO_2 || uiTypeIdx == SAO_EO_3)
+    {
-      for (i=0;i<pOnePart->iLength;i++)
+      {
-        iOffset[i+1] = pOnePart->iOffset[i] << m_uiSaoBitIncrease;
+      }
-      for (uiEdgeType=0;uiEdgeType<6;uiEdgeType++)
+      {
-        m_iOffsetEo[uiEdgeType]= iOffset[m_auiEoTable[uiEdgeType]];
+      }
+    }
-    for (LcuIdxY = pOnePart->StartCUY; LcuIdxY<= pOnePart->EndCUY; LcuIdxY++)
+    {
-      for (LcuIdxX = pOnePart->StartCUX; LcuIdxX<= pOnePart->EndCUX; LcuIdxX++)
+      {
-        iAddr = LcuIdxY * iFrameWidthInCU + LcuIdxX;
-        processSaoCu(iAddr, uiTypeIdx, iYCbCr);
+      }
+    }
+  }
+}
-/** Process quadtree sample adaptive offset
- * \param  psQTPart, uiPartIdx, iYCbCr
- */
-Void TComSampleAdaptiveOffset::processSaoQuadTree(SAOQTPart *psQTPart, UInt uiPartIdx, Int iYCbCr)
+{
-  SAOQTPart*  pSaoPart= &(psQTPart[uiPartIdx]);
-  if (uiPartIdx == 0)
+  {
-    initTmpSaoQuadTree(psQTPart, iYCbCr);
-    xSaoAllPart(psQTPart, iYCbCr);
-    return;
+  }
-  if (!pSaoPart->bSplit)
+  {
-    if (pSaoPart->bEnableFlag)
+    {
-      processSaoOnePart(psQTPart, uiPartIdx, iYCbCr);
+    }
-    return;
+  }
-  if (pSaoPart->PartLevel < m_uiMaxSplitLevel)
+  {
-    processSaoQuadTree(psQTPart, pSaoPart->DownPartsIdx[0], iYCbCr);
-    processSaoQuadTree(psQTPart, pSaoPart->DownPartsIdx[1], iYCbCr);
-    processSaoQuadTree(psQTPart, pSaoPart->DownPartsIdx[2], iYCbCr);
-    processSaoQuadTree(psQTPart, pSaoPart->DownPartsIdx[3], iYCbCr);
+  }
+}
-/** run SAO processing in LCU order
- * \param *psQTPart,  iYCbCr
- */
-Void TComSampleAdaptiveOffset::xSaoAllPart(SAOQTPart *psQTPart, Int iYCbCr)
+{
-  int  i;
-  UInt uiEdgeType;
-  Pel* ppLumaTable = NULL;
-  Int  iTypeIdx;
-  static Int iOffset[LUMA_GROUP_NUM];
-  Int LcuIdxX;
-  Int LcuIdxY;
-  Int iAddr;
-  Int iFrameWidthInCU = m_pcPic->getFrameWidthInCU();
-  Int iFrameHeightInCU = m_pcPic->getFrameHeightInCU();
-  Int iPartIdx;
-  Pel *pRec;
-  Int iPicWidthTmp;
-  Int iStride;
-  Pel *pTmpUSwap;
-  Int iIsChroma = (iYCbCr == 0) ? 0:1;
-  SAOQTPart*  pOnePart;
-  for (LcuIdxY = 0; LcuIdxY< iFrameHeightInCU; LcuIdxY++)
+  {
-    iAddr = LcuIdxY * iFrameWidthInCU;
-    if (iYCbCr == 0)
+    {
-      pRec  = m_pcPic->getPicYuvRec()->getLumaAddr(iAddr);
-      iStride = m_pcPic->getStride();
-      iPicWidthTmp = m_iPicWidth;
+    }
-    else if (iYCbCr == 1)
+    {
-      pRec  = m_pcPic->getPicYuvRec()->getCbAddr(iAddr);
-      iStride = m_pcPic->getCStride();
-      iPicWidthTmp = m_iPicWidth>>1;
+    }
-    else
+    {
-      pRec  = m_pcPic->getPicYuvRec()->getCrAddr(iAddr);
-      iStride = m_pcPic->getCStride();
-      iPicWidthTmp = m_iPicWidth>>1;
+    }
-//     pRec += iStride*(m_uiMaxCUHeight-1);
-    for (i=0;i<(m_uiMaxCUHeight>>iIsChroma)+1;i++)
+    {
-      m_pTmpL1[i] = pRec[0];
-      pRec+=iStride;
+    }
-    pRec-=(iStride<<1);
-    memcpy(m_pTmpU2, pRec, sizeof(Pel)*iPicWidthTmp);
-    for (LcuIdxX = 0; LcuIdxX< iFrameWidthInCU; LcuIdxX++)
+    {
-      iAddr = LcuIdxY * iFrameWidthInCU + LcuIdxX;
-      iPartIdx = m_iLcuPartIdx[iAddr];
-      if (iPartIdx>=0)
+      {
-        pOnePart = &(psQTPart[iPartIdx]);
-        iTypeIdx = pOnePart->iBestType;
-        if (iTypeIdx>=0)
+        {
-          if (iTypeIdx == SAO_BO_0 || iTypeIdx == SAO_BO_1)
+          {
-            for (i=0;i<pOnePart->iLength;i++)
-              iOffset[i+1] = pOnePart->iOffset[i] << m_uiSaoBitIncrease;
-            if (iTypeIdx == SAO_BO_0 )
+            {
-              ppLumaTable = m_ppLumaTableBo0;
+            }
-            if (iTypeIdx == SAO_BO_1 )
+            {
-              ppLumaTable = m_ppLumaTableBo1;
+            }
-#if FULL_NBIT
-            for (i=0;i<(1<<(g_uiBitDepth));i++)
-#else
-            for (i=0;i<(1<<(g_uiBitIncrement+8));i++)
-#endif
+            {
-              m_iOffsetBo[i] = m_pClipTable[i + iOffset[ppLumaTable[i]]];
+            }
+          }
-          if (iTypeIdx == SAO_EO_0 || iTypeIdx == SAO_EO_1 || iTypeIdx == SAO_EO_2 || iTypeIdx == SAO_EO_3)
+          {
-            for (i=0;i<pOnePart->iLength;i++)
+            {
-              iOffset[i+1] = pOnePart->iOffset[i] << m_uiSaoBitIncrease;
+            }
-            for (uiEdgeType=0;uiEdgeType<6;uiEdgeType++)
+            {
-              m_iOffsetEo[uiEdgeType]= iOffset[m_auiEoTable[uiEdgeType]];
+            }
+          }
-          processSaoCu(iAddr, iTypeIdx, iYCbCr);
+        }
+      }
-      else
+      {
-        if (LcuIdxX != (iFrameWidthInCU-1))
+        {
-          if( m_iLcuPartIdx[iAddr+1] >=0)
+          {
-            if (iYCbCr == 0)
+            {
-              pRec  = m_pcPic->getPicYuvRec()->getLumaAddr(iAddr);
-              iStride = m_pcPic->getStride();
+            }
-            else if (iYCbCr == 1)
+            {
-              pRec  = m_pcPic->getPicYuvRec()->getCbAddr(iAddr);
-              iStride = m_pcPic->getCStride();
+            }
-            else
+            {
-              pRec  = m_pcPic->getPicYuvRec()->getCrAddr(iAddr);
-              iStride = m_pcPic->getCStride();
+            }
-            Int iWidthShift = m_uiMaxCUWidth>>iIsChroma;
-            for (i=0;i<(m_uiMaxCUHeight>>iIsChroma)+1;i++)
+            {
-              m_pTmpL1[i] = pRec[iWidthShift-1];
-              pRec+=iStride;
+            }
+          }
+        }
+      }
+    }
-    pTmpUSwap = m_pTmpU1;
-    m_pTmpU1  = m_pTmpU2;
-    m_pTmpU2  = pTmpUSwap;
+  }
+}
-/** initialize buffer for quadtree boundary
- * \param *psQTPart,  iYCbCr
- */
-Void TComSampleAdaptiveOffset::initTmpSaoQuadTree(SAOQTPart *psQTPart, Int iYCbCr)
+{
-  Pel *pRec;
-  Int iPicWidthTmp;
-  memset(m_iLcuPartIdx,-1, sizeof(Int)*m_iNumCuInWidth*m_iNumCuInHeight);
-  convertSaoQt2Lcu(psQTPart, 0);
-  if (iYCbCr == 0)
+  {
-    pRec       = m_pcPic->getPicYuvRec()->getLumaAddr();
-    iPicWidthTmp = m_iPicWidth;
+  }
-  else if (iYCbCr == 1)
+  {
-    pRec       = m_pcPic->getPicYuvRec()->getCbAddr();
-    iPicWidthTmp =  m_iPicWidth>>1;
+  }
-  else
+  {
-    pRec       = m_pcPic->getPicYuvRec()->getCrAddr();
-    iPicWidthTmp =  m_iPicWidth>>1;
+  }
-  memcpy(m_pTmpU1, pRec, sizeof(Pel)*iPicWidthTmp);
+}
-/** recursive covert quadtree partition index to each LCU
- * \param psQTPart, uiPartIdx
- */
-Void TComSampleAdaptiveOffset::convertSaoQt2Lcu(SAOQTPart *psQTPart,UInt uiPartIdx)
+{
-  SAOQTPart*  pSaoPart= &(psQTPart[uiPartIdx]);
-  if (!pSaoPart->bSplit)
+  {
-    xSaoQt2Lcu(psQTPart, uiPartIdx);
-    return;
+  }
-  if (pSaoPart->PartLevel < m_uiMaxSplitLevel)
+  {
-    convertSaoQt2Lcu(psQTPart, pSaoPart->DownPartsIdx[0]);
-    convertSaoQt2Lcu(psQTPart, pSaoPart->DownPartsIdx[1]);
-    convertSaoQt2Lcu(psQTPart, pSaoPart->DownPartsIdx[2]);
-    convertSaoQt2Lcu(psQTPart, pSaoPart->DownPartsIdx[3]);
+  }
+}
-/** assign quadtree partition index to each LCU
- * \param psQTPart, uiPartIdx
- */
-Void TComSampleAdaptiveOffset::xSaoQt2Lcu(SAOQTPart *psQTPart,UInt uiPartIdx)
+{
-  Int LcuIdxX;
-  Int LcuIdxY;
-  Int iAddr;
-  Int iFrameWidthInCU = m_iNumCuInWidth;
-  for (LcuIdxY = psQTPart[uiPartIdx].StartCUY; LcuIdxY<= psQTPart[uiPartIdx].EndCUY; LcuIdxY++)
+  {
-    for (LcuIdxX = psQTPart[uiPartIdx].StartCUX; LcuIdxX<= psQTPart[uiPartIdx].EndCUX; LcuIdxX++)
+    {
-      iAddr = LcuIdxY * iFrameWidthInCU + LcuIdxX;
-      if (psQTPart[uiPartIdx].bEnableFlag)
+      {
-        m_iLcuPartIdx[iAddr] = (Int)uiPartIdx;
+      }
-      else
+      {
-        m_iLcuPartIdx[iAddr] = -1;
+      }
+    }
+  }
+}
-#endif
 /** Sample adaptive offset process
  * \param pcPic, pcSaoParam
 …
+    }
-#if SAO_UNIT_INTERLEAVING
     if (m_saoInterleavingFlag)
+    {
 …
-#else
-    Int iY  = 0;
-    processSaoQuadTree( pcSaoParam->psSaoPart[iY], 0 , iY);
-    Int iCb = 1;
-    Int iCr = 2;
-    if (pcSaoParam->bSaoFlag[iCb])
+    {
-      processSaoQuadTree( pcSaoParam->psSaoPart[iCb], 0 , iCb);
+    }
-    if (pcSaoParam->bSaoFlag[iCr])
+    {
-      processSaoQuadTree( pcSaoParam->psSaoPart[iCr], 0 , iCr);
+    }
-#endif
     m_pcPic = NULL;
+  }
 …
+  }
+}
-#if SAO_UNIT_INTERLEAVING
 /** Process SAO all units
  * \param saoLcuParam SAO LCU parameters
 …
-#endif
 //! \}

trunk/source/Lib/TLibCommon/TComSampleAdaptiveOffset.h

-                      r56
+                      r296
 #define SAO_BO_BITS                   5
 #define LUMA_GROUP_NUM                (1<<SAO_BO_BITS)
-#if SAO_UNIT_INTERLEAVING
 #define MAX_NUM_SAO_OFFSETS           4
 #define MAX_NUM_SAO_CLASS             33
-#else
-#define MAX_NUM_SAO_CLASS             32
-#endif
 // ====================================================================================================================
 // Class definition
 …
   Pel   *m_pClipTable;
   Pel   *m_pClipTableBase;
-#if SAO_UNIT_INTERLEAVING
   Pel   *m_lumaTableBo;
-#else
-  Pel   *m_ppLumaTableBo0;
-  Pel   *m_ppLumaTableBo1;
-#endif
   Int   *m_iUpBuff1;
   Int   *m_iUpBuff2;
 …
   Pel* m_pTmpL2;
   Int* m_iLcuPartIdx;
-#if SAO_UNIT_INTERLEAVING
   Int     m_maxNumOffsetsPerPic;
   Bool    m_saoInterleavingFlag;
-#else
-  Void initTmpSaoQuadTree(SAOQTPart *psQTPart, Int iYCbCr);
-  Void disableSaoOnePart(SAOQTPart *psQTPart, UInt uiPartIdx, Int iYCbCr);
-  Void xSaoQt2Lcu(SAOQTPart *psQTPart,UInt uiPartIdx);
-  Void convertSaoQt2Lcu(SAOQTPart *psQTPart,UInt uiPartIdx);
-  Void xSaoAllPart(SAOQTPart *psQTPart, Int iYCbCr);
-#endif
 public:
   TComSampleAdaptiveOffset         ();
 …
   Void processSaoBlock(Pel* pDec, Pel* pRest, Int stride, Int iSaoType, UInt xPos, UInt yPos, UInt width, UInt height, Bool* pbBorderAvail);
-#if SAO_UNIT_INTERLEAVING
   Void resetLcuPart(SaoLcuParam* saoLcuParam);
   Void convertQT2SaoUnit(SAOParam* saoParam, UInt partIdx, Int yCbCr);
 …
   Void setSaoInterleavingFlag (Bool bVal)  {m_saoInterleavingFlag = bVal;}
   Bool getSaoInterleavingFlag ()           {return m_saoInterleavingFlag;}
-#endif
 };

trunk/source/Lib/TLibCommon/TComSlice.cpp

-                      r210
+                      r296
 , m_cabacInitIdc                 ( -1 )
 #endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
 , m_numEntryPointOffsets          ( 0 )
-#endif
-#if SONY_COLPIC_AVAILABILITY
-, m_iViewOrderIdx                 ( 0 )
-#endif
 #if LGE_ILLUCOMP_B0045
 , m_bApplyIC                      ( false )
 #endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+, m_bIVScalingFlag                (false)
+, m_iViewOrderIdx                 ( 0 )        // will be changed to view_id
+#endif
+{
   m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = m_aiNumRefIdx[2] = 0;
   initEqualRef();
 …
   m_cabacInitFlag        = false;
 #endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   m_numEntryPointOffsets = 0;
+#if QC_TMVP_MRG_REFIDX_C0047
+  m_aiNewRefIdx[0]                  = -1;
+  m_aiNewRefIdx[1]                  = -1;
 #endif
+}
 …
+    }
+  }
+#if QC_TMVP_MRG_REFIDX_C0047
+  Int  iCurrPOC = this->getPOC();
+  for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )//just to get one updated ref idx for merge in each L0/L1 direction, if it is not avaialbe, it is still -1
+  {
+    if ( this->getNumRefIdx( RefPicList( uiRefListIdx ) ) == 0)
+        continue;
+    Bool bZeroIdxInterViewFlag =  ( this->getRefPic(RefPicList(uiRefListIdx), 0)->getPOC() == iCurrPOC ) ? true : false;
+    for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
+    {
+      if ( (bZeroIdxInterViewFlag && this->getRefPic(RefPicList(uiRefListIdx), i)->getPOC() != iCurrPOC ) ||
+           (!bZeroIdxInterViewFlag && this->getRefPic(RefPicList(uiRefListIdx), i)->getPOC() == iCurrPOC ) )
+      {
+        this->setNewRefIdx(RefPicList(uiRefListIdx),i);
+        break;
+      }
+    }
+  }
+#endif
+}
 …
+    }
+  }
-#if H0566_TLA
   if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
-#else
-  if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR ) // CDR picture found
-#endif
+  {
     pocCRA = getPOC();
 …
       bRefreshPending = false;
+    }
-#if H0566_TLA
     if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
-#else
-    if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR ) // CDR picture found
-#endif
+    {
       bRefreshPending = true;
 …
   m_iPOC                 = pSrc->m_iPOC;
   m_viewId               = pSrc->m_viewId;
+#if SONY_COLPIC_AVAILABILITY
+  m_iViewOrderIdx        = pSrc->m_iViewOrderIdx;
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  m_iViewOrderIdx        = pSrc->m_iViewOrderIdx;// will be changed to view_id
+  m_bIVScalingFlag       = pSrc->m_bIVScalingFlag;
 #endif
   m_eNalUnitType         = pSrc->m_eNalUnitType;
 …
   m_saoEnabledFlag = pSrc->m_saoEnabledFlag;
-#if SAO_UNIT_INTERLEAVING
   m_saoInterleavingFlag = pSrc->m_saoInterleavingFlag;
   m_saoEnabledFlagCb = pSrc->m_saoEnabledFlagCb;
   m_saoEnabledFlagCr = pSrc->m_saoEnabledFlagCr;
-#endif
 #if CABAC_INIT_FLAG
   m_cabacInitFlag                = pSrc->m_cabacInitFlag;
 #endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   m_numEntryPointOffsets  = pSrc->m_numEntryPointOffsets;
+#endif
+#if H0111_MVD_L1_ZERO
   m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
-#endif
+}
 …
 Void TComSlice::setTLayerInfo( UInt uiTLayer )
+{
-#if !H0566_TLA
-  // If temporal_id_nesting_flag == 1, then num_temporal_layer_switching_point_flags shall be inferred to be 0 and temporal_layer_switching_point_flag shall be inferred to be 1 for all temporal layers
-  if ( m_pcSPS->getTemporalIdNestingFlag() )
+  {
-    m_pcPPS->setNumTLayerSwitchingFlags( 0 );
-    for ( UInt i = 0; i < MAX_TLAYER; i++ )
+    {
-      m_pcPPS->setTLayerSwitchingFlag( i, true );
+    }
+  }
-  else
+  {
-    for ( UInt i = m_pcPPS->getNumTLayerSwitchingFlags(); i < MAX_TLAYER; i++ )
+    {
-      m_pcPPS->setTLayerSwitchingFlag( i, false );
+    }
+  }
-#endif
   m_uiTLayer = uiTLayer;
+#if !H0566_TLA
+  m_bTLayerSwitchingFlag = m_pcPPS->getTLayerSwitchingFlag( uiTLayer );
+#endif
+}
+#if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
+}
+#if H0566_TLA_SET_FOR_SWITCHING_POINTS
 /** Function for checking if this is a switching-point
 */
 …
 /** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
 */
-#if START_DECODING_AT_CRA
 Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag, Int pocRandomAccess)
-#else
-Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag)
-#endif
+{
   TComPic* rpcPic;
 …
     if(isAvailable == 0)
+    {
-#if START_DECODING_AT_CRA
       if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
+      {
-#endif
         if(!pReferencePictureSet->getUsed(i) )
+        {
 …
           iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
+        }
+#if START_DECODING_AT_CRA
+      }
+#endif
+      }
+    }
+  }
 …
     if(isAvailable == 0)
+    {
-#if START_DECODING_AT_CRA
       if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
+      {
-#endif
         if(!pReferencePictureSet->getUsed(i) )
+        {
 …
           iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
+        }
+#if START_DECODING_AT_CRA
+      }
+#endif
+      }
+    }
+  }
 …
     Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
     Int deltaRPS = pReferencePictureSet->getDeltaRPS();
-#if RPS_IN_SPS
     TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
-#else
-    TComReferencePictureSet* pcRefRPS = this->getPPS()->getRPSList()->getReferencePictureSet(rIdx);
-#endif
     Int iRefPics = pcRefRPS->getNumberOfPictures();
     Int iNewIdc=0;
 …
     pcRPS->setNumRefIdc(iNewIdc);
     pcRPS->setDeltaRPS(deltaRPS);
-#if RPS_IN_SPS
     pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
-#else
-    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getPPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
-#endif
+  }
 …
     Int iRefStride = pcRefPicYuvOrg->getStride();
     Int iSumOrgSAD = 0;
+#if LGE_ILLUCOMP_DEPTH_C0046
+    Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
+#else
     double dThresholdOrgSAD = 0.05;
+#endif
     // Histogram building - luminance
     for ( Int y = 0; y < iHeight; y++)
 …
 , m_picWidthInLumaSamples     (352)
 , m_picHeightInLumaSamples    (288)
-#if PIC_CROPPING
 , m_picCroppingFlag           (false)
 , m_picCropLeftOffset         (  0)
 …
 , m_picCropTopOffset          (  0)
 , m_picCropBottomOffset       (  0)
-#endif
 , m_uiMaxCUWidth              ( 32)
 , m_uiMaxCUHeight             ( 32)
 …
 , m_uiMinTrDepth              (  0)
 , m_uiMaxTrDepth              (  1)
-#if RPS_IN_SPS
 , m_bLongTermRefsPresent      (false)
-#endif
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-, m_numReorderFrames          (  0)
-#endif
 , m_iNumberOfUsableInterViewRefs( 0 )
 , m_uiQuadtreeTULog2MaxSize   (  0)
 …
 , m_bDisInter4x4              (  1)
 , m_bUseALF                   (false)
-#if LCU_SYNTAX_ALF
 , m_bALFCoefInSlice           (false)
-#endif
-#if !PIC_CROPPING
-, m_bUsePAD                   (false)
-#endif
 , m_bUseLMChroma              (false)
 , m_bUseLComb                 (false)
 , m_bLCMod                    (false)
-#if H0412_REF_PIC_LIST_RESTRICTION
 #if QC_MVHEVC_B0046
 , m_restrictedRefPicListsFlag   (  0)
 …
 #endif
 , m_listsModificationPresentFlag(  0)
-#endif
 , m_uiBitDepth                (  8)
 , m_uiBitIncrement            (  0)
-#if H0736_AVC_STYLE_QP_RANGE
 , m_qpBDOffsetY               (  0)
 , m_qpBDOffsetC               (  0)
-#endif
 #if LOSSLESS_CODING
 , m_useLossless               (false)
 …
 , m_bTemporalIdNestingFlag    (false)
 , m_scalingListEnabledFlag    (false)
-#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
-, m_uiMaxDecFrameBuffering    (  0)
-, m_uiMaxLatencyIncrease      (  0)
-#endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
 ,  m_tilesOrEntropyCodingSyncIdc( 0 )
 ,  m_numSubstreams              ( 0 )
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 , m_bUseDMM                   (false)
 …
   // AMVP parameter
   ::memset( m_aeAMVPMode, 0, sizeof( m_aeAMVPMode ) );
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   for ( Int i = 0; i < MAX_TLAYER; i++ )
+  {
 …
     m_numReorderPics[i]       = 0;
+  }
-#endif
   m_uiViewId              = 0;
 …
   ::memset( m_aiPdmOffset,        0x00, sizeof( m_aiPdmOffset         ) );
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   m_uiMultiviewMvPredMode    = 0;
 #endif
 …
 , m_iChromaQpOffset             (0)
 , m_iChromaQpOffset2nd          (0)
-#if !RPS_IN_SPS
-, m_bLongTermRefsPresent        (false)
-#endif
-#if !H0566_TLA
-, m_uiNumTlayerSwitchingFlags   (0)
-#endif
 , m_iSliceGranularity           (0)
 , m_iTileBehaviorControlPresentFlag (0)
 …
 , m_iColumnRowInfoPresent        (0)
 , m_iUniformSpacingIdr           (0)
-#if !REMOVE_TILE_DEPENDENCE
-, m_iTileBoundaryIndependenceIdr (0)
-#endif
 , m_iNumColumnsMinus1            (0)
 , m_puiColumnWidth               (NULL)
 , m_iNumRowsMinus1               (0)
 , m_puiRowHeight                 (NULL)
-#if !WPP_SIMPLIFICATION
-,  m_iEntropyCodingSynchro      (0)
-,  m_bCabacIstateReset          (false)
-#endif
 ,  m_iNumSubstreams             (1)
-#if MULTIBITS_DATA_HIDING
 , m_signHideFlag(0)
 , m_signHidingThreshold(0)
-#endif
 #if CABAC_INIT_FLAG
 , m_cabacInitPresentFlag        (false)
 …
 #endif
+{
-#if !H0566_TLA
-  for ( UInt i = 0; i < MAX_TLAYER; i++ )
+  {
-    m_abTLayerSwitchingFlag[i] = false;
+  }
-#endif
+}
 …
   m_uiPredDepthMapGeneration = uiPdmGenMode;
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   m_uiMultiviewMvPredMode    = uiPdmMvPredMode;
 #endif
 …
 : m_bRefPicListModificationFlagL0 (false)
 , m_bRefPicListModificationFlagL1 (false)
+#if !H0137_0138_LIST_MODIFICATION
+, m_uiNumberOfRefPicListModificationsL0 (0)
+, m_uiNumberOfRefPicListModificationsL1 (0)
+#endif
+{
+#if !H0137_0138_LIST_MODIFICATION
+  ::memset( m_ListIdcL0, 0, sizeof(m_ListIdcL0) );
+#endif
+{
   ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
-#if !H0137_0138_LIST_MODIFICATION
-  ::memset( m_ListIdcL1, 0, sizeof(m_ListIdcL1) );
-#endif
   ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
+}
 …
   m_bSaoEnabled = false;
   m_pSaoParam = NULL;
-#if LCU_SYNTAX_ALF
   m_alfParamSet = NULL;
-#else
-  m_pAlfParam = NULL;
-#endif
   m_scalingList = NULL;
   m_scalingListEnabled = false;
 …
   m_bSaoEnabled = src.m_bSaoEnabled;
   m_pSaoParam   = src.m_pSaoParam;
-#if LCU_SYNTAX_ALF
   m_alfParamSet    = src.m_alfParamSet;
-#else
-  m_pAlfParam   = src.m_pAlfParam;
-#endif
   m_scalingList = src.m_scalingList;
   m_scalingListEnabled = src.m_scalingListEnabled;
-#if SAO_UNIT_INTERLEAVING
   m_saoInterleavingFlag = src.m_saoInterleavingFlag;
-#endif
   return *this;
 …
 Void TComAPS::createAlfParam()
+{
-#if LCU_SYNTAX_ALF
   m_alfParamSet = new AlfParamSet;
-#else
-  m_pAlfParam = new ALFParam;
-#endif
+}
 Void TComAPS::destroyAlfParam()
+{
-#if LCU_SYNTAX_ALF
   if(m_alfParamSet != NULL)
+  {
 …
     m_alfParamSet = NULL;
+  }
-#else
-  if(m_pAlfParam != NULL)
+  {
-    delete m_pAlfParam;
-    m_pAlfParam = NULL;
+  }
-#endif
+}
 …
  * \returns true if use default quantization matrix in all size
 */
-#if SCALING_LIST
 Bool TComSlice::checkDefaultScalingList()
+{
 …
   return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? true : false; // -4 for 32x32
+}
-#else
-Bool TComSlice::checkDefaultScalingList()
+{
-  UInt i;
-  Int *dst=0;
-  Int *src=0;
-  UInt defaultCounter=0;
-  //4x4
-  for(i=0;i<SCALING_LIST_NUM;i++)
+  {
-    src = (i<3) ? g_quantIntraDefault4x4 : g_quantInterDefault4x4;
-    dst = getScalingList()->getScalingListAddress(SCALING_LIST_4x4,i);
-    if(::memcmp(dst,src,sizeof(UInt)*16) == 0) defaultCounter++;
+  }
-  //8x8
-  for(i=0;i<SCALING_LIST_NUM;i++)
+  {
-    src = (i<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
-    dst = getScalingList()->getScalingListAddress(SCALING_LIST_8x8,i);
-    if(::memcmp(dst,src,sizeof(UInt)*64) == 0) defaultCounter++;
+  }
-  //16x16
-  for(i=0;i<SCALING_LIST_NUM;i++)
+  {
-    src = (i<3) ? g_quantIntraDefault16x16 : g_quantInterDefault16x16;
-    dst = getScalingList()->getScalingListAddress(SCALING_LIST_16x16,i);
-    if(::memcmp(dst,src,sizeof(UInt)*256) == 0) defaultCounter++;
+  }
-  //32x32
-  for(i=0;i<SCALING_LIST_NUM_32x32;i++)
+  {
-    src = (i<1) ? g_quantIntraDefault32x32 : g_quantInterDefault32x32;
-    dst = getScalingList()->getScalingListAddress(SCALING_LIST_32x32,i*3);
-    if(::memcmp(dst,src,sizeof(UInt)*1024) == 0) defaultCounter++;
+  }
-  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? true : false; // -4 for 32x32
+}
-#endif
 /** get scaling matrix from RefMatrixID
  * \param sizeId size index
 …
 Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
+{
-#if SCALING_LIST
   ::memcpy(getScalingListAddress(sizeId, listId),getScalingListAddress(sizeId, refListId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
-#else
-  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListAddress(sizeId, refListId),sizeof(Int)*g_scalingListSize[sizeId]);
-#endif
+}
 /** parse syntax infomation
 …
   for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
+  {
-#if SCALING_LIST
     size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
-#else
-    size = g_scalingListSize[sizeIdc];
-#endif
     for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
+    {
 …
         src[i] = data;
+      }
-#if SCALING_LIST
       //set DC value for default matrix check
       setScalingListDC(sizeIdc,listIdc,src[0]);
 …
           setScalingListDC(sizeIdc,listIdc,data);
+      }
-#endif
+    }
+  }
 …
     for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
+    {
-#if SCALING_LIST
       m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
-#else
-      m_scalingListCoef[sizeId][listId] = new Int [g_scalingListSize[sizeId]];
-#endif
+    }
+  }
 …
       src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
       break;
-#if SCALING_LIST
     case SCALING_LIST_16x16:
       src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
 …
       src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
       break;
-#else
-    case SCALING_LIST_16x16:
-      src = (listId<3) ? g_quantIntraDefault16x16 : g_quantInterDefault16x16;
-      break;
-    case SCALING_LIST_32x32:
-      src = (listId<1) ? g_quantIntraDefault32x32 : g_quantInterDefault32x32;
-      break;
-#endif
     default:
       assert(0);
 …
 Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
+{
-#if SCALING_LIST
   ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
   setUseDefaultScalingMatrixFlag(sizeId,listId,true);
   setScalingListDC(sizeId,listId,SCALING_LIST_DC);
+#else
+  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*(Int)g_scalingListSize[sizeId]);
+#endif
+}
+#if SCALING_LIST
+}
 /** check DC value of matrix for default matrix signaling
  */
 …
+  }
+}
-#endif
 ParameterSetManager::ParameterSetManager()

trunk/source/Lib/TLibCommon/TComSlice.h

-                      r210
+                      r296
 class TComDepthMapGenerator;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 class TComResidualGenerator;
 #endif
 …
 // ====================================================================================================================
-#if RPS_IN_SPS
 /// Reference Picture Set class
 class TComReferencePictureSet
 …
   Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
 };
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
 …
   UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Bool          m_bIVScalingFlag;
+#endif
 public:
   TComVPS();
 …
   Void    setDependentLayer(UInt v, UInt layer)                     { m_uiDependentLayer[layer] = v;    }
   UInt    getDependentLayer(UInt layer)                             { return m_uiDependentLayer[layer]; }
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Bool getIVScalingFlag( )                                   { return m_bIVScalingFlag; }
+  Void setIVScalingFlag(Bool b)                              { m_bIVScalingFlag = b;    }
 #endif
   Void    setNumReorderPics(UInt v, UInt tLayer)                { m_numReorderPics[tLayer] = v;    }
 …
   UInt        m_picWidthInLumaSamples;
   UInt        m_picHeightInLumaSamples;
-#if PIC_CROPPING
   Bool        m_picCroppingFlag;
   Int         m_picCropLeftOffset;
 …
   Int         m_picCropTopOffset;
   Int         m_picCropBottomOffset;
-#else
-  Int         m_aiPad[2];
-#endif
   UInt        m_uiMaxCUWidth;
   UInt        m_uiMaxCUHeight;
 …
   UInt        m_uiMinTrDepth;
   UInt        m_uiMaxTrDepth;
-#if RPS_IN_SPS
   TComRPSList* m_RPSList;
   Bool        m_bLongTermRefsPresent;
-#endif
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Int         m_numReorderPics[MAX_TLAYER];
-#else
-  Int         m_maxNumberOfReferencePictures;
-  Int         m_numReorderFrames;
-#endif
   Int         m_iNumberOfUsableInterViewRefs;
 …
   Bool        m_useAMP;
   Bool        m_bUseALF;
-#if LCU_SYNTAX_ALF
   Bool        m_bALFCoefInSlice;
-#endif
-#if !PIC_CROPPING
-  Bool        m_bUsePAD;
-#endif
   Bool        m_bUseLMChroma; // JL:
 …
   Bool        m_useNSQT;
-#if H0412_REF_PIC_LIST_RESTRICTION
   Bool        m_restrictedRefPicListsFlag;
   Bool        m_listsModificationPresentFlag;
-#endif
   // Parameter
 …
   UInt        m_uiBitDepth;
   UInt        m_uiBitIncrement;
-#if H0736_AVC_STYLE_QP_RANGE
   Int         m_qpBDOffsetY;
   Int         m_qpBDOffsetC;
-#endif
 #if LOSSLESS_CODING
 …
   Bool        m_scalingListEnabledFlag;
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
-#else
-  UInt        m_uiMaxDecFrameBuffering;
-  UInt        m_uiMaxLatencyIncrease;
-#endif
   Bool        m_useDF;
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   UInt        m_tilesOrEntropyCodingSyncIdc;
   Int         m_numSubstreams;
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   UInt  m_uiMultiviewMvPredMode;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt  m_uiMultiviewResPredMode;
 #endif
 …
   TComDepthMapGenerator* m_pcDepthMapGenerator;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComResidualGenerator* m_pcResidualGenerator;
 #endif
 …
   UInt getPicHeightInLumaSamples      ()         { return  m_picHeightInLumaSamples;   }
-#if PIC_CROPPING
   Bool getPicCroppingFlag() const          { return m_picCroppingFlag; }
   Void setPicCroppingFlag(Bool val)        { m_picCroppingFlag = val; }
 …
   Int  getPicCropBottomOffset() const      { return m_picCropBottomOffset; }
   Void setPicCropBottomOffset(Int val)     { m_picCropBottomOffset = val; }
-#endif
   Void setMaxCUWidth  ( UInt u ) { m_uiMaxCUWidth = u;      }
 …
   UInt getQuadtreeTUMaxDepthInter()         { return m_uiQuadtreeTUMaxDepthInter; }
   UInt getQuadtreeTUMaxDepthIntra()         { return m_uiQuadtreeTUMaxDepthIntra; }
-#if !PIC_CROPPING
-  Void setPad         (Int iPad[2]) { m_aiPad[0] = iPad[0]; m_aiPad[1] = iPad[1]; }
-#endif
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Void setNumReorderPics(Int i, UInt tlayer)              { m_numReorderPics[tlayer] = i;    }
   Int  getNumReorderPics(UInt tlayer)                     { return m_numReorderPics[tlayer]; }
-#else
-  Void setMaxNumberOfReferencePictures( Int u )  { m_maxNumberOfReferencePictures = u;    }
-  Int  getMaxNumberOfReferencePictures()         { return m_maxNumberOfReferencePictures; }
-  Void setNumReorderFrames( Int i )              { m_numReorderFrames = i;    }
-  Int  getNumReorderFrames()                     { return m_numReorderFrames; }
-#endif
-#if RPS_IN_SPS
   Void      setRPSList( TComRPSList* RPSList )   { m_RPSList = RPSList;       }
   TComRPSList* getRPSList()                      { return m_RPSList;          }
   Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
   Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
-#endif
   Void setNumberOfUsableInterViewRefs( Int number )      { m_iNumberOfUsableInterViewRefs = number;    }
 …
   Int  getUsableInterViewRef( Int pos )                  { return m_aiUsableInterViewRefs[pos];        }
-#if !PIC_CROPPING
-  Void setPadX        ( Int  u ) { m_aiPad[0] = u; }
-  Void setPadY        ( Int  u ) { m_aiPad[1] = u; }
-  Int  getPad         ( Int  u ) { assert(u < 2); return m_aiPad[u];}
-  Int* getPad         ( )        { return m_aiPad; }
-#endif
   // physical transform
 …
   // Tool list
   Bool getUseALF      ()         { return m_bUseALF;        }
-#if LCU_SYNTAX_ALF
   Void setUseALFCoefInSlice(Bool b) {m_bALFCoefInSlice = b;}
   Bool getUseALFCoefInSlice()    {return m_bALFCoefInSlice;}
+#endif
+#if !PIC_CROPPING
+  Bool getUsePAD      ()         { return m_bUsePAD;        }
+  Void setUsePAD      ( Bool b ) { m_bUsePAD   = b;         }
+#endif
   Void setUseALF      ( Bool b ) { m_bUseALF  = b;          }
   Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
 …
   Void setUseNSQT( Bool b ) { m_useNSQT = b; }
-#if H0412_REF_PIC_LIST_RESTRICTION
   Bool getRestrictedRefPicListsFlag    ()          { return m_restrictedRefPicListsFlag;   }
   Void setRestrictedRefPicListsFlag    ( Bool b )  { m_restrictedRefPicListsFlag = b;      }
   Bool getListsModificationPresentFlag ()          { return m_listsModificationPresentFlag; }
   Void setListsModificationPresentFlag ( Bool b )  { m_listsModificationPresentFlag = b;    }
-#endif
   // AMVP mode (for each depth)
 …
   UInt      getBitIncrement ()         { return m_uiBitIncrement; }
   Void      setBitIncrement ( UInt u ) { m_uiBitIncrement = u;    }
-#if H0736_AVC_STYLE_QP_RANGE
   Int       getQpBDOffsetY  ()             { return m_qpBDOffsetY;   }
   Void      setQpBDOffsetY  ( Int value  ) { m_qpBDOffsetY = value;  }
   Int       getQpBDOffsetC  ()             { return m_qpBDOffsetC;   }
   Void      setQpBDOffsetC  ( Int value  ) { m_qpBDOffsetC = value;  }
-#endif
   Void      setLFCrossSliceBoundaryFlag     ( Bool   bValue  )    { m_bLFCrossSliceBoundaryFlag = bValue; }
 …
   Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
   Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
-#if !REMOVE_TILE_DEPENDENCE
-  Void     setTileBoundaryIndependenceIdr   ( Int i )           { m_iTileBoundaryIndependenceIdr = i; }
-  Int      getTileBoundaryIndependenceIdr   ()                  { return m_iTileBoundaryIndependenceIdr; }
-#endif
   Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
   Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
 …
   Bool getScalingListFlag       ()         { return m_scalingListEnabledFlag;     }
   Void setScalingListFlag       ( Bool b ) { m_scalingListEnabledFlag  = b;       }
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
   Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
   UInt getMaxLatencyIncrease  (UInt tlayer)            { return m_uiMaxLatencyIncrease[tlayer];   }
   Void setMaxLatencyIncrease  ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui;      }
-#else
-  UInt getMaxDecFrameBuffering  ()            { return m_uiMaxDecFrameBuffering; }
-  Void setMaxDecFrameBuffering  ( UInt ui )   { m_uiMaxDecFrameBuffering = ui;   }
-  UInt getMaxLatencyIncrease    ()            { return m_uiMaxLatencyIncrease;   }
-  Void setMaxLatencyIncrease    ( UInt ui )   { m_uiMaxLatencyIncrease= ui;      }
-#endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   UInt getTilesOrEntropyCodingSyncIdc ()                    { return m_tilesOrEntropyCodingSyncIdc;   }
   Void setTilesOrEntropyCodingSyncIdc ( UInt val )          { m_tilesOrEntropyCodingSyncIdc = val;    }
   Int  getNumSubstreams               ()                    { return m_numSubstreams;                 }
   Void setNumSubstreams               ( Int numSubstreams ) { m_numSubstreams = numSubstreams;        }
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 …
   Void setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode = 0, UInt uiPdmMvPredMode = 0, UInt uiPdmPrec = 0, Int** aaiPdmScaleNomDelta = 0, Int** aaiPdmOffset = 0 );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void  setMultiviewResPredMode  ( UInt uiResPrdMode ) { m_uiMultiviewResPredMode = uiResPrdMode; }
 #endif
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   UInt  getMultiviewMvPredMode   ()          { return m_uiMultiviewMvPredMode;    }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt  getMultiviewResPredMode  ()          { return m_uiMultiviewResPredMode;   }
 #endif
 …
   TComDepthMapGenerator*  getDepthMapGenerator()                                              { return m_pcDepthMapGenerator; }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void                    setResidualGenerator( TComResidualGenerator* pcResidualGenerator )  { m_pcResidualGenerator = pcResidualGenerator; }
   TComResidualGenerator*  getResidualGenerator()                                              { return m_pcResidualGenerator; }
 …
 };
-#if !RPS_IN_SPS
-/// Reference Picture Set class
-class TComReferencePictureSet
+{
-private:
-  Int m_numberOfPictures;
-  Int m_numberOfNegativePictures;
-  Int m_numberOfPositivePictures;
-  Int m_numberOfLongtermPictures;
-  Int  m_deltaPOC[MAX_NUM_REF_PICS];
-  Int  m_POC[MAX_NUM_REF_PICS];
-  Bool m_used[MAX_NUM_REF_PICS];
-  Bool m_interRPSPrediction;
-  Int  m_deltaRIdxMinus1;
-  Int  m_deltaRPS;
-  Int  m_numRefIdc;
-  Int  m_refIdc[MAX_NUM_REF_PICS+1];
-public:
-  TComReferencePictureSet();
-  virtual ~TComReferencePictureSet();
-  Void setUsed(Int bufferNum, Bool used);
-  Void setDeltaPOC(Int bufferNum, Int deltaPOC);
-  Void setPOC(Int bufferNum, Int deltaPOC);
-  Void setNumberOfPictures(Int numberOfPictures);
-  Int  getUsed(Int bufferNum);
-  Int  getDeltaPOC(Int bufferNum);
-  Int  getPOC(Int bufferNum);
-  Int  getNumberOfPictures();
-  Void setNumberOfNegativePictures(Int number)  { m_numberOfNegativePictures = number; }
-  Int  getNumberOfNegativePictures()            { return m_numberOfNegativePictures; }
-  Void setNumberOfPositivePictures(Int number)  { m_numberOfPositivePictures = number; }
-  Int  getNumberOfPositivePictures()            { return m_numberOfPositivePictures; }
-  Void setNumberOfLongtermPictures(Int number)  { m_numberOfLongtermPictures = number; }
-  Int  getNumberOfLongtermPictures()            { return m_numberOfLongtermPictures; }
-  Void setInterRPSPrediction(Bool flag)         { m_interRPSPrediction = flag; }
-  Bool getInterRPSPrediction()                  { return m_interRPSPrediction; }
-  Void setDeltaRIdxMinus1(Int x)                { m_deltaRIdxMinus1 = x; }
-  Int  getDeltaRIdxMinus1()                     { return m_deltaRIdxMinus1; }
-  Void setDeltaRPS(Int x)                       { m_deltaRPS = x; }
-  Int  getDeltaRPS()                            { return m_deltaRPS; }
-  Void setNumRefIdc(Int x)                      { m_numRefIdc = x; }
-  Int  getNumRefIdc()                           { return m_numRefIdc; }
-  Void setRefIdc(Int bufferNum, Int refIdc);
-  Int  getRefIdc(Int bufferNum);
-  Void sortDeltaPOC();
-  Void printDeltaPOC();
-};
-/// Reference Picture Set set class
-class TComRPSList
+{
-private:
-  Int  m_numberOfReferencePictureSets;
-  TComReferencePictureSet* m_referencePictureSets;
-public:
-  TComRPSList();
-  virtual ~TComRPSList();
-  Void  create  (Int numberOfEntries);
-  Void  destroy ();
-  TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
-  Int getNumberOfReferencePictureSets();
-  Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
-};
-#endif
 /// Reference Picture Lists class
 …
   UInt      m_bRefPicListModificationFlagL0;
   UInt      m_bRefPicListModificationFlagL1;
-#if !H0137_0138_LIST_MODIFICATION
-  UInt      m_uiNumberOfRefPicListModificationsL0;
-  UInt      m_uiNumberOfRefPicListModificationsL1;
-  UInt      m_ListIdcL0[32];
-#endif
   UInt      m_RefPicSetIdxL0[32];
-#if !H0137_0138_LIST_MODIFICATION
-  UInt      m_ListIdcL1[32];
-#endif
   UInt      m_RefPicSetIdxL1[32];
 …
   Bool       getRefPicListModificationFlagL1() { return m_bRefPicListModificationFlagL1; }
   Void       setRefPicListModificationFlagL1(Bool flag) { m_bRefPicListModificationFlagL1 = flag; }
-#if !H0137_0138_LIST_MODIFICATION
-  UInt       getNumberOfRefPicListModificationsL0() { return m_uiNumberOfRefPicListModificationsL0; }
-  Void       setNumberOfRefPicListModificationsL0(UInt nr) { m_uiNumberOfRefPicListModificationsL0 = nr; }
-  UInt       getNumberOfRefPicListModificationsL1() { return m_uiNumberOfRefPicListModificationsL1; }
-  Void       setNumberOfRefPicListModificationsL1(UInt nr) { m_uiNumberOfRefPicListModificationsL1 = nr; }
-  Void       setListIdcL0(UInt idx, UInt idc) { m_ListIdcL0[idx] = idc; }
-  UInt       getListIdcL0(UInt idx) { return m_ListIdcL0[idx]; }
-#endif
   Void       setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL0[idx] = refPicSetIdx; }
   UInt       getRefPicSetIdxL0(UInt idx) { return m_RefPicSetIdxL0[idx]; }
-#if !H0137_0138_LIST_MODIFICATION
-  Void       setListIdcL1(UInt idx, UInt idc) { m_ListIdcL1[idx] = idc; }
-  UInt       getListIdcL1(UInt idx) { return m_ListIdcL1[idx]; }
-#endif
   Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
   UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
 …
   // access channel
   TComSPS*    m_pcSPS;
-#if !RPS_IN_SPS
-  TComRPSList* m_RPSList;
-#endif
   UInt        m_uiMaxCuDQPDepth;
   UInt        m_uiMinCuDQPSize;
 …
   Int        m_iChromaQpOffset2nd;
+#if !RPS_IN_SPS
+  Bool        m_bLongTermRefsPresent;
+#endif
+#if !H0566_TLA
+  UInt        m_uiNumTlayerSwitchingFlags;            // num_temporal_layer_switching_point_flags
+  Bool        m_abTLayerSwitchingFlag[ MAX_TLAYER ];  // temporal_layer_switching_point_flag
+#endif
   Int         m_iSliceGranularity;
 …
   UInt        m_uiBiPredIdc;              // Use of Weighting Bi-Prediction (B_SLICE)
-#if H0388
   Bool        m_OutputFlagPresentFlag;   // Indicates the presence of output_flag in slice header
-#endif
   Int      m_iTileBehaviorControlPresentFlag;
 …
   Int      m_iColumnRowInfoPresent;
   Int      m_iUniformSpacingIdr;
-#if !REMOVE_TILE_DEPENDENCE
-  Int      m_iTileBoundaryIndependenceIdr;
-#endif
   Int      m_iNumColumnsMinus1;
   UInt*    m_puiColumnWidth;
 …
   Int      m_iEntropyCodingMode; // !!! in PPS now, but also remains in slice header!
-#if !WPP_SIMPLIFICATION
-  Int      m_iEntropyCodingSynchro;
-  Bool     m_bCabacIstateReset;
-#endif
   Int      m_iNumSubstreams;
   Bool     m_enableTMVPFlag;
-#if MULTIBITS_DATA_HIDING
   Int      m_signHideFlag;
   Int      m_signHidingThreshold;
-#endif
 #if CABAC_INIT_FLAG
 …
 #endif
 #endif
-#if DBL_CONTROL
   Bool     m_DeblockingFilterControlPresent;
-#endif
-#if PARALLEL_MERGE
   UInt m_log2ParallelMergeLevelMinus2;
-#endif
 public:
   TComPPS();
 …
   Void      setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b;     }
+#if !H0566_TLA
+  UInt      getNumTLayerSwitchingFlags()                                  { return m_uiNumTlayerSwitchingFlags; }
+  Void      setNumTLayerSwitchingFlags( UInt uiNumTlayerSwitchingFlags )  { assert( uiNumTlayerSwitchingFlags < MAX_TLAYER ); m_uiNumTlayerSwitchingFlags = uiNumTlayerSwitchingFlags; }
+  Bool      getTLayerSwitchingFlag( UInt uiTLayer )                       { assert( uiTLayer < MAX_TLAYER ); return m_abTLayerSwitchingFlag[ uiTLayer ]; }
+  Void      setTLayerSwitchingFlag( UInt uiTLayer, Bool bValue )          { m_abTLayerSwitchingFlag[ uiTLayer ] = bValue; }
+#endif
+#if !RPS_IN_SPS
+  Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
+  Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
+#endif
   Void      setSPS              ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
   TComSPS*  getSPS              ()         { return m_pcSPS;          }
-#if !RPS_IN_SPS
-  Void      setRPSList          ( TComRPSList* RPSList ) { m_RPSList = RPSList; }
-  TComRPSList* getRPSList       ()         { return m_RPSList;        }
-#endif
   Void      setMaxCuDQPDepth    ( UInt u ) { m_uiMaxCuDQPDepth = u;   }
   UInt      getMaxCuDQPDepth    ()         { return m_uiMaxCuDQPDepth;}
 …
   Void setWPBiPredIdc               ( UInt u )  { m_uiBiPredIdc = u;        }
-#if H0388
   Void      setOutputFlagPresentFlag( Bool b )  { m_OutputFlagPresentFlag = b;    }
   Bool      getOutputFlagPresentFlag()          { return m_OutputFlagPresentFlag; }
-#endif
   Void    setTileBehaviorControlPresentFlag        ( Int i )             { m_iTileBehaviorControlPresentFlag = i;    }
 …
   Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
   Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
-#if !REMOVE_TILE_DEPENDENCE
-  Void     setTileBoundaryIndependenceIdr   ( Int i )           { m_iTileBoundaryIndependenceIdr = i; }
-  Int      getTileBoundaryIndependenceIdr   ()                  { return m_iTileBoundaryIndependenceIdr; }
-#endif
   Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
   Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
 …
   Void     setEntropyCodingMode(Int iEntropyCodingMode)       { m_iEntropyCodingMode = iEntropyCodingMode; }
   Int      getEntropyCodingMode()                             { return m_iEntropyCodingMode; }
-#if !WPP_SIMPLIFICATION
-  Void     setEntropyCodingSynchro(Int iEntropyCodingSynchro) { m_iEntropyCodingSynchro = iEntropyCodingSynchro; }
-  Int      getEntropyCodingSynchro()                          { return m_iEntropyCodingSynchro; }
-  Void     setCabacIstateReset(Bool bCabacIstateReset)        { m_bCabacIstateReset = bCabacIstateReset; }
-  Bool     getCabacIstateReset()                              { return m_bCabacIstateReset; }
-#endif
   Void     setNumSubstreams(Int iNumSubstreams)               { m_iNumSubstreams = iNumSubstreams; }
   Int      getNumSubstreams()                                 { return m_iNumSubstreams; }
-#if MULTIBITS_DATA_HIDING
   Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
   Void      setTSIG( Int tsig )                 { m_signHidingThreshold = tsig; }
   Int       getSignHideFlag()                    { return m_signHideFlag; }
   Int       getTSIG()                            { return m_signHidingThreshold; }
-#endif
   Void     setEnableTMVPFlag( Bool b )  { m_enableTMVPFlag = b;    }
 …
 #endif
 #endif
-#if DBL_CONTROL
   Void setDeblockingFilterControlPresent    ( Bool bValue )       { m_DeblockingFilterControlPresent = bValue; }
   Bool getDeblockingFilterControlPresent    ()                    { return m_DeblockingFilterControlPresent; }
-#endif
-#if PARALLEL_MERGE
   UInt getLog2ParallelMergeLevelMinus2      ()                    { return m_log2ParallelMergeLevelMinus2; }
   Void setLog2ParallelMergeLevelMinus2      (UInt mrgLevel)       { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
-#endif
 };
 …
   Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
   Void     processDefaultMarix            (UInt sizeId, UInt listId);
-#if SCALING_LIST
   Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
   Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
 …
   Void     setUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId, Bool b)   { m_useDefaultScalingMatrixFlag[sizeId][listId] = b;    } //!< set default matrix enabled/disabled in each matrix
   Bool     getUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId)           { return m_useDefaultScalingMatrixFlag[sizeId][listId]; } //!< get default matrix enabled/disabled in each matrix
-#endif
   Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
   Bool     xParseScalingList              (char* pchFile);
 …
   Void     init                    ();
   Void     destroy                 ();
-#if SCALING_LIST
   Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
   Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
-#endif
   UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
   Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
 …
   Bool      getAlfEnabled ()          {return m_bAlfEnabled;     }  //!< get ALF enabled/disabled in APS
-#if LCU_SYNTAX_ALF
   AlfParamSet* getAlfParam   ()          {return m_alfParamSet;}
-#else
-  ALFParam* getAlfParam   ()          {return m_pAlfParam;       }  //!< get ALF parameters in APS
-#endif
   SAOParam* getSaoParam   ()          {return m_pSaoParam;       }  //!< get SAO parameters in APS
 …
   Bool      getScalingListEnabled ()          { return m_scalingListEnabled; }  //!< get ScalingList enabled/disabled in APS
   TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in APS
-#if SAO_UNIT_INTERLEAVING
   Bool     getSaoInterleavingFlag() {return m_saoInterleavingFlag;}             //!< get SAO interleaving flag in APS
   Void     setSaoInterleavingFlag(Bool bVal) {m_saoInterleavingFlag = bVal;}    //!< set SAO interleaving flag in APS
-#endif
 private:
 …
   Bool        m_bAlfEnabled;  //!< ALF enabled/disabled in APS (true for enabled)
   SAOParam*   m_pSaoParam;    //!< SAO parameter object pointer
-#if LCU_SYNTAX_ALF
   AlfParamSet*   m_alfParamSet;
-#else
-  ALFParam*   m_pAlfParam;    //!< ALF parameter object pointer
-#endif
   Bool        m_loopFilterOffsetInAPS;       //< offset for deblocking filter in 0 = slice header, 1 = APS
   Bool        m_loopFilterDisable;           //< Deblocking filter enabled/disabled in APS
 …
   Bool        m_scalingListEnabled;     //!< ScalingList enabled/disabled in APS (true for enabled)
   TComScalingList*     m_scalingList;   //!< ScalingList class pointer
-#if SAO_UNIT_INTERLEAVING
   Bool        m_saoInterleavingFlag;    //!< SAO interleaving flag
-#endif
 public:
 …
   bool       m_alfEnabledFlag;
   bool       m_saoEnabledFlag;
-#if SAO_UNIT_INTERLEAVING
   bool       m_saoInterleavingFlag;   ///< SAO interleaving flag
   bool       m_saoEnabledFlagCb;      ///< SAO Cb enabled flag
   bool       m_saoEnabledFlagCr;      ///< SAO Cr enabled flag
-#endif
   Int         m_iPPSId;               ///< picture parameter set ID
-#if H0388
   Bool        m_PicOutputFlag;        ///< pic_output_flag
-#endif
   Int         m_iPOC;
   Int         m_iLastIDR;
 …
   Bool        m_bCheckLDC;
+#if QC_TMVP_MRG_REFIDX_C0047
+  Int         m_aiNewRefIdx    [2];
+#endif
   //  Data
 …
 #endif
 #if QC_IV_AS_LT_B0046
   Bool                  m_bWasLongTerm[2][MAX_NUM_REF+1]; //was long-term picture
+  Bool        m_bWasLongTerm[2][MAX_NUM_REF+1]; //was long-term picture
 #endif
   TComSPS*    m_pcSPS;
 …
 #endif
-#if H0111_MVD_L1_ZERO
   Bool       m_bLMvdL1Zero;
-#endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   Int         m_numEntryPointOffsets;
-#endif
   Int        m_viewId;
 …
   Int        m_aaiCodedOffset[2][MAX_VIEW_NUM];
-#if SONY_COLPIC_AVAILABILITY|QC_MVHEVC_B0046
-  Int         m_iViewOrderIdx;
-#endif
 #if LGE_ILLUCOMP_B0045
   Bool        m_bApplyIC;
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115|QC_MVHEVC_B0046
+  Bool       m_bIVScalingFlag;
+  Int        m_iViewOrderIdx;    // will be changed to view_id
+#endif
+#if MERL_VSP_C0152
+  TComPic*     m_apcRefPicBaseTxt;
+  TComPic*     m_apcRefPicBaseDepth;
+  Int*         m_aiShiftLUT;
+  Int          m_iShiftPrec;
 #endif
 …
   Void      setAPSId        ( Int Id)          { m_iAPSId =Id;    } //!< set APS ID
   Int       getAPSId        ()                 { return m_iAPSId; } //!< get APS ID
-#if H0388
   Void      setPicOutputFlag( Bool b )         { m_PicOutputFlag = b;    }
   Bool      getPicOutputFlag()                 { return m_PicOutputFlag; }
-#endif
   Void      setAlfEnabledFlag(Bool s) {m_alfEnabledFlag =s; }
   Bool      getAlfEnabledFlag() { return m_alfEnabledFlag; }
   Void      setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
   Bool      getSaoEnabledFlag() { return m_saoEnabledFlag; }
-#if SAO_UNIT_INTERLEAVING
   Void      setSaoInterleavingFlag(Bool s) {m_saoInterleavingFlag =s; } //!< set SAO interleaving flag
   Bool      getSaoInterleavingFlag() { return m_saoInterleavingFlag;  } //!< get SAO interleaving flag
 …
   Void      setSaoEnabledFlagCr(Bool s) {m_saoEnabledFlagCr =s; }       //!< set SAO Cr enabled flag
   Bool      getSaoEnabledFlagCr() { return m_saoEnabledFlagCr; }        //!< get SAO Cr enabled flag
-#endif
   Void      setRPS          ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
   TComReferencePictureSet*  getRPS          () { return m_pcRPS; }
 …
   Int       getRefViewId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefViewIdList[e][iRefIdx]; }
   TComPic*  getTexturePic       () const                        { return  m_pcTexturePic; }
-#if SONY_COLPIC_AVAILABILITY
-  Int       getViewOrderIdx     ()                                  { return  m_iViewOrderIdx;              }
-#endif
   Int       getDepth            ()                              { return  m_iDepth;                     }
   UInt      getColDir           ()                              { return  m_uiColDir;                   }
 …
 #endif
   Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
-#if H0111_MVD_L1_ZERO
   Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
-#endif
   Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
   Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
 …
   Void      setRefViewId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefViewIdList[e][iRefIdx] = i; }
   Void      setTexturePic       ( TComPic *pcTexturePic )       { m_pcTexturePic = pcTexturePic; }
-#if SONY_COLPIC_AVAILABILITY
-  Void      setViewOrderIdx     ( Int i )                       { m_iViewOrderIdx     = i;      }
-#endif
   Void      setNumRefIdx        ( RefPicList e, Int i )         { m_aiNumRefIdx[e]    = i;      }
   Void      setPic              ( TComPic* p )                  { m_pcPic             = p;      }
 …
 #endif
   Void      setCheckLDC         ( Bool b )                      { m_bCheckLDC = b; }
-#if H0111_MVD_L1_ZERO
   Void      setMvdL1ZeroFlag     ( Bool b)                       { m_bLMvdL1Zero = b; }
-#endif
   Bool      isIntra         ()                          { return  m_eSliceType == I_SLICE;  }
 …
   Void setTLayer             ( UInt uiTLayer )             { m_uiTLayer = uiTLayer;                  }
-#if !H0566_TLA
-  Bool getTLayerSwitchingFlag()                            { return m_bTLayerSwitchingFlag;          }
-  Void setTLayerSwitchingFlag( Bool bValue )               { m_bTLayerSwitchingFlag = bValue;        }
-#endif
   Void setTLayerInfo( UInt uiTLayer );
   Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
   Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
 #if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
+#if H0566_TLA_SET_FOR_SWITCHING_POINTS
   Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
 #endif
-#if START_DECODING_AT_CRA
   Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag, Int pocRandomAccess = 0);
-#else
-  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag);
-#endif
   Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet);
 …
   Int       getCABACinitIDC()         {return m_cabacInitIdc;    }  //!< get CABAC initial IDC number
 #endif
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   Void      setNumEntryPointOffsets(Int val)  { m_numEntryPointOffsets = val;     }
   Int       getNumEntryPointOffsets()         { return m_numEntryPointOffsets;    }
-#endif
   Void setViewId( Int viewId )       { m_viewId = viewId;   }
 …
   Bool      getApplyIC            ()  { return m_bApplyIC; }
   Void      xSetApplyIC           ();
+#endif
+#if QC_TMVP_MRG_REFIDX_C0047
+  Int       getNewRefIdx        ( RefPicList e )                { return  m_aiNewRefIdx[e];     }
+  Void      setNewRefIdx        ( RefPicList e, Int i )         { m_aiNewRefIdx[e]    = i;      }
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Void setIVScalingFlag( Bool val )         { m_bIVScalingFlag = val;     }
+  Bool getIVScalingFlag()                   { return m_bIVScalingFlag;    }
+  Void setViewOrderIdx     ( Int i )        { m_iViewOrderIdx     = i;    }   // will be changed to view_id
+  Int  getViewOrderIdx     ()               { return  m_iViewOrderIdx;    }   // will be changed to view_id
+#endif
+#if MERL_VSP_C0152
+  TComPic*     getRefPicBaseTxt          ()                        { return  m_apcRefPicBaseTxt; }
+  Void         setRefPicBaseTxt          ( TComPic* RefPic)        { m_apcRefPicBaseTxt = RefPic; }
+  TComPic*     getRefPicBaseDepth        ()                        { return  m_apcRefPicBaseDepth; }
+  Void         setRefPicBaseDepth        ( TComPic* RefPic)        { m_apcRefPicBaseDepth = RefPic; }
+  Void setBWVSPLUTParam( Int *pShiftLUT, Int iLoG2LUTPrec) { m_aiShiftLUT = pShiftLUT; m_iShiftPrec = iLoG2LUTPrec; }
+  Void getBWVSPLUTParam( Int*&pShiftLUT, Int&iLoG2LUTPrec) { pShiftLUT = m_aiShiftLUT; iLoG2LUTPrec = m_iShiftPrec; }
 #endif

trunk/source/Lib/TLibCommon/TComTrQuant.cpp

-                      r56
+                      r296
-#if H0736_AVC_STYLE_QP_RANGE
 /** Set qP for Quantization.
  * \param qpy QPy
 …
   m_cQP.setQpParam( qpScaled, bLowpass, eSliceType );
+}
-#else
-/// Including Chroma QP Parameter setting
-Void TComTrQuant::setQPforQuant( Int iQP, Bool bLowpass, SliceType eSliceType, TextType eTxtType, Int Shift)
+{
-  iQP = Clip3( MIN_QP, MAX_QP, iQP + Shift );
-  if(eTxtType != TEXT_LUMA) //Chroma
+  {
-    iQP  = g_aucChromaScale[ iQP ];
+  }
-  m_cQP.setQpParam( iQP, bLowpass, eSliceType );
+}
-#endif
 #if MATRIX_MULT
 …
  *  \param shift specifies right shift after 1D transform
  */
-#if !UNIFIED_TRANSFORM
-void partialButterfly4(short src[4][4],short dst[4][4],int shift)
+{
-  int j;
-  int E[2],O[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<4; j++)
+  {
-    /* E and O */
-    E[0] = src[j][0] + src[j][3];
-    O[0] = src[j][0] - src[j][3];
-    E[1] = src[j][1] + src[j][2];
-    O[1] = src[j][1] - src[j][2];
-    dst[0][j] = (g_aiT4[0][0]*E[0] + g_aiT4[0][1]*E[1] + add)>>shift;
-    dst[2][j] = (g_aiT4[2][0]*E[0] + g_aiT4[2][1]*E[1] + add)>>shift;
-    dst[1][j] = (g_aiT4[1][0]*O[0] + g_aiT4[1][1]*O[1] + add)>>shift;
-    dst[3][j] = (g_aiT4[3][0]*O[0] + g_aiT4[3][1]*O[1] + add)>>shift;
+  }
+}
-#endif
 void partialButterfly4(short *src,short *dst,int shift, int line)
 …
 // Fast DST Algorithm. Full matrix multiplication for DST and Fast DST algorithm
 // give identical results
-#if UNIFIED_TRANSFORM
 void fastForwardDst(short *block,short *coeff,int shift)  // input block, output coeff
-#else
-void fastForwardDst(short block[4][4],short coeff[4][4],int shift)  // input block, output coeff
-#endif
+{
   int i, c[4];
 …
+  {
     // Intermediate Variables
-#if UNIFIED_TRANSFORM
     c[0] = block[4*i+0] + block[4*i+3];
     c[1] = block[4*i+1] + block[4*i+3];
 …
     coeff[ 8+i] =  ( 29 * c[2] + 55 * c[0]         - c[3]               + rnd_factor ) >> shift;
     coeff[12+i] =  ( 55 * c[2] - 29 * c[1]         + c[3]               + rnd_factor ) >> shift;
+#else
+    c[0] = block[i][0] + block[i][3];
+    c[1] = block[i][1] + block[i][3];
+    c[2] = block[i][0] - block[i][1];
+    c[3] = 74* block[i][2];
+    coeff[0][i] =  ( 29 * c[0] + 55 * c[1]         + c[3]               + rnd_factor ) >> shift;
+    coeff[1][i] =  ( 74 * (block[i][0]+ block[i][1] - block[i][3])      + rnd_factor ) >> shift;
+    coeff[2][i] =  ( 29 * c[2] + 55 * c[0]         - c[3]               + rnd_factor ) >> shift;
+    coeff[3][i] =  ( 55 * c[2] - 29 * c[1]         + c[3]               + rnd_factor ) >> shift;
+#endif
+  }
+}
+#if UNIFIED_TRANSFORM
+  }
+}
 void fastInverseDst(short *tmp,short *block,int shift)  // input tmp, output block
-#else
-void fastInverseDst(short tmp[4][4],short block[4][4],int shift)  // input tmp, output block
-#endif
+{
   int i, c[4];
 …
+  {
     // Intermediate Variables
-#if UNIFIED_TRANSFORM
     c[0] = tmp[  i] + tmp[ 8+i];
     c[1] = tmp[8+i] + tmp[12+i];
 …
     block[4*i+2] = Clip3( -32768, 32767, ( 74 * (tmp[i] - tmp[8+i]  + tmp[12+i])      + rnd_factor ) >> shift );
     block[4*i+3] = Clip3( -32768, 32767, ( 55 * c[0] + 29 * c[2]     - c[3]               + rnd_factor ) >> shift );
+#else
+    c[0] = tmp[0][i] + tmp[2][i];
+    c[1] = tmp[2][i] + tmp[3][i];
+    c[2] = tmp[0][i] - tmp[3][i];
+    c[3] = 74* tmp[1][i];
+    block[i][0] = Clip3( -32768, 32767, ( 29 * c[0] + 55 * c[1]     + c[3]               + rnd_factor ) >> shift );
+    block[i][1] = Clip3( -32768, 32767, ( 55 * c[2] - 29 * c[1]     + c[3]               + rnd_factor ) >> shift );
+    block[i][2] = Clip3( -32768, 32767, ( 74 * (tmp[0][i] - tmp[2][i]  + tmp[3][i])      + rnd_factor ) >> shift );
+    block[i][3] = Clip3( -32768, 32767, ( 55 * c[0] + 29 * c[2]     - c[3]               + rnd_factor ) >> shift );
+#endif
+  }
+}
+#if !UNIFIED_TRANSFORM
+/** 4x4 forward transform (2D)
+ *  \param block input data (residual)
+ *  \param coeff output data (transform coefficients)
+ *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
+ */
+void xTr4(short block[4][4],short coeff[4][4],UInt uiMode)
+{
+#if FULL_NBIT
+  int shift_1st = 1 + g_uiBitDepth - 8; // log2(4) - 1 + g_uiBitDepth - 8
+#else
+  int shift_1st = 1 + g_uiBitIncrement; // log2(4) - 1 + g_uiBitIncrement
+#endif
+  int shift_2nd = 8;                    // log2(4) + 6
+  short tmp[4][4];
+#if LOGI_INTRA_NAME_3MPM
+  if (uiMode != REG_DCT && (!uiMode || (uiMode>=2 && uiMode <= 25)))    // Check for DCT or DST
+#else
+  if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode])// Check for DCT or DST
+#endif
+  {
+    fastForwardDst(block,tmp,shift_1st); // Forward DST BY FAST ALGORITHM, block input, tmp output
+  }
+  else
+  {
+    partialButterfly4(block,tmp,shift_1st);
+  }
+#if LOGI_INTRA_NAME_3MPM
+  if (uiMode != REG_DCT && (!uiMode || (uiMode>=11 && uiMode <= 34)))    // Check for DCT or DST
+#else
+  if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode] )   // Check for DCT or DST
+#endif
+  {
+    fastForwardDst(tmp,coeff,shift_2nd); // Forward DST BY FAST ALGORITHM, tmp input, coeff output
+  }
+  else
+  {
+    partialButterfly4(tmp,coeff,shift_2nd);
+  }
+}
+/** 4x4 inverse transform implemented using partial butterfly structure (1D)
+ *  \param src   input data (transform coefficients)
+ *  \param dst   output data (residual)
+ *  \param shift specifies right shift after 1D transform
+ */
+void partialButterflyInverse4(short src[4][4],short dst[4][4],int shift)
+{
+  int j;
+  int E[2],O[2];
+  int add = 1<<(shift-1);
+  for (j=0; j<4; j++)
+  {
+    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
+    O[0] = g_aiT4[1][0]*src[1][j] + g_aiT4[3][0]*src[3][j];
+    O[1] = g_aiT4[1][1]*src[1][j] + g_aiT4[3][1]*src[3][j];
+    E[0] = g_aiT4[0][0]*src[0][j] + g_aiT4[2][0]*src[2][j];
+    E[1] = g_aiT4[0][1]*src[0][j] + g_aiT4[2][1]*src[2][j];
+    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
+    dst[j][0] = Clip3( -32768, 32767, (E[0] + O[0] + add)>>shift );
+    dst[j][1] = Clip3( -32768, 32767, (E[1] + O[1] + add)>>shift );
+    dst[j][2] = Clip3( -32768, 32767, (E[1] - O[1] + add)>>shift );
+    dst[j][3] = Clip3( -32768, 32767, (E[0] - O[0] + add)>>shift );
+  }
+}
+#endif
+  }
+}
 void partialButterflyInverse4(short *src,short *dst,int shift, int line)
 …
+}
-#if !UNIFIED_TRANSFORM
-/** 4x4 inverse transform (2D)
- *  \param coeff input data (transform coefficients)
- *  \param block output data (residual)
- *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
- */
-void xITr4(short coeff[4][4],short block[4][4], UInt uiMode)
+{
-  int shift_1st = SHIFT_INV_1ST;
-#if FULL_NBIT
-  int shift_2nd = SHIFT_INV_2ND - ((short)g_uiBitDepth - 8);
-#else
-  int shift_2nd = SHIFT_INV_2ND - g_uiBitIncrement;
-#endif
-  short tmp[4][4];
-#if LOGI_INTRA_NAME_3MPM
-  if (uiMode != REG_DCT && (!uiMode || (uiMode>=11 && uiMode <= 34)))    // Check for DCT or DST
-#else
-  if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode] )    // Check for DCT or DST
-#endif
+  {
-    fastInverseDst(coeff,tmp,shift_1st);    // Inverse DST by FAST Algorithm, coeff input, tmp output
+  }
-  else
+  {
-    partialButterflyInverse4(coeff,tmp,shift_1st);
+  }
-#if LOGI_INTRA_NAME_3MPM
-  if (uiMode != REG_DCT && (!uiMode || (uiMode>=2 && uiMode <= 25)))    // Check for DCT or DST
-#else
-  if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode] )    // Check for DCT or DST
-#endif
+  {
-    fastInverseDst(tmp,block,shift_2nd); // Inverse DST by FAST Algorithm, tmp input, coeff output
+  }
-  else
+  {
-    partialButterflyInverse4(tmp,block,shift_2nd);
+  }
+}
-/** 8x8 forward transform implemented using partial butterfly structure (1D)
- *  \param src   input data (residual)
- *  \param dst   output data (transform coefficients)
- *  \param shift specifies right shift after 1D transform
- */
-void partialButterfly8(short src[8][8],short dst[8][8],int shift)
+{
-  int j,k;
-  int E[4],O[4];
-  int EE[2],EO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<8; j++)
+  {
-    /* E and O*/
-    for (k=0;k<4;k++)
+    {
-      E[k] = src[j][k] + src[j][7-k];
-      O[k] = src[j][k] - src[j][7-k];
+    }
-    /* EE and EO */
-    EE[0] = E[0] + E[3];
-    EO[0] = E[0] - E[3];
-    EE[1] = E[1] + E[2];
-    EO[1] = E[1] - E[2];
-    dst[0][j] = (g_aiT8[0][0]*EE[0] + g_aiT8[0][1]*EE[1] + add)>>shift;
-    dst[4][j] = (g_aiT8[4][0]*EE[0] + g_aiT8[4][1]*EE[1] + add)>>shift;
-    dst[2][j] = (g_aiT8[2][0]*EO[0] + g_aiT8[2][1]*EO[1] + add)>>shift;
-    dst[6][j] = (g_aiT8[6][0]*EO[0] + g_aiT8[6][1]*EO[1] + add)>>shift;
-    dst[1][j] = (g_aiT8[1][0]*O[0] + g_aiT8[1][1]*O[1] + g_aiT8[1][2]*O[2] + g_aiT8[1][3]*O[3] + add)>>shift;
-    dst[3][j] = (g_aiT8[3][0]*O[0] + g_aiT8[3][1]*O[1] + g_aiT8[3][2]*O[2] + g_aiT8[3][3]*O[3] + add)>>shift;
-    dst[5][j] = (g_aiT8[5][0]*O[0] + g_aiT8[5][1]*O[1] + g_aiT8[5][2]*O[2] + g_aiT8[5][3]*O[3] + add)>>shift;
-    dst[7][j] = (g_aiT8[7][0]*O[0] + g_aiT8[7][1]*O[1] + g_aiT8[7][2]*O[2] + g_aiT8[7][3]*O[3] + add)>>shift;
+  }
+}
-#endif
 void partialButterfly8(short *src,short *dst,int shift, int line)
 …
+}
+#if !UNIFIED_TRANSFORM
+/** 8x8 forward transform (2D)
+ *  \param block input data (residual)
+ *  \param coeff  output data (transform coefficients)
+ */
+void xTr8(short block[8][8],short coeff[8][8])
+{
+#if FULL_NBIT
+  int shift_1st = 2 + g_uiBitDepth - 8; // log2(8) - 1 + g_uiBitDepth - 8
+#else
+  int shift_1st = 2 + g_uiBitIncrement; // log2(8) - 1 + g_uiBitIncrement
+#endif
+  int shift_2nd = 9;                    // log2(8) + 6
+  short tmp[8][8];
+  partialButterfly8(block,tmp,shift_1st);
+  partialButterfly8(tmp,coeff,shift_2nd);
+}
+/** 8x8 inverse transform implemented using partial butterfly structure (1D)
+ *  \param src   input data (transform coefficients)
+ *  \param dst   output data (residual)
+ *  \param shift specifies right shift after 1D transform
+ */
+void partialButterflyInverse8(short src[8][8],short dst[8][8],int shift)
+void partialButterflyInverse8(short *src,short *dst,int shift, int line)
+{
   int j,k;
 …
   int add = 1<<(shift-1);
   for (j=0; j<8; j++)
+  for (j=0; j<line; j++)
+  {
     /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
     for (k=0;k<4;k++)
+    {
       O[k] = g_aiT8[ 1][k]*src[ 1][j] + g_aiT8[ 3][k]*src[ 3][j] + g_aiT8[ 5][k]*src[ 5][j] + g_aiT8[ 7][k]*src[ 7][j];
+    }
     EO[0] = g_aiT8[2][0]*src[2][j] + g_aiT8[6][0]*src[6][j];
     EO[1] = g_aiT8[2][1]*src[2][j] + g_aiT8[6][1]*src[6][j];
     EE[0] = g_aiT8[0][0]*src[0][j] + g_aiT8[4][0]*src[4][j];
     EE[1] = g_aiT8[0][1]*src[0][j] + g_aiT8[4][1]*src[4][j];
+      O[k] = g_aiT8[ 1][k]*src[line] + g_aiT8[ 3][k]*src[3*line] + g_aiT8[ 5][k]*src[5*line] + g_aiT8[ 7][k]*src[7*line];
+    }
+    EO[0] = g_aiT8[2][0]*src[ 2*line ] + g_aiT8[6][0]*src[ 6*line ];
+    EO[1] = g_aiT8[2][1]*src[ 2*line ] + g_aiT8[6][1]*src[ 6*line ];
+    EE[0] = g_aiT8[0][0]*src[ 0      ] + g_aiT8[4][0]*src[ 4*line ];
+    EE[1] = g_aiT8[0][1]*src[ 0      ] + g_aiT8[4][1]*src[ 4*line ];
     /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
 …
     for (k=0;k<4;k++)
+    {
-      dst[j][k]   = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
-      dst[j][k+4] = Clip3( -32768, 32767, (E[3-k] - O[3-k] + add)>>shift );
+    }
+  }
+}
-#endif
-void partialButterflyInverse8(short *src,short *dst,int shift, int line)
+{
-  int j,k;
-  int E[4],O[4];
-  int EE[2],EO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<line; j++)
+  {
-    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
-    for (k=0;k<4;k++)
+    {
-      O[k] = g_aiT8[ 1][k]*src[line] + g_aiT8[ 3][k]*src[3*line] + g_aiT8[ 5][k]*src[5*line] + g_aiT8[ 7][k]*src[7*line];
+    }
-    EO[0] = g_aiT8[2][0]*src[ 2*line ] + g_aiT8[6][0]*src[ 6*line ];
-    EO[1] = g_aiT8[2][1]*src[ 2*line ] + g_aiT8[6][1]*src[ 6*line ];
-    EE[0] = g_aiT8[0][0]*src[ 0      ] + g_aiT8[4][0]*src[ 4*line ];
-    EE[1] = g_aiT8[0][1]*src[ 0      ] + g_aiT8[4][1]*src[ 4*line ];
-    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
-    E[0] = EE[0] + EO[0];
-    E[3] = EE[0] - EO[0];
-    E[1] = EE[1] + EO[1];
-    E[2] = EE[1] - EO[1];
-    for (k=0;k<4;k++)
+    {
       dst[ k   ] = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
       dst[ k+4 ] = Clip3( -32768, 32767, (E[3-k] - O[3-k] + add)>>shift );
 …
+}
+#if !UNIFIED_TRANSFORM
+/** 8x8 inverse transform (2D)
+ *  \param coeff input data (transform coefficients)
+ *  \param block output data (residual)
+ */
+void xITr8(short coeff[8][8],short block[8][8])
+void partialButterfly16(short *src,short *dst,int shift, int line)
+{
+  int j,k;
+  int E[8],O[8];
+  int EE[4],EO[4];
+  int EEE[2],EEO[2];
+  int add = 1<<(shift-1);
+  for (j=0; j<line; j++)
+  {
+    /* E and O*/
+    for (k=0;k<8;k++)
+    {
+      E[k] = src[k] + src[15-k];
+      O[k] = src[k] - src[15-k];
+    }
+    /* EE and EO */
+    for (k=0;k<4;k++)
+    {
+      EE[k] = E[k] + E[7-k];
+      EO[k] = E[k] - E[7-k];
+    }
+    /* EEE and EEO */
+    EEE[0] = EE[0] + EE[3];
+    EEO[0] = EE[0] - EE[3];
+    EEE[1] = EE[1] + EE[2];
+    EEO[1] = EE[1] - EE[2];
+    dst[ 0      ] = (g_aiT16[ 0][0]*EEE[0] + g_aiT16[ 0][1]*EEE[1] + add)>>shift;
+    dst[ 8*line ] = (g_aiT16[ 8][0]*EEE[0] + g_aiT16[ 8][1]*EEE[1] + add)>>shift;
+    dst[ 4*line ] = (g_aiT16[ 4][0]*EEO[0] + g_aiT16[ 4][1]*EEO[1] + add)>>shift;
+    dst[ 12*line] = (g_aiT16[12][0]*EEO[0] + g_aiT16[12][1]*EEO[1] + add)>>shift;
+    for (k=2;k<16;k+=4)
+    {
+      dst[ k*line ] = (g_aiT16[k][0]*EO[0] + g_aiT16[k][1]*EO[1] + g_aiT16[k][2]*EO[2] + g_aiT16[k][3]*EO[3] + add)>>shift;
+    }
+    for (k=1;k<16;k+=2)
+    {
+      dst[ k*line ] = (g_aiT16[k][0]*O[0] + g_aiT16[k][1]*O[1] + g_aiT16[k][2]*O[2] + g_aiT16[k][3]*O[3] +
+        g_aiT16[k][4]*O[4] + g_aiT16[k][5]*O[5] + g_aiT16[k][6]*O[6] + g_aiT16[k][7]*O[7] + add)>>shift;
+    }
+    src += 16;
+    dst ++;
+  }
+}
+void partialButterflyInverse16(short *src,short *dst,int shift, int line)
+{
+  int j,k;
+  int E[8],O[8];
+  int EE[4],EO[4];
+  int EEE[2],EEO[2];
+  int add = 1<<(shift-1);
+  for (j=0; j<line; j++)
+  {
+    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
+    for (k=0;k<8;k++)
+    {
+      O[k] = g_aiT16[ 1][k]*src[ line] + g_aiT16[ 3][k]*src[ 3*line] + g_aiT16[ 5][k]*src[ 5*line] + g_aiT16[ 7][k]*src[ 7*line] +
+        g_aiT16[ 9][k]*src[ 9*line] + g_aiT16[11][k]*src[11*line] + g_aiT16[13][k]*src[13*line] + g_aiT16[15][k]*src[15*line];
+    }
+    for (k=0;k<4;k++)
+    {
+      EO[k] = g_aiT16[ 2][k]*src[ 2*line] + g_aiT16[ 6][k]*src[ 6*line] + g_aiT16[10][k]*src[10*line] + g_aiT16[14][k]*src[14*line];
+    }
+    EEO[0] = g_aiT16[4][0]*src[ 4*line ] + g_aiT16[12][0]*src[ 12*line ];
+    EEE[0] = g_aiT16[0][0]*src[ 0      ] + g_aiT16[ 8][0]*src[ 8*line  ];
+    EEO[1] = g_aiT16[4][1]*src[ 4*line ] + g_aiT16[12][1]*src[ 12*line ];
+    EEE[1] = g_aiT16[0][1]*src[ 0      ] + g_aiT16[ 8][1]*src[ 8*line  ];
+    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
+    for (k=0;k<2;k++)
+    {
+      EE[k] = EEE[k] + EEO[k];
+      EE[k+2] = EEE[1-k] - EEO[1-k];
+    }
+    for (k=0;k<4;k++)
+    {
+      E[k] = EE[k] + EO[k];
+      E[k+4] = EE[3-k] - EO[3-k];
+    }
+    for (k=0;k<8;k++)
+    {
+      dst[k]   = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
+      dst[k+8] = Clip3( -32768, 32767, (E[7-k] - O[7-k] + add)>>shift );
+    }
+    src ++;
+    dst += 16;
+  }
+}
+void partialButterfly32(short *src,short *dst,int shift, int line)
+{
+  int j,k;
+  int E[16],O[16];
+  int EE[8],EO[8];
+  int EEE[4],EEO[4];
+  int EEEE[2],EEEO[2];
+  int add = 1<<(shift-1);
+  for (j=0; j<line; j++)
+  {
+    /* E and O*/
+    for (k=0;k<16;k++)
+    {
+      E[k] = src[k] + src[31-k];
+      O[k] = src[k] - src[31-k];
+    }
+    /* EE and EO */
+    for (k=0;k<8;k++)
+    {
+      EE[k] = E[k] + E[15-k];
+      EO[k] = E[k] - E[15-k];
+    }
+    /* EEE and EEO */
+    for (k=0;k<4;k++)
+    {
+      EEE[k] = EE[k] + EE[7-k];
+      EEO[k] = EE[k] - EE[7-k];
+    }
+    /* EEEE and EEEO */
+    EEEE[0] = EEE[0] + EEE[3];
+    EEEO[0] = EEE[0] - EEE[3];
+    EEEE[1] = EEE[1] + EEE[2];
+    EEEO[1] = EEE[1] - EEE[2];
+    dst[ 0       ] = (g_aiT32[ 0][0]*EEEE[0] + g_aiT32[ 0][1]*EEEE[1] + add)>>shift;
+    dst[ 16*line ] = (g_aiT32[16][0]*EEEE[0] + g_aiT32[16][1]*EEEE[1] + add)>>shift;
+    dst[ 8*line  ] = (g_aiT32[ 8][0]*EEEO[0] + g_aiT32[ 8][1]*EEEO[1] + add)>>shift;
+    dst[ 24*line ] = (g_aiT32[24][0]*EEEO[0] + g_aiT32[24][1]*EEEO[1] + add)>>shift;
+    for (k=4;k<32;k+=8)
+    {
+      dst[ k*line ] = (g_aiT32[k][0]*EEO[0] + g_aiT32[k][1]*EEO[1] + g_aiT32[k][2]*EEO[2] + g_aiT32[k][3]*EEO[3] + add)>>shift;
+    }
+    for (k=2;k<32;k+=4)
+    {
+      dst[ k*line ] = (g_aiT32[k][0]*EO[0] + g_aiT32[k][1]*EO[1] + g_aiT32[k][2]*EO[2] + g_aiT32[k][3]*EO[3] +
+        g_aiT32[k][4]*EO[4] + g_aiT32[k][5]*EO[5] + g_aiT32[k][6]*EO[6] + g_aiT32[k][7]*EO[7] + add)>>shift;
+    }
+    for (k=1;k<32;k+=2)
+    {
+      dst[ k*line ] = (g_aiT32[k][ 0]*O[ 0] + g_aiT32[k][ 1]*O[ 1] + g_aiT32[k][ 2]*O[ 2] + g_aiT32[k][ 3]*O[ 3] +
+        g_aiT32[k][ 4]*O[ 4] + g_aiT32[k][ 5]*O[ 5] + g_aiT32[k][ 6]*O[ 6] + g_aiT32[k][ 7]*O[ 7] +
+        g_aiT32[k][ 8]*O[ 8] + g_aiT32[k][ 9]*O[ 9] + g_aiT32[k][10]*O[10] + g_aiT32[k][11]*O[11] +
+        g_aiT32[k][12]*O[12] + g_aiT32[k][13]*O[13] + g_aiT32[k][14]*O[14] + g_aiT32[k][15]*O[15] + add)>>shift;
+    }
+    src += 32;
+    dst ++;
+  }
+}
+void partialButterflyInverse32(short *src,short *dst,int shift, int line)
+{
+  int j,k;
+  int E[16],O[16];
+  int EE[8],EO[8];
+  int EEE[4],EEO[4];
+  int EEEE[2],EEEO[2];
+  int add = 1<<(shift-1);
+  for (j=0; j<line; j++)
+  {
+    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
+    for (k=0;k<16;k++)
+    {
+      O[k] = g_aiT32[ 1][k]*src[ line  ] + g_aiT32[ 3][k]*src[ 3*line  ] + g_aiT32[ 5][k]*src[ 5*line  ] + g_aiT32[ 7][k]*src[ 7*line  ] +
+        g_aiT32[ 9][k]*src[ 9*line  ] + g_aiT32[11][k]*src[ 11*line ] + g_aiT32[13][k]*src[ 13*line ] + g_aiT32[15][k]*src[ 15*line ] +
+        g_aiT32[17][k]*src[ 17*line ] + g_aiT32[19][k]*src[ 19*line ] + g_aiT32[21][k]*src[ 21*line ] + g_aiT32[23][k]*src[ 23*line ] +
+        g_aiT32[25][k]*src[ 25*line ] + g_aiT32[27][k]*src[ 27*line ] + g_aiT32[29][k]*src[ 29*line ] + g_aiT32[31][k]*src[ 31*line ];
+    }
+    for (k=0;k<8;k++)
+    {
+      EO[k] = g_aiT32[ 2][k]*src[ 2*line  ] + g_aiT32[ 6][k]*src[ 6*line  ] + g_aiT32[10][k]*src[ 10*line ] + g_aiT32[14][k]*src[ 14*line ] +
+        g_aiT32[18][k]*src[ 18*line ] + g_aiT32[22][k]*src[ 22*line ] + g_aiT32[26][k]*src[ 26*line ] + g_aiT32[30][k]*src[ 30*line ];
+    }
+    for (k=0;k<4;k++)
+    {
+      EEO[k] = g_aiT32[4][k]*src[ 4*line ] + g_aiT32[12][k]*src[ 12*line ] + g_aiT32[20][k]*src[ 20*line ] + g_aiT32[28][k]*src[ 28*line ];
+    }
+    EEEO[0] = g_aiT32[8][0]*src[ 8*line ] + g_aiT32[24][0]*src[ 24*line ];
+    EEEO[1] = g_aiT32[8][1]*src[ 8*line ] + g_aiT32[24][1]*src[ 24*line ];
+    EEEE[0] = g_aiT32[0][0]*src[ 0      ] + g_aiT32[16][0]*src[ 16*line ];
+    EEEE[1] = g_aiT32[0][1]*src[ 0      ] + g_aiT32[16][1]*src[ 16*line ];
+    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
+    EEE[0] = EEEE[0] + EEEO[0];
+    EEE[3] = EEEE[0] - EEEO[0];
+    EEE[1] = EEEE[1] + EEEO[1];
+    EEE[2] = EEEE[1] - EEEO[1];
+    for (k=0;k<4;k++)
+    {
+      EE[k] = EEE[k] + EEO[k];
+      EE[k+4] = EEE[3-k] - EEO[3-k];
+    }
+    for (k=0;k<8;k++)
+    {
+      E[k] = EE[k] + EO[k];
+      E[k+8] = EE[7-k] - EO[7-k];
+    }
+    for (k=0;k<16;k++)
+    {
+      dst[k]    = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
+      dst[k+16] = Clip3( -32768, 32767, (E[15-k] - O[15-k] + add)>>shift );
+    }
+    src ++;
+    dst += 32;
+  }
+}
+/** MxN forward transform (2D)
+*  \param block input data (residual)
+*  \param coeff output data (transform coefficients)
+*  \param iWidth input data (width of transform)
+*  \param iHeight input data (height of transform)
+*/
+void xTrMxN(short *block,short *coeff, int iWidth, int iHeight, UInt uiMode)
+{
+#if FULL_NBIT
+  int shift_1st = g_aucConvertToBit[iWidth]  + 1 + g_uiBitDepth - 8; // log2(iWidth) - 1 + g_uiBitDepth - 8
+#else
+  int shift_1st = g_aucConvertToBit[iWidth]  + 1 + g_uiBitIncrement; // log2(iWidth) - 1 + g_uiBitIncrement
+#endif
+  int shift_2nd = g_aucConvertToBit[iHeight]  + 8;                   // log2(iHeight) + 6
+  short tmp[ 64 * 64 ];
+  if( iWidth == 16 && iHeight == 4)
+  {
+    partialButterfly16( block, tmp, shift_1st, iHeight );
+    partialButterfly4( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 32 && iHeight == 8 )
+  {
+    partialButterfly32( block, tmp, shift_1st, iHeight );
+    partialButterfly8( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 4 && iHeight == 16)
+  {
+    partialButterfly4( block, tmp, shift_1st, iHeight );
+    partialButterfly16( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 8 && iHeight == 32 )
+  {
+    partialButterfly8( block, tmp, shift_1st, iHeight );
+    partialButterfly32( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 4 && iHeight == 4)
+  {
+    if (uiMode != REG_DCT && (!uiMode || (uiMode>=2 && uiMode <= 25)))    // Check for DCT or DST
+    {
+      fastForwardDst(block,tmp,shift_1st); // Forward DST BY FAST ALGORITHM, block input, tmp output
+    }
+    else
+    {
+      partialButterfly4(block, tmp, shift_1st, iHeight);
+    }
+    if (uiMode != REG_DCT && (!uiMode || (uiMode>=11 && uiMode <= 34)))    // Check for DCT or DST
+    {
+      fastForwardDst(tmp,coeff,shift_2nd); // Forward DST BY FAST ALGORITHM, tmp input, coeff output
+    }
+    else
+    {
+      partialButterfly4(tmp, coeff, shift_2nd, iWidth);
+    }
+  }
+  else if( iWidth == 8 && iHeight == 8)
+  {
+    partialButterfly8( block, tmp, shift_1st, iHeight );
+    partialButterfly8( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 16 && iHeight == 16)
+  {
+    partialButterfly16( block, tmp, shift_1st, iHeight );
+    partialButterfly16( tmp, coeff, shift_2nd, iWidth );
+  }
+  else if( iWidth == 32 && iHeight == 32)
+  {
+    partialButterfly32( block, tmp, shift_1st, iHeight );
+    partialButterfly32( tmp, coeff, shift_2nd, iWidth );
+  }
+}
+/** MxN inverse transform (2D)
+*  \param coeff input data (transform coefficients)
+*  \param block output data (residual)
+*  \param iWidth input data (width of transform)
+*  \param iHeight input data (height of transform)
+*/
+void xITrMxN(short *coeff,short *block, int iWidth, int iHeight, UInt uiMode)
+{
   int shift_1st = SHIFT_INV_1ST;
 …
   int shift_2nd = SHIFT_INV_2ND - g_uiBitIncrement;
 #endif
-  short tmp[8][8];
-  partialButterflyInverse8(coeff,tmp,shift_1st);
-  partialButterflyInverse8(tmp,block,shift_2nd);
+}
-/** 16x16 forward transform implemented using partial butterfly structure (1D)
- *  \param src   input data (residual)
- *  \param dst   output data (transform coefficients)
- *  \param shift specifies right shift after 1D transform
- */
-void partialButterfly16(short src[16][16],short dst[16][16],int shift)
+{
-  int j,k;
-  int E[8],O[8];
-  int EE[4],EO[4];
-  int EEE[2],EEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<16; j++)
+  {
-    /* E and O*/
-    for (k=0;k<8;k++)
+    {
-      E[k] = src[j][k] + src[j][15-k];
-      O[k] = src[j][k] - src[j][15-k];
+    }
-    /* EE and EO */
-    for (k=0;k<4;k++)
+    {
-      EE[k] = E[k] + E[7-k];
-      EO[k] = E[k] - E[7-k];
+    }
-    /* EEE and EEO */
-    EEE[0] = EE[0] + EE[3];
-    EEO[0] = EE[0] - EE[3];
-    EEE[1] = EE[1] + EE[2];
-    EEO[1] = EE[1] - EE[2];
-    dst[ 0][j] = (g_aiT16[ 0][0]*EEE[0] + g_aiT16[ 0][1]*EEE[1] + add)>>shift;
-    dst[ 8][j] = (g_aiT16[ 8][0]*EEE[0] + g_aiT16[ 8][1]*EEE[1] + add)>>shift;
-    dst[ 4][j] = (g_aiT16[ 4][0]*EEO[0] + g_aiT16[ 4][1]*EEO[1] + add)>>shift;
-    dst[12][j] = (g_aiT16[12][0]*EEO[0] + g_aiT16[12][1]*EEO[1] + add)>>shift;
-    for (k=2;k<16;k+=4)
+    {
-      dst[k][j] = (g_aiT16[k][0]*EO[0] + g_aiT16[k][1]*EO[1] + g_aiT16[k][2]*EO[2] + g_aiT16[k][3]*EO[3] + add)>>shift;
+    }
-    for (k=1;k<16;k+=2)
+    {
-      dst[k][j] = (g_aiT16[k][0]*O[0] + g_aiT16[k][1]*O[1] + g_aiT16[k][2]*O[2] + g_aiT16[k][3]*O[3] +
-                     g_aiT16[k][4]*O[4] + g_aiT16[k][5]*O[5] + g_aiT16[k][6]*O[6] + g_aiT16[k][7]*O[7] + add)>>shift;
+    }
+  }
+}
-#endif
-void partialButterfly16(short *src,short *dst,int shift, int line)
+{
-  int j,k;
-  int E[8],O[8];
-  int EE[4],EO[4];
-  int EEE[2],EEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<line; j++)
+  {
-    /* E and O*/
-    for (k=0;k<8;k++)
+    {
-      E[k] = src[k] + src[15-k];
-      O[k] = src[k] - src[15-k];
+    }
-    /* EE and EO */
-    for (k=0;k<4;k++)
+    {
-      EE[k] = E[k] + E[7-k];
-      EO[k] = E[k] - E[7-k];
+    }
-    /* EEE and EEO */
-    EEE[0] = EE[0] + EE[3];
-    EEO[0] = EE[0] - EE[3];
-    EEE[1] = EE[1] + EE[2];
-    EEO[1] = EE[1] - EE[2];
-    dst[ 0      ] = (g_aiT16[ 0][0]*EEE[0] + g_aiT16[ 0][1]*EEE[1] + add)>>shift;
-    dst[ 8*line ] = (g_aiT16[ 8][0]*EEE[0] + g_aiT16[ 8][1]*EEE[1] + add)>>shift;
-    dst[ 4*line ] = (g_aiT16[ 4][0]*EEO[0] + g_aiT16[ 4][1]*EEO[1] + add)>>shift;
-    dst[ 12*line] = (g_aiT16[12][0]*EEO[0] + g_aiT16[12][1]*EEO[1] + add)>>shift;
-    for (k=2;k<16;k+=4)
+    {
-      dst[ k*line ] = (g_aiT16[k][0]*EO[0] + g_aiT16[k][1]*EO[1] + g_aiT16[k][2]*EO[2] + g_aiT16[k][3]*EO[3] + add)>>shift;
+    }
-    for (k=1;k<16;k+=2)
+    {
-      dst[ k*line ] = (g_aiT16[k][0]*O[0] + g_aiT16[k][1]*O[1] + g_aiT16[k][2]*O[2] + g_aiT16[k][3]*O[3] +
-        g_aiT16[k][4]*O[4] + g_aiT16[k][5]*O[5] + g_aiT16[k][6]*O[6] + g_aiT16[k][7]*O[7] + add)>>shift;
+    }
-    src += 16;
-    dst ++;
+  }
+}
-#if !UNIFIED_TRANSFORM
-/** 16x16 forward transform (2D)
- *  \param block input data (residual)
- *  \param coeff output data (transform coefficients)
- */
-void xTr16(short block[16][16],short coeff[16][16])
+{
- #if FULL_NBIT
-  int shift_1st = 3 + g_uiBitDepth - 8; // log2(16) - 1 + g_uiBitDepth - 8
-#else
-  int shift_1st = 3 + g_uiBitIncrement; // log2(16) - 1 + g_uiBitIncrement
-#endif
-  int shift_2nd = 10;                   // log2(16) + 6
-  short tmp[16][16];
-  partialButterfly16(block,tmp,shift_1st);
-  partialButterfly16(tmp,coeff,shift_2nd);
+}
-/** 16x16 inverse transform implemented using partial butterfly structure (1D)
- *  \param src   input data (transform coefficients)
- *  \param dst   output data (residual)
- *  \param shift specifies right shift after 1D transform
- */
-void partialButterflyInverse16(short src[16][16],short dst[16][16],int shift)
+{
-  int j,k;
-  int E[8],O[8];
-  int EE[4],EO[4];
-  int EEE[2],EEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<16; j++)
+  {
-    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
-    for (k=0;k<8;k++)
+    {
-      O[k] = g_aiT16[ 1][k]*src[ 1][j] + g_aiT16[ 3][k]*src[ 3][j] + g_aiT16[ 5][k]*src[ 5][j] + g_aiT16[ 7][k]*src[ 7][j] +
-             g_aiT16[ 9][k]*src[ 9][j] + g_aiT16[11][k]*src[11][j] + g_aiT16[13][k]*src[13][j] + g_aiT16[15][k]*src[15][j];
+    }
-    for (k=0;k<4;k++)
+    {
-      EO[k] = g_aiT16[ 2][k]*src[ 2][j] + g_aiT16[ 6][k]*src[ 6][j] + g_aiT16[10][k]*src[10][j] + g_aiT16[14][k]*src[14][j];
+    }
-    EEO[0] = g_aiT16[4][0]*src[4][j] + g_aiT16[12][0]*src[12][j];
-    EEE[0] = g_aiT16[0][0]*src[0][j] + g_aiT16[ 8][0]*src[ 8][j];
-    EEO[1] = g_aiT16[4][1]*src[4][j] + g_aiT16[12][1]*src[12][j];
-    EEE[1] = g_aiT16[0][1]*src[0][j] + g_aiT16[ 8][1]*src[ 8][j];
-    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
-    for (k=0;k<2;k++)
+    {
-      EE[k] = EEE[k] + EEO[k];
-      EE[k+2] = EEE[1-k] - EEO[1-k];
+    }
-    for (k=0;k<4;k++)
+    {
-      E[k] = EE[k] + EO[k];
-      E[k+4] = EE[3-k] - EO[3-k];
+    }
-    for (k=0;k<8;k++)
+    {
-      dst[j][k]   = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
-      dst[j][k+8] = Clip3( -32768, 32767, (E[7-k] - O[7-k] + add)>>shift );
+    }
+  }
+}
-#endif
-void partialButterflyInverse16(short *src,short *dst,int shift, int line)
+{
-  int j,k;
-  int E[8],O[8];
-  int EE[4],EO[4];
-  int EEE[2],EEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<line; j++)
+  {
-    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
-    for (k=0;k<8;k++)
+    {
-      O[k] = g_aiT16[ 1][k]*src[ line] + g_aiT16[ 3][k]*src[ 3*line] + g_aiT16[ 5][k]*src[ 5*line] + g_aiT16[ 7][k]*src[ 7*line] +
-        g_aiT16[ 9][k]*src[ 9*line] + g_aiT16[11][k]*src[11*line] + g_aiT16[13][k]*src[13*line] + g_aiT16[15][k]*src[15*line];
+    }
-    for (k=0;k<4;k++)
+    {
-      EO[k] = g_aiT16[ 2][k]*src[ 2*line] + g_aiT16[ 6][k]*src[ 6*line] + g_aiT16[10][k]*src[10*line] + g_aiT16[14][k]*src[14*line];
+    }
-    EEO[0] = g_aiT16[4][0]*src[ 4*line ] + g_aiT16[12][0]*src[ 12*line ];
-    EEE[0] = g_aiT16[0][0]*src[ 0      ] + g_aiT16[ 8][0]*src[ 8*line  ];
-    EEO[1] = g_aiT16[4][1]*src[ 4*line ] + g_aiT16[12][1]*src[ 12*line ];
-    EEE[1] = g_aiT16[0][1]*src[ 0      ] + g_aiT16[ 8][1]*src[ 8*line  ];
-    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
-    for (k=0;k<2;k++)
+    {
-      EE[k] = EEE[k] + EEO[k];
-      EE[k+2] = EEE[1-k] - EEO[1-k];
+    }
-    for (k=0;k<4;k++)
+    {
-      E[k] = EE[k] + EO[k];
-      E[k+4] = EE[3-k] - EO[3-k];
+    }
-    for (k=0;k<8;k++)
+    {
-      dst[k]   = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
-      dst[k+8] = Clip3( -32768, 32767, (E[7-k] - O[7-k] + add)>>shift );
+    }
-    src ++;
-    dst += 16;
+  }
+}
-#if !UNIFIED_TRANSFORM
-/** 16x16 inverse transform (2D)
- *  \param coeff input data (transform coefficients)
- *  \param block output data (residual)
- */
-void xITr16(short coeff[16][16],short block[16][16])
+{
-  int shift_1st = SHIFT_INV_1ST;
-#if FULL_NBIT
-  int shift_2nd = SHIFT_INV_2ND - ((short)g_uiBitDepth - 8);
-#else
-  int shift_2nd = SHIFT_INV_2ND - g_uiBitIncrement;
-#endif
-  short tmp[16][16];
-  partialButterflyInverse16(coeff,tmp,shift_1st);
-  partialButterflyInverse16(tmp,block,shift_2nd);
+}
-/** 32x32 forward transform implemented using partial butterfly structure (1D)
- *  \param src   input data (residual)
- *  \param dst   output data (transform coefficients)
- *  \param shift specifies right shift after 1D transform
- */
-void partialButterfly32(short src[32][32],short dst[32][32],int shift)
+{
-  int j,k;
-  int E[16],O[16];
-  int EE[8],EO[8];
-  int EEE[4],EEO[4];
-  int EEEE[2],EEEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<32; j++)
+  {
-    /* E and O*/
-    for (k=0;k<16;k++)
+    {
-      E[k] = src[j][k] + src[j][31-k];
-      O[k] = src[j][k] - src[j][31-k];
+    }
-    /* EE and EO */
-    for (k=0;k<8;k++)
+    {
-      EE[k] = E[k] + E[15-k];
-      EO[k] = E[k] - E[15-k];
+    }
-    /* EEE and EEO */
-    for (k=0;k<4;k++)
+    {
-      EEE[k] = EE[k] + EE[7-k];
-      EEO[k] = EE[k] - EE[7-k];
+    }
-    /* EEEE and EEEO */
-    EEEE[0] = EEE[0] + EEE[3];
-    EEEO[0] = EEE[0] - EEE[3];
-    EEEE[1] = EEE[1] + EEE[2];
-    EEEO[1] = EEE[1] - EEE[2];
-    dst[ 0][j] = (g_aiT32[ 0][0]*EEEE[0] + g_aiT32[ 0][1]*EEEE[1] + add)>>shift;
-    dst[16][j] = (g_aiT32[16][0]*EEEE[0] + g_aiT32[16][1]*EEEE[1] + add)>>shift;
-    dst[ 8][j] = (g_aiT32[ 8][0]*EEEO[0] + g_aiT32[ 8][1]*EEEO[1] + add)>>shift;
-    dst[24][j] = (g_aiT32[24][0]*EEEO[0] + g_aiT32[24][1]*EEEO[1] + add)>>shift;
-    for (k=4;k<32;k+=8)
+    {
-      dst[k][j] = (g_aiT32[k][0]*EEO[0] + g_aiT32[k][1]*EEO[1] + g_aiT32[k][2]*EEO[2] + g_aiT32[k][3]*EEO[3] + add)>>shift;
+    }
-    for (k=2;k<32;k+=4)
+    {
-      dst[k][j] = (g_aiT32[k][0]*EO[0] + g_aiT32[k][1]*EO[1] + g_aiT32[k][2]*EO[2] + g_aiT32[k][3]*EO[3] +
-                     g_aiT32[k][4]*EO[4] + g_aiT32[k][5]*EO[5] + g_aiT32[k][6]*EO[6] + g_aiT32[k][7]*EO[7] + add)>>shift;
+    }
-    for (k=1;k<32;k+=2)
+    {
-      dst[k][j] = (g_aiT32[k][ 0]*O[ 0] + g_aiT32[k][ 1]*O[ 1] + g_aiT32[k][ 2]*O[ 2] + g_aiT32[k][ 3]*O[ 3] +
-                     g_aiT32[k][ 4]*O[ 4] + g_aiT32[k][ 5]*O[ 5] + g_aiT32[k][ 6]*O[ 6] + g_aiT32[k][ 7]*O[ 7] +
-                     g_aiT32[k][ 8]*O[ 8] + g_aiT32[k][ 9]*O[ 9] + g_aiT32[k][10]*O[10] + g_aiT32[k][11]*O[11] +
-                     g_aiT32[k][12]*O[12] + g_aiT32[k][13]*O[13] + g_aiT32[k][14]*O[14] + g_aiT32[k][15]*O[15] + add)>>shift;
+    }
+  }
+}
-#endif
-void partialButterfly32(short *src,short *dst,int shift, int line)
+{
-  int j,k;
-  int E[16],O[16];
-  int EE[8],EO[8];
-  int EEE[4],EEO[4];
-  int EEEE[2],EEEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<line; j++)
+  {
-    /* E and O*/
-    for (k=0;k<16;k++)
+    {
-      E[k] = src[k] + src[31-k];
-      O[k] = src[k] - src[31-k];
+    }
-    /* EE and EO */
-    for (k=0;k<8;k++)
+    {
-      EE[k] = E[k] + E[15-k];
-      EO[k] = E[k] - E[15-k];
+    }
-    /* EEE and EEO */
-    for (k=0;k<4;k++)
+    {
-      EEE[k] = EE[k] + EE[7-k];
-      EEO[k] = EE[k] - EE[7-k];
+    }
-    /* EEEE and EEEO */
-    EEEE[0] = EEE[0] + EEE[3];
-    EEEO[0] = EEE[0] - EEE[3];
-    EEEE[1] = EEE[1] + EEE[2];
-    EEEO[1] = EEE[1] - EEE[2];
-    dst[ 0       ] = (g_aiT32[ 0][0]*EEEE[0] + g_aiT32[ 0][1]*EEEE[1] + add)>>shift;
-    dst[ 16*line ] = (g_aiT32[16][0]*EEEE[0] + g_aiT32[16][1]*EEEE[1] + add)>>shift;
-    dst[ 8*line  ] = (g_aiT32[ 8][0]*EEEO[0] + g_aiT32[ 8][1]*EEEO[1] + add)>>shift;
-    dst[ 24*line ] = (g_aiT32[24][0]*EEEO[0] + g_aiT32[24][1]*EEEO[1] + add)>>shift;
-    for (k=4;k<32;k+=8)
+    {
-      dst[ k*line ] = (g_aiT32[k][0]*EEO[0] + g_aiT32[k][1]*EEO[1] + g_aiT32[k][2]*EEO[2] + g_aiT32[k][3]*EEO[3] + add)>>shift;
+    }
-    for (k=2;k<32;k+=4)
+    {
-      dst[ k*line ] = (g_aiT32[k][0]*EO[0] + g_aiT32[k][1]*EO[1] + g_aiT32[k][2]*EO[2] + g_aiT32[k][3]*EO[3] +
-        g_aiT32[k][4]*EO[4] + g_aiT32[k][5]*EO[5] + g_aiT32[k][6]*EO[6] + g_aiT32[k][7]*EO[7] + add)>>shift;
+    }
-    for (k=1;k<32;k+=2)
+    {
-      dst[ k*line ] = (g_aiT32[k][ 0]*O[ 0] + g_aiT32[k][ 1]*O[ 1] + g_aiT32[k][ 2]*O[ 2] + g_aiT32[k][ 3]*O[ 3] +
-        g_aiT32[k][ 4]*O[ 4] + g_aiT32[k][ 5]*O[ 5] + g_aiT32[k][ 6]*O[ 6] + g_aiT32[k][ 7]*O[ 7] +
-        g_aiT32[k][ 8]*O[ 8] + g_aiT32[k][ 9]*O[ 9] + g_aiT32[k][10]*O[10] + g_aiT32[k][11]*O[11] +
-        g_aiT32[k][12]*O[12] + g_aiT32[k][13]*O[13] + g_aiT32[k][14]*O[14] + g_aiT32[k][15]*O[15] + add)>>shift;
+    }
-    src += 32;
-    dst ++;
+  }
+}
-#if !UNIFIED_TRANSFORM
-/** 32x32 forward transform (2D)
- *  \param block input data (residual)
- *  \param coeff output data (transform coefficients)
- */
-void xTr32(short block[32][32],short coeff[32][32])
+{
- #if FULL_NBIT
-  int shift_1st = 4 + g_uiBitDepth - 8; // log2(32) - 1 + g_uiBitDepth - 8
-#else
-  int shift_1st = 4 + g_uiBitIncrement; // log2(32) - 1 + g_uiBitIncrement
-#endif
-  int shift_2nd = 11;                   // log2(32) + 6
-  short tmp[32][32];
-  partialButterfly32(block,tmp,shift_1st);
-  partialButterfly32(tmp,coeff,shift_2nd);
+}
-/** 32x32 inverse transform implemented using partial butterfly structure (1D)
- *  \param src   input data (transform coefficients)
- *  \param dst   output data (residual)
- *  \param shift specifies right shift after 1D transform
- */
-void partialButterflyInverse32(short src[32][32],short dst[32][32],int shift)
+{
-  int j,k;
-  int E[16],O[16];
-  int EE[8],EO[8];
-  int EEE[4],EEO[4];
-  int EEEE[2],EEEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<32; j++)
+  {
-    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
-    for (k=0;k<16;k++)
+    {
-      O[k] = g_aiT32[ 1][k]*src[ 1][j] + g_aiT32[ 3][k]*src[ 3][j] + g_aiT32[ 5][k]*src[ 5][j] + g_aiT32[ 7][k]*src[ 7][j] +
-             g_aiT32[ 9][k]*src[ 9][j] + g_aiT32[11][k]*src[11][j] + g_aiT32[13][k]*src[13][j] + g_aiT32[15][k]*src[15][j] +
-             g_aiT32[17][k]*src[17][j] + g_aiT32[19][k]*src[19][j] + g_aiT32[21][k]*src[21][j] + g_aiT32[23][k]*src[23][j] +
-             g_aiT32[25][k]*src[25][j] + g_aiT32[27][k]*src[27][j] + g_aiT32[29][k]*src[29][j] + g_aiT32[31][k]*src[31][j];
+    }
-    for (k=0;k<8;k++)
+    {
-      EO[k] = g_aiT32[ 2][k]*src[ 2][j] + g_aiT32[ 6][k]*src[ 6][j] + g_aiT32[10][k]*src[10][j] + g_aiT32[14][k]*src[14][j] +
-              g_aiT32[18][k]*src[18][j] + g_aiT32[22][k]*src[22][j] + g_aiT32[26][k]*src[26][j] + g_aiT32[30][k]*src[30][j];
+    }
-    for (k=0;k<4;k++)
+    {
-      EEO[k] = g_aiT32[4][k]*src[4][j] + g_aiT32[12][k]*src[12][j] + g_aiT32[20][k]*src[20][j] + g_aiT32[28][k]*src[28][j];
+    }
-    EEEO[0] = g_aiT32[8][0]*src[8][j] + g_aiT32[24][0]*src[24][j];
-    EEEO[1] = g_aiT32[8][1]*src[8][j] + g_aiT32[24][1]*src[24][j];
-    EEEE[0] = g_aiT32[0][0]*src[0][j] + g_aiT32[16][0]*src[16][j];
-    EEEE[1] = g_aiT32[0][1]*src[0][j] + g_aiT32[16][1]*src[16][j];
-    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
-    EEE[0] = EEEE[0] + EEEO[0];
-    EEE[3] = EEEE[0] - EEEO[0];
-    EEE[1] = EEEE[1] + EEEO[1];
-    EEE[2] = EEEE[1] - EEEO[1];
-    for (k=0;k<4;k++)
+    {
-      EE[k] = EEE[k] + EEO[k];
-      EE[k+4] = EEE[3-k] - EEO[3-k];
+    }
-    for (k=0;k<8;k++)
+    {
-      E[k] = EE[k] + EO[k];
-      E[k+8] = EE[7-k] - EO[7-k];
+    }
-    for (k=0;k<16;k++)
+    {
-      dst[j][k]    = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
-      dst[j][k+16] = Clip3( -32768, 32767, (E[15-k] - O[15-k] + add)>>shift );
+    }
+  }
+}
-#endif
-void partialButterflyInverse32(short *src,short *dst,int shift, int line)
+{
-  int j,k;
-  int E[16],O[16];
-  int EE[8],EO[8];
-  int EEE[4],EEO[4];
-  int EEEE[2],EEEO[2];
-  int add = 1<<(shift-1);
-  for (j=0; j<line; j++)
+  {
-    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
-    for (k=0;k<16;k++)
+    {
-      O[k] = g_aiT32[ 1][k]*src[ line  ] + g_aiT32[ 3][k]*src[ 3*line  ] + g_aiT32[ 5][k]*src[ 5*line  ] + g_aiT32[ 7][k]*src[ 7*line  ] +
-        g_aiT32[ 9][k]*src[ 9*line  ] + g_aiT32[11][k]*src[ 11*line ] + g_aiT32[13][k]*src[ 13*line ] + g_aiT32[15][k]*src[ 15*line ] +
-        g_aiT32[17][k]*src[ 17*line ] + g_aiT32[19][k]*src[ 19*line ] + g_aiT32[21][k]*src[ 21*line ] + g_aiT32[23][k]*src[ 23*line ] +
-        g_aiT32[25][k]*src[ 25*line ] + g_aiT32[27][k]*src[ 27*line ] + g_aiT32[29][k]*src[ 29*line ] + g_aiT32[31][k]*src[ 31*line ];
+    }
-    for (k=0;k<8;k++)
+    {
-      EO[k] = g_aiT32[ 2][k]*src[ 2*line  ] + g_aiT32[ 6][k]*src[ 6*line  ] + g_aiT32[10][k]*src[ 10*line ] + g_aiT32[14][k]*src[ 14*line ] +
-        g_aiT32[18][k]*src[ 18*line ] + g_aiT32[22][k]*src[ 22*line ] + g_aiT32[26][k]*src[ 26*line ] + g_aiT32[30][k]*src[ 30*line ];
+    }
-    for (k=0;k<4;k++)
+    {
-      EEO[k] = g_aiT32[4][k]*src[ 4*line ] + g_aiT32[12][k]*src[ 12*line ] + g_aiT32[20][k]*src[ 20*line ] + g_aiT32[28][k]*src[ 28*line ];
+    }
-    EEEO[0] = g_aiT32[8][0]*src[ 8*line ] + g_aiT32[24][0]*src[ 24*line ];
-    EEEO[1] = g_aiT32[8][1]*src[ 8*line ] + g_aiT32[24][1]*src[ 24*line ];
-    EEEE[0] = g_aiT32[0][0]*src[ 0      ] + g_aiT32[16][0]*src[ 16*line ];
-    EEEE[1] = g_aiT32[0][1]*src[ 0      ] + g_aiT32[16][1]*src[ 16*line ];
-    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
-    EEE[0] = EEEE[0] + EEEO[0];
-    EEE[3] = EEEE[0] - EEEO[0];
-    EEE[1] = EEEE[1] + EEEO[1];
-    EEE[2] = EEEE[1] - EEEO[1];
-    for (k=0;k<4;k++)
+    {
-      EE[k] = EEE[k] + EEO[k];
-      EE[k+4] = EEE[3-k] - EEO[3-k];
+    }
-    for (k=0;k<8;k++)
+    {
-      E[k] = EE[k] + EO[k];
-      E[k+8] = EE[7-k] - EO[7-k];
+    }
-    for (k=0;k<16;k++)
+    {
-      dst[k]    = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
-      dst[k+16] = Clip3( -32768, 32767, (E[15-k] - O[15-k] + add)>>shift );
+    }
-    src ++;
-    dst += 32;
+  }
+}
-#if !UNIFIED_TRANSFORM
-/** 32x32 inverse transform (2D)
- *  \param coeff input data (transform coefficients)
- *  \param block output data (residual)
- */
-void xITr32(short coeff[32][32],short block[32][32])
+{
-  int shift_1st = SHIFT_INV_1ST;
-#if FULL_NBIT
-  int shift_2nd = SHIFT_INV_2ND - ((short)g_uiBitDepth - 8);
-#else
-  int shift_2nd = SHIFT_INV_2ND - g_uiBitIncrement;
-#endif
-  short tmp[32][32];
-  partialButterflyInverse32(coeff,tmp,shift_1st);
-  partialButterflyInverse32(tmp,block,shift_2nd);
+}
-#endif
-/** MxN forward transform (2D)
-*  \param block input data (residual)
-*  \param coeff output data (transform coefficients)
-*  \param iWidth input data (width of transform)
-*  \param iHeight input data (height of transform)
-*/
-#if UNIFIED_TRANSFORM
-void xTrMxN(short *block,short *coeff, int iWidth, int iHeight, UInt uiMode)
-#else
-void xTrMxN(short *block,short *coeff, int iWidth, int iHeight)
-#endif
+{
-#if FULL_NBIT
-  int shift_1st = g_aucConvertToBit[iWidth]  + 1 + g_uiBitDepth - 8; // log2(iWidth) - 1 + g_uiBitDepth - 8
-#else
-  int shift_1st = g_aucConvertToBit[iWidth]  + 1 + g_uiBitIncrement; // log2(iWidth) - 1 + g_uiBitIncrement
-#endif
-  int shift_2nd = g_aucConvertToBit[iHeight]  + 8;                   // log2(iHeight) + 6
-  short tmp[ 64 * 64 ];
-  if( iWidth == 16 && iHeight == 4)
+  {
-    partialButterfly16( block, tmp, shift_1st, iHeight );
-    partialButterfly4( tmp, coeff, shift_2nd, iWidth );
+  }
-  else if( iWidth == 32 && iHeight == 8 )
+  {
-    partialButterfly32( block, tmp, shift_1st, iHeight );
-    partialButterfly8( tmp, coeff, shift_2nd, iWidth );
+  }
-  else if( iWidth == 4 && iHeight == 16)
+  {
-    partialButterfly4( block, tmp, shift_1st, iHeight );
-    partialButterfly16( tmp, coeff, shift_2nd, iWidth );
+  }
-  else if( iWidth == 8 && iHeight == 32 )
+  {
-    partialButterfly8( block, tmp, shift_1st, iHeight );
-    partialButterfly32( tmp, coeff, shift_2nd, iWidth );
+  }
-#if UNIFIED_TRANSFORM
-  else if( iWidth == 4 && iHeight == 4)
+  {
-#if LOGI_INTRA_NAME_3MPM
-    if (uiMode != REG_DCT && (!uiMode || (uiMode>=2 && uiMode <= 25)))    // Check for DCT or DST
-#else
-    if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode])// Check for DCT or DST
-#endif
+    {
-      fastForwardDst(block,tmp,shift_1st); // Forward DST BY FAST ALGORITHM, block input, tmp output
+    }
-    else
+    {
-      partialButterfly4(block, tmp, shift_1st, iHeight);
+    }
-#if LOGI_INTRA_NAME_3MPM
-    if (uiMode != REG_DCT && (!uiMode || (uiMode>=11 && uiMode <= 34)))    // Check for DCT or DST
-#else
-    if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode] )   // Check for DCT or DST
-#endif
+    {
-      fastForwardDst(tmp,coeff,shift_2nd); // Forward DST BY FAST ALGORITHM, tmp input, coeff output
+    }
-    else
+    {
-      partialButterfly4(tmp, coeff, shift_2nd, iWidth);
+    }
+  }
-  else if( iWidth == 8 && iHeight == 8)
+  {
-    partialButterfly8( block, tmp, shift_1st, iHeight );
-    partialButterfly8( tmp, coeff, shift_2nd, iWidth );
+  }
-  else if( iWidth == 16 && iHeight == 16)
+  {
-    partialButterfly16( block, tmp, shift_1st, iHeight );
-    partialButterfly16( tmp, coeff, shift_2nd, iWidth );
+  }
-  else if( iWidth == 32 && iHeight == 32)
+  {
-    partialButterfly32( block, tmp, shift_1st, iHeight );
-    partialButterfly32( tmp, coeff, shift_2nd, iWidth );
+  }
-#endif
+}
-/** MxN inverse transform (2D)
-*  \param coeff input data (transform coefficients)
-*  \param block output data (residual)
-*  \param iWidth input data (width of transform)
-*  \param iHeight input data (height of transform)
-*/
-#if UNIFIED_TRANSFORM
-void xITrMxN(short *coeff,short *block, int iWidth, int iHeight, UInt uiMode)
-#else
-void xITrMxN(short *coeff,short *block, int iWidth, int iHeight)
-#endif
+{
-  int shift_1st = SHIFT_INV_1ST;
-#if FULL_NBIT
-  int shift_2nd = SHIFT_INV_2ND - ((short)g_uiBitDepth - 8);
-#else
-  int shift_2nd = SHIFT_INV_2ND - g_uiBitIncrement;
-#endif
   short tmp[ 64*64];
 …
     partialButterflyInverse8(tmp,block,shift_2nd,iHeight);
+  }
-#if UNIFIED_TRANSFORM
   else if( iWidth == 4 && iHeight == 4)
+  {
-#if LOGI_INTRA_NAME_3MPM
     if (uiMode != REG_DCT && (!uiMode || (uiMode>=11 && uiMode <= 34)))    // Check for DCT or DST
-#else
-    if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode] )    // Check for DCT or DST
-#endif
+    {
       fastInverseDst(coeff,tmp,shift_1st);    // Inverse DST by FAST Algorithm, coeff input, tmp output
 …
       partialButterflyInverse4(coeff,tmp,shift_1st,iWidth);
+    }
-#if LOGI_INTRA_NAME_3MPM
     if (uiMode != REG_DCT && (!uiMode || (uiMode>=2 && uiMode <= 25)))    // Check for DCT or DST
-#else
-    if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode] )    // Check for DCT or DST
-#endif
+    {
       fastInverseDst(tmp,block,shift_2nd); // Inverse DST by FAST Algorithm, tmp input, coeff output
 …
     partialButterflyInverse32(tmp,block,shift_2nd,iHeight);
+  }
-#endif
+}
 #endif //MATRIX_MULT
-#if MULTIBITS_DATA_HIDING
 // To minimize the distortion only. No rate is considered.
 Void TComTrQuant::signBitHidingHDQ( TComDataCU* pcCU, TCoeff* pQCoef, TCoeff* pCoef, UInt const *scan, Int* deltaU, Int width, Int height )
 …
   return;
+}
-#endif
 Void TComTrQuant::xQuant( TComDataCU* pcCU,
 …
   else
+  {
-#if MULTIBITS_DATA_HIDING
     const UInt   log2BlockSize   = g_aucConvertToBit[ iWidth ] + 2;
 …
     Int deltaU[32*32] ;
-#endif
 #if ADAPTIVE_QP_SELECTION
 …
     Int iQpBase = pcCU->getSlice()->getSliceQpBase();
-#if H0736_AVC_STYLE_QP_RANGE
     Int qpScaled;
     Int qpBDOffset = (eTType == TEXT_LUMA)? pcCU->getSlice()->getSPS()->getQpBDOffsetY() : pcCU->getSlice()->getSPS()->getQpBDOffsetC();
 …
+    }
     cQpBase.setQpParam(qpScaled, false, pcCU->getSlice()->getSliceType());
-#else
-    if(eTType != TEXT_LUMA)
+    {
-      iQpBase = g_aucChromaScale[iQpBase];
+    }
-    cQpBase.setQpParam(iQpBase, false, pcCU->getSlice()->getSliceType());
-#endif
 #endif
 …
 #endif
-#if MULTIBITS_DATA_HIDING
     Int qBits8 = iQBits-8;
-#endif
     for( Int n = 0; n < iWidth*iHeight; n++ )
+    {
 …
+      }
       iLevel = (Int)((tmpLevel + iAdd ) >> iQBits);
-#if MULTIBITS_DATA_HIDING
       deltaU[uiBlockPos] = (Int)((tmpLevel - (iLevel<<iQBits) )>> qBits8);
-#endif
 #else
       iLevel = ((Int64)abs(iLevel) * piQuantCoeff[uiBlockPos] + iAdd ) >> iQBits;
-#if MULTIBITS_DATA_HIDING
       deltaU[uiBlockPos] = (Int)( ((Int64)abs(iLevel) * piQuantCoeff[uiBlockPos] - (iLevel<<iQBits) )>> qBits8 );
-#endif
 #endif
       uiAcSum += iLevel;
 …
       piQCoef[uiBlockPos] = Clip3( -32768, 32767, iLevel );
     } // for n
-#if MULTIBITS_DATA_HIDING
     if( pcCU->getSlice()->getPPS()->getSignHideFlag() )
+    {
 …
+      }
+    }
-#endif
   } //if RDOQ
   //return;
 …
   iShift = QUANT_IQUANT_SHIFT - QUANT_SHIFT - iTransformShift;
-#if DEQUANT_CLIPPING
   TCoeff clipQCoef;
   const Int bitRange = min( 15, ( Int )( 12 + uiLog2TrSize + uiBitDepth - m_cQP.m_iPer) );
   const Int levelLimit = 1 << bitRange;
-#endif
   if(getUseScalingList())
 …
       for( Int n = 0; n < iWidth*iHeight; n++ )
+      {
-#if DEQUANT_CLIPPING
         clipQCoef = Clip3( -32768, 32767, piQCoef[n] );
         iCoeffQ = ((clipQCoef * piDequantCoef[n]) + iAdd ) >> (iShift -  m_cQP.m_iPer);
-#else
-        iCoeffQ = ((piQCoef[n] * piDequantCoef[n]) + iAdd ) >> (iShift -  m_cQP.m_iPer);
-#endif
         piCoef[n] = Clip3(-32768,32767,iCoeffQ);
+      }
 …
       for( Int n = 0; n < iWidth*iHeight; n++ )
+      {
-#if DEQUANT_CLIPPING
         clipQCoef = Clip3( -levelLimit, levelLimit - 1, piQCoef[n] );
         iCoeffQ = (clipQCoef * piDequantCoef[n]) << (m_cQP.m_iPer - iShift);
-#else
-        iCoeffQ = (piQCoef[n] * piDequantCoef[n]) << (m_cQP.m_iPer - iShift);
-#endif
         piCoef[n] = Clip3(-32768,32767,iCoeffQ);
+      }
 …
     for( Int n = 0; n < iWidth*iHeight; n++ )
+    {
-#if DEQUANT_CLIPPING
       clipQCoef = Clip3( -32768, 32767, piQCoef[n] );
       iCoeffQ = ( clipQCoef * scale + iAdd ) >> iShift;
-#else
-      iCoeffQ = ( piQCoef[n] * scale + iAdd ) >> iShift;
-#endif
       piCoef[n] = Clip3(-32768,32767,iCoeffQ);
+    }
 …
   xTr(piBlkResi,psCoeff,uiStride,(UInt)iSize,uiMode);
 #else
-#if UNIFIED_TRANSFORM
   Int j;
-#else
-  Int iSize = iWidth;
-  if( iWidth != iHeight)
-#endif
+  {
     short block[ 64 * 64 ];
 …
+      }
+    }
-#if UNIFIED_TRANSFORM
     xTrMxN( block, coeff, iWidth, iHeight, uiMode );
-#else
-    xTrMxN( block, coeff, iWidth, iHeight );
-#endif
     for ( j = 0; j < iHeight * iWidth; j++ )
+    {
 …
     return ;
+  }
-#if !UNIFIED_TRANSFORM
-  if (iSize==4)
+  {
-    short block[4][4];
-    short coeff[4][4];
-    for (j=0; j<4; j++)
+    {
-      memcpy(block[j],piBlkResi+j*uiStride,4*sizeof(short));
+    }
-    xTr4(block,coeff,uiMode);
-    for (j=0; j<4; j++)
+    {
-      for (k=0; k<4; k++)
+      {
-        psCoeff[j*4+k] = coeff[j][k];
+      }
+    }
+  }
-  else if (iSize==8)
+  {
-    short block[8][8];
-    short coeff[8][8];
-    for (j=0; j<8; j++)
+    {
-      memcpy(block[j],piBlkResi+j*uiStride,8*sizeof(short));
+    }
-    xTr8(block,coeff);
-    for (j=0; j<8; j++)
+    {
-      for (k=0; k<8; k++)
+      {
-        psCoeff[j*8+k] = coeff[j][k];
+      }
+    }
+  }
-  else if (iSize==16)
+  {
-    short block[16][16];
-    short coeff[16][16];
-    for (j=0; j<16; j++)
+    {
-      memcpy(block[j],piBlkResi+j*uiStride,16*sizeof(short));
+    }
-    xTr16(block,coeff);
-    for (j=0; j<16; j++)
+    {
-      for (k=0; k<16; k++)
+      {
-        psCoeff[j*16+k] = coeff[j][k];
+      }
+    }
+  }
-  else if (iSize==32)
+  {
-    short block[32][32];
-    short coeff[32][32];
-    for (j=0; j<32; j++)
+    {
-      memcpy(block[j],piBlkResi+j*uiStride,32*sizeof(short));
+    }
-    xTr32(block,coeff);
-    for (j=0; j<32; j++)
+    {
-      for (k=0; k<32; k++)
+      {
-        psCoeff[j*32+k] = coeff[j][k];
+      }
+    }
+  }
-#endif
 #endif
+}
 …
   xITr(plCoef,pResidual,uiStride,(UInt)iSize,uiMode);
 #else
-#if UNIFIED_TRANSFORM
   Int j;
-#else
-  Int j,k;
-  Int iSize = iWidth;
-  if( iWidth != iHeight )
-#endif
+  {
     short block[ 64 * 64 ];
 …
       coeff[j] = (short)plCoef[j];
+    }
-#if UNIFIED_TRANSFORM
     xITrMxN( coeff, block, iWidth, iHeight, uiMode );
-#else
-    xITrMxN( coeff, block, iWidth, iHeight );
-#endif
+    {
       for ( j = 0; j < iHeight; j++ )
 …
     return ;
+  }
-#if !UNIFIED_TRANSFORM
-  if (iSize==4)
+  {
-    short block[4][4];
-    short coeff[4][4];
-    for (j=0; j<4; j++)
+    {
-      for (k=0; k<4; k++)
+      {
-        coeff[j][k] = (short)plCoef[j*4+k];
+      }
+    }
-    xITr4(coeff,block,uiMode);
-    for (j=0; j<4; j++)
+    {
-      memcpy(pResidual+j*uiStride,block[j],4*sizeof(short));
+    }
+  }
-  else if (iSize==8)
+  {
-    short block[8][8];
-    short coeff[8][8];
-    for (j=0; j<8; j++)
+    {
-      for (k=0; k<8; k++)
+      {
-        coeff[j][k] = (short)plCoef[j*8+k];
+      }
+    }
-    xITr8(coeff,block);
-    for (j=0; j<8; j++)
+    {
-      memcpy(pResidual+j*uiStride,block[j],8*sizeof(short));
+    }
+  }
-  else if (iSize==16)
+  {
-    short block[16][16];
-    short coeff[16][16];
-    for (j=0; j<16; j++)
+    {
-      for (k=0; k<16; k++)
+      {
-        coeff[j][k] = (short)plCoef[j*16+k];
+      }
+    }
-    xITr16(coeff,block);
-    for (j=0; j<16; j++)
+    {
-      memcpy(pResidual+j*uiStride,block[j],16*sizeof(short));
+    }
+  }
-  else if (iSize==32)
+  {
-    short block[32][32];
-    short coeff[32][32];
-    for (j=0; j<32; j++)
+    {
-      for (k=0; k<32; k++)
+      {
-        coeff[j][k] = (short)plCoef[j*32+k];
+      }
+    }
-    xITr32(coeff,block);
-    for (j=0; j<32; j++)
+    {
-      memcpy(pResidual+j*uiStride,block[j],32*sizeof(short));
+    }
+  }
-#endif
 #endif
+}
 …
   ::memset( pdCostCoeff, 0, sizeof(Double) *  uiMaxNumCoeff );
   ::memset( pdCostSig,   0, sizeof(Double) *  uiMaxNumCoeff );
-#if MULTIBITS_DATA_HIDING
   Int rateIncUp   [ 32 * 32 ];
   Int rateIncDown [ 32 * 32 ];
 …
   ::memset( sigRateDelta, 0, sizeof(Int) *  uiMaxNumCoeff );
   ::memset( deltaU,       0, sizeof(Int) *  uiMaxNumCoeff );
-#endif
   const UInt * scanCG;
 …
+  {
     scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlkSize > 3 ? uiLog2BlkSize-2-1 : 0  ];
-#if MULTILEVEL_SIGMAP_EXT
     if( uiLog2BlkSize == 3 )
+    {
 …
       scanCG = g_sigLastScanCG32x32;
+    }
-#endif
+  }
   else
 …
   dTemp                       = dErrScale;
-#if RESTRICT_GR1GR2FLAG_NUMBER
   UInt    c1Idx     = 0;
   UInt    c2Idx     = 0;
   Int     baseLevel;
-#endif
   const UInt * scan;
 …
+  }
-#if !MULTILEVEL_SIGMAP_EXT
-  if (blockType < 4)
+  {
-  for( Int iScanPos = (Int) uiMaxNumCoeff-1; iScanPos >= 0; iScanPos-- )
+  {
-    //===== quantization =====
-    UInt    uiBlkPos          = scan[iScanPos];
-    // set coeff
-    uiQ  = piQCoef[uiBlkPos];
-    dTemp = pdErrScale[uiBlkPos];
-    Int lLevelDouble          = plSrcCoeff[ uiBlkPos ];
-    lLevelDouble              = (Int)min<Int64>(((Int64)abs(lLevelDouble) * uiQ), MAX_INT-(1 << (iQBits - 1)));
-#if ADAPTIVE_QP_SELECTION
-    if( m_bUseAdaptQpSelect )
+    {
-      piArlDstCoeff[uiBlkPos]   = (Int)(( lLevelDouble + iAddC) >> iQBitsC );
+    }
-#endif
-    UInt uiMaxAbsLevel        = (lLevelDouble + (1 << (iQBits - 1))) >> iQBits;
-    uiMaxAbsLevel=plSrcCoeff[ uiBlkPos ]>=0 ? min<UInt>(uiMaxAbsLevel,32767): min<UInt>(uiMaxAbsLevel,32768);
-    Double dErr               = Double( lLevelDouble );
-    pdCostCoeff0[ iScanPos ]  = dErr * dErr * dTemp;
-    d64BlockUncodedCost      += pdCostCoeff0[ iScanPos ];
-    piDstCoeff[ uiBlkPos ]    = uiMaxAbsLevel;
-    if ( uiMaxAbsLevel > 0 && iLastScanPos < 0 )
+    {
-      iLastScanPos            = iScanPos;
-#if LEVEL_CTX_LUMA_RED
-      uiCtxSet                = (iScanPos < SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
-#else
-      uiCtxSet                = iScanPos < SCAN_SET_SIZE ? 0 : 3;
-      uiCtxSet                = (iScanPos < SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 3;
-#endif
+    }
-    if ( iLastScanPos >= 0 )
+    {
-      //===== coefficient level estimation =====
-      UInt  uiLevel;
-      UInt  uiOneCtx         = 4 * uiCtxSet + c1;
-#if RESTRICT_GR1GR2FLAG_NUMBER
-      UInt  uiAbsCtx         = uiCtxSet + c2;
-#else
-      UInt  uiAbsCtx         = 3 * uiCtxSet + c2;
-#endif
-      if( iScanPos == iLastScanPos )
+      {
-#if RESTRICT_GR1GR2FLAG_NUMBER
-        uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ], lLevelDouble, uiMaxAbsLevel, 0, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx, iQBits, dTemp, 1 );
-#else
-        uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ], lLevelDouble, uiMaxAbsLevel, 0, uiOneCtx, uiAbsCtx, uiGoRiceParam, iQBits, dTemp, 1 );
-#endif
+      }
-      else
+      {
-        UInt   uiPosY        = uiBlkPos >> uiLog2BlkSize;
-        UInt   uiPosX        = uiBlkPos - ( uiPosY << uiLog2BlkSize );
-        UShort uiCtxSig      = getSigCtxInc( piDstCoeff, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
-#if RESTRICT_GR1GR2FLAG_NUMBER
-        uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ], lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx, iQBits, dTemp, 0 );
-#else
-        uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ], lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam, iQBits, dTemp, 0 );
-#endif
-#if MULTIBITS_DATA_HIDING
-        sigRateDelta[ uiBlkPos ] = m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 1 ] - m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 0 ];
-#endif
+      }
-#if MULTIBITS_DATA_HIDING
-      deltaU[ uiBlkPos ]        = (lLevelDouble - ((Int)uiLevel << iQBits)) >> (iQBits-8);
-      if( uiLevel > 0 )
+      {
-#if RESTRICT_GR1GR2FLAG_NUMBER
-        Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx );
-        rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
-        rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
-#else
-        Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam );
-        rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam ) - rateNow;
-        rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam ) - rateNow;
-#endif
+      }
-      else // uiLevel == 0
+      {
-        rateIncUp   [ uiBlkPos ] = m_pcEstBitsSbac->m_greaterOneBits[ uiOneCtx ][ 0 ];
+      }
-#endif
-      piDstCoeff[ uiBlkPos ] = uiLevel;
-      d64BaseCost           += pdCostCoeff [ iScanPos ];
-#if RESTRICT_GR1GR2FLAG_NUMBER
-      baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
-      if( uiLevel >= baseLevel )
+      {
-#if EIGHT_BITS_RICE_CODE
-        uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - baseLevel, 23 ) ];
-#else
-        uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - baseLevel, 15 ) ];
-#endif
+      }
-      if ( uiLevel >= 1)
+      {
-        c1Idx ++;
+      }
-#endif
-      //===== update bin model =====
-      if( uiLevel > 1 )
+      {
-        c1 = 0;
-        c2 += (c2 < 2);
-        uiNumOne++;
-#if RESTRICT_GR1GR2FLAG_NUMBER
-        c2Idx ++;
-#else
-        if( uiLevel > 2 )
+        {
-#if EIGHT_BITS_RICE_CODE
-          uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - 3, 23 ) ];
-#else
-          uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - 3, 15 ) ];
-#endif
+        }
-#endif
+      }
-      else if( (c1 < 3) && (c1 > 0) && uiLevel)
+      {
-        c1++;
+      }
-      //===== context set update =====
-      if( ( iScanPos % SCAN_SET_SIZE == 0 ) && ( iScanPos > 0 ) )
+      {
-        c1                = 1;
-        c2                = 0;
-        uiGoRiceParam     = 0;
-#if RESTRICT_GR1GR2FLAG_NUMBER
-        c1Idx   = 0;
-        c2Idx   = 0;
-#endif
-#if LEVEL_CTX_LUMA_RED
-        uiCtxSet          = (iScanPos == SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
-#else
-        uiCtxSet          = (iScanPos == SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 3;
-#endif
-        if( uiNumOne > 0 )
+        {
-          uiCtxSet++;
-#if !LEVEL_CTX_LUMA_RED
-          if(uiNumOne > 3 && eTType==TEXT_LUMA)
+          {
-            uiCtxSet++;
+          }
-#endif
+        }
-        uiNumOne    >>= 1;
+      }
+    }
-    else
+    {
-      d64BaseCost    += pdCostCoeff0[ iScanPos ];
+    }
+  }
+  }
-  else //(uiLog2BlkSize > 3), for 16x16 and 32x32 TU
+  {
-#endif
     ::memset( pdCostCoeffGroupSig,   0, sizeof(Double) * MLS_GRP_NUM );
     ::memset( uiSigCoeffGroupFlag,   0, sizeof(UInt) * MLS_GRP_NUM );
 …
       UInt uiCGPosY   = uiCGBlkPos / uiNumBlkSide;
       UInt uiCGPosX   = uiCGBlkPos - (uiCGPosY * uiNumBlkSide);
-#if MULTILEVEL_SIGMAP_EXT
       if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
+      {
 …
         uiCGPosX = (uiScanIdx == SCAN_VER ? uiCGBlkPos : 0);
+      }
-#endif
       ::memset( &rdStats, 0, sizeof (coeffGroupRDStats));
 …
+        {
           iLastScanPos            = iScanPos;
-#if LEVEL_CTX_LUMA_RED
           uiCtxSet                = (iScanPos < SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
-#else
-          uiCtxSet                = (iScanPos < SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 3;
-#endif
           iCGLastScanPos          = iCGScanPos;
+        }
 …
           UInt  uiLevel;
           UInt  uiOneCtx         = 4 * uiCtxSet + c1;
-#if RESTRICT_GR1GR2FLAG_NUMBER
           UInt  uiAbsCtx         = uiCtxSet + c2;
-#else
-          UInt  uiAbsCtx         = 3 * uiCtxSet + c2;
-#endif
           if( iScanPos == iLastScanPos )
+          {
-#if RESTRICT_GR1GR2FLAG_NUMBER
             uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                                    lLevelDouble, uiMaxAbsLevel, 0, uiOneCtx, uiAbsCtx, uiGoRiceParam,
                                                    c1Idx, c2Idx, iQBits, dTemp, 1 );
-#else
-            uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
-                                                   lLevelDouble, uiMaxAbsLevel, 0, uiOneCtx, uiAbsCtx, uiGoRiceParam,
-                                                   iQBits, dTemp, 1 );
-#endif
+          }
           else
 …
             UInt   uiPosX        = uiBlkPos - ( uiPosY << uiLog2BlkSize );
             UShort uiCtxSig      = getSigCtxInc( piDstCoeff, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
-#if RESTRICT_GR1GR2FLAG_NUMBER
             uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                                    lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam,
                                                    c1Idx, c2Idx, iQBits, dTemp, 0 );
-#else
-            uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
-                                                   lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam,
-                                                   iQBits, dTemp, 0 );
-#endif
-#if MULTIBITS_DATA_HIDING
             sigRateDelta[ uiBlkPos ] = m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 1 ] - m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 0 ];
-#endif
+          }
-#if MULTIBITS_DATA_HIDING
           deltaU[ uiBlkPos ]        = (lLevelDouble - ((Int)uiLevel << iQBits)) >> (iQBits-8);
           if( uiLevel > 0 )
+          {
-#if RESTRICT_GR1GR2FLAG_NUMBER
             Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx );
             rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
             rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
-#else
-            Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam );
-            rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam ) - rateNow;
-            rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam ) - rateNow;
-#endif
+          }
           else // uiLevel == 0
 …
             rateIncUp   [ uiBlkPos ] = m_pcEstBitsSbac->m_greaterOneBits[ uiOneCtx ][ 0 ];
+          }
-#endif
           piDstCoeff[ uiBlkPos ] = uiLevel;
           d64BaseCost           += pdCostCoeff [ iScanPos ];
-#if RESTRICT_GR1GR2FLAG_NUMBER
           baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
           if( uiLevel >= baseLevel )
+          {
-#if EIGHT_BITS_RICE_CODE
             uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - baseLevel , 23 ) ];
-#else
-            uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - baseLevel, 15 ) ];
-#endif
+          }
           if ( uiLevel >= 1)
 …
             c1Idx ++;
+          }
-#endif
           //===== update bin model =====
 …
             c2 += (c2 < 2);
             uiNumOne++;
-#if RESTRICT_GR1GR2FLAG_NUMBER
             c2Idx ++;
-#else
-            if( uiLevel > 2 )
+            {
-#if EIGHT_BITS_RICE_CODE
-              uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - 3, 23 ) ];
-#else
-              uiGoRiceParam = g_aauiGoRiceUpdate[ uiGoRiceParam ][ min<UInt>( uiLevel - 3, 15 ) ];
-#endif
+            }
-#endif
+          }
           else if( (c1 < 3) && (c1 > 0) && uiLevel)
 …
             uiGoRiceParam     = 0;
-#if RESTRICT_GR1GR2FLAG_NUMBER
             c1Idx   = 0;
             c2Idx   = 0;
-#endif
-#if LEVEL_CTX_LUMA_RED
             uiCtxSet          = (iScanPos == SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
-#else
-            uiCtxSet          = (iScanPos == SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 3;
-#endif
             if( uiNumOne > 0 )
+            {
               uiCtxSet++;
-#if !LEVEL_CTX_LUMA_RED
-              if( uiNumOne > 3 && eTType==TEXT_LUMA)
+              {
-                uiCtxSet++;
+              }
-#endif
+            }
             uiNumOne    >>= 1;
 …
       if (iCGLastScanPos >= 0)
+      {
-#if REMOVE_INFER_SIGGRP
         if( iCGScanPos )
-#else
-#if MULTILEVEL_SIGMAP_EXT
-        if ( !bothCGNeighboursOne( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiScanIdx, uiWidth, uiHeight ) && (iCGScanPos != 0) )
-#else
-        if ( !bothCGNeighboursOne( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight ) && (iCGScanPos != 0) )
-#endif
-#endif
+        {
           if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
+          {
-#if MULTILEVEL_SIGMAP_EXT
             UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiScanIdx, uiWidth, uiHeight);
-#else
-            UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight);
-#endif
             d64BaseCost += xGetRateSigCoeffGroup(0, uiCtxSig) - rdStats.d64SigCost;;
             pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(0, uiCtxSig);
 …
               // add SigCoeffGroupFlag cost to total cost
-#if MULTILEVEL_SIGMAP_EXT
               UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiScanIdx, uiWidth, uiHeight);
-#else
-              UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight);
-#endif
               if (iCGScanPos < iCGLastScanPos)
+              {
 …
           } // end if if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
+        }
-#if REMOVE_INFER_SIGGRP
         else
+        {
           uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
+        }
-#else
-        else // if ( !bothCGNeighboursOne( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY ) && (uiCGScanPos != 0) && (uiSigCoeffGroupFlag[ uiCGBlkPos ] != 0) )
+        {
-          uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
-        } // end if ( !bothCGNeighboursOne( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY ) && (uiCGScanPos != 0) && (uiSigCoeffGroupFlag[ uiCGBlkPos ] != 0) )
-#endif
+      }
     } //end for (iCGScanPos)
-#if !MULTILEVEL_SIGMAP_EXT
+  }
-#endif
   //===== estimate last position =====
 …
+  }
-#if !MULTILEVEL_SIGMAP_EXT
-  if (blockType < 4)
+  {
-  for( Int iScanPos = iLastScanPos; iScanPos >= 0; iScanPos-- )
+  {
-    UInt   uiBlkPos     = scan[iScanPos];
-    if( piDstCoeff[ uiBlkPos ] )
+    {
-      UInt   uiPosY       = uiBlkPos >> uiLog2BlkSize;
-      UInt   uiPosX       = uiBlkPos - ( uiPosY << uiLog2BlkSize );
-      Double d64CostLast= uiScanIdx == SCAN_VER ? xGetRateLast( uiPosY, uiPosX, uiWidth ) : xGetRateLast( uiPosX, uiPosY, uiWidth );
-      Double totalCost = d64BaseCost + d64CostLast - pdCostSig[ iScanPos ];
-      if( totalCost < d64BestCost )
+      {
-        iBestLastIdxP1  = iScanPos + 1;
-        d64BestCost     = totalCost;
+      }
-      if( piDstCoeff[ uiBlkPos ] > 1 )
+      {
-        break;
+      }
-      d64BaseCost      -= pdCostCoeff[ iScanPos ];
-      d64BaseCost      += pdCostCoeff0[ iScanPos ];
+    }
-    else
+    {
-      d64BaseCost      -= pdCostSig[ iScanPos ];
+    }
+  }
+  }
-  else //if (uiLog2BlkSize < 4)
+  {
-#endif
     Bool bFoundLast = false;
     for (Int iCGScanPos = iCGLastScanPos; iCGScanPos >= 0; iCGScanPos--)
 …
         for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
+        {
-#if MULTILEVEL_SIGMAP_EXT
           iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
-#else
-          Int iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
-#endif
           if (iScanPos > iLastScanPos) continue;
           UInt   uiBlkPos     = scan[iScanPos];
 …
       } // end if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
     } // end for
-#if !MULTILEVEL_SIGMAP_EXT
-  } //if (uiLog2BlkSize < 4)
-#endif
   for ( Int scanPos = 0; scanPos < iBestLastIdxP1; scanPos++ )
 …
+  }
-#if MULTIBITS_DATA_HIDING
   if( pcCU->getSlice()->getPPS()->getSignHideFlag() && uiAbsSum>=2)
+  {
 …
+    }
+  }
-#endif
+}
 …
   const TCoeff *pData = pcCoeff + posX + posY * width;
-#if !SIGMAP_CTX_SUBBLOCK
-  Int thred = std::max(height, width) >> 2;
-#endif
   Int cnt = 0;
 …
   cnt = ( cnt + 1 ) >> 1;
-#if SIGMAP_CTX_SUBBLOCK
   return (( textureType == TEXT_LUMA && ((posX>>2) + (posY>>2)) > 0 ) ? 4 : 1) + offset + cnt;
-#else
-  return (( textureType == TEXT_LUMA && posX + posY >= thred ) ? 4 : 1) + offset + cnt;
-#endif
+}
 …
                                             UShort                          ui16CtxNumAbs,
                                             UShort                          ui16AbsGoRice,
-#if RESTRICT_GR1GR2FLAG_NUMBER
                                             UInt                            c1Idx,
                                             UInt                            c2Idx,
-#endif
                                             Int                             iQBits,
                                             Double                          dTemp,
 …
+  {
     Double dErr         = Double( lLevelDouble  - ( uiAbsLevel << iQBits ) );
-#if RESTRICT_GR1GR2FLAG_NUMBER
     Double dCurrCost    = dErr * dErr * dTemp + xGetICRateCost( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice, c1Idx, c2Idx );
-#else
-    Double dCurrCost    = dErr * dErr * dTemp + xGetICRateCost( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice );
-#endif
     dCurrCost          += dCurrCostSig;
 …
                                                UShort                          ui16CtxNumAbs,
                                                UShort                          ui16AbsGoRice
-#if RESTRICT_GR1GR2FLAG_NUMBER
                                             ,  UInt                            c1Idx,
                                                UInt                            c2Idx
-#endif
                                                ) const
+{
   Double iRate = xGetIEPRate();
-#if RESTRICT_GR1GR2FLAG_NUMBER
   UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
 …
+  }
   else
-#endif
   if( uiAbsLevel == 1 )
+  {
 …
   else
+  {
-#if RESTRICT_GR1GR2FLAG_NUMBER
     assert (0);
+#else
+    UInt uiSymbol     = uiAbsLevel - 3;
+  }
+  return xGetICost( iRate );
+}
+__inline Int TComTrQuant::xGetICRate  ( UInt                            uiAbsLevel,
+                                       UShort                          ui16CtxNumOne,
+                                       UShort                          ui16CtxNumAbs,
+                                       UShort                          ui16AbsGoRice
+                                     , UInt                            c1Idx,
+                                       UInt                            c2Idx
+                                       ) const
+{
+  Int iRate = 0;
+  UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
+  if ( uiAbsLevel >= baseLevel )
+  {
+    UInt uiSymbol     = uiAbsLevel - baseLevel;
     UInt uiMaxVlc     = g_auiGoRiceRange[ ui16AbsGoRice ];
     Bool bExpGolomb   = ( uiSymbol > uiMaxVlc );
 …
     iRate += ui16NumBins << 15;
-    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
-    iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
-#endif
+  }
-  return xGetICost( iRate );
+}
-#if MULTIBITS_DATA_HIDING
-__inline Int TComTrQuant::xGetICRate  ( UInt                            uiAbsLevel,
-                                       UShort                          ui16CtxNumOne,
-                                       UShort                          ui16CtxNumAbs,
-                                       UShort                          ui16AbsGoRice
-#if RESTRICT_GR1GR2FLAG_NUMBER
-                                     , UInt                            c1Idx,
-                                       UInt                            c2Idx
-#endif
-                                       ) const
+{
-  Int iRate = 0;
-#if RESTRICT_GR1GR2FLAG_NUMBER
-  UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
-  if ( uiAbsLevel >= baseLevel )
+  {
-    UInt uiSymbol     = uiAbsLevel - baseLevel;
-    UInt uiMaxVlc     = g_auiGoRiceRange[ ui16AbsGoRice ];
-    Bool bExpGolomb   = ( uiSymbol > uiMaxVlc );
-    if( bExpGolomb )
+    {
-      uiAbsLevel  = uiSymbol - uiMaxVlc;
-      int iEGS    = 1;  for( UInt uiMax = 2; uiAbsLevel >= uiMax; uiMax <<= 1, iEGS += 2 );
-      iRate      += iEGS << 15;
-      uiSymbol    = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
+    }
-    UShort ui16PrefLen = UShort( uiSymbol >> ui16AbsGoRice ) + 1;
-    UShort ui16NumBins = min<UInt>( ui16PrefLen, g_auiGoRicePrefixLen[ ui16AbsGoRice ] ) + ui16AbsGoRice;
-    iRate += ui16NumBins << 15;
     if (c1Idx < C1FLAG_NUMBER)
 …
+  }
   else
-#endif
   if( uiAbsLevel == 0 )
+  {
 …
   else
+  {
-#if RESTRICT_GR1GR2FLAG_NUMBER
     assert(0);
-#else
-    UInt uiSymbol     = uiAbsLevel - 3;
-    UInt uiMaxVlc     = g_auiGoRiceRange[ ui16AbsGoRice ];
-    Bool bExpGolomb   = ( uiSymbol > uiMaxVlc );
-    if( bExpGolomb )
+    {
-      uiAbsLevel  = uiSymbol - uiMaxVlc;
-      int iEGS    = 1;  for( UInt uiMax = 2; uiAbsLevel >= uiMax; uiMax <<= 1, iEGS += 2 );
-      iRate      += iEGS << 15;
-      uiSymbol    = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
+    }
-    UShort ui16PrefLen = UShort( uiSymbol >> ui16AbsGoRice ) + 1;
-    UShort ui16NumBins = min<UInt>( ui16PrefLen, g_auiGoRicePrefixLen[ ui16AbsGoRice ] ) + ui16AbsGoRice;
-    iRate += ui16NumBins << 15;
-    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
-    iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
-#endif
+  }
   return iRate;
+}
-#endif
 __inline Double TComTrQuant::xGetRateSigCoeffGroup  ( UShort                    uiSignificanceCoeffGroup,
 …
                                            const UInt                      uiCGPosX,
                                            const UInt                      uiCGPosY,
-#if MULTILEVEL_SIGMAP_EXT
                                            const UInt                      scanIdx,
-#endif
                                            Int width, Int height)
+{
 …
   width >>= 2;
   height >>= 2;
-#if MULTILEVEL_SIGMAP_EXT
   if( width == 2 && height == 2 ) // 8x8
+  {
 …
+    }
+  }
-#endif
   if( uiCGPosX < width - 1 )
+  {
 …
     uiLower = (uiSigCoeffGroupFlag[ (uiCGPosY  + 1 ) * width + uiCGPosX ] != 0);
+  }
-#if REMOVE_INFER_SIGGRP
   return (uiRight || uiLower);
+#else
+  return uiRight + uiLower;
+#endif
+}
+#if !REMOVE_INFER_SIGGRP
+// return 1 if both right neighbour and lower neighour are 1's
+Bool TComTrQuant::bothCGNeighboursOne ( const UInt*                   uiSigCoeffGroupFlag,
+                                       const UInt                      uiCGPosX,
+                                       const UInt                      uiCGPosY,
+#if MULTILEVEL_SIGMAP_EXT
+                                       const UInt                      scanIdx,
+#endif
+                                       Int width, Int height)
+{
+  UInt uiRight = 0;
+  UInt uiLower = 0;
+  width >>= 2;
+  height >>= 2;
+#if MULTILEVEL_SIGMAP_EXT
+  if( width == 2 && height == 2 ) // 8x8
+  {
+    if( scanIdx == SCAN_HOR )
+    {
+      width = 1;
+      height = 4;
+    }
+    else if( scanIdx == SCAN_VER )
+    {
+      width = 4;
+      height = 1;
+    }
+  }
+#endif
+  if( uiCGPosX < width - 1 )
+  {
+    uiRight = (uiSigCoeffGroupFlag[ uiCGPosY * width + uiCGPosX + 1 ] != 0);
+  }
+  if (uiCGPosY < height - 1 )
+  {
+    uiLower = (uiSigCoeffGroupFlag[ (uiCGPosY  + 1 ) * width + uiCGPosX ] != 0);
+  }
+  return (uiRight & uiLower);
+}
+#endif
+}
 /** set quantized matrix coefficient for encode
  * \param scalingList quantaized matrix address
 …
   UInt width = g_scalingListSizeX[sizeId];
   UInt height = g_scalingListSizeX[sizeId];
-#if SCALING_LIST
   UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
-#endif
   Int *quantcoeff;
   Int *coeff = scalingList->getScalingListAddress(sizeId,listId);
   quantcoeff   = getQuantCoeff(listId, qp, sizeId, SCALING_LIST_SQT);
-#if SCALING_LIST
   processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-  processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height,width,1,(Int)g_scalingListSizeX[sizeId],0);
-#endif
   if(sizeId == SCALING_LIST_32x32 || sizeId == SCALING_LIST_16x16) //for NSQT
+  {
     quantcoeff   = getQuantCoeff(listId, qp, sizeId-1,SCALING_LIST_VER);
-#if SCALING_LIST
     processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height,width>>2,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-    processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height,width>>2,1,(Int)g_scalingListSizeX[sizeId],0);
-#endif
     quantcoeff   = getQuantCoeff(listId, qp, sizeId-1,SCALING_LIST_HOR);
-#if SCALING_LIST
     processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height>>2,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-    processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height>>2,width,1,(Int)g_scalingListSizeX[sizeId],0);
-#endif
+  }
+}
 …
   UInt width = g_scalingListSizeX[sizeId];
   UInt height = g_scalingListSizeX[sizeId];
-#if SCALING_LIST
   UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
-#endif
   Int *dequantcoeff;
   Int *coeff = scalingList->getScalingListAddress(sizeId,listId);
   dequantcoeff = getDequantCoeff(listId, qp, sizeId,SCALING_LIST_SQT);
-#if SCALING_LIST
   processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-  processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height,width,1,(Int)g_scalingListSizeX[sizeId],0);
-#endif
   if(sizeId == SCALING_LIST_32x32 || sizeId == SCALING_LIST_16x16)
+  {
     dequantcoeff   = getDequantCoeff(listId, qp, sizeId-1,SCALING_LIST_VER);
-#if SCALING_LIST
     processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height,width>>2,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-    processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height,width>>2,1,(Int)g_scalingListSizeX[sizeId],0);
-#endif
     dequantcoeff   = getDequantCoeff(listId, qp, sizeId-1,SCALING_LIST_HOR);
-#if SCALING_LIST
     processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height>>2,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
-#else
-    processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height>>2,width,1,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),0);
-#endif
+  }
+}
 …
+    }
+  }
-#if SCALING_LIST
   if(ratio > 1)
+  {
     quantcoeff[0] = quantScales / dc;
+  }
-#endif
+}
 /** set quantized matrix coefficient for decode
 …
+    }
+  }
-#if SCALING_LIST
   if(ratio > 1)
+  {
     dequantcoeff[0] = invQuantScales * dc;
+  }
-#endif
+}

trunk/source/Lib/TLibCommon/TComTrQuant.h

-                      r56
+                      r296
   Int m_iBits;
-#if H0736_AVC_STYLE_QP_RANGE
   Void setQpParam( Int qpScaled, Bool bLowpass, SliceType eSliceType )
+  {
 …
     m_iBits = QP_BITS + m_iPer;
+  }
-#else
-  Void setQpParam( Int iQP, Bool bLowpass, SliceType eSliceType )
+  {
-    assert ( iQP >= MIN_QP && iQP <= MAX_QP );
-    m_iQP   = iQP;
-    m_iPer  = (iQP + 6*g_uiBitIncrement)/6;
-#if FULL_NBIT
-    m_iPer += g_uiBitDepth - 8;
-#endif
-    m_iRem  = iQP % 6;
-    m_iBits = QP_BITS + m_iPer;
+  }
-#endif
   Void clear()
 …
   // Misc functions
-#if H0736_AVC_STYLE_QP_RANGE
   Void setQPforQuant( Int qpy, Bool bLowpass, SliceType eSliceType, TextType eTxtType, Int qpBdOffset, Int chromaQPOffset);
-#else
-  Void setQPforQuant( Int iQP, Bool bLowpass, SliceType eSliceType, TextType eTxtType, Int Shift);
-#endif
 #if RDOQ_CHROMA_LAMBDA
 …
                                        const UInt                       uiCGPosX,
                                        const UInt                       uiCGPosY,
-#if MULTILEVEL_SIGMAP_EXT
                                        const UInt                     scanIdx,
-#endif
                                        Int width, Int height);
-#if !REMOVE_INFER_SIGGRP
-  static Bool bothCGNeighboursOne  ( const UInt*                      uiSigCoeffGroupFlag,
-                                    const UInt                       uiCGPosX,
-                                    const UInt                       uiCGPosY,
-#if MULTILEVEL_SIGMAP_EXT
-                                    const UInt                       scanIdx,
-#endif
-                                    Int width, Int height);
-#endif
   Void initScalingList                      ();
   Void destroyScalingList                   ();
 …
   Void xT   ( UInt uiMode,Pel* pResidual, UInt uiStride, Int* plCoeff, Int iWidth, Int iHeight );
-#if MULTIBITS_DATA_HIDING
   Void signBitHidingHDQ( TComDataCU* pcCU, TCoeff* pQCoef, TCoeff* pCoef, UInt const *scan, Int* deltaU, Int width, Int height );
-#endif
   // quantization
 …
                                              UShort                          ui16CtxNumAbs,
                                              UShort                          ui16AbsGoRice,
-#if RESTRICT_GR1GR2FLAG_NUMBER
                                              UInt                            c1Idx,
                                              UInt                            c2Idx,
-#endif
                                              Int                             iQBits,
                                              Double                          dTemp,
 …
                                      UShort                          ui16CtxNumAbs,
                                      UShort                          ui16AbsGoRice
-#if RESTRICT_GR1GR2FLAG_NUMBER
                                    , UInt                            c1Idx,
                                      UInt                            c2Idx
-#endif
                                      ) const;
-#if MULTIBITS_DATA_HIDING
 __inline Int xGetICRate  ( UInt                            uiAbsLevel,
                            UShort                          ui16CtxNumOne,
                            UShort                          ui16CtxNumAbs,
                            UShort                          ui16AbsGoRice
-#if RESTRICT_GR1GR2FLAG_NUMBER
                          , UInt                            c1Idx,
                            UInt                            c2Idx
-#endif
                          ) const;
-#endif
   __inline Double xGetRateLast     ( const UInt                      uiPosX,
                                      const UInt                      uiPosY,

trunk/source/Lib/TLibCommon/TComWedgelet.cpp

-                      r189
+                      r296
                                                             m_uhOri    ( 0 ),
                                                             m_eWedgeRes( FULL_PEL )
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
                                                             , m_bIsCoarse( false )
 #endif
 …
                                                             m_uhOri    ( rcWedge.m_uhOri     ),
                                                             m_eWedgeRes( rcWedge.m_eWedgeRes ),
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
                                                             m_bIsCoarse( rcWedge.m_bIsCoarse ),
                                                             m_uiAng    ( rcWedge.m_uiAng     ),
 …
+}
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 Void TComWedgelet::findClosetAngle()
+{
 …
   m_uhOri     = uhOri;
   m_eWedgeRes = eWedgeRes;
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
   m_bIsCoarse = bIsCoarse;
 #endif
 …
   case( 2 ): { for( UInt iX = uiTempBlockSize-1; iX > uhXs;            iX-- ) { UInt iY = uiTempBlockSize-1; while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iY--; } } } break;
   case( 3 ): { for( UInt iY = uiTempBlockSize-1; iY > uhYs;            iY-- ) { UInt iX = 0;                 while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iX++; } } } break;
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
   case( 4 ):
+    {
 …
       case( 2 ): { uiOffX = 1; uiOffY = 1; } break;
       case( 3 ): { uiOffX = 0; uiOffY = 1; } break;
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
       case( 4 ):
+        {
 …
+}
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 TComWedgeNode::TComWedgeNode()
+{

trunk/source/Lib/TLibCommon/TComWedgelet.h

-                      r189
+                      r296
 };
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 #define NUM_WEDGE_REFINES 8
 #define NO_IDX MAX_UINT
 …
   UChar           m_uhOri;                      // orientation index
   WedgeResolution m_eWedgeRes;                  // start/end pos resolution
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
   Bool            m_bIsCoarse;
   UInt            m_uiAng;
 …
   UChar           getEndY    () { return m_uhYe; }
   UChar           getOri     () { return m_uhOri; }
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
   Bool            getIsCoarse() { return m_bIsCoarse; }
   UInt            getAng     () { return m_uiAng; }
 …
 typedef std::vector<TComWedgeRef> WedgeRefList;
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 // ====================================================================================================================
 // Class definition TComWedgeNode

trunk/source/Lib/TLibCommon/TComYuv.cpp

-                      r189
+                      r296
+}
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766  && !MTK_MDIVRP_C0138
 Void
 TComYuv::add(Int *iPUResiPredShift, PartSize uhPartitionSize,  TComYuv* pcYuvAdd, Int iWidth, Int iHeight, Bool bSubtract )
 …
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void
 TComYuv::getPUXYOffset(PartSize uhPartitionSize, Int iWidth, Int iHeight, Int &iXOffset, Int &iYOffset)
 …
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void
 TComYuv::addLuma(Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvAdd, Int iWidth, Int iHeight, Bool bSubtract )
 …
   Pel*  pDstSamples = getLumaAddr();
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Int iXOffset, iYOffset;
 …
+}
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void
 TComYuv::addChroma(Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvAdd, Int iWidth, Int iHeight, Bool bSubtract )
 …
   Pel*  pDstSamplesCr = getCrAddr();
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Int iXOffset, iYOffset;
 …
+}
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void TComYuv::subtract(Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize )
+{
 …
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void TComYuv::subtractLuma(Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize )
 #else
 …
   Int  iDstStride  = getStride();
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Int iXOffset, iYOffset;
 …
+}
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
 Void TComYuv::subtractChroma(Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize )
 #else
 …
   Int  iSrc1Stride = pcYuvSrc1->getCStride();
   Int  iDstStride  = getCStride();
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Int iXOffset, iYOffset;

trunk/source/Lib/TLibCommon/TComYuv.h

-                      r100
+                      r296
   Void    addClipPartLuma   ( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize ); //GT
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   //  pcYuvSrc0 - pcYuvSrc1 -> m_apiBuf
   Void    subtract          (Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize );
 …
   //   Remove High frequency
   Void    removeHighFreq    ( TComYuv* pcYuvSrc, UInt uiPartIdx, UInt uiWidht, UInt uiHeight );
 #if LG_RESTRICTEDRESPRED_M24766
+#if LG_RESTRICTEDRESPRED_M24766 && !MTK_MDIVRP_C0138
   Void    getPUXYOffset     (PartSize uhPartitionSize, Int iWidth, Int iHeight, Int &iXOffset, Int &iYOffset);
   Void    add               (Int *iPUResiPredShift, PartSize uhPartitionSize, TComYuv* pcYuvAdd, Int iWidth, Int iHeight, Bool bSubtract = false );

trunk/source/Lib/TLibCommon/TypeDef.h

-                      r211
+                      r296
 //! \ingroup TLibCommon
 //! \{
+// MV-HEVC
+#define QC_IV_AS_LT_B0046                 1   //JCT3V-B0046: inter-view reference pictures are treated as long-term pictures
+#define QC_REM_IDV_B0046                  1   //JCT3V-B0046: removal of IDV NAL unit type
+#define DV_V_RESTRICTION_B0037            1   //JCT3V-B0037: disparity vector vertical range restriction
+#define QC_TMVP_IDX_MOD_B0046             1   //JCT3V-B0046: the reference index for temporal merging candidate is set to 0, as defined in HEVC
+// 3D-HEVC
 #define QC_MVHEVC_B0046                   0   //JCT3V-B0046: disable 3DHEVC tools
-#define QC_IV_AS_LT_B0046                 1   //JCT3V-B0046: inter-view reference pictures are treated as long-term pictures
-#define QC_TMVP_IDX_MOD_B0046             1   //JCT3V-B0046: the reference index for temporal merging candidate is set to 0, as defined in HEVC
-#define QC_REM_IDV_B0046                  1   //JCT3V-B0046: removal of IDV NAL unit type
-#define FIX_DEL_NULLPTR                   1
-#define FIX_MISUSE_REFINDEX               1
-#define FIX_FCO_COMP_WARNING              1
-#define DV_V_RESTRICTION_B0037            1   // JCT3V-B0037 disparity vector vertical range restriction
 #if !QC_MVHEVC_B0046
+///// ***** FIXES *********
+// A
+#define FIX_POZNAN_CABAC_INIT_FLAG        1
+#define FIX_LG_RESTRICTEDRESPRED_M24766   1
+// B
+#define FIX_LGE_IVMP_PARALLEL_MERGE_B0136 1
+#define FIX_RDO_NEGDIST                   1
+#define FIX_DMM_NEG_DIST                  1
+#define FIX_LGE_DVMCP_B0133               1
+// FCO
+#define FLEX_CODING_ORDER_M23723          1
+#if FLEX_CODING_ORDER_M23723
+  #define DISABLE_FCO_FOR_VSO             0 // Optional compile settings to disable VSO with FCO.
+#endif
+///// ***** PATCHES *********
+#define TMVP_DEPTH_SWITCH                 1   // JCT3V-B0092 additional encoder option only
+///// ***** DEPTH MODELING MODES *********
+///// ***** DMM *********
 #define HHI_DMM_WEDGE_INTRA               1   // depth model modes independent on texture (explicit and intra-predicted Wedgelet prediction)
 #define HHI_DMM_PRED_TEX                  1   // depth model modes dependent on texture (inter-component Wedgelet and Contour prediction )
+                                              // HHIQC_DMMFASTSEARCH_B0039, fast Wedgelet search for DMM modes 1 and 3
 #define LGE_EDGE_INTRA_A0070              1   // JCT3V-A0070
+#define HHI_DMM_DELTADC_Q1_C0034          1   // JCT3V-C0034: no quantization and fast encoder search for DMM delta DC values
+#if ( HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA ) && HHI_DMM_PRED_TEX
+#define LGE_DMM3_SIMP_C0044               1
+#endif
+#define FIX_DMM_CTX_INIT_C0034            1   // JCT3V-C0034 fix for wrong init type of DMM contexts (UChar instead of Short)
+///// ***** SDC *********
 #define RWTH_SDC_DLT_B0036                1   // JCT3V-B0036: Simplified Depth Coding + Depth Lookup Table
+#define HHIQC_DMMFASTSEARCH_B0039         1   // JCT3V-B0039: fast Wedgelet search for DMM modes 1 and 3
+///// ***** INTERVIEW MOTION VECTOR PREDICTION *********
+#define HHI_INTER_VIEW_MOTION_PRED        1   // inter-view motion parameter prediction
+#define SHARP_INTERVIEW_DECOUPLE_B0111    1   // JCT3V-B0111 decoupling inter-view candidate
+#define QC_MRG_CANS_B0048                 1   // JCT3V-B0048, B0086, B0069
+#if     QC_MRG_CANS_B0048
+#define OL_DISMV_POS_B0069                1   // different pos for disparity MV candidate, B0069
+#endif
+#define MTK_INTERVIEW_MERGE_A0049         1   // JCT3V-A0049 second part
+#if HHI_INTER_VIEW_MOTION_PRED
+#define SAIT_IMPROV_MOTION_PRED_M24829    1   // improved inter-view motion vector prediction
+#else
+#define SAIT_IMPROV_MOTION_PRED_M24829    0
+#endif
+#if RWTH_SDC_DLT_B0036
+#define SAIT_SDC_C0096                    1   // JCT3V-C0096: Improved Simple Depth Coding(removal of DMM2 among four SDC modes(DC, Planar, DMM1 and DMM2))
+#endif
+#define FIX_SDC_ENC_C0143                 1   // JCT3V-C0143 fix for unnecessary encoder checks in case of SDC
+///// ***** TMVP/AMVP *********
+#define TMVP_DEPTH_SWITCH                 1   // JCT3V-B0092 additional encoder option only
+#define QC_TMVP_MRG_REFIDX_C0047          1   // only enabled when QC_TMVP_IDX_MOD_B0046 is enabled.
+#define INTER_VIEW_VECTOR_SCALING_C0115   1   // JCT3V-C0115 Inter-view vector scaling for TMVP & flag
+#define INTER_VIEW_VECTOR_SCALING_C0116   1   // JCT3V-C0116 Inter-view vector scaling for AMVP
+///// ***** INTERVIEW MOTION PARAMETER PREDICTION *********
+#define H3D_IVMP                          1   // Inter-view motion parameter prediction
+                                              // HHI_INTER_VIEW_MOTION_PRED
+                                              // SAIT_IMPROV_MOTION_PRED_M24829, improved inter-view motion vector prediction
+                                              // SHARP_INTERVIEW_DECOUPLE_B0111, decoupling inter-view candidate
+                                              // QC_MRG_CANS_B0048             , JCT3V-B0048, B0086, B0069
+                                              // OL_DISMV_POS_B0069            , different pos for disparity MV candidate, B0069
+                                              // MTK_INTERVIEW_MERGE_A0049     , second part
+#define QC_AMVP_MRG_UNIFY_IVCAN_C0051     1
+#define QC_C0051_FIXED_BY_MTK             1   // Bug fix for C0051 implementation
 ///// ***** INTERVIEW RESIDUAL PREDICTION *********
+#define HHI_INTER_VIEW_RESIDUAL_PRED      1   // inter-view residual prediction
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#define LG_RESTRICTEDRESPRED_M24766       1   // restricted inter-view residual prediction
+#define QC_SIMPLIFIEDIVRP_M24938          1
+#define H3D_IVRP                          1   // Inter-view residual prediction
+                                              // HHI_INTER_VIEW_RESIDUAL_PRED
+                                              // QC_SIMPLIFIEDIVRP_M24938
+#if H3D_IVRP
+#define LG_RESTRICTEDRESPRED_M24766       1   // Restricted inter-view residual prediction
+#define FIX_LG_RESTRICTEDRESPRED_M24766   1
 #else
 #define LG_RESTRICTEDRESPRED_M24766       0
+#define QC_SIMPLIFIEDIVRP_M24938          0
+#endif
+#endif
+#define MTK_MDIVRP_C0138                  1   // Mode-dependent inter-view residual prediction
+#define MTK_C0138_FIXED                   1   // Fix for IBP coding structure in view direction (not CTC)
 ///// ***** DISPARITY VECTOR DERIVATION *********
+#define QC_MULTI_DIS_CAN_A0097            1   // JCT3V-A0097
+#define LGE_DVMCP_A0126                   1   // JCT3V-A0126
+#define LGE_DVMCP_MEM_REDUCTION_B0135     1   // JCT3V-B0135
+#define DV_DERIVATION_PARALLEL_B0096      1   // JCT3V-B0096, enable parallel derivation of disparity vector
+#define QC_SIMPLE_NBDV_B0047              1   // JCT3V-B0047
+#define H3D_NBDV                          1   // Neighboring block disparity derivation
+                                              // JCT3V-A0097
+                                              // LGE_DVMCP_A0126
+                                              // LGE_DVMCP_MEM_REDUCTION_B0135
+                                              // DV_DERIVATION_PARALLEL_B0096, enable parallel derivation of disparity vector
+                                              // QC_SIMPLE_NBDV_B0047
+                                              // FIX_LGE_DVMCP_B0133
+                                              // LGE_IVMP_PARALLEL_MERGE_B0136, B0136 support of parallel merge/skip in disparity vector derivation
+                                              // FIX_LGE_IVMP_PARALLEL_MERGE_B0136
+#define QC_NBDV_LDB_FIX_C0055             1   // JCT3V-C0055
+#define MTK_SAIT_TEMPORAL_FIRST_ORDER_C0141_C0097     1   // JCT3V-C0141/C0097
+#define MTK_RELEASE_DV_CONSTRAINT_C0129   1   // JCT3V-C0129
+#define MTK_SIMPLIFY_DVTC_C0135           1   // JCT3V-C0135
 ///// ***** MOTION PARAMETER INHERITANCE  *********
+#define HHI_MPI                           1   // motion parameter inheritance from texture picture for depth map coding
+#define MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137   1   // JCT3V-C0137
+#define HHI_MPI                           0   // motion parameter inheritance from texture picture for depth map coding
 #if HHI_MPI
 #define FIX_MPI_B0065                     1   // JCT3V-B0065, fix the MPI bug when RQT is off
 …
 #if LGE_ILLUCOMP_B0045
 #define LGE_ILLUCOMP_B0045_ENCSIMP        1
+#define FIX_LGE_ILLUCOMP_B0045            1
+#define LGE_ILLUCOMP_DEPTH_C0046          1   // JCT2-C0046 Apply illumination compensation to depth
+#if LGE_ILLUCOMP_DEPTH_C0046
+#define FIX_ILLUCOMP_DEPTH                1
+#endif
 #endif
 …
 ///// ***** QUADTREE LIMITATION *********
 #define OL_QTLIMIT_PREDCODING_B0068       1    //JCT3V-B0068
+#define HHI_QTLPC_RAU_OFF_C0160           1   // JCT3V-C0160 change 2: quadtree limitation and predictive coding switched off in random access units
 ///// ***** OTHERS *********
 #define LG_ZEROINTRADEPTHRESI_A0087       1   // JCT2-A0087
-#define SONY_COLPIC_AVAILABILITY          1
 #define HHI_FULL_PEL_DEPTH_MAP_MV_ACC     1   // full-pel mv accuracy for depth maps
+#define VIDYO_VPS_INTEGRATION             1
+///// ***** DEFINED PARAMETERS *********
+#if QC_MULTI_DIS_CAN_A0097
+#define VIDYO_VPS_INTEGRATION             1   // Integration of VPS
+#define HHI_DEPTH_INTRA_SEARCH_RAU_C0160  1   // JCT3V-C0160 change 1: full Intra search in depth random access units
+#define FIX_POZNAN_CABAC_INIT_FLAG        1
+///// ***** FCO  *********
+#define FLEX_CODING_ORDER_M23723          1
+#if FLEX_CODING_ORDER_M23723
+#define DISABLE_FCO_FOR_VSO               0 // Optional compile settings to disable VSO with FCO.
+#endif
+///// ***** VSP *********
+#define MERL_VSP_C0152                    1 // JCT3V-C0152: 1: enable VSP-related tools; 0: disable VSP-related tools
+#if MERL_VSP_C0152
+/*
+ * Two macros are used to configure combinations of JCT3V-C0152 and JCT3V-C0131
+ *
+ *   a) (full) A full JCT3V-C0152 implementation, including JCT3V-C0131
+ *      #define MERL_VSP_COMPENSATION_C0152          1
+ *      #define MERL_MTK_VSP_DVP_REFINE_C0152_C0131  1
+ *
+ *   b) (mvp2off) For partial JCT3V-C0152 excluding overlaps from JCT3V-C0131
+ *      #define MERL_VSP_COMPENSATION_C0152          1
+ *      #define MERL_MTK_VSP_DVP_REFINE_C0152_C0131  0
+ *
+ *   c) (nocand) For JCT3V-C0131 only
+ *      #define MERL_VSP_COMPENSATION_C0152          0
+ *      #define MERL_MTK_VSP_DVP_REFINE_C0152_C0131  1
+ */
+#define MERL_VSP_COMPENSATION_C0152          1 // JCT3V-C0152: 1: add VSP merge candidate to merging candidate list; 0: not to add   (nocand).
+#define MERL_MTK_VSP_DVP_REFINE_C0152_C0131  1 // JCT3V-C0152 && JCT3V-C0131: 1: refine disparity vector using a warped depth block; 0: not to refine  (mvp2off).
+#define MERL_VSP_BLOCKSIZE_C0152             4 // JCT3V-C0152: VSP block size, supported values: 1, 2 and 4.
+#define VSP_MERGE_POS                        5 // JCT3V-C0152: fixed position of VSP candidate in merge list, supported values: 5.
+#define LGE_SIMP_DVP_REFINE_C0112            1 // JCT3V-C0112: 1: simplification of refining disparity vector using a warped depth block
+#else // !MERL_VSP_C0152
+#define MERL_VSP_COMPENSATION_C0152          0 // JCT3V-C0152: 1: add VSP merge candidate to merging candidate list; 0: not to add
+#define MERL_MTK_VSP_DVP_REFINE_C0152_C0131  0 // JCT3V-C0152 && JCT3V-C0131: 1: refine disparity vector using a warped depth block; 0: not to refine
+#define MERL_VSP_BLOCKSIZE_C0152             4 // JCT3V-C0152: VSP block size, supported values: 1, 2 and 4.
+#define LGE_SIMP_DVP_REFINE_C0112            0 // JCT3V-C0112: 1: simplification of refining disparity vector using a warped depth block
+#endif
+///// ***** DERIVED PARAMETERS *********
+#if H3D_NBDV
 #define DIS_CANS                          1
 #endif
 …
 #if LGE_DVMCP_A0126
+#if H3D_NBDV
 #define DVFROM_LEFTBELOW                  1
 #define DVFROM_LEFT                       2
 …
 #if HHIQC_DMMFASTSEARCH_B0039
+#if HHI_DMM_PRED_TEX || HHI_DMM_WEDGE_INTRA
 #define DMM3_SIMPLIFY_TR                  1
 #endif
 …
 #if RWTH_SDC_DLT_B0036
 #define Log2( n ) ( log((double)n) / log(2.0) )
+#define HS_REFERENCE_SUBSAMPLE_C0154      1
 #endif
 #define HHI_MPI_MERGE_POS                 0
 #endif
 ///// ***** HM 6.1 *********
+//// REMOVED HM 6.1 Guard macros (corresponding to macros removed in HM 6.3.1)
+/*
 #define SKIPFRAME_BUGFIX                  1 ///< bug fix to enable skipFrame at decoder
 #define START_DECODING_AT_CRA             1 ///< H0496, start decoding at clear random access point
 #define NO_COMBINED_PARALLEL              1 ///< Disallow any combined usage of parallel tools among Tile, EntropySlice and Wavefont
+#define PARALLEL_MERGE                    1 ///< H0082 parallel merge/skip
+#define MVP_AT_ENTROPYSLICE_BOUNDARY      1  //< H0362 enable motion prediction accross entropy slice boundary
+#define FAST_DECISION_FOR_MRG_RD_COST     1  ////< H0178: Fast Decision for Merge 2Nx2N RDCost
+#define PIC_CROPPING                      1  ///< Picture cropping and size constraints
+#define NAL_REF_FLAG                      1  ///< Change nal_ref_idc to nal_ref_flag (JCTVC-F463)
+#define REMOVE_DIV_OPERATION      1  ///< H0238: Simplified intra horizontal and vertical filtering
+#define LOGI_INTRA_NAME_3MPM      1  ///< H0407: logical Intra mode naming (sequential angular mode numbering) and 3 MPM mode coding
+#define LEVEL_CTX_LUMA_RED        1  ///<H0130: Luma level context reduction
+#define REMOVE_INFER_SIGGRP       1  ///<H0131: Remove inferred significant_coeff_group_flag
+#define SET_MERGE_TMVP_REFIDX     1  ///< H0278/H0199: Setting the merge TMVP refidx to 0 for the non-first partition
+#define MULTILEVEL_SIGMAP_EXT     1  ///< H0526: multi-level significance map extended to smaller TUs
+#define MULTIBITS_DATA_HIDING     1  ///< H0481: multiple sign bit hiding
+#define DEQUANT_CLIPPING          1  ///< H0312/H0541: transformed coefficients clipping before de-quantization
+#define REMOVE_NON_SCALED         1 ///< H0164/H0250: Removal of non-scaled merge candidate
+#define MRG_IDX_CTX_RED           1 ///< H0251: Merge index context reduction
+#define SIMP_MRG_PRUN             1 ///< H0252: simplification of merge pruning process
+#define AMVP_PRUNING_SIMPLIFICATION         1     ///H0316: simplify the pruning process of AMVP by exempting the temporal candidate
+#define AMVP_ZERO_CHECKING_REMOVAL          1     ///H0239/H0316: remove zero motion vector checking of AMVP
+#define H0111_MVD_L1_ZERO         1  ///< H0111: modification of bi-prediction
+#define CLIPSCALEDMVP               1  ///< H0216: Clipping scaled MV to 16 bit
+#define UNIFIED_TRANSFORM_TREE      1   ///< H0123: unified tree structure for TU
+#define SIGMAP_CTX_SUBBLOCK       1 ///< H0290: 4x4 sub-block based region for significant_flag context selection
+#define LAST_CTX_REDUCTION        1  ///< H0537/H514: contexts reduction for last position coding
+#define AMP_CTX                   1 ///<H0545: context reduction for asymmetric partition
+#define RESTRICT_GR1GR2FLAG_NUMBER    1 ///< H0554: Throughput improvement of CABAC coefficients level coding
+#define EIGHT_BITS_RICE_CODE        1 ///< H0498 : 8 bits rice codes
+#define SAO_UNIT_INTERLEAVING      1   ///< H0273
+#define ALF_SINGLE_FILTER_SHAPE    1     //< !!! H0068: Single filter type : 9x7 cross + 3x3 square
+#define ALF_16_BA_GROUPS        1     ///< H0409 16 BA groups
+#define LCU_SYNTAX_ALF          1     ///< H0274 LCU-syntax ALF
+#define ALF_CHROMA_COEF_PRED_HARMONIZATION 1 ///< H0483: ALF chroma coeff pred harmonization
+#define CABAC_LINEAR_INIT       1     ///< H0535 : linear CABAC initialization
+#define UNIFIED_TRANSFORM       1     ///< H0492: unify square and non-square transform
+#define G519_TU_AMP_NSQT_HARMONIZATION  1   ///< G519: Harmonization of implicit TU, AMP and NSQT
+#define CHROMA_MODE_CODING                   1     //H0326/H0475 : 2-length fixed, bypass coding for chroma intra prediction mode
+#define NSQT_LFFIX                           1     ///< Bug fix related to NSQT and deblocking filter
+#define H0736_AVC_STYLE_QP_RANGE             1    ///< H0736: AVC style qp range and wrapping.
+#define H0204_QP_PREDICTION                  1    ///< H0204: improved QP prediction
+#define BURST_IPCM                        1           ///< H0051: Burst IPCM
+#define H0137_0138_LIST_MODIFICATION      1           // Enabled reference picture lists combination (H0137) and reference picture list modification (H0138) updates
+#define LTRP_MULT                       1           ///< enable/disable multiple long term reference pictures with same POC LSB
+#define OL_FLUSH 1          // Set to 1 to enable Wavefront Flush.
+#define FIXED_NUMBER_OF_TILES_SLICE_MODE                1
+#define SCALING_LIST                  1 //JCTVC-H0230/H0461/H0237
+#define DEFAULT_DC                    1 // JCTVC-H0242
+#define RPS_IN_SPS                    1 // Adopted during discussion of JCTVC-H0423
+#define H0412_REF_PIC_LIST_RESTRICTION 1
+#define H0566_TLA                     1
+#define H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER 1
+#define DBL_H0473_PART_1          1   //Deblocking filtering simplification
+#define DBL_CONTROL               1   //PPS deblocking_filter_control_present_flag (JCTVC-H0398); condition for inherit params flag in SH (JCTVC-H0424)
+#define DBL_STRONG_FILTER_CLIP    1   //Introduction of strong filter clipping in deblocking filter (JCTVC-H0275)
+#define H0388                       1 // JCTVC-H0388
+#define TILES_WPP_ENTRY_POINT_SIGNALLING        1 // JCTVC-H0556. Assumes either Tiles is ON or WPP is ON (not both simultaneously).
+#define REMOVE_TILE_DEPENDENCE                  1 // remove tile_boundary_independence_flag and dependent tiles
+#define TILES_OR_ENTROPY_SYNC_IDC               1 // tiles_or_entropy_coding_sync_idc flag
+#define COMPLETE_SLICES_IN_TILE     1 // Among the constraints between slices and tiles, all slices within a tile shall be complete (JCTVC-H0348/JCTVC-H0463) for SliceMode 1&2
+#define WPP_SIMPLIFICATION          1 // JCTVC-H0349/JCTVC-0517
+*/
 #define LOSSLESS_CODING                   1 ///< H0530: lossless and lossy (mixed) coding
 …
 #endif
-#define PARALLEL_MERGE  1                   //< H0082 parallel merge/skip
-#define LGE_IVMP_PARALLEL_MERGE_B0136     1 //< B0136 support of parallel merge/skip in disparity vector derivation
 #define LOG2_PARALLEL_MERGE_LEVEL_MINUS2  0 //< H0082 parallel merge level 0-> 4x4, 1-> 8x8, 2->16x16, 3->32x32, 4->64x64
 #if PARALLEL_MERGE && LOG2_PARALLEL_MERGE_LEVEL_MINUS2
+#if LOG2_PARALLEL_MERGE_LEVEL_MINUS2
 #define CU_BASED_MRG_CAND_LIST            1  //< H0240: single merge candidate list for all PUs inside a 8x8 CU conditioned on LOG2_PARALLEL_MERGE_LEVEL_MINUS2 > 0
 #define FIX_CU_BASED_MRG_CAND_LIST_B0136  1  //< B0136 bug fix for CU_BASED_MRG_CAND_LIST
 #endif
-#define MVP_AT_ENTROPYSLICE_BOUNDARY      1  //< H0362 enable motion prediction accross entropy slice boundary
-#define FAST_DECISION_FOR_MRG_RD_COST     1  ////< H0178: Fast Decision for Merge 2Nx2N RDCost
-#define PIC_CROPPING              1  ///< Picture cropping and size constraints
-#define NAL_REF_FLAG              1  ///< Change nal_ref_idc to nal_ref_flag (JCTVC-F463)
-#define REMOVE_DIV_OPERATION      1  ///< H0238: Simplified intra horizontal and vertical filtering
-#define LOGI_INTRA_NAME_3MPM      1  ///< H0407: logical Intra mode naming (sequential angular mode numbering) and 3 MPM mode coding
-#define LEVEL_CTX_LUMA_RED        1  ///<H0130: Luma level context reduction
-#define REMOVE_INFER_SIGGRP       1  ///<H0131: Remove inferred significant_coeff_group_flag
-#define SET_MERGE_TMVP_REFIDX     1  ///< H0278/H0199: Setting the merge TMVP refidx to 0 for the non-first partition
-#define MULTILEVEL_SIGMAP_EXT     1  ///< H0526: multi-level significance map extended to smaller TUs
-#define MULTIBITS_DATA_HIDING     1  ///< H0481: multiple sign bit hiding
-#define DEQUANT_CLIPPING          1  ///< H0312/H0541: transformed coefficients clipping before de-quantization
-#define REMOVE_NON_SCALED         1 ///< H0164/H0250: Removal of non-scaled merge candidate
-#define MRG_IDX_CTX_RED           1 ///< H0251: Merge index context reduction
-#define SIMP_MRG_PRUN             1 ///< H0252: simplification of merge pruning process
-#define AMVP_PRUNING_SIMPLIFICATION         1     ///H0316: simplify the pruning process of AMVP by exempting the temporal candidate
-#define AMVP_ZERO_CHECKING_REMOVAL          1     ///H0239/H0316: remove zero motion vector checking of AMVP
-#define H0111_MVD_L1_ZERO         1  ///< H0111: modification of bi-prediction
 #define DISABLING_CLIP_FOR_BIPREDME         1  ///< Ticket #175
-#define CLIPSCALEDMVP               1  ///< H0216: Clipping scaled MV to 16 bit
-#define UNIFIED_TRANSFORM_TREE      1   ///< H0123: unified tree structure for TU
-#define SIGMAP_CTX_SUBBLOCK       1 ///< H0290: 4x4 sub-block based region for significant_flag context selection
 #define SIGMAP_CONST_AT_HIGH_FREQUENCY      1      ///< H0095 method2.1: const significance map at high freaquency
-#define LAST_CTX_REDUCTION        1  ///< H0537/H514: contexts reduction for last position coding
-#define AMP_CTX                   1 ///<H0545: context reduction for asymmetric partition
-#define RESTRICT_GR1GR2FLAG_NUMBER    1 ///< H0554: Throughput improvement of CABAC coefficients level coding
-#if RESTRICT_GR1GR2FLAG_NUMBER    //
 #define C1FLAG_NUMBER               8 // maximum number of largerThan1 flag coded in one chunk :  16 in HM5
 #define C2FLAG_NUMBER               1 // maximum number of largerThan2 flag coded in one chunk:  16 in HM5
+#endif
+#define EIGHT_BITS_RICE_CODE        1 ///< H0498 : 8 bits rice codes
+#define SAO_UNIT_INTERLEAVING      1   ///< H0273
 #define REMOVE_SAO_LCU_ENC_CONSTRAINTS_1 0  ///< disable the encoder constraint that does not test SAO/BO mode for chroma in interleaved mode
 #define REMOVE_SAO_LCU_ENC_CONSTRAINTS_2 0  ///< disable the encoder constraint that reduce the range of SAO/EO for chroma in interleaved mode
 #define REMOVE_SAO_LCU_ENC_CONSTRAINTS_3 0  ///< disable the encoder constraint that conditionally disable SAO for chroma for entire slice in interleaved mode
+#define ALF_SINGLE_FILTER_SHAPE    1     //< !!! H0068: Single filter type : 9x7 cross + 3x3 square
+#define ALF_16_BA_GROUPS        1     ///< H0409 16 BA groups
+#define LCU_SYNTAX_ALF          1     ///< H0274 LCU-syntax ALF
+#define ALF_CHROMA_COEF_PRED_HARMONIZATION 1 ///< H0483: ALF chroma coeff pred harmonization
+#define CABAC_LINEAR_INIT       1     ///< H0535 : linear CABAC initialization
+#define COLLOCATED_REF_IDX      1     ///< H0442: signal collocated reference index
+#define UNIFIED_TRANSFORM       1     ///< H0492: unify square and non-square transform
+#define COLLOCATED_REF_IDX      1           ///< H0442: signal collocated reference index
 #define MAX_NUM_SPS                32
 …
 #define FAST_BIT_EST                1   ///< G763: Table-based bit estimation for CABAC
-#define G519_TU_AMP_NSQT_HARMONIZATION  1   ///< G519: Harmonization of implicit TU, AMP and NSQT
 #define MLS_GRP_NUM                         64     ///< G644 : Max number of coefficient groups, max(16, 64)
 …
-#define CHROMA_MODE_CODING                   1     //H0326/H0475 : 2-length fixed, bypass coding for chroma intra prediction mode
-#define NSQT_LFFIX                           1     ///< Bug fix related to NSQT and deblocking filter
 #define NS_HAD                               1
 …
 #define APS_BITS_FOR_ALF_BYTE_LENGTH 8
+#define H0736_AVC_STYLE_QP_RANGE             1    ///< H0736: AVC style qp range and wrapping.
+#define H0204_QP_PREDICTION                  1    ///< H0204: improved QP prediction
 #define HHI_RQT_INTRA_SPEEDUP             1           ///< tests one best mode with full rqt
 #define HHI_RQT_INTRA_SPEEDUP_MOD         0           ///< tests two best modes with full rqt
+#define BURST_IPCM                        1           ///< H0051: Burst IPCM
 #if HHI_RQT_INTRA_SPEEDUP_MOD && !HHI_RQT_INTRA_SPEEDUP
 …
 #endif
+#define H0137_0138_LIST_MODIFICATION      1           // Enabled reference picture lists combination (H0137) and reference picture list modification (H0138) updates
+#if !H0137_0138_LIST_MODIFICATION
+#error "H0137_0138_LIST_MODIFICATION must be enabled for multi-view coding."
+#endif
 #define VERBOSE_RATE 0                               ///< Print additional rate information in encoder
 …
 #if LGE_EDGE_INTRA_A0070
 #if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
+#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 #define EDGE_INTRA_IDX  (NUM_INTRA_MODE+NUM_DMM_MODE)
 #endif // HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
+#endif // HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 #if LGE_EDGE_INTRA_DELTA_DC
 #define EDGE_INTRA_DELTA_IDX          (EDGE_INTRA_IDX+1)
 …
                                                     // this should be done with encoder only decision
                                                     // but because of the absence of reference frame management, the related code was hard coded currently
-#define LTRP_MULT                       1           ///< enable/disable multiple long term reference pictures with same POC LSB
-#define OL_FLUSH 1          // Set to 1 to enable Wavefront Flush.
 #define OL_FLUSH_ALIGN 0    // Align flush to byte boundary.  This preserves byte operations in CABAC (faster) but at the expense of an average
                             // of 4 bits per flush.
 …
 #define PLANAR_IDX             0
-#if LOGI_INTRA_NAME_3MPM
 #define VER_IDX                26                    // index for intra VERTICAL   mode
 #define HOR_IDX                10                    // index for intra HORIZONTAL mode
 #define DC_IDX                 1                     // index for intra DC mode
-#else
-#define DC_IDX                 3                     // index for intra DC mode
-#endif
 #define NUM_CHROMA_MODE        6                     // total number of chroma modes
 #define DM_CHROMA_IDX          36                    // chroma mode index for derived from luma intra mode
 …
 #define FULL_NBIT 0 ///< When enabled, does not use g_uiBitIncrement anymore to support > 8 bit data
+#define FIXED_NUMBER_OF_TILES_SLICE_MODE                1
 #define AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE      1          ///< OPTION IDENTIFIER. mode==1 -> Limit maximum number of largest coding tree blocks in a slice
 #define AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE    2          ///< OPTION IDENTIFIER. mode==2 -> Limit maximum number of bins/bits in a slice
-#if FIXED_NUMBER_OF_TILES_SLICE_MODE
 #define AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE    3
-#endif
 // Entropy slice options
 …
 #define SCALING_LIST_OUTPUT_RESULT    0 //JCTVC-G880/JCTVC-G1016 quantization matrices
-#define SCALING_LIST                  1 //JCTVC-H0230/H0461/H0237
-#define DEFAULT_DC                    1 // JCTVC-H0242
-#define RPS_IN_SPS                    1 // Adopted during discussion of JCTVC-H0423
-#define H0412_REF_PIC_LIST_RESTRICTION 1
-#define H0566_TLA                     1
-#if H0566_TLA
 #define H0566_TLA_SET_FOR_SWITCHING_POINTS 1
+#endif
+#define H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER 1
+#define DBL_H0473_PART_1          1   //Deblocking filtering simplification
+#define DBL_CONTROL               1   //PPS deblocking_filter_control_present_flag (JCTVC-H0398); condition for inherit params flag in SH (JCTVC-H0424)
+#define DBL_STRONG_FILTER_CLIP    1   //Introduction of strong filter clipping in deblocking filter (JCTVC-H0275)
 #define CABAC_INIT_FLAG             1 // JCTVC-H0540
 #define CABAC_INIT_PRESENT_FLAG     1
-#define H0388                       1 // JCTVC-H0388
-#define TILES_WPP_ENTRY_POINT_SIGNALLING        1 // JCTVC-H0556. Assumes either Tiles is ON or WPP is ON (not both simultaneously).
-#define REMOVE_TILE_DEPENDENCE                  1 // remove tile_boundary_independence_flag and dependent tiles
-#define TILES_OR_ENTROPY_SYNC_IDC               1 // tiles_or_entropy_coding_sync_idc flag
-#define COMPLETE_SLICES_IN_TILE     1 // Among the constraints between slices and tiles, all slices within a tile shall be complete (JCTVC-H0348/JCTVC-H0463) for SliceMode 1&2
-#define WPP_SIMPLIFICATION          1 // JCTVC-H0349/JCTVC-0517
 // ====================================================================================================================
 …
+{
   SAO_EO_LEN    = 4,
-#if SAO_UNIT_INTERLEAVING
   SAO_BO_LEN    = 4,
   SAO_MAX_BO_CLASSES = 32
-#else
-  SAO_BO_LEN    = 16
-#endif
 };
 …
   SAO_EO_2,
   SAO_EO_3,
-#if SAO_UNIT_INTERLEAVING
   SAO_BO,
-#else
-  SAO_BO_0,
-  SAO_BO_1,
-#endif
   MAX_NUM_SAO_TYPE
 };
 …
 typedef struct _SaoQTPart
+{
-#if !SAO_UNIT_INTERLEAVING
-  Bool        bEnableFlag;
-#endif
   Int         iBestType;
   Int         iLength;
-#if SAO_UNIT_INTERLEAVING
   Int         bandPosition ;
   Int         iOffset[4];
-#else
-  Int         iOffset[32];
-#endif
   Int         StartCUX;
   Int         StartCUY;
 …
 } SAOQTPart;
-#if SAO_UNIT_INTERLEAVING
 typedef struct _SaoLcuParam
+{
 …
   Int        length;
 } SaoLcuParam;
-#endif
 struct SAOParam
 …
   Int        iMaxSplitLevel;
   Int        iNumClass[MAX_NUM_SAO_TYPE];
-#if SAO_UNIT_INTERLEAVING
   Bool         oneUnitFlag[3];
   SaoLcuParam* saoLcuParam[3];
   Int          numCuInHeight;
   Int          numCuInWidth;
-#endif
   ~SAOParam();
 };
 …
+{
   Int alf_flag;                           ///< indicates use of ALF
-#if !LCU_SYNTAX_ALF
-  Int chroma_idc;                         ///< indicates use of ALF for chroma
-#endif
   Int num_coeff;                          ///< number of filter coefficients
   Int filter_shape;
-#if !LCU_SYNTAX_ALF
-  Int filter_shape_chroma;
-  Int num_coeff_chroma;                   ///< number of filter coefficients (chroma)
-  Int *coeff_chroma;                      ///< filter coefficient array (chroma)
-#endif
   Int *filterPattern;
   Int startSecondFilter;
 …
   Int **coeffmulti;
   Int minKStart;
-#if !LCU_SYNTAX_ALF
-  Int maxScanVal;
-  Int kMinTab[42];
-  Int alf_pcr_region_flag;
-  ~ALFParam();
-#endif
-#if LCU_SYNTAX_ALF
   Int componentID;
   Int* kMinTab;
 …
   Void destroy();
   Void copy(const ALFParam& src);
+#endif
+};
+#if LCU_SYNTAX_ALF
+};
 struct AlfUnitParam
+{
 …
   Void destroy();
 };
-#endif

trunk/source/Lib/TLibDecoder/NALread.cpp

-                      r210
+                      r296
   assert(forbidden_zero_bit == 0);
-#if NAL_REF_FLAG
   nalu.m_nalRefFlag  = (bs.read(1) != 0 );
   nalu.m_nalUnitType = (NalUnitType) bs.read(6);
-#else
-  nalu.m_nalRefIDC   = (NalRefIdc) bs.read(2);
-  nalu.m_nalUnitType = (NalUnitType) bs.read(5);
-#endif
 #if QC_MVHEVC_B0046
 …
   nalu.m_temporalId = bs.read(3) - 1;
 #else
-#if H0388
   nalu.m_temporalId = bs.read(3);
  //  unsigned reserved_one_5bits = bs.read(5);
 …
   nalu.m_isDepth  = bs.read(1);
 #endif
-#if H0566_TLA
   if ( nalu.m_temporalId )
+  {
 …
+  }
 #endif
-#else
-  switch (nalu.m_nalUnitType)
+  {
-  case NAL_UNIT_CODED_SLICE:
-  case NAL_UNIT_CODED_SLICE_IDR:
-#if H0566_TLA
-#if !QC_REM_IDV_B0046
-  case NAL_UNIT_CODED_SLICE_IDV:
-#endif
-  case NAL_UNIT_CODED_SLICE_CRA:
-  case NAL_UNIT_CODED_SLICE_TLA:
-#else
-  case NAL_UNIT_CODED_SLICE_CDR:
-#endif
+    {
-      nalu.m_temporalId = bs.read(3);
-#if VIDYO_VPS_INTEGRATION
-      nalu.m_layerId    = bs.read(5) - 1;
-#else
-      nalu.m_OutputFlag = bs.read(1);
-  //    unsigned reserved_one_4bits = bs.read(4);
-  //    assert(reserved_one_4bits == 1);
-      nalu.m_viewId   = bs.read(3)-1;
-      nalu.m_isDepth  = bs.read(1);
-#endif
-#if H0566_TLA
-      if (nalu.m_temporalId == 0)
+      {
-#if QC_REM_IDV_B0046
-        assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR);
-#else
-        assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDV );
-#endif
+      }
-      else
+      {
-        assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA);
+      }
-#endif
+    }
-    break;
-  default:
-    nalu.m_temporalId = 0;
-    nalu.m_OutputFlag = true;
-    break;
+  }
-#endif
-#endif
+}
 //! \}

trunk/source/Lib/TLibDecoder/TDecBinCoder.h

-                      r56
+                      r296
   virtual Void  start             ()                                          = 0;
   virtual Void  finish            ()                                          = 0;
-#if OL_FLUSH
   virtual Void  flush            ()                                           = 0;
-#endif
   virtual Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel )  = 0;
 …
   virtual Void  resetBac          ()                                          = 0;
-#if BURST_IPCM
   virtual Void  decodeNumSubseqIPCM( Int& numSubseqIPCM )                  = 0;
-#endif
   virtual Void  decodePCMAlignBits()                                          = 0;
   virtual Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode)              = 0;

trunk/source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

-                      r56
+                      r296
 TDecBinCABAC::start()
+{
 #if !OL_FLUSH || OL_FLUSH_ALIGN
+#if OL_FLUSH_ALIGN
   assert( m_pcTComBitstream->getNumBitsUntilByteAligned() == 0 );
 #endif
 …
   m_bitsNeeded = -8;
   m_uiValue    = m_pcTComBitstream->readByte() << 8;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
   m_uiLastByte = m_pcTComBitstream->readByte();
   m_uiValue   |= m_uiLastByte;
 …
+}
-#if OL_FLUSH
 Void
 TDecBinCABAC::flush()
 …
 #endif // OL_FLUSH_ALIGN
+}
-#endif // OL_FLUSH
 /**
 …
   m_uiValue   = pcTDecBinCABAC->m_uiValue;
   m_bitsNeeded= pcTDecBinCABAC->m_bitsNeeded;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
   m_uiLastByte= pcTDecBinCABAC->m_uiLastByte;
 #endif
 …
+    {
       m_bitsNeeded = -8;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
       m_uiLastByte = m_pcTComBitstream->readByte();
       m_uiValue += m_uiLastByte;
 …
     if ( m_bitsNeeded >= 0 )
+    {
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
       m_uiLastByte = m_pcTComBitstream->readByte();
       m_uiValue += m_uiLastByte << m_bitsNeeded;
 …
+  {
     m_bitsNeeded = -8;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
     m_uiLastByte = m_pcTComBitstream->readByte();
     m_uiValue += m_uiLastByte;
 …
   while ( numBins > 8 )
+  {
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
     m_uiLastByte = m_pcTComBitstream->readByte();
     m_uiValue = ( m_uiValue << 8 ) + ( m_uiLastByte << ( 8 + m_bitsNeeded ) );
 …
   if ( m_bitsNeeded >= 0 )
+  {
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
     m_uiLastByte = m_pcTComBitstream->readByte();
     m_uiValue += m_uiLastByte << m_bitsNeeded;
 …
+      {
         m_bitsNeeded = -8;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
         m_uiLastByte = m_pcTComBitstream->readByte();
         m_uiValue += m_uiLastByte;
 …
+}
-#if BURST_IPCM
 /** Decode subsequent_pcm_num.
  * \param numSubseqIPCM
 …
+    {
       m_bitsNeeded = -8;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
       m_uiLastByte = m_pcTComBitstream->readByte();
       m_uiValue += m_uiLastByte;
 …
   numSubseqIPCM --;
+}
-#endif
 /** Decode PCM alignment zero bits.

trunk/source/Lib/TLibDecoder/TDecBinCoderCABAC.h

-                      r56
+                      r296
   Void  start             ();
   Void  finish            ();
-#if OL_FLUSH
   Void  flush             ();
-#endif
   Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel );
 …
   Void  resetBac          ();
-#if BURST_IPCM
   Void  decodeNumSubseqIPCM( Int& numSubseqIPCM ) ;
-#endif
   Void  decodePCMAlignBits();
   Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode );
 …
   UInt                m_uiRange;
   UInt                m_uiValue;
 #if OL_FLUSH && !OL_FLUSH_ALIGN
+#if !OL_FLUSH_ALIGN
   UInt                m_uiLastByte;
 #endif

trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

-                      r210
+                      r296
   assert(m_pcBitstream->getNumBitsLeft() == 8); /* rsbp_trailing_bits */
+}
-#if RPS_IN_SPS
 void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
-#else
-void TDecCavlc::parseShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps, Int idx )
-#endif
+{
   UInt code;
 …
     Int rIdx =  idx - 1 - code;
     assert (rIdx <= idx && rIdx >= 0);
-#if RPS_IN_SPS
     TComReferencePictureSet*   rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
-#else
-    TComReferencePictureSet*   rpsRef = pcPPS->getRPSList()->getReferencePictureSet(rIdx);
-#endif
     Int k = 0, k0 = 0, k1 = 0;
     READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
 …
   READ_FLAG(uiCode, "aps_scaling_list_data_present_flag"); aps->setScalingListEnabled( (uiCode==1)?true:false );
   READ_FLAG(uiCode, "aps_deblocking_filter_flag");         aps->setLoopFilterOffsetInAPS( (uiCode==1)?true:false );
-#if !SAO_UNIT_INTERLEAVING
-  READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag");    aps->setSaoEnabled( (uiCode==1)?true:false );
-#endif
-#if !LCU_SYNTAX_ALF
-  READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag");      aps->setAlfEnabled( (uiCode==1)?true:false );
-#endif
   if(aps->getScalingListEnabled())
+  {
     parseScalingList( aps->getScalingList() );
+  }
-#if DBL_CONTROL
   if(aps->getLoopFilterOffsetInAPS())
+  {
     xParseDblParam( aps );
+  }
-#endif
-#if SAO_UNIT_INTERLEAVING
   READ_FLAG(uiCode, "aps_sao_interleaving_flag");      aps->setSaoInterleavingFlag( (uiCode==1)?true:false );
   if(!aps->getSaoInterleavingFlag())
+  {
     READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag");      aps->setSaoEnabled( (uiCode==1)?true:false );
-#endif
   if(aps->getSaoEnabled())
+  {
 …
     xParseSaoParam( aps->getSaoParam() );
+  }
+#if SAO_UNIT_INTERLEAVING
+  }
+#endif
+#if LCU_SYNTAX_ALF
+  }
   READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag");      aps->setAlfEnabled( (uiCode==1)?true:false );
-#endif
   if(aps->getAlfEnabled())
+  {
-#if !LCU_SYNTAX_ALF
-    aps->getAlfParam()->alf_flag = 1;
-#endif
     xParseAlfParam( aps->getAlfParam());
+  }
 …
+}
-#if DBL_CONTROL
 Void  TDecCavlc::xParseDblParam       ( TComAPS* aps )
+{
 …
+  }
+}
-#endif
 /** parse SAO parameters
  * \param pSaoParam
 …
   UInt uiSymbol;
-#if SAO_UNIT_INTERLEAVING
   int i,j, compIdx;
   int numCuInWidth;
 …
+    }
+  }
+#else
+  if (pSaoParam->bSaoFlag[0])
+  {
+    xParseSaoSplitParam (pSaoParam, 0, 0);
+    xParseSaoOffsetParam(pSaoParam, 0, 0);
+    READ_FLAG (uiSymbol, "sao_flag_cb");
+    pSaoParam->bSaoFlag[1] = uiSymbol? true:false;
+    if (pSaoParam->bSaoFlag[1])
+    {
+      xParseSaoSplitParam (pSaoParam, 0, 1);
+      xParseSaoOffsetParam(pSaoParam, 0, 1);
+    }
+    READ_FLAG (uiSymbol, "sao_flag_cr");
+    pSaoParam->bSaoFlag[2] = uiSymbol? true:false;
+    if (pSaoParam->bSaoFlag[2])
+    {
+      xParseSaoSplitParam (pSaoParam, 0, 2);
+      xParseSaoOffsetParam(pSaoParam, 0, 2);
+    }
+  }
+#endif
+}
+#if SAO_UNIT_INTERLEAVING
+}
 /** copy SAO parameter
  * \param dst
 …
+}
+#else
+/** Decode quadtree split flag
+ * \param  pSaoParam, iPartIdx
+ */
+Void TDecCavlc::xParseSaoSplitParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
+{
+  UInt uiSymbol;
+  SAOQTPart*  pSaoPart = NULL;
+  pSaoPart= &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
+  if(pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
+  {
+    READ_FLAG (uiSymbol, "sao_split_flag");
+    pSaoPart->bSplit = uiSymbol? true:false;
+    if(pSaoPart->bSplit)
+    {
+      for (Int i=0;i<NUM_DOWN_PART;i++)
+      {
+        xParseSaoSplitParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
+      }
+    }
+  }
+  else
+  {
+    pSaoPart->bSplit = false;
+  }
+}
+/** Decode SAO for one partition
+ * \param  pSaoParam, iPartIdx
+ */
+Void TDecCavlc::xParseSaoOffsetParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
+{
+  UInt uiSymbol;
+  Int iSymbol;
+  SAOQTPart*  pSaoPart = NULL;
+  pSaoPart = &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
+  static Int iTypeLength[MAX_NUM_SAO_TYPE] = {
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_BO_LEN,
+    SAO_BO_LEN
+  };
+  if(!pSaoPart->bSplit)
+  {
+    READ_UVLC (uiSymbol, "sao_type_idx");
+    if (uiSymbol)
+    {
+      pSaoPart->iBestType = uiSymbol-1;
+      pSaoPart->bEnableFlag = true;
+    }
+    else
+    {
+      pSaoPart->iBestType = -1;
+      pSaoPart->bEnableFlag = false;
+    }
+    if (pSaoPart->bEnableFlag)
+    {
+      pSaoPart->iLength = iTypeLength[pSaoPart->iBestType];
+      for(Int i=0; i< pSaoPart->iLength; i++)
+      {
+        READ_SVLC (iSymbol, "sao_offset");
+        pSaoPart->iOffset[i] = iSymbol;
+      }
+    }
+    return;
+  }
+  //split
+  if (pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
+  {
+    for(Int i=0;i<NUM_DOWN_PART;i++)
+    {
+      xParseSaoOffsetParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
+    }
+  }
+}
+#endif
+#if LCU_SYNTAX_ALF
 Void TDecCavlc::xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS, Int firstLCUAddr, Bool acrossSlice, Int numLCUInWidth, Int numLCUInHeight)
+{
 …
+}
-#endif
 Void TDecCavlc::xParseAlfParam(ALFParam* pAlfParam)
 …
   UInt uiSymbol;
   Int iSymbol;
-#if ALF_SINGLE_FILTER_SHAPE
   Int sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE] = {ALF_FILTER_LEN};
+#else
+  Int sqrFiltLengthTab[2] = { 9, 9};
+#endif
+#if LCU_SYNTAX_ALF
   switch(pAlfParam->componentID)
+  {
 …
   case ALF_Y:
+    {
-#endif
   pAlfParam->filters_per_group = 0;
   memset (pAlfParam->filterPattern, 0 , sizeof(Int)*NO_VAR_BINS);
-#if !LCU_SYNTAX_ALF
-  READ_FLAG (uiSymbol, "alf_region_adaptation_flag");
-  pAlfParam->alf_pcr_region_flag = uiSymbol;
-#endif
-#if ALF_SINGLE_FILTER_SHAPE
   pAlfParam->filter_shape = 0;
-#else
-  READ_UVLC (uiSymbol, "alf_length_luma_minus_5_div2");
-  pAlfParam->filter_shape = uiSymbol;
-#endif
   pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
 …
+  {
     pAlfParam->filters_per_group = 1;
-#if LCU_SYNTAX_ALF
-#if ALF_16_BA_GROUPS
     Int numMergeFlags = 16;
-#else
-    Int numMergeFlags = 15;
-#endif
-#else
-#if ALF_16_BA_GROUPS
-    Int numMergeFlags = 16;
-#else
-    Int numMergeFlags = pAlfParam->alf_pcr_region_flag ? 16 : 15;
-#endif
-#endif
     for (Int i=1; i<numMergeFlags; i++)
+    {
 …
+  }
-#if ALF_SINGLE_FILTER_SHAPE
   Int minScanVal = MIN_SCAN_POS_CROSS;
-#else
-  Int minScanVal = (pAlfParam->filter_shape == ALF_STAR5x5) ? 0: MIN_SCAN_POS_CROSS;
-#endif
   // Determine maxScanVal
 …
   // Golomb parameters
-#if LCU_SYNTAX_ALF
   if( pAlfParam->filters_per_group > 1 )
+  {
-#endif
   READ_UVLC (uiSymbol, "alf_min_kstart_minus1");
   pAlfParam->minKStart = 1 + uiSymbol;
 …
     kMin = pAlfParam->kMinTab[scanPos];
+  }
+#if LCU_SYNTAX_ALF
+  }
+#endif
+  }
   Int scanPos;
 …
+    {
       scanPos = pDepthInt[i] - 1;
-#if LCU_SYNTAX_ALF
       Int k = (pAlfParam->filters_per_group == 1) ? kTableTabShapes[ALF_CROSS9x7_SQUARE3x3][i] : pAlfParam->kMinTab[scanPos];
       pAlfParam->coeffmulti[idx][i] = xGolombDecode(k);
+#else
+      pAlfParam->coeffmulti[idx][i] = xGolombDecode(pAlfParam->kMinTab[scanPos]);
+#endif
+    }
+  }
+#if LCU_SYNTAX_ALF
+    }
+  }
+    }
     break;
 …
+    }
+  }
-#else
-  // filter parameters for chroma
-  READ_UVLC (uiSymbol, "alf_chroma_idc");
-  pAlfParam->chroma_idc = uiSymbol;
-  if(pAlfParam->chroma_idc)
+  {
-#if ALF_SINGLE_FILTER_SHAPE
-    pAlfParam->filter_shape_chroma  = 0;
-#else
-    READ_UVLC (uiSymbol, "alf_length_chroma_minus_5_div2");
-    pAlfParam->filter_shape_chroma = uiSymbol;
-#endif
-    pAlfParam->num_coeff_chroma = sqrFiltLengthTab[pAlfParam->filter_shape_chroma];
-    // filter coefficients for chroma
-    for(Int pos=0; pos<pAlfParam->num_coeff_chroma; pos++)
+    {
-      READ_SVLC (iSymbol, "alf_coeff_chroma");
-      pAlfParam->coeff_chroma[pos] = iSymbol;
+    }
+  }
-#endif
+}
 …
+}
-#if TILES_OR_ENTROPY_SYNC_IDC
 Void TDecCavlc::parsePPS(TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet)
-#else
-Void TDecCavlc::parsePPS(TComPPS* pcPPS)
-#endif
+{
 #if ENC_DEC_TRACE
 …
   Int   iCode;
-#if !RPS_IN_SPS
-  TComRPSList* rpsList = pcPPS->getRPSList();
-#endif
   READ_UVLC( uiCode, "pic_parameter_set_id");                      pcPPS->setPPSId (uiCode);
   READ_UVLC( uiCode, "seq_parameter_set_id");                      pcPPS->setSPSId (uiCode);
-#if MULTIBITS_DATA_HIDING
   READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
   if( pcPPS->getSignHideFlag() )
 …
     READ_CODE( 4, uiCode, "sign_hiding_threshold"); pcPPS->setTSIG(uiCode);
+  }
-#endif
 #if CABAC_INIT_FLAG
   READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
-#endif
-#if !RPS_IN_SPS
-  // RPS is put before entropy_coding_mode_flag
-  // since entropy_coding_mode_flag will probably be removed from the WD
-  TComReferencePictureSet*      pcRPS;
-  READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
-  rpsList->create(uiCode);
-  for(Int i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
+  {
-    pcRPS = rpsList->getReferencePictureSet(i);
-    parseShortTermRefPicSet(pcPPS,pcRPS,i);
+  }
-  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcPPS->setLongTermRefsPresent(uiCode);
 #endif
   // entropy_coding_mode_flag
 …
   if (pcPPS->getEntropyCodingMode())
+  {
+#if !WPP_SIMPLIFICATION
+    READ_UVLC( uiCode, "entropy_coding_synchro" );                 pcPPS->setEntropyCodingSynchro( uiCode );
+    READ_FLAG( uiCode, "cabac_istate_reset" );                     pcPPS->setCabacIstateReset( uiCode ? true : false );
+#endif
+#if !TILES_OR_ENTROPY_SYNC_IDC
+#if !WPP_SIMPLIFICATION
+    if ( pcPPS->getEntropyCodingSynchro() )
+#endif
+    {
+      READ_UVLC( uiCode, "num_substreams_minus1" );                pcPPS->setNumSubstreams(uiCode+1);
+    }
+#endif
+  }
+#if !H0566_TLA
+  READ_UVLC( uiCode, "num_temporal_layer_switching_point_flags" ); pcPPS->setNumTLayerSwitchingFlags( uiCode );
+  for ( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
+  {
+    READ_FLAG( uiCode, "temporal_layer_switching_point_flag" );    pcPPS->setTLayerSwitchingFlag( i, uiCode > 0 ? true : false );
+  }
+#endif
+  }
   // num_ref_idx_l0_default_active_minus1
 …
 //printf("TDecCavlc::parsePPS():\tm_bUseWeightPred=%d\tm_uiBiPredIdc=%d\n", pcPPS->getUseWP(), pcPPS->getWPBiPredIdc());
-#if H0388
   READ_FLAG( uiCode, "output_flag_present_flag" );
   pcPPS->setOutputFlagPresentFlag( uiCode==1 );
+#endif
+#if TILES_OR_ENTROPY_SYNC_IDC
   if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==1)
+  {
-#endif
     READ_FLAG ( uiCode, "tile_info_present_flag" );
     pcPPS->setColumnRowInfoPresent(uiCode);
 …
       Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
       Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
-#if !REMOVE_TILE_DEPENDENCE
-      pcPPS->setTileBoundaryIndependenceIdr( 1 ); //default
-#endif
       pcPPS->setLFCrossTileBoundaryFlag(true); //default
       if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0)
+      {
-#if !REMOVE_TILE_DEPENDENCE
-        READ_FLAG ( uiCode, "tile_boundary_independence_flag" );
-        pcPPS->setTileBoundaryIndependenceIdr( uiCode );
-        if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
+        {
-#endif
           READ_FLAG ( uiCode, "loop_filter_across_tile_flag" );
           pcPPS->setLFCrossTileBoundaryFlag( (uiCode == 1)?true:false );
+#if !REMOVE_TILE_DEPENDENCE
+        }
+#endif
+      }
+    }
+#if TILES_OR_ENTROPY_SYNC_IDC
+      }
+    }
+  }
   else if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==2)
 …
     READ_UVLC( uiCode, "num_substreams_minus1" );                pcPPS->setNumSubstreams(uiCode+1);
+  }
+#endif
+#if DBL_CONTROL
   READ_FLAG( uiCode, "deblocking_filter_control_present_flag" );
   pcPPS->setDeblockingFilterControlPresent( uiCode ? true : false);
-#endif
-#if PARALLEL_MERGE
   READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
   assert(uiCode == LOG2_PARALLEL_MERGE_LEVEL_MINUS2);
   pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
-#endif
   READ_FLAG( uiCode, "pps_extension_flag");
 …
+      }
+    }
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    READ_FLAG( uiCode,  "inter_view_vector_scaling_flag" );    pcVPS->setIVScalingFlag( uiCode ? true:false);
+#endif
+  }
 …
 #endif
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
 Void TDecCavlc::parseSPS(TComSPS* pcSPS, Bool bIsDepth)
 #else
 …
   READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
   READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
-#if PIC_CROPPING
   READ_FLAG(     uiCode, "pic_cropping_flag");                   pcSPS->setPicCroppingFlag ( uiCode ? true : false );
   if (uiCode != 0)
 …
     READ_UVLC(   uiCode, "pic_crop_bottom_offset" );             pcSPS->setPicCropBottomOffset( uiCode );
+  }
-#endif
 #if FULL_NBIT
 …
 #endif
-#if H0736_AVC_STYLE_QP_RANGE
   pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
-#endif
   g_uiBASE_MAX  = ((1<<(g_uiBitDepth))-1);
 …
 #endif
   READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
-#if H0736_AVC_STYLE_QP_RANGE
   pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
-#endif
   READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
 …
   READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
+  {
 …
     pcSPS->setMaxLatencyIncrease( uiCode, i );
+  }
+#else
+  READ_UVLC( uiCode,    "max_num_ref_pics" );                    pcSPS->setMaxNumberOfReferencePictures(uiCode);
+  READ_UVLC( uiCode,    "num_reorder_frames" );                  pcSPS->setNumReorderFrames(uiCode);
+  READ_UVLC ( uiCode, "max_dec_frame_buffering");
+  pcSPS->setMaxDecFrameBuffering( uiCode );
+  READ_UVLC ( uiCode, "max_latency_increase");
+  pcSPS->setMaxLatencyIncrease( uiCode );
+#endif
+#if H0412_REF_PIC_LIST_RESTRICTION
   READ_FLAG( uiCode, "restricted_ref_pic_lists_flag" );
   pcSPS->setRestrictedRefPicListsFlag( uiCode );
 …
     pcSPS->setListsModificationPresentFlag(true);
+  }
-#endif
   READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
   UInt log2MinCUSize = uiCode + 3;
 …
   READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" );       pcSPS->setUseSAO ( uiCode ? true : false );
   READ_FLAG( uiCode, "adaptive_loop_filter_enabled_flag" );         pcSPS->setUseALF ( uiCode ? true : false );
-#if LCU_SYNTAX_ALF
   if(pcSPS->getUseALF())
+  {
     READ_FLAG( uiCode, "alf_coef_in_slice_flag" );      pcSPS->setUseALFCoefInSlice ( uiCode ? true : false );
+  }
-#endif
   if( pcSPS->getUsePCM() )
+  {
 …
-#if RPS_IN_SPS
   TComRPSList* rpsList = pcSPS->getRPSList();
   TComReferencePictureSet* rps;
 …
+  }
   READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
-#endif
-#if !PIC_CROPPING
-  //!!!KS: Syntax not in WD !!!
-  xReadUvlc ( uiCode ); pcSPS->setPadX        ( uiCode    );
-  xReadUvlc ( uiCode ); pcSPS->setPadY        ( uiCode    );
-#endif
   // AMVP mode for each depth (AM_NONE or AM_EXPL)
 …
+  }
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   READ_CODE(2, uiCode, "tiles_or_entropy_coding_sync_idc");         pcSPS->setTilesOrEntropyCodingSyncIdc(uiCode);
+#endif
+#if TILES_OR_ENTROPY_SYNC_IDC
   if(pcSPS->getTilesOrEntropyCodingSyncIdc() == 1)
+  {
-#endif
     READ_UVLC ( uiCode, "num_tile_columns_minus1" );
     pcSPS->setNumColumnsMinus1( uiCode );
 …
       free(rowHeight);
+    }
-#if !REMOVE_TILE_DEPENDENCE
-    pcSPS->setTileBoundaryIndependenceIdr( 1 ); //default
-#endif
     pcSPS->setLFCrossTileBoundaryFlag(true); //default
     if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0)
+    {
-#if !REMOVE_TILE_DEPENDENCE
-      READ_FLAG ( uiCode, "tile_boundary_independence_flag" );
-      pcSPS->setTileBoundaryIndependenceIdr( uiCode );
-      if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
+      {
-#endif
         READ_FLAG ( uiCode, "loop_filter_across_tile_flag" );
         pcSPS->setLFCrossTileBoundaryFlag( (uiCode==1)?true:false);
+#if !REMOVE_TILE_DEPENDENCE
+      }
+#endif
+    }
+#if TILES_OR_ENTROPY_SYNC_IDC
+  }
+#endif
+    }
+  }
   READ_FLAG( uiCode, "sps_extension_flag");
 #if !QC_MVHEVC_B0046
 …
       pcSPS->setPredDepthMapGeneration( 0, false );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     pcSPS->setMultiviewResPredMode  ( 0 );
 #endif
 …
         pcSPS->setPredDepthMapGeneration( uiCode, true );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       pcSPS->setMultiviewResPredMode  ( 0 );
 #endif
 …
 #if DEPTH_MAP_GENERATION
         UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
         UInt uiMultiviewMvPredMode = 0;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       UInt uiMultiviewResPredMode = 0;
 #endif
 …
             READ_SVLC( iCode, "Pdm_offset" );   m_aaiTempPdmOffset       [ uiViewId ][ uiBaseId ] = iCode;
+          }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
           READ_UVLC( uiMultiviewMvPredMode, "multi_view_mv_pred_mode" );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
           READ_FLAG( uiMultiviewResPredMode, "multi_view_residual_pred_mode" );
 #endif
+        }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
         pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
 #else
 …
 #endif
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       pcSPS->setMultiviewResPredMode  ( uiMultiviewResPredMode );
 #endif
 …
+}
+#if LCU_SYNTAX_ALF
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)
+#else
 Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)
-#else
-Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl)
 #endif
+{
 …
+  {
     UInt uiCodeTmp = 0;
+    if ( rpcSlice->getSPS()->getViewId() && !rpcSlice->getSPS()->isDepth() )
+    if ( rpcSlice->getSPS()->getViewId()
+#if !LGE_ILLUCOMP_DEPTH_C0046
+        && !rpcSlice->getSPS()->isDepth()
+#endif
+        )
+    {
       READ_FLAG (uiCodeTmp, "applying IC flag");
 …
     rpcSlice->setSPS(sps);
     rpcSlice->setPPS(pps);
-#if H0388
     if( pps->getOutputFlagPresentFlag() )
+    {
 …
       rpcSlice->setPicOutputFlag( true );
+    }
-#endif
 #if QC_REM_IDV_B0046
 #if !QC_MVHEVC_B0046
 …
+        {
           rps = rpcSlice->getLocalRPS();
-#if RPS_IN_SPS
           parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
-#else
-          parseShortTermRefPicSet(pps,rps, pps->getRPSList()->getNumberOfReferencePictureSets());
-#endif
           rpcSlice->setRPS(rps);
+        }
         else // use reference to short-term reference picture set in PPS
+        {
-#if RPS_IN_SPS
           READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
-#else
-          READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(pps->getRPSList()->getReferencePictureSet(uiCode));
-#endif
           rps = rpcSlice->getRPS();
+        }
-#if RPS_IN_SPS
         if(sps->getLongTermRefsPresent())
-#else
-        if(pps->getLongTermRefsPresent())
-#endif
+        {
           Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
           READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
           Int prev = 0;
-#if LTRP_MULT
           Int prevMsb=0;
           Int prevDeltaPocLt=0;
-#endif
           for(Int j=rps->getNumberOfLongtermPictures()+offset-1 ; j > offset-1; j--)
+          {
 …
             prev += uiCode;
-#if LTRP_MULT
             READ_FLAG(uiCode,"delta_poc_msb_present_flag");
             Int decDeltaPOCMsbPresent=uiCode;
 …
             else
+            {
-#endif
               rps->setPOC(j,rpcSlice->getPOC()-prev);
               rps->setDeltaPOC(j,-(Int)prev);
-#if LTRP_MULT
+            }
             prevDeltaPocLt=prev;
-#endif
             READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
+          }
 …
       if (sps->getUseSAO())
+      {
-#if SAO_UNIT_INTERLEAVING
         READ_FLAG(uiCode, "slice_sao_interleaving_flag");        rpcSlice->setSaoInterleavingFlag(uiCode);
-#endif
         READ_FLAG(uiCode, "slice_sample_adaptive_offset_flag");  rpcSlice->setSaoEnabledFlag((Bool)uiCode);
-#if SAO_UNIT_INTERLEAVING
         if (rpcSlice->getSaoEnabledFlag() && rpcSlice->getSaoInterleavingFlag())
+        {
 …
           rpcSlice->setSaoEnabledFlagCr(0);
+        }
-#endif
+      }
       READ_UVLC (    uiCode, "aps_id" );  rpcSlice->setAPSId(uiCode);
 …
     if( !rpcSlice->isIntra() )
+    {
-#if H0412_REF_PIC_LIST_RESTRICTION
 #if QC_MVHEVC_B0046
     if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
 …
       else
+      {
-#endif
         READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
+#if H0412_REF_PIC_LIST_RESTRICTION
+      }
+#endif
+      }
       if(refPicListModification->getRefPicListModificationFlagL0())
 …
         uiCode = 0;
         Int i = 0;
-#if H0137_0138_LIST_MODIFICATION
         Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
         if ( NumPocTotalCurr > 1 )
 …
+          }
+        }
+#else
+        Int list_modification_idc = 0;
+        while(list_modification_idc != 3)
+        {
+          READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL0(i, uiCode );
+          list_modification_idc = uiCode;
+          if(uiCode != 3)
+          {
+            READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL0(i, uiCode );
+          }
+          i++;
+        }
+        refPicListModification->setNumberOfRefPicListModificationsL0(i-1);
+#endif
+      }
+#if !H0137_0138_LIST_MODIFICATION
+      else
+      {
+        refPicListModification->setNumberOfRefPicListModificationsL0(0);
+      }
+#endif
+      }
+    }
     else
+    {
       refPicListModification->setRefPicListModificationFlagL0(0);
-#if !H0137_0138_LIST_MODIFICATION
-      refPicListModification->setNumberOfRefPicListModificationsL0(0);
-#endif
+    }
     if(rpcSlice->isInterB())
+    {
-#if H0412_REF_PIC_LIST_RESTRICTION
 #if QC_MVHEVC_B0046
     if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
 …
       else
+      {
-#endif
         READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
+#if H0412_REF_PIC_LIST_RESTRICTION
+      }
+#endif
+      }
       if(refPicListModification->getRefPicListModificationFlagL1())
+      {
         uiCode = 0;
         Int i = 0;
-#if H0137_0138_LIST_MODIFICATION
         Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
         if ( NumPocTotalCurr > 1 )
 …
+          }
+        }
+#else
+        Int list_modification_idc = 0;
+        while(list_modification_idc != 3)
+        {
+          READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL1(i, uiCode );
+          list_modification_idc = uiCode;
+          if(uiCode != 3)
+          {
+            READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL1(i, uiCode );
+          }
+          i++;
+        }
+        refPicListModification->setNumberOfRefPicListModificationsL1(i-1);
+#endif
+      }
+#if !H0137_0138_LIST_MODIFICATION
+      else
+      {
+        refPicListModification->setNumberOfRefPicListModificationsL1(0);
+      }
+#endif
+      }
+    }
     else
+    {
       refPicListModification->setRefPicListModificationFlagL1(0);
-#if !H0137_0138_LIST_MODIFICATION
-      refPicListModification->setNumberOfRefPicListModificationsL1(0);
-#endif
+    }
+  }
 …
       READ_UVLC( uiCode, "num_ref_idx_lc_active_minus1" );      rpcSlice->setNumRefIdx( REF_PIC_LIST_C, uiCode + 1 );
-#if H0412_REF_PIC_LIST_RESTRICTION
 #if QC_MVHEVC_B0046
     if( rpcSlice->getViewId() && rpcSlice->getSPS()->getListsModificationPresentFlag() )
 …
 #endif
+      {
-#endif
         READ_FLAG( uiCode, "ref_pic_list_modification_flag_lc" ); rpcSlice->setRefPicListModificationFlagLC( uiCode ? 1 : 0 );
         if(uiCode)
 …
             READ_FLAG( uiCode, "pic_from_list_0_flag" );
             rpcSlice->setListIdFromIdxOfLC(i, uiCode);
-#if H0137_0138_LIST_MODIFICATION
           if (((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_0) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_0 ) == 1)) || ((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_1) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_1 ) == 1)) )
+          {
 …
             READ_UVLC( uiCode, "ref_idx_list_curr" );
+          }
-#else
-            READ_UVLC( uiCode, "ref_idx_list_curr" );
-#endif
             rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
             rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
+          }
+        }
-#if H0412_REF_PIC_LIST_RESTRICTION
+      }
       else
 …
         rpcSlice->setRefPicListModificationFlagLC(false);
+      }
-#endif
+    }
     else
 …
+  }
-#if H0111_MVD_L1_ZERO
   if (rpcSlice->isInterB())
+  {
     READ_FLAG( uiCode, "mvd_l1_zero_flag" );       rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
+  }
-#endif
 #if CABAC_INIT_FLAG
 …
     rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
-#if H0736_AVC_STYLE_QP_RANGE
     assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
     assert( rpcSlice->getSliceQp() <=  51 );
+#endif
+#if DBL_CONTROL
     if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
+    {
 …
         rpcSlice->setInheritDblParamFromAPS(0);
+      }
-#else
-    READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
-#endif
       if(!rpcSlice->getInheritDblParamFromAPS())
+      {
 …
+        }
+      }
-#if DBL_CONTROL
+   }
-#endif
     if ( rpcSlice->getSliceType() == B_SLICE )
+    {
 …
+  }
 #if ( HHI_MPI || HHI_INTER_VIEW_MOTION_PRED )
   #if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
+#if ( HHI_MPI || H3D_IVMP )
+  #if ( HHI_MPI && H3D_IVMP )
   const int iExtraMergeCandidates = ( sps->getUseMVI() || sps->getMultiviewMvPredMode() ) ? 1 : 0;
   #elif HHI_MPI
   const int iExtraMergeCandidates = sps->getUseMVI() ? 1 : 0;
+  #elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  const int iExtraMergeCandidates = (  (isDepth || sps->getMultiviewMvPredMode()) ) ? 1 : 0;
   #else
   const int iExtraMergeCandidates = sps->getMultiviewMvPredMode() ? 1 : 0;
 …
       Int uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight;
-#if LCU_SYNTAX_ALF
       if(sps->getUseALFCoefInSlice())
+      {
 …
       if(!sps->getUseALFCoefInSlice())
+      {
-#endif
       xParseAlfCuControlParam(alfCUCtrl, uiNumCUsInFrame);
+#if LCU_SYNTAX_ALF
+      }
+#endif
+      }
+    }
 …
   if (!bEntropySlice)
+  {
-#if !REMOVE_TILE_DEPENDENCE
-    if (sps->getTileBoundaryIndependenceIdr())
+    {
-#endif
     xReadCode(1, uiCode); // read flag indicating if tile markers transmitted
     rpcSlice->setTileMarkerFlag( uiCode );
+#if !REMOVE_TILE_DEPENDENCE
+    }
+#endif
+  }
+#if TILES_WPP_ENTRY_POINT_SIGNALLING
+  }
   Int tilesOrEntropyCodingSyncIdc = rpcSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
   UInt *entryPointOffset          = NULL;
 …
     delete [] entryPointOffset;
+  }
-#else
-#if WPP_SIMPLIFICATION
-  if (pps->getNumSubstreams() > 1)
-#else
-  if (pps->getEntropyCodingSynchro())
-#endif
+  {
-    UInt uiNumSubstreams = pps->getNumSubstreams();
-    rpcSlice->allocSubstreamSizes(uiNumSubstreams);
-    UInt *puiSubstreamSizes = rpcSlice->getSubstreamSizes();
-    for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
+    {
-      xReadCode(2, uiCode);
-      switch ( uiCode )
+      {
-      case 0:
-        xReadCode(8,  uiCode);
-        break;
-      case 1:
-        xReadCode(16, uiCode);
-        break;
-      case 2:
-        xReadCode(24, uiCode);
-        break;
-      case 3:
-        xReadCode(32, uiCode);
-        break;
-      default:
-        printf("Error in parseSliceHeader\n");
-        exit(-1);
-        break;
+      }
-      puiSubstreamSizes[ui] = uiCode;
+    }
+  }
-#endif
   if (!bEntropySlice)
+  {
     // Reading location information
-#if !REMOVE_TILE_DEPENDENCE
-    if (sps->getTileBoundaryIndependenceIdr())
+    {
-#endif
-#if !TILES_WPP_ENTRY_POINT_SIGNALLING
-      xReadCode(1, uiCode); // read flag indicating if location information signaled in slice header
-      Bool bTileLocationInformationInSliceHeaderFlag = (uiCode)? true : false;
-      if (bTileLocationInformationInSliceHeaderFlag)
+      {
-        // location count
-        xReadCode(5, uiCode); // number of tiles for which location information signaled
-        rpcSlice->setTileLocationCount ( uiCode + 1 );
-        xReadCode(5, uiCode); // number of bits used by diff
-        Int iBitsUsedByDiff = uiCode + 1;
-        // read out tile start location
-        Int iLastSize = 0;
-        for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
+        {
-          Int iAbsDiff, iCurSize, iCurDiff;
-          if (uiIdx==0)
+          {
-            xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff  = uiCode;
-            rpcSlice->setTileLocation( uiIdx, iAbsDiff );
-            iCurDiff  = iAbsDiff;
-            iLastSize = iAbsDiff;
+          }
-          else
+          {
-            xReadCode(1, uiCode); // read sign
-            Int iSign = (uiCode) ? -1 : +1;
-            xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff  = uiCode;
-            iCurDiff  = (iSign) * iAbsDiff;
-            iCurSize  = iLastSize + iCurDiff;
-            iLastSize = iCurSize;
-            rpcSlice->setTileLocation( uiIdx, rpcSlice->getTileLocation( uiIdx-1 ) + iCurSize ); // calculate byte location
+          }
+        }
+      }
-#endif
       // read out trailing bits
     m_pcBitstream->readOutTrailingBits();
-#if !REMOVE_TILE_DEPENDENCE
+    }
-#endif
+  }
   return;
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )
 #else
 …
 Void TDecCavlc::parseIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-#if BURST_IPCM
   assert(0);
-#else
-  UInt uiSymbol;
-  xReadFlag( uiSymbol );
-  if ( uiSymbol )
+  {
-    Bool bIpcmFlag   = true;
-    xReadPCMAlignZero();
-    pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
-    pcCU->setSizeSubParts      ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
-    pcCU->setIPCMFlagSubParts  ( bIpcmFlag, uiAbsPartIdx, uiDepth );
-    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
-    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
-    UInt uiChromaOffset = uiLumaOffset>>2;
-    Pel* piPCMSample;
-    UInt uiWidth;
-    UInt uiHeight;
-    UInt uiSampleBits;
-    UInt uiX, uiY;
-    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx);
-    uiHeight = pcCU->getHeight(uiAbsPartIdx);
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample;
-        xReadCode(uiSampleBits, uiSample);
-        piPCMSample[uiX] = uiSample;
+      }
-      piPCMSample += uiWidth;
+    }
-    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
-    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample;
-        xReadCode(uiSampleBits, uiSample);
-        piPCMSample[uiX] = uiSample;
+      }
-      piPCMSample += uiWidth;
+    }
-    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
-    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample;
-        xReadCode(uiSampleBits, uiSample);
-        piPCMSample[uiX] = uiSample;
+      }
-      piPCMSample += uiWidth;
+    }
+  }
-#endif
+}
 …
 Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-#if H0736_AVC_STYLE_QP_RANGE
   Int qp;
-#else
-  UInt uiQp;
-#endif
   Int  iDQp;
   xReadSvlc( iDQp );
-#if H0736_AVC_STYLE_QP_RANGE
   Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
   qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) -  qpBdOffsetY;
-#else
-  uiQp = pcCU->getRefQP( uiAbsPartIdx ) + iDQp;
-#endif
   UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
   UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
-#if H0736_AVC_STYLE_QP_RANGE
   pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
-#else
-  pcCU->setQPSubParts( uiQp, uiAbsQpCUPartIdx, uiQpCUDepth );
-#endif
+}
 …
+}
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
 …
           READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
           scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code+1)));
-#if SCALING_LIST
           if( sizeId > SCALING_LIST_8x8 )
+          {
             scalingList->setScalingListDC(sizeId,listId,scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId)));
+          }
-#endif
           scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
 …
 Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
+{
-#if SCALING_LIST
   Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
   Int data;
 …
+    }
+  }
-#else
-  Int i,coefNum = g_scalingListSize[sizeId];
-  Int data;
-  Int nextCoef = SCALING_LIST_START_VALUE;
-  UInt* scan  = g_auiFrameScanXY [ sizeId + 1 ];
-  Int *dst = scalingList->getScalingListAddress(sizeId, listId);
-  for(i = 0; i < coefNum; i++)
+  {
-    READ_SVLC( data, "scaling_list_delta_coef");
-    nextCoef = (nextCoef + data + 256 ) % 256;
-    dst[scan[i]] = nextCoef;
+  }
-#endif
+}

trunk/source/Lib/TLibDecoder/TDecCAVLC.h

-                      r210
+                      r296
   UInt  xGetBit             ();
-#if RPS_IN_SPS
   void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
-#else
-  void  parseShortTermRefPicSet            (TComPPS* pcPPS, TComReferencePictureSet* pcRPS, Int idx);
-#endif
 private:
   TComInputBitstream*   m_pcBitstream;
 …
   Void  parseVPS            ( TComVPS* pcVPS );
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   Void  parseSPS            ( TComSPS* pcSPS, Bool bIsDepth );
 #else
   Void  parseSPS            ( TComSPS* pcSPS );
 #endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   Void  parsePPS            ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet);
-#else
-  Void  parsePPS            ( TComPPS* pcPPS);
-#endif
   Void  parseSEI(SEImessages&);
   Void  parseAPS            ( TComAPS* pAPS );
+#if LCU_SYNTAX_ALF
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth);
+#else
   Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet);
-#else
-  Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl );
 #endif
   Void  parseTerminatingBit ( UInt& ruiBit );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void  parseMVPIdx         ( Int& riMVPIdx, Int iAMVPCands );
 #else
 …
   Void parseMergeFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
   Void parseMergeIndex      ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void parseResPredFlag     ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth );
 #endif
 …
   Void readTileMarker     ( UInt& uiTileIdx, UInt uiBitsUsed );
   Void updateContextTables  ( SliceType eSliceType, Int iQp ) { return; }
-#if OL_FLUSH
   Void decodeFlush() {};
-#endif
   Void xParsePredWeightTable ( TComSlice* pcSlice );
 …
 #endif
 protected:
-#if DBL_CONTROL
   Void  xParseDblParam       ( TComAPS* aps );
-#endif
   Void  xParseSaoParam       ( SAOParam* pSaoParam );
-#if SAO_UNIT_INTERLEAVING
   Void  xParseSaoOffset      (SaoLcuParam* saoLcuParam);
   Void  xParseSaoUnit        (Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool& repeatedRow );
-#else
-  Void  xParseSaoSplitParam  ( SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr );
-  Void  xParseSaoOffsetParam ( SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr );
-#endif
-#if LCU_SYNTAX_ALF
   Void  xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS = true, Int firstLCUAddr = 0, Bool acrossSlice = true, Int numLCUInWidth= -1, Int numLCUInHeight= -1);
   Void  parseAlfParamSet(AlfParamSet* pAlfParamSet, Int firstLCUAddr, Bool alfAcrossSlice);
   Void  parseAlfFixedLengthRun(UInt& idx, UInt rx, UInt numLCUInWidth);
   Void  parseAlfStoredFilterIdx(UInt& idx, UInt numFilterSetsInBuffer);
-#endif
   Void  xParseAlfParam       ( ALFParam* pAlfParam );
   Void  xParseAlfCuControlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic);

trunk/source/Lib/TLibDecoder/TDecCu.cpp

-                      r189
+                      r296
   m_ppcYuvResi = NULL;
   m_ppcYuvReco = NULL;
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_ppcYuvResPred = NULL;
 #endif
 …
   m_ppcYuvResi = new TComYuv*[m_uiMaxDepth-1];
   m_ppcYuvReco = new TComYuv*[m_uiMaxDepth-1];
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_ppcYuvResPred = new TComYuv*   [m_uiMaxDepth-1];
 #endif
 …
     m_ppcYuvResi[ui] = new TComYuv;    m_ppcYuvResi[ui]->create( uiWidth, uiHeight );
     m_ppcYuvReco[ui] = new TComYuv;    m_ppcYuvReco[ui]->create( uiWidth, uiHeight );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     m_ppcYuvResPred[ui] = new TComYuv;    m_ppcYuvResPred[ui]->create( uiWidth, uiHeight );
 #endif
 …
     m_ppcYuvResi[ui]->destroy(); delete m_ppcYuvResi[ui]; m_ppcYuvResi[ui] = NULL;
     m_ppcYuvReco[ui]->destroy(); delete m_ppcYuvReco[ui]; m_ppcYuvReco[ui] = NULL;
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     m_ppcYuvResPred[ui]->destroy(); delete m_ppcYuvResPred[ui]; m_ppcYuvResPred[ui] = NULL;
 #endif
 …
   delete [] m_ppcYuvResi; m_ppcYuvResi = NULL;
   delete [] m_ppcYuvReco; m_ppcYuvReco = NULL;
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   delete [] m_ppcYuvResPred; m_ppcYuvResPred = NULL;
 #endif
 …
+  }
-#if BURST_IPCM
   pcCU->setNumSucIPCM(0);
-#endif
   // start from the top level CU
 …
   if((!bStartInCU) && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
+  {
-#if BURST_IPCM
     if(pcCU->getNumSucIPCM() == 0)
+    {
 …
       pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
+    }
-#else
-#if HHI_MPI
-    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
-#endif
-    m_pcEntropyDecoder->decodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
-#endif
+  }
   else
 …
   // decode CU mode and the partition size
-#if BURST_IPCM
   if( !pcCU->getSlice()->isIntra() && pcCU->getNumSucIPCM() == 0 )
-#else
-  if( !pcCU->getSlice()->isIntra() )
-#endif
 #if HHI_MPI
   if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
 …
     m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_0 );
     m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_1 );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
     UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
 …
       UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
       for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
+      {
         const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
+#if MERL_VSP_C0152
+        Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
+        pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
+#endif
         pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_SKIP );
         pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
 …
         pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
+      }
+#if LGE_ILLUCOMP_DEPTH_C0046
+      m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
+#endif
+    }
     else
+    {
 #endif
-#if SIMP_MRG_PRUN
     UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
+#if MERL_VSP_C0152
+    Int iVSPIndexTrue[3] = {-1, -1, -1};
+    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, iVSPIndexTrue, uiMergeIndex );
+    {
+      Int iVSPIdx = 0;
+      Int numVspIdx;
+      numVspIdx = 3;
+      for (Int i = 0; i < numVspIdx; i++)
+      {
+        if (iVSPIndexTrue[i] == uiMergeIndex)
+          {
+            iVSPIdx = i+1;
+            break;
+          }
+      }
+      pcCU->setVSPIndexSubParts( iVSPIdx, uiAbsPartIdx, 0, uiDepth );  //Initialize the VSP, may change later in get InterMergeCandidates()
+    }
+#else
     m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
-#else
-    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
-    UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
 #endif
     pcCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeIndex], uiAbsPartIdx, 0, uiDepth );
 …
+    }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP && !MTK_MDIVRP_C0138
     m_pcEntropyDecoder->decodeResPredFlag( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
 #endif
 …
+  {
 #endif
-#if BURST_IPCM
   if( pcCU->getNumSucIPCM() == 0 )
+  {
 …
     pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
+  }
-#else
-  m_pcEntropyDecoder->decodePredMode( pcCU, uiAbsPartIdx, uiDepth );
-  m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
-#endif
   if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
 …
 #if LGE_ILLUCOMP_B0045
+#if LGE_ILLUCOMP_DEPTH_C0046 && HHI_MPI
+  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) != uiDepth )
+  {
+#endif
   m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP && !MTK_MDIVRP_C0138
   if( !pcCU->isIntra( uiAbsPartIdx ) )
+  {
     m_pcEntropyDecoder->decodeResPredFlag    ( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
+  }
+#endif
+#if LGE_ILLUCOMP_DEPTH_C0046 && HHI_MPI
+  }
 #endif
 …
       UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
       for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
+      {
         const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
+#if MERL_VSP_C0152
+        Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
+        pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
+#endif
         pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_INTER );
         pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
 …
         pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
+      }
+#if LGE_ILLUCOMP_DEPTH_C0046
+      m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
+#endif
       if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
+      {
 …
+  }
-#if BURST_IPCM
   if( pcCU->getNumSucIPCM() > 0 )
+  {
 …
     return;
+  }
-#endif
   ruiIsLast = xDecodeSliceEnd( pcCU, uiAbsPartIdx, uiDepth);
 …
   // inter prediction
+#if MERL_VSP_C0152
+  m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth], uiAbsPartIdx );
+#else
   m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth] );
+#endif
+#if MTK_MDIVRP_C0138
+  if (pcCU->getMergeFlag(0) && pcCU->getMergeIndex(0)==0 && pcCU->getResPredAvail(0))
+  {
+    m_pcPrediction->residualPrediction(pcCU, m_ppcYuvReco[uiDepth], m_ppcYuvResPred[uiDepth]);
+  }
+#endif
 #if HHI_MPI
   if( pcCU->getTextureModeDepth( 0 ) != -1 )
 …
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP && !MTK_MDIVRP_C0138
   if( pcCU->getResPredFlag( 0 ) )
+  {
 …
   else
+  {
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
+#if MTK_MDIVRP_C0138
+    if (pcCU->getMergeFlag(0) && pcCU->getMergeIndex(0)==0 && pcCU->getResPredAvail(0))
+#else
     if( pcCU->getResPredFlag( 0 ) )
+#endif
+    {
       m_ppcYuvReco[uiDepth]->clip( pcCU->getWidth( 0 ), pcCU->getHeight( 0 ) );
 …
   //===== inverse transform =====
-#if H0736_AVC_STYLE_QP_RANGE
   m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
-#else
-  m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
-#endif
   Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)TEXT_LUMA];
 …
   if(eText == TEXT_CHROMA_U)
+  {
-#if H0736_AVC_STYLE_QP_RANGE
     m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
-#else
-    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
-#endif
+  }
   else
+  {
-#if H0736_AVC_STYLE_QP_RANGE
     m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
-#else
-    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
-#endif
+  }
 …
   pResi = m_ppcYuvResi[uiDepth]->getLumaAddr();
-#if H0736_AVC_STYLE_QP_RANGE
   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
-#else
-  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
-#endif
   m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_LUMA, pResi, 0, m_ppcYuvResi[uiDepth]->getStride(), uiWidth, uiHeight, uiLumaTrMode, 0, piCoeff );
   // Cb and Cr
-#if H0736_AVC_STYLE_QP_RANGE
   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
-#else
-  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
-#endif
   uiWidth  >>= 1;
 …
   m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_U, pResi, 0, m_ppcYuvResi[uiDepth]->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
-#if H0736_AVC_STYLE_QP_RANGE
   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
-#else
-  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
-#endif
   piCoeff = pcCU->getCoeffCr(); pResi = m_ppcYuvResi[uiDepth]->getCrAddr();
 …
   Int iSumPix[2];
   memset(iSumPix, 0, sizeof(Int)*2);
+#if HS_REFERENCE_SUBSAMPLE_C0154
+  Int subSamplePix;
+  if ( uiSize == 64 || uiSize == 32 )
+  {
+    subSamplePix = 2;
+  }
+  else
+  {
+    subSamplePix = 1;
+  }
+  for (Int y=0; y<uiSize; y+=subSamplePix)
+  {
+    for (Int x=0; x<uiSize; x+=subSamplePix)
+    {
+      UChar ucSegment = pMask?(UChar)pMask[x]:0;
+      assert( ucSegment < uiNumSegments );
+      iSumDepth[ucSegment] += pOrig[x];
+      iSumPix[ucSegment]   += 1;
+    }
+    pOrig  += uiStride*subSamplePix;
+    pMask  += uiMaskStride*subSamplePix;
+  }
+#else
   for (Int y=0; y<uiSize; y++)
+  {
 …
     pMask  += uiMaskStride;
+  }
+#endif
   // compute mean for each segment
   for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )

trunk/source/Lib/TLibDecoder/TDecCu.h

-                      r189
+                      r296
   TComYuv**           m_ppcYuvResi;       ///< array of residual buffer
   TComYuv**           m_ppcYuvReco;       ///< array of prediction & reconstruction buffer
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComYuv**           m_ppcYuvResPred;    ///< residual prediction buffer
 #endif
   TComDataCU**        m_ppcCU;            ///< CU data array
   // access channel
   TComTrQuant*        m_pcTrQuant;
 …
   /// destroy internal buffers
   Void  destroy                 ();
   /// decode CU information
   Void  decodeCU                ( TComDataCU* pcCU, UInt& ruiIsLast );

trunk/source/Lib/TLibDecoder/TDecEntropy.cpp

-                      r189
+                      r296
   pcCU->setICFlagSubParts( false , uiAbsPartIdx, 0, uiDepth );
+  if (pcCU->isIntra(uiAbsPartIdx) || (pcCU->getSlice()->getViewId() == 0) || pcCU->getSlice()->getSPS()->isDepth())
+  if (pcCU->isIntra(uiAbsPartIdx) || (pcCU->getSlice()->getViewId() == 0)
+#if !LGE_ILLUCOMP_DEPTH_C0046
+      || pcCU->getSlice()->getSPS()->isDepth()
+#endif
+      )
+  {
     return;
 …
     return;
+#if LGE_ILLUCOMP_DEPTH_C0046
+  if(pcCU->isICFlagRequired(uiAbsPartIdx, uiDepth)) //This modification is not needed after integrating JCT3V-C0137
+#else
   if(pcCU->isICFlagRequired(uiAbsPartIdx))
+#endif
     m_pcEntropyDecoderIf->parseICFlag( pcCU, uiAbsPartIdx, uiDepth );
+}
 …
+}
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP && !MTK_MDIVRP_C0138
 Void
 TDecEntropy::decodeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComDataCU* pcSubCU, UInt uiPUIdx )
 …
   if( bResPredAllowed )
+  {
+    bResPredAvailable       = pcSubCU->getResidualSamples( uiPUIdx
+#if QC_SIMPLIFIEDIVRP_M24938
+      , false
+#endif
+      );
+    bResPredAvailable       = pcSubCU->getResidualSamples( uiPUIdx , false  );
+  }
 …
 #if CU_BASED_MRG_CAND_LIST
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
   UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
 …
+  {
 #if !CU_BASED_MRG_CAND_LIST
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
     UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
 …
       else
+      {
-#if SIMP_MRG_PRUN
         uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
         pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
-#else
-        pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
-        uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
-#endif
+      }
 #else
-#if SIMP_MRG_PRUN
       UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
+#if MERL_VSP_C0152
+      Int iVSPIndexTrue[3] = {-1, -1, -1};
+      pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, iVSPIndexTrue, uiMergeIndex );
+#if HHI_MPI
+      if(pcCU->getTextureModeDepth( uiSubPartIdx ) == uiDepth)//MPI is used
+      {
+        TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
+        UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
+        for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
+        {
+          Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
+          pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
+        }
+      }
+      else // MPI not used
+#endif
+      {
+        Int iVSPIdx = 0;
+        Int numVspIdx;
+        numVspIdx = 3;
+        for (Int i = 0; i < numVspIdx; i++)
+        {
+          if (iVSPIndexTrue[i] == uiMergeIndex)
+            {
+              iVSPIdx = i+1;
+              break;
+            }
+        }
+        pcCU->setVSPIndexSubParts( iVSPIdx, uiSubPartIdx, uiPartIdx, uiDepth );  //Initialize the VSP, may change later in get InterMergeCandidates()
+      }
+#else
       pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
-#else
-      pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
-      UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
 #endif
 #endif
 …
   if ( (pcSubCU->getInterDir(uiPartAddr) & ( 1 << eRefList )) && (pcSubCU->getAMVPMode(uiPartAddr) == AM_EXPL) )
+  {
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
     const Int iNumAMVPCands = AMVP_MAX_NUM_CANDS + ( pcSubCU->getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
     m_pcEntropyDecoderIf->parseMVPIdx( iMVPIdx, iNumAMVPCands );
 …
 #endif
+  }
 #if SHARP_INTERVIEW_DECOUPLE_B0111
+#if H3D_IVMP
   pcSubCU->fillMvpCand(uiPartIdx, uiPartAddr, eRefList, iRefIdx, pAMVPInfo, iMVPIdx);
 #else
 …
+}
-#if UNIFIED_TRANSFORM_TREE
 Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3, Bool& bCodeDQP )
-#else
-Void TDecEntropy::xDecodeTransformSubdiv( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3 )
-#endif
+{
   UInt uiSubdiv;
   const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
-#if UNIFIED_TRANSFORM_TREE
   if(uiTrIdx==0)
+  {
 …
+    }
+  }
-#endif // UNIFIED_TRANSFORM_TREE
   if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
+  {
     uiSubdiv = 1;
+  }
-#if G519_TU_AMP_NSQT_HARMONIZATION
   else if( (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER) && ( pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N ) && (uiDepth == pcCU->getDepth(uiAbsPartIdx)) )
-#else
-  else if( (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER) && ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && (uiDepth == pcCU->getDepth(uiAbsPartIdx)) )
-#endif
+  {
     uiSubdiv = (uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx));
 …
   if( uiSubdiv )
+  {
-#if UNIFIED_TRANSFORM_TREE
     UInt size;
     width  >>= 1;
 …
     size = width*height;
     uiTrIdx++;
-#endif
     ++uiDepth;
     const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
 …
     for( Int i = 0; i < 4; i++ )
+    {
-#if UNIFIED_TRANSFORM_TREE
       UInt nsAddr = 0;
       nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, i, uiTrDepth+1 );
       xDecodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, i, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );
-#else
-      UInt nsAddr = 0;
-      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, i, uiTrDepth+1 );
-      xDecodeTransformSubdiv( pcCU, uiAbsPartIdx, nsAddr, uiDepth, i, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV );
-#endif
       uiYCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiLumaTrMode );
       uiUCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiChromaTrMode );
       uiVCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiChromaTrMode );
       uiAbsPartIdx += uiQPartNum;
-#if UNIFIED_TRANSFORM_TREE
       offsetLuma += size;  offsetChroma += (size>>2);
-#endif
+    }
 …
+      }
+    }
-#if UNIFIED_TRANSFORM_TREE
     // transform_unit begin
     UInt cbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA    , uiTrIdx );
 …
+    }
     // transform_unit end
+#endif // UNIFIED_TRANSFORM_TREE
+  }
+}
+#if !UNIFIED_TRANSFORM_TREE
+Void TDecEntropy::decodeTransformIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  DTRACE_CABAC_VL( g_nSymbolCounter++ )
+  DTRACE_CABAC_T( "\tdecodeTransformIdx()\tCUDepth=" )
+  DTRACE_CABAC_V( uiDepth )
+  DTRACE_CABAC_T( "\n" )
+  UInt temp = 0;
+  UInt temp1 = 0;
+  UInt temp2 = 0;
+  xDecodeTransformSubdiv( pcCU, uiAbsPartIdx, uiAbsPartIdx, uiDepth, 0, temp, temp1, temp2 );
+}
+#endif // UNIFIED_TRANSFORM_TREE
+#if UNIFIED_TRANSFORM_TREE
+  }
+}
 Void TDecEntropy::decodeQP          ( TComDataCU* pcCU, UInt uiAbsPartIdx )
+{
 …
+  }
+}
+#else
+Void TDecEntropy::decodeQP          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  if ( pcCU->getSlice()->getPPS()->getUseDQP() )
+  {
+    m_pcEntropyDecoderIf->parseDeltaQP( pcCU, uiAbsPartIdx, uiDepth );
+  }
+}
+#endif
+#if !UNIFIED_TRANSFORM_TREE
+Void TDecEntropy::xDecodeCoeff( TComDataCU* pcCU, UInt uiLumaOffset, UInt uiChromaOffset, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiTrIdx, UInt uiCurrTrIdx, Bool& bCodeDQP )
+{
+  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth ] + 2;
+  UInt uiCbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrIdx );
+  UInt uiCbfU = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
+  UInt uiCbfV = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
+  if( uiLog2TrSize == 2 )
+  {
+    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
+    if( ( uiAbsPartIdx % uiQPDiv ) == 0 )
+    {
+      m_uiBakAbsPartIdx   = uiAbsPartIdx;
+      m_uiBakChromaOffset = uiChromaOffset;
+    }
+    else if( ( uiAbsPartIdx % uiQPDiv ) == (uiQPDiv - 1) )
+    {
+      uiCbfU = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
+      uiCbfV = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
+    }
+  }
+  if ( uiCbfY || uiCbfU || uiCbfV )
+  {
+    // dQP: only for LCU
+    if ( pcCU->getSlice()->getPPS()->getUseDQP() )
+    {
+      if ( bCodeDQP )
+      {
+        decodeQP( pcCU, uiAbsPartIdx, uiDepth);
+        bCodeDQP = false;
+      }
+    }
+    UInt uiLumaTrMode, uiChromaTrMode;
+    pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx( uiAbsPartIdx ), uiLumaTrMode, uiChromaTrMode );
+    const UInt uiStopTrMode = uiLumaTrMode;
+    if( uiTrIdx == uiStopTrMode )
+    {
+      if( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrIdx ) )
+      {
+        Int trWidth = uiWidth;
+        Int trHeight = uiHeight;
+        pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
+        m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffY()+uiLumaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_LUMA );
+      }
+      uiWidth  >>= 1;
+      uiHeight >>= 1;
+      if( uiLog2TrSize == 2 )
+      {
+        UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
+        if( ( uiAbsPartIdx % uiQPDiv ) == (uiQPDiv - 1) )
+        {
+          uiWidth  <<= 1;
+          uiHeight <<= 1;
+          Int trWidth = uiWidth;
+          Int trHeight = uiHeight;
+          pcCU->getNSQTSize( uiTrIdx-1, uiAbsPartIdx, trWidth, trHeight );
+          if( pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx ) )
+          {
+            m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCb()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
+          }
+          if( pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx ) )
+          {
+            m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCr()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
+          }
+        }
+      }
+      else
+      {
+        Int trWidth = uiWidth;
+        Int trHeight = uiHeight;
+        pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
+        if( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx ) )
+        {
+          m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCb()+uiChromaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
+        }
+        if( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx ) )
+        {
+          m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCr()+uiChromaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
+        }
+      }
+    }
+    else
+    {
+      {
+        DTRACE_CABAC_VL( g_nSymbolCounter++ );
+        DTRACE_CABAC_T( "\tgoing down\tdepth=" );
+        DTRACE_CABAC_V( uiDepth );
+        DTRACE_CABAC_T( "\ttridx=" );
+        DTRACE_CABAC_V( uiTrIdx );
+        DTRACE_CABAC_T( "\n" );
+      }
+      if( uiCurrTrIdx <= uiTrIdx )
+      {
+        assert(1);
+      }
+      UInt uiSize;
+      uiWidth  >>= 1;
+      uiHeight >>= 1;
+      uiSize = uiWidth*uiHeight;
+      uiDepth++;
+      uiTrIdx++;
+      UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
+      UInt uiIdx      = uiAbsPartIdx;
+      xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
+      uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
+      xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
+      uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
+      xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
+      uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
+      xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
+      {
+        DTRACE_CABAC_VL( g_nSymbolCounter++ );
+        DTRACE_CABAC_T( "\tgoing up\n" );
+      }
+    }
+  }
+}
+#endif // !UNIFIED_TRANSFORM_TREE
 /** decode coefficients
 …
   UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
   UInt uiChromaOffset = uiLumaOffset>>2;
-#if UNIFIED_TRANSFORM_TREE
   UInt temp  = 0;
   UInt temp1 = 0;
   UInt temp2 = 0;
-#else
-  UInt uiLumaTrMode, uiChromaTrMode;
-#endif
 #if RWTH_SDC_DLT_B0036
 …
   if( pcCU->isIntra(uiAbsPartIdx) )
+  {
-#if !UNIFIED_TRANSFORM_TREE
-    decodeTransformIdx( pcCU, uiAbsPartIdx, pcCU->getDepth(uiAbsPartIdx) );
-    pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx(uiAbsPartIdx), uiLumaTrMode, uiChromaTrMode );
-#endif // !UNIFIED_TRANSFORM_TREE
+  }
   else
 …
+    }
-#if !UNIFIED_TRANSFORM_TREE
-    decodeTransformIdx( pcCU, uiAbsPartIdx, pcCU->getDepth(uiAbsPartIdx) );
-    pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx(uiAbsPartIdx), uiLumaTrMode, uiChromaTrMode );
-#endif // !UNIFIED_TRANSFORM_TREE
+  }
 …
 #endif
-#if UNIFIED_TRANSFORM_TREE
   xDecodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, 0, temp, temp1, temp2, bCodeDQP );
-#else // UNIFIED_TRANSFORM_TREE
-  xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, uiLumaTrMode, bCodeDQP );
-#endif // UNIFIED_TRANSFORM_TREE
 #if FIX_MPI_B0065

trunk/source/Lib/TLibDecoder/TDecEntropy.h

-                      r210
+                      r296
   virtual Void  setBitstream          ( TComInputBitstream* p )  = 0;
-#if OL_FLUSH
   virtual Void  decodeFlush()                                                                      = 0;
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   virtual Void  parseVPS                  ( TComVPS* pcVPS )                       = 0;
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   virtual Void  parseSPS                  ( TComSPS* pcSPS, Bool bIsDepth )                       = 0;
 #else
   virtual Void  parseSPS                  ( TComSPS* pcSPS )                                      = 0;
 #endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   virtual Void  parsePPS                  ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet )                                      = 0;
-#else
-  virtual Void  parsePPS                  ( TComPPS* pcPPS )                                      = 0;
-#endif
   virtual Void  parseAPS                  ( TComAPS* pAPS  )                                      = 0;
   virtual void parseSEI(SEImessages&) = 0;
+#if LCU_SYNTAX_ALF
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)       = 0;
+#else
   virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)       = 0;
-#else
-  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl )                                = 0;
 #endif
   virtual Void  parseTerminatingBit       ( UInt& ruilsLast )                                     = 0;
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   virtual Void parseMVPIdx        ( Int& riMVPIdx, Int iNumAMVPCands ) = 0;
 #else
 …
   virtual Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx ) = 0;
   virtual Void parseMergeIndex    ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   virtual Void parseResPredFlag   ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
 #endif
 …
   UInt    m_uiBakAbsPartIdx;
   UInt    m_uiBakChromaOffset;
-#if UNIFIED_TRANSFORM_TREE
   UInt    m_bakAbsPartIdxCU;
-#endif
 public:
 …
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   Void    decodeSPS                   ( TComSPS* pcSPS, Bool bIsDepth ) { m_pcEntropyDecoderIf->parseSPS(pcSPS, bIsDepth); }
 #else
   Void    decodeSPS                   ( TComSPS* pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
 #endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   Void    decodePPS                   ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet    )    { m_pcEntropyDecoderIf->parsePPS(pcPPS, parameterSet);                    }
-#else
-  Void    decodePPS                   ( TComPPS* pcPPS     )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
-#endif
   Void    decodeAPS                   ( TComAPS* pAPS      )    { m_pcEntropyDecoderIf->parseAPS(pAPS);}
   void decodeSEI(SEImessages& seis) { m_pcEntropyDecoderIf->parseSEI(seis); }
+#if LCU_SYNTAX_ALF
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl, alfParamSet, isDepth);         }
+#else
   Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl, alfParamSet);         }
-#else
-  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl )  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl);         }
 #endif
 …
   Void decodeMergeFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
   Void decodeMergeIndex        ( TComDataCU* pcSubCU, UInt uiPartIdx, UInt uiPartAddr, PartSize eCUMode, UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, UInt uiDepth );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP && !MTK_MDIVRP_C0138
   Void decodeResPredFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComDataCU* pcSubCU, UInt uiPUIdx );
 #endif
 …
   Void decodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
-#if !UNIFIED_TRANSFORM_TREE
-  Void decodeTransformIdx      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
-#endif
-#if UNIFIED_TRANSFORM_TREE
   Void decodeQP                ( TComDataCU* pcCU, UInt uiAbsPartIdx );
-#else
-  Void decodeQP                ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
-#endif
   Void readTileMarker         ( UInt& uiTileIdx, UInt uiBitsUsed )  {  m_pcEntropyDecoderIf->readTileMarker( uiTileIdx, uiBitsUsed ); }
 …
 private:
-#if UNIFIED_TRANSFORM_TREE
   Void xDecodeTransform        ( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3, Bool& bCodeDQP );
-#else
-  Void xDecodeTransformSubdiv  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3 );
-  Void xDecodeCoeff            ( TComDataCU* pcCU, UInt uiLumaOffset, UInt uiChromaOffset, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiTrIdx, UInt uiCurrTrIdx, Bool& bCodeDQP );
-#endif //UNIFIED_TRANSFORM_TREE
 public:
 …
   Void setSliceGranularity (Int iSliceGranularity) {m_pcEntropyDecoderIf->setSliceGranularity(iSliceGranularity);}
-#if SAO_UNIT_INTERLEAVING
   Void decodeSaoParam         (SAOParam* saoParam);
   void decodeSaoLcu(Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool &repeatedRow );
   Void decodeSaoOneLcu(SaoLcuParam* saoLcuParam);
+#endif
+#if OL_FLUSH
   Void decodeFlush() { m_pcEntropyDecoderIf->decodeFlush(); }
-#endif
 #if RWTH_SDC_DLT_B0036

trunk/source/Lib/TLibDecoder/TDecGop.cpp

-                      r189
+                      r296
 Void TDecGop::destroy()
+{
-#if LCU_SYNTAX_ALF
   m_alfParamSetPilot.releaseALFParam();
-#endif
+}
 …
                    ,TComDepthMapGenerator*  pcDepthMapGenerator
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
                   ,TComResidualGenerator*  pcResidualGenerator
 #endif
 …
   m_pcDepthMapGenerator   = pcDepthMapGenerator;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_pcResidualGenerator   = pcResidualGenerator;
 #endif
 …
 // Private member functions
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 Void TDecGop::patchAlfLCUParams(ALFParam*** alfLCUParam, AlfParamSet* alfParamSet, Int firstLCUAddr)
+{
 …
+}
-#endif
 // ====================================================================================================================
 // Public member functions
 …
         if(pcSlice->getAlfEnabledFlag())
+        {
-#if LCU_SYNTAX_ALF
           if(pcSlice->getSPS()->getUseALFCoefInSlice())
+          {
 …
           if( !pcSlice->getSPS()->getUseALFCoefInSlice())
+          {
-#endif
           m_vAlfCUCtrlSlices.push_back(m_cAlfCUCtrlOneSlice);
-#if LCU_SYNTAX_ALF
+          }
-#endif
+        }
+      }
 …
+    {
       m_pcDepthMapGenerator->initViewComponent( rpcPic );
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
       m_pcDepthMapGenerator->predictDepthMap  ( rpcPic );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
       m_pcResidualGenerator->initViewComponent( rpcPic );
 #endif
 …
 #endif
 #if QC_SIMPLE_NBDV_B0047
+#if H3D_NBDV
     if(pcSlice->getViewId() && pcSlice->getSPS()->getMultiviewMvPredMode())
+    {
 …
     m_pcSliceDecoder->decompressSlice( pcBitstream, ppcSubstreams, rpcPic, m_pcSbacDecoder, m_pcSbacDecoders);
     m_pcEntropyDecoder->setBitstream(  ppcSubstreams[uiNumSubstreams-1] );
-#if WPP_SIMPLIFICATION
     if ( uiNumSubstreams > 1 )
-#else
-    if ( pcSlice->getPPS()->getEntropyCodingSynchro() )
-#endif
+    {
       // deallocate all created substreams, including internal buffers.
 …
   else
+  {
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     // set residual picture
     m_pcResidualGenerator->setRecResidualPic( rpcPic );
 #endif
 #if DEPTH_MAP_GENERATION
 #if !QC_MULTI_DIS_CAN_A0097
+#if !H3D_NBDV
     // update virtual depth map
     m_pcDepthMapGenerator->updateDepthMap( rpcPic );
 …
     Bool bLFCrossTileBoundary = (pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)?
                                 (pcSlice->getPPS()->getLFCrossTileBoundaryFlag()):(pcSlice->getPPS()->getSPS()->getLFCrossTileBoundaryFlag());
-#if DBL_CONTROL
     if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
+    {
-#endif
       if(pcSlice->getSPS()->getUseDF())
+      {
 …
+        }
+      }
-#if DBL_CONTROL
+    }
     m_pcLoopFilter->setCfg(pcSlice->getPPS()->getDeblockingFilterControlPresent(), pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
-#else
-    m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
-#endif
     m_pcLoopFilter->loopFilterPic( rpcPic );
 …
       if(pcSlice->getSaoEnabledFlag())
+      {
-#if SAO_UNIT_INTERLEAVING
         if (pcSlice->getSaoInterleavingFlag())
+        {
 …
+        }
         m_pcSAO->setSaoInterleavingFlag(pcSlice->getAPS()->getSaoInterleavingFlag());
-#endif
         m_pcSAO->createPicSaoInfo(rpcPic, m_uiILSliceCount);
         m_pcSAO->SAOProcess(rpcPic, pcSlice->getAPS()->getSaoParam());
 …
     if( pcSlice->getSPS()->getUseALF() )
+    {
-#if LCU_SYNTAX_ALF
       if( (pcSlice->getSPS()->getUseALFCoefInSlice())?(true):(pcSlice->getAlfEnabledFlag()))
+#else
+      if(pcSlice->getAlfEnabledFlag())
+#endif
+      {
+#if LCU_SYNTAX_ALF
+      {
         if(!pcSlice->getSPS()->getUseALFCoefInSlice())
+        {
 …
         m_pcAdaptiveLoopFilter->createPicAlfInfo(rpcPic, m_uiILSliceCount, pcSlice->getSliceQp());
         m_pcAdaptiveLoopFilter->ALFProcess(rpcPic, m_vAlfCUCtrlSlices, pcSlice->getSPS()->getUseALFCoefInSlice());
-#else
-        m_pcAdaptiveLoopFilter->createPicAlfInfo(rpcPic, m_uiILSliceCount);
-      m_pcAdaptiveLoopFilter->ALFProcess(rpcPic, pcSlice->getAPS()->getAlfParam(), m_vAlfCUCtrlSlices);
-#endif
       m_pcAdaptiveLoopFilter->PCMLFDisableProcess(rpcPic);
       m_pcAdaptiveLoopFilter->destroyPicAlfInfo();
+      }
-#if LCU_SYNTAX_ALF
       m_pcAdaptiveLoopFilter->resetLCUAlfInfo(); //reset all LCU ALFParam->alf_flag = 0
-#endif
+    }
 …
     m_vAlfCUCtrlSlices.clear();
+  }
+  fflush(stdout);
+}

trunk/source/Lib/TLibDecoder/TDecGop.h

-                      r56
+                      r296
   TComDepthMapGenerator*  m_pcDepthMapGenerator;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComResidualGenerator*  m_pcResidualGenerator;
 #endif
 …
   bool m_pictureDigestEnabled; ///< if true, handle picture_digest SEI messages
   AlfCUCtrlInfo       m_cAlfCUCtrlOneSlice;
-#if LCU_SYNTAX_ALF
   AlfParamSet           m_alfParamSetPilot;
-#endif
 public:
 …
                  ,TComDepthMapGenerator*  pcDepthMapGenerator
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
                 ,TComResidualGenerator*  pcResidualGenerator
 #endif
 …
   void setPictureDigestEnabled(bool enabled) { m_pictureDigestEnabled = enabled; }
   AlfCUCtrlInfo& getAlfCuCtrlParam() { return m_cAlfCUCtrlOneSlice; }
-#if LCU_SYNTAX_ALF
   AlfParamSet& getAlfParamSet() {return m_alfParamSetPilot;}
-#endif
 private:
-#if LCU_SYNTAX_ALF
   Void patchAlfLCUParams(ALFParam*** alfLCUParam, AlfParamSet* alfParamSet, Int firstLCUAddr = 0);
-#endif

trunk/source/Lib/TLibDecoder/TDecSbac.cpp

-                      r189
+                      r296
 , m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 , m_cResPredFlagSCModel       ( 1,             1,               NUM_RES_PRED_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
 #endif
 …
 , m_cALFUvlcSCModel           ( 1,             1,               NUM_ALF_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cALFSvlcSCModel           ( 1,             1,               NUM_ALF_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
-#if AMP_CTX
 , m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
-#else
-, m_cCUXPosiSCModel           ( 1,             1,               NUM_CU_X_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
-, m_cCUYPosiSCModel           ( 1,             1,               NUM_CU_Y_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
-#endif
 , m_cSaoFlagSCModel           ( 1,             1,               NUM_SAO_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoUvlcSCModel           ( 1,             1,               NUM_SAO_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoSvlcSCModel           ( 1,             1,               NUM_SAO_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
-#if SAO_UNIT_INTERLEAVING
 , m_cSaoMergeLeftSCModel      ( 1,             1,               NUM_SAO_MERGE_LEFT_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoMergeUpSCModel        ( 1,             1,               NUM_SAO_MERGE_UP_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 , m_cDmmFlagSCModel           ( 1,             1,               NUM_DMM_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 …
   m_cCUMergeFlagExtSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
   m_cCUMergeIdxExtSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_cResPredFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_RES_PRED_FLAG );
 #endif
   m_cCUAlfCtrlFlagSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
   m_cCUPartSizeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PART_SIZE );
-#if AMP_CTX
   m_cCUAMPSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CU_AMP_POS );
-#else
-  m_cCUXPosiSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_CU_X_POS );
-  m_cCUYPosiSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_CU_Y_POS );
-#endif
   m_cCUPredModeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PRED_MODE );
   m_cCUIntraPredSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
 …
   m_cSaoUvlcSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_SAO_UVLC );
   m_cSaoSvlcSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_SAO_SVLC );
-#if SAO_UNIT_INTERLEAVING
   m_cSaoMergeLeftSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
   m_cSaoMergeUpSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
   m_cSaoTypeIdxSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
-#endif
   m_cCUTransSubdivFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
 …
   m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT );
   m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
 #endif
   m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
-#if AMP_CTX
   m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
-#else
-  m_cCUXPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_X_POS );
-  m_cCUYPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_Y_POS );
-#endif
   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
 …
   m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
   m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
-#if SAO_UNIT_INTERLEAVING
   m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
   m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
   m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
-#endif
   m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
 …
+  }
-#if EIGHT_BITS_RICE_CODE
   ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( ruiSymbol, 23 ) ];
-#else
-  ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( ruiSymbol, 15 ) ];
-#endif
   return;
 …
+{
   UInt uiSymbol;
-#if BURST_IPCM
   Int numSubseqIPCM = 0;
   Bool readPCMSampleFlag = false;
 …
+    }
+  }
+#else
+  m_pcTDecBinIf->decodeBinTrm(uiSymbol);
+#endif
+#if BURST_IPCM
   if (readPCMSampleFlag == true)
-#else
-  if (uiSymbol)
-#endif
+  {
     Bool bIpcmFlag = true;
-#if !BURST_IPCM
-    m_pcTDecBinIf->decodePCMAlignBits();
-#endif
     pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
 …
+    }
-#if BURST_IPCM
     pcCU->setNumSucIPCM( pcCU->getNumSucIPCM() - 1);
     if(pcCU->getNumSucIPCM() == 0)
 …
       m_pcTDecBinIf->resetBac();
+    }
-#else
-    m_pcTDecBinIf->resetBac();
-#endif
+  }
+}
 …
+{
   UInt uiNumCand = MRG_MAX_NUM_CANDS;
-#if !MRG_IDX_CTX_RED
-  UInt auiCtx[4] = { 0, 1, 2, 3 };
-#endif
   UInt uiUnaryIdx = 0;
   uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
 …
+    {
       UInt uiSymbol = 0;
-#if MRG_IDX_CTX_RED
       if ( uiUnaryIdx==0 )
+      {
 …
         m_pcTDecBinIf->decodeBinEP( uiSymbol );
+      }
-#else
-      m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, auiCtx[uiUnaryIdx] ) );
-#endif
       if( uiSymbol == 0 )
+      {
 …
+}
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TDecSbac::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 Void TDecSbac::parseMVPIdx      ( Int& riMVPIdx, Int iNumAMVPCands )
+{
 …
   Bool bIntraSliceDetect  = (pcCU->getSlice()->getSliceType() == I_SLICE);
+#if HHI_QTLPC_RAU_OFF_C0160
+  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && sps->getUseQTLPC())
+#endif
+  {
     TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
 …
   Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
+#if HHI_QTLPC_RAU_OFF_C0160
+  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && sps->getUseQTLPC())
+#endif
+  {
     TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
 …
         if (eMode == SIZE_2NxN)
+        {
-#if AMP_CTX
             m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
-#else
-          m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUYPosiSCModel.get( 0, 0, 0 ));
-#endif
           if (uiSymbol == 0)
+          {
-#if AMP_CTX
             m_pcTDecBinIf->decodeBinEP(uiSymbol);
-#else
-            m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUYPosiSCModel.get( 0, 0, 1 ));
-#endif
             eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
+          }
 …
         else if (eMode == SIZE_Nx2N)
+        {
-#if AMP_CTX
           m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
-#else
-          m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUXPosiSCModel.get( 0, 0, 0 ));
-#endif
           if (uiSymbol == 0)
+          {
-#if AMP_CTX
             m_pcTDecBinIf->decodeBinEP(uiSymbol);
-#else
-            m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUXPosiSCModel.get( 0, 0, 1 ));
-#endif
             eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
+          }
 …
 #if HHI_DMM_PRED_TEX
     if( intraPredMode == DMM_WEDGE_PREDTEX_D_IDX )     { xParseWedgePredTexDeltaInfo  ( pcCU, uiAbsPartIdx, uiDepth ); }
+#if LGE_DMM3_SIMP_C0044
+    if( intraPredMode == DMM_WEDGE_PREDTEX_IDX )       { xParseWedgePredTexInfo       ( pcCU, uiAbsPartIdx, uiDepth ); }
+#endif
     if( intraPredMode == DMM_CONTOUR_PREDTEX_D_IDX )   { xParseContourPredTexDeltaInfo( pcCU, uiAbsPartIdx, uiDepth ); }
 #endif
 …
   else
+  {
-#endif
-#if !LOGI_INTRA_NAME_3MPM
-    Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
 #endif
 …
 #endif
-#if LOGI_INTRA_NAME_3MPM
     Int uiPreds[3] = {-1, -1, -1};
-#else
-    Int uiPreds[2] = {-1, -1};
-#endif
     Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds);
 #if LGE_EDGE_INTRA_A0070
 …
+    {
       m_pcTDecBinIf->decodeBinEP( uiSymbol );
-#if LOGI_INTRA_NAME_3MPM
       if (uiSymbol)
+      {
 …
         uiSymbol++;
+      }
-#endif
       intraPredMode = uiPreds[uiSymbol];
+    }
 …
       intraPredMode = 0;
-#if LOGI_INTRA_NAME_3MPM
       m_pcTDecBinIf->decodeBinsEP( uiSymbol, 5 );
 …
         std::swap(uiPreds[1], uiPreds[2]);
+      }
-#else
-      m_pcTDecBinIf->decodeBinsEP( uiSymbol, g_aucIntraModeBitsAng[iIntraIdx] - 1 );
-      intraPredMode = uiSymbol;
-      if ( intraPredMode == 31 )
+      {
-        m_pcTDecBinIf->decodeBinEP( uiSymbol );
-        intraPredMode += uiSymbol;
+      }
-#endif
 #if LGE_EDGE_INTRA_A0070
       if ( intraPredMode != EDGE_INTRA_IDX)
 …
+    {
       UInt uiIPredMode;
-#if CHROMA_MODE_CODING
       m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 );
-#else
-      xReadUnaryMaxSymbol( uiIPredMode, m_cCUChromaPredSCModel.get( 0, 0 ) + 1, 0, 3 );
-#endif
       UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
       pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
 …
   ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
-#if H0111_MVD_L1_ZERO
   if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
+  {
 …
   else
+  {
-#endif
     m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx );
 …
+    }
+#if H0111_MVD_L1_ZERO
+  }
+#endif
+  }
   const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
 …
 Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-#if H0736_AVC_STYLE_QP_RANGE
   Int qp;
-#endif
   UInt uiDQp;
   Int  iDQp;
 …
   if ( uiDQp == 0 )
+  {
-#if H0736_AVC_STYLE_QP_RANGE
     qp = pcCU->getRefQP(uiAbsPartIdx);
-#else
-    uiDQp = pcCU->getRefQP(uiAbsPartIdx);
-#endif
+  }
   else
+  {
     UInt uiSign;
-#if H0736_AVC_STYLE_QP_RANGE
     Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
-#else
-    UInt uiQpBdOffsetY = 6*(g_uiBitIncrement + g_uiBitDepth - 8);
-#endif
     m_pcTDecBinIf->decodeBinEP(uiSign);
-#if H0736_AVC_STYLE_QP_RANGE
     UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
-#else
-    UInt uiMaxAbsDQpMinus1 = 24 + (uiQpBdOffsetY/2) + (uiSign);
-#endif
     UInt uiAbsDQpMinus1;
     xReadUnaryMaxSymbol (uiAbsDQpMinus1,  &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
 …
+    }
-#if H0736_AVC_STYLE_QP_RANGE
     qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
-#else
-#if LOSSLESS_CODING
-    uiDQp = (pcCU->getRefQP(uiAbsPartIdx) + iDQp + 52) % 52;
-#else
-    uiDQp = pcCU->getRefQP(uiAbsPartIdx) + iDQp;
-#endif
-#endif
+  }
   UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
   UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
-#if H0736_AVC_STYLE_QP_RANGE
   pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
-#else
-  pcCU->setQPSubParts( uiDQp, uiAbsQpCUPartIdx, uiQpCUDepth );
-#endif
+}
 …
   // posX
-#if LAST_CTX_REDUCTION
   Int widthCtx = eTType ? 4 : width;
   const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] * ( g_aucConvertToBit[ widthCtx ] + 3 ) );
-#else
-  const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ width ] * ( g_aucConvertToBit[ width ] + 3 ) );
-#endif
   for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
+  {
-#if LAST_CTX_REDUCTION
     if ( eTType  )
+    {
 …
     else
+    {
-#endif
       m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + puiCtxIdxX[ uiPosLastX ] ) );
+#if LAST_CTX_REDUCTION
+    }
+#endif
+    }
     if( !uiLast )
+    {
 …
   // posY
-#if LAST_CTX_REDUCTION
   Int heightCtx = eTType? 4 : height;
   const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] * ( g_aucConvertToBit[ heightCtx ] + 3 ) );
-#else
-  const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ height ] * ( g_aucConvertToBit[ height ] + 3 ) );
-#endif
   for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
+  {
-#if LAST_CTX_REDUCTION
     if (eTType)
+    {
 …
     else
+    {
-#endif
       m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + puiCtxIdxY[ uiPosLastY ] ) );
+#if LAST_CTX_REDUCTION
+    }
+#endif
+    }
     if( !uiLast )
+    {
 …
   UInt uiGoRiceParam           = 0;
-#if MULTIBITS_DATA_HIDING
   UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
 #if LOSSLESS_CODING
 …
 #endif
   UInt absSum = 0;
-#endif  // MULTIBITS_DATA_HIDING
   UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
 …
+  {
     scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0  ];
-#if MULTILEVEL_SIGMAP_EXT
     if( uiLog2BlockSize == 3 )
+    {
 …
       scanCG = g_sigLastScanCG32x32;
+    }
-#endif
+  }
   else
 …
     Int numNonZero = 0;
-#if MULTIBITS_DATA_HIDING
     Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
-#endif
     Int pos[SCAN_SET_SIZE];
     if( iScanPosSig == (Int) uiScanPosLast )
+    {
-#if MULTIBITS_DATA_HIDING
       lastNZPosInCG  = iScanPosSig;
       firstNZPosInCG = iScanPosSig;
-#endif
       iScanPosSig--;
       pos[ numNonZero ] = uiBlkPosLast;
 …
+    }
-#if !MULTILEVEL_SIGMAP_EXT
-    if( blockType > 3 )
+    {
-#endif
       // decode significant_coeffgroup_flag
       Int iCGBlkPos = scanCG[ iSubSet ];
       Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
       Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
-#if MULTILEVEL_SIGMAP_EXT
       if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
+      {
 …
         iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
+      }
-#endif
-#if !REMOVE_INFER_SIGGRP
-      Bool bInferredCGFlag = false;
-#endif
-#if REMOVE_INFER_SIGGRP
       if( iSubSet == iLastScanSet || iSubSet == 0)
-#else
-      if( iSubSet == iLastScanSet )
-#endif
+      {
         uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
 …
       else
+      {
-#if !REMOVE_INFER_SIGGRP
-#if MULTILEVEL_SIGMAP_EXT
-        if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight) && ( iSubSet ) )
-#else
-        if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight) && ( iSubSet ) )
-#endif
+        {
-#endif
           UInt uiSigCoeffGroup;
-#if MULTILEVEL_SIGMAP_EXT
           UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
-#else
-          UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
-#endif
           m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
           uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
-#if !REMOVE_INFER_SIGGRP
+        }
-        else
+        {
-          uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
-          bInferredCGFlag = true;
+        }
-#endif
+      }
 …
         if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
+        {
-#if REMOVE_INFER_SIGGRP
           if( iScanPosSig > iSubPos || iSubSet == 0  || numNonZero )
-#else
-          if( iScanPosSig > iSubPos || bInferredCGFlag || numNonZero )
-#endif
+          {
             uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
 …
           pos[ numNonZero ] = uiBlkPos;
           numNonZero ++;
-#if MULTIBITS_DATA_HIDING
           if( lastNZPosInCG == -1 )
+          {
 …
+          }
           firstNZPosInCG = iScanPosSig;
-#endif
+        }
+      }
-#if !MULTILEVEL_SIGMAP_EXT
+    }
-    else
+    {
-      for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
+      {
-        UInt uiBlkPos   = scan[ iScanPosSig ];
-        UInt  uiPosY    = uiBlkPos >> uiLog2BlockSize;
-        UInt  uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
-        UInt  uiSig     = 0;
-        UInt  uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
-        m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] );
-        pcCoef[ uiBlkPos ] = uiSig;
-        if( uiSig )
+        {
-          pos[ numNonZero ] = uiBlkPos;
-          numNonZero ++;
-#if MULTIBITS_DATA_HIDING
-          if( lastNZPosInCG == -1 )
+          {
-            lastNZPosInCG = iScanPosSig;
+          }
-          firstNZPosInCG = iScanPosSig;
-#endif
+        }
+      }
+    }
-#endif
     if( numNonZero )
+    {
-#if MULTIBITS_DATA_HIDING
       Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
       absSum = 0;
-#endif  // MULTIBITS_DATA_HIDING
       UInt c1 = 1;
-#if !RESTRICT_GR1GR2FLAG_NUMBER
-      UInt c2 = 0;
-#endif
-#if LEVEL_CTX_LUMA_RED
       UInt uiCtxSet    = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
-#else
-      UInt uiCtxSet    = (iSubSet > 0 && eTType==TEXT_LUMA) ? 3 : 0;
-#endif
       UInt uiBin;
 …
+      {
         uiCtxSet++;
-#if !LEVEL_CTX_LUMA_RED
-        if(eTType==TEXT_LUMA && uiNumOne > 3)
+        {
-          uiCtxSet++;
+        }
-#endif
+      }
 …
       Int absCoeff[SCAN_SET_SIZE];
-#if RESTRICT_GR1GR2FLAG_NUMBER
       for ( Int i = 0; i < numNonZero; i++) absCoeff[i] = 1;
       Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
 …
       for( Int idx = 0; idx < numC1Flag; idx++ )
-#else
-      for( Int idx = 0; idx < numNonZero; idx++ )
-#endif
+      {
         m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] );
 …
+        {
           c1 = 0;
-#if RESTRICT_GR1GR2FLAG_NUMBER
           if (firstC2FlagIdx == -1)
+          {
             firstC2FlagIdx = idx;
+          }
-#endif
+        }
         else if( (c1 < 3) && (c1 > 0) )
 …
       if (c1 == 0)
+      {
-#if RESTRICT_GR1GR2FLAG_NUMBER
         baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
         if ( firstC2FlagIdx != -1)
 …
           absCoeff[ firstC2FlagIdx ] = uiBin + 2;
+        }
+#else
+        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + 3 * uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + 3 * uiCtxSet;
+      }
+      UInt coeffSigns;
+      if ( signHidden && beValid )
+      {
+        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
+        coeffSigns <<= 32 - (numNonZero-1);
+      }
+      else
+      {
+        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
+        coeffSigns <<= 32 - numNonZero;
+      }
+      Int iFirstCoeff2 = 1;
+      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
+      {
         for( Int idx = 0; idx < numNonZero; idx++ )
+        {
-          if( absCoeff[ idx ] == 2 )
+          {
-            m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c2] );
-            absCoeff[ idx ] = uiBin + 2;
-            c2 += (c2 < 2);
-            uiNumOne++;
+          }
+        }
-#endif
+      }
-#if MULTIBITS_DATA_HIDING
-      UInt coeffSigns;
-      if ( signHidden && beValid )
+      {
-        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
-        coeffSigns <<= 32 - (numNonZero-1);
+      }
-      else
+      {
-        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
-        coeffSigns <<= 32 - numNonZero;
+      }
-#else
-      UInt coeffSigns;
-      m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
-      coeffSigns <<= 32 - numNonZero;
-#endif
-#if RESTRICT_GR1GR2FLAG_NUMBER
-      Int iFirstCoeff2 = 1;
-      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
-#else
-      if (c1 == 0)
-#endif
+      {
-        for( Int idx = 0; idx < numNonZero; idx++ )
+        {
-#if RESTRICT_GR1GR2FLAG_NUMBER
           UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
 …
             uiNumOne++;
+          }
-#else
-          if( absCoeff[ idx ] == 3 )
+          {
-            UInt uiLevel;
-            xReadGoRiceExGolomb( uiLevel, uiGoRiceParam );
-            absCoeff[ idx ] = uiLevel + 3;
+          }
-#endif
+        }
+      }
 …
+      {
         Int blkPos = pos[ idx ];
-#if MULTIBITS_DATA_HIDING
         // Signs applied later.
         pcCoef[ blkPos ] = absCoeff[ idx ];
 …
           coeffSigns <<= 1;
+        }
-#else
-        Int sign = static_cast<Int>( coeffSigns ) >> 31;
-        pcCoef[ blkPos ] = ( absCoeff[ idx ] ^ sign ) - sign;
-        coeffSigns <<= 1;
-#endif
+      }
+    }
 …
-#if SAO_UNIT_INTERLEAVING
 Void TDecSbac::parseSaoUvlc (UInt& ruiVal)
+{
 …
+  }
+}
-#endif
 /**
 …
+}
-#if OL_FLUSH
 Void TDecSbac::decodeFlush ( )
+{
 …
+}
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX || (LGE_EDGE_INTRA_A0070 && LGE_EDGE_INTRA_DELTA_DC)
 …
 #endif
 #if HHI_DMM_PRED_TEX
+#if LGE_DMM3_SIMP_C0044
+Void TDecSbac::xParseWedgePredTexInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
+  Int iBits = g_aucWedgeTexPredBitsListIdx[iIntraIdx];
+  UInt uiSymbol, uiTabIdx = 0;
+  for ( Int i = 0; i < iBits; i++ )
+  {
+    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 3) );
+    uiTabIdx += ( uiSymbol && i == 0 ) ? 1 : 0;
+    uiTabIdx += ( uiSymbol && i == 1 ) ? 2 : 0;
+    uiTabIdx += ( uiSymbol && i == 2 ) ? 4 : 0;
+    uiTabIdx += ( uiSymbol && i == 3 ) ? 8 : 0;
+    uiTabIdx += ( uiSymbol && i == 4 ) ? 16 : 0;
+    uiTabIdx += ( uiSymbol && i == 5 ) ? 32 : 0;
+    uiTabIdx += ( uiSymbol && i == 6 ) ? 64 : 0;
+    uiTabIdx += ( uiSymbol && i == 7 ) ? 128 : 0;
+    uiTabIdx += ( uiSymbol && i == 8 ) ? 256 : 0;
+    uiTabIdx += ( uiSymbol && i == 9 ) ? 512 : 0;
+    uiTabIdx += ( uiSymbol && i == 10 ) ? 1024 : 0;
+  }
+  pcCU->setWedgePredTexIntraTabIdxSubParts( uiTabIdx, uiAbsPartIdx, uiDepth );
+}
+#endif
 Void TDecSbac::xParseWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+#if LGE_DMM3_SIMP_C0044
+  xParseWedgePredTexInfo( pcCU, uiAbsPartIdx, uiDepth );
+#endif
   UInt uiDC1, uiDC2;
   xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );

trunk/source/Lib/TLibDecoder/TDecSbac.h

-                      r210
+                      r296
   Void xCopyFrom           ( TDecSbac* pSrc );
   Void xCopyContextsFrom       ( TDecSbac* pSrc );
-#if OL_FLUSH
   Void decodeFlush();
-#endif
 #if CABAC_INIT_FLAG
 …
   Void  parseVPS                  ( TComVPS* pcVPS )  {}
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   Void  parseSPS                  ( TComSPS* pcSPS, Bool bIsDepth ) {}
 #else
   Void  parseSPS                  ( TComSPS* pcSPS         ) {}
 #endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   Void  parsePPS                  ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet         ) {}
-#else
-  Void  parsePPS                  ( TComPPS* pcPPS         ) {}
-#endif
   Void  parseAPS                  ( TComAPS* pAPS          ) {}
   void parseSEI(SEImessages&) {}
+#if LCU_SYNTAX_ALF
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth) {}
+#else
   Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet) {}
-#else
-  Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl ) {}
 #endif
   Void  parseTerminatingBit       ( UInt& ruiBit );
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void  parseMVPIdx               ( Int& riMVPIdx, Int iNumAMVPCands );
 #else
 …
 #endif
-#if SAO_UNIT_INTERLEAVING
   Void  parseSaoUvlc              ( UInt& ruiVal           );
   Void  parseSaoSvlc              ( Int&  riVal            );
 …
   Void  parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Bool bLFCrossSliceBoundaryFlag);
   Void  parseSaoOffset            (SaoLcuParam* psSaoLcuParam);
-#endif
 #if RWTH_SDC_DLT_B0036
 …
 #endif
 #if HHI_DMM_PRED_TEX
+#if LGE_DMM3_SIMP_C0044
+  Void xParseWedgePredTexInfo       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#endif
   Void xParseWedgePredTexDeltaInfo  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
   Void xParseContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
 …
   Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
   Void parseMergeIndex    ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void parseResPredFlag   ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth );
 #endif
 …
   ContextModel3DBuffer m_cCUMergeFlagExtSCModel;
   ContextModel3DBuffer m_cCUMergeIdxExtSCModel;
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   ContextModel3DBuffer m_cResPredFlagSCModel;
 #endif
 …
   ContextModel3DBuffer m_cALFUvlcSCModel;
   ContextModel3DBuffer m_cALFSvlcSCModel;
-#if AMP_CTX
   ContextModel3DBuffer m_cCUAMPSCModel;
-#else
-  ContextModel3DBuffer m_cCUXPosiSCModel;
-  ContextModel3DBuffer m_cCUYPosiSCModel;
-#endif
   ContextModel3DBuffer m_cSaoFlagSCModel;
   ContextModel3DBuffer m_cSaoUvlcSCModel;
   ContextModel3DBuffer m_cSaoSvlcSCModel;
-#if SAO_UNIT_INTERLEAVING
   ContextModel3DBuffer m_cSaoMergeLeftSCModel;
   ContextModel3DBuffer m_cSaoMergeUpSCModel;
   ContextModel3DBuffer m_cSaoTypeIdxSCModel;
-#endif
 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX

trunk/source/Lib/TLibDecoder/TDecSlice.cpp

-                      r210
+                      r296
   UInt uiCol=0, uiLin=0, uiSubStrm=0;
-#if !REMOVE_TILE_DEPENDENCE
-  Int iBreakDep;
-#endif
   UInt uiTileCol;
   UInt uiTileStartLCU;
 …
     pcCU = rpcPic->getCU( iCUAddr );
     pcCU->initCU( rpcPic, iCUAddr );
-#if !REMOVE_TILE_DEPENDENCE
-    iBreakDep = rpcPic->getPicSym()->getTileBoundaryIndependenceIdr();
-#endif
     uiTileCol = rpcPic->getPicSym()->getTileIdxMap(iCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
     uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr();
 …
     uiLin     = iCUAddr / uiWidthInLCUs;
     // inherit from TR if necessary, select substream to use.
-#if WPP_SIMPLIFICATION
     if( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() > 1 )
+#else
+    if( iSymbolMode && pcSlice->getPPS()->getEntropyCodingSynchro() )
+#endif
+    {
+#if !REMOVE_TILE_DEPENDENCE
+#if WPP_SIMPLIFICATION
+      if (iBreakDep && pcSlice->getPPS()->getNumSubstreams() > 1)
+#else
+      if (iBreakDep && pcSlice->getPPS()->getEntropyCodingSynchro())
+#endif
+#else
+#if WPP_SIMPLIFICATION
+    {
       if (pcSlice->getPPS()->getNumSubstreams() > 1)
-#else
-      if (pcSlice->getPPS()->getEntropyCodingSynchro())
-#endif
-#endif
+      {
         // independent tiles => substreams are "per tile".  iNumSubstreams has already been multiplied.
 …
       m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiSubStrm] );
       // Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
-#if WPP_SIMPLIFICATION
       if (pcSlice->getPPS()->getNumSubstreams() > 1 && uiCol == uiTileLCUX)
-#else
-      if (pcSlice->getPPS()->getEntropyCodingSynchro() && uiCol == uiTileLCUX)
-#endif
+      {
         // We'll sync if the TR is available.
 …
         UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
         TComDataCU *pcCUTR = NULL;
-#if WPP_SIMPLIFICATION
         if ( pcCUUp && ((iCUAddr%uiWidthInCU+1) < uiWidthInCU)  )
+        {
           pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + 1 );
+        }
-#else
-        if ( pcCUUp && ((iCUAddr%uiWidthInCU+pcSlice->getPPS()->getEntropyCodingSynchro()) < uiWidthInCU)  )
+        {
-          pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + pcSlice->getPPS()->getEntropyCodingSynchro() );
+        }
-#endif
         UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
 …
              ((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
              ((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr()) ||
-#if !REMOVE_TILE_DEPENDENCE
-             (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr() && (rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
-#else
              ((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
-#endif
              ))||
              (true/*bEnforceEntropySliceRestriction*/ &&
              ((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
              ((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getEntropySliceCurStartCUAddr()) ||
-#if !REMOVE_TILE_DEPENDENCE
-             (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr() && (rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
-#else
              ((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
-#endif
              ))
+           )
 …
       pcSbacDecoder->load(&pcSbacDecoders[uiSubStrm]);  //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
+    }
-#if WPP_SIMPLIFICATION
     else if ( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() <= 1 )
-#else
-    else if ( iSymbolMode && !pcSlice->getPPS()->getEntropyCodingSynchro() )
-#endif
+    {
       // Set variables to appropriate values to avoid later code change.
 …
          (iCUAddr!=0) && (iCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU())) // !1st in frame && !1st in slice
+    {
-#if WPP_SIMPLIFICATION
       if (pcSlice->getPPS()->getNumSubstreams() > 1)
-#else
-      if (pcSlice->getPPS()->getEntropyCodingSynchro())
-#endif
+      {
         // We're crossing into another tile, tiles are independent.
 …
+    }
-#if !REMOVE_TILE_DEPENDENCE
-    if ( (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr()==0) && (rpcPic->getPicSym()->getNumColumnsMinus1()!=0) )
+    {
-      // Synchronize cabac probabilities with LCU among Tiles
-      if( (uiTileLCUX != 0) &&
-          (iCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr()) )
+      {
-        TComDataCU *pcCULeft = pcCU->getCULeft();
-        UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
-        if ( (true/*bEnforceSliceRestriction*/ &&
-              ((pcCULeft==NULL) || (pcCULeft->getSlice()==NULL) ||
-               ((pcCULeft->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr())
+              )
-             )||
-             (true/*bEnforceEntropySliceRestriction*/ &&
-              ((pcCULeft==NULL) || (pcCULeft->getSlice()==NULL) ||
-               ((pcCULeft->getSCUAddr()+uiMaxParts-1) < pcSlice->getEntropySliceCurStartCUAddr())
+              )
+             )
+           )
+        {
-          // Left not available.
+        }
-        else
+        {
-          // Left is available, we use it.
-          pcSbacDecoders[uiSubStrm].loadContexts( &m_pcBufferLowLatSbacDecoders[uiTileCol-1] );
-          pcSbacDecoder->loadContexts(&pcSbacDecoders[uiSubStrm]);  //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
+        }
+      }
+    }
-#endif
 …
     g_bJustDoIt = g_bEncDecTraceEnable;
 #endif
-#if SAO_UNIT_INTERLEAVING
     if ( pcSlice->getSPS()->getUseSAO() && pcSlice->getSaoInterleavingFlag() && pcSlice->getSaoEnabledFlag() )
+    {
 …
       pcSbacDecoder->parseSaoOneLcuInterleaving(rx, ry, pcSlice->getAPS()->getSaoParam(),pcCU, cuAddrInSlice, cuAddrUpInSlice, pcSlice->getSPS()->getLFCrossSliceBoundaryFlag() );
+    }
-#endif
     m_pcCuDecoder->decodeCU     ( pcCU, uiIsLast );
 …
     if( iSymbolMode )
+    {
-#if OL_FLUSH
       /*If at the end of a LCU line but not at the end of a substream, perform CABAC flush*/
-#if WPP_SIMPLIFICATION
       if (!uiIsLast && pcSlice->getPPS()->getNumSubstreams() > 1)
+#else
+      if (!uiIsLast && pcSlice->getPPS()->getCabacIstateReset())
+#endif
+      {
+#if !REMOVE_TILE_DEPENDENCE
+        if ((iBreakDep && (uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
+            || (!iBreakDep && (uiCol == uiWidthInLCUs-1) && (uiLin+iNumSubstreams < pcCU->getPic()->getFrameHeightInCU())))
+#else
+      {
         if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
-#endif
+        {
           m_pcEntropyDecoder->decodeFlush();
+        }
+      }
-#endif
       pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
       //Store probabilities of second LCU in line into buffer
-#if WPP_SIMPLIFICATION
       if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX+1))
-#else
-      if (pcSlice->getPPS()->getEntropyCodingSynchro() && (uiCol == uiTileLCUX+pcSlice->getPPS()->getEntropyCodingSynchro()))
-#endif
+      {
         m_pcBufferSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
 …
+    }
-#if !REMOVE_TILE_DEPENDENCE
-    if ( (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr()==0) && (rpcPic->getPicSym()->getNumColumnsMinus1()!=0) )
+    {
-      pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
-       //Store probabilties for next tile
-      if( (uiLin == (rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr() / uiWidthInLCUs )) &&
-          (uiCol == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getRightEdgePosInCU()) )
+      {
-        m_pcBufferLowLatSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
+      }
+    }
-#endif
+  }

trunk/source/Lib/TLibDecoder/TDecTop.cpp

-                      r210
+                      r296
     m_aaiCodedScale       [ uiId ] = new Int [ MAX_VIEW_NUM ];
+  }
+#if MERL_VSP_C0152
+  xCreateLUTs( (UInt)MAX_VIEW_NUM, (UInt)MAX_VIEW_NUM, m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+  m_iLog2Precision   = LOG2_DISP_PREC_LUT;
+  m_uiBitDepthForLUT = 8; // fixed
+#endif
+}
 …
   delete [] m_aiViewOrderIndex;
   delete [] m_aiViewReceived;
+#if MERL_VSP_C0152
+  xDeleteArray( m_adBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+  xDeleteArray( m_aiBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+#endif
+}
 …
   m_uiMaxViewId             = 0;
+}
+#if MERL_VSP_C0152
+Void
+CamParsCollector::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT)
+{
+  //AOF( m_uiBitDepthForLUT == 8 );
+  //AOF(radLUT == NULL && raiLUT == NULL );
+  uiNumberSourceViews = Max( 1, uiNumberSourceViews );
+  uiNumberTargetViews = Max( 1, uiNumberTargetViews );
+  radLUT         = new Double***[ uiNumberSourceViews ];
+  raiLUT         = new Int   ***[ uiNumberSourceViews ];
+  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
+  {
+    radLUT        [ uiSourceView ] = new Double**[ uiNumberTargetViews ];
+    raiLUT        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
+    {
+      radLUT        [ uiSourceView ][ uiTargetView ]      = new Double*[ 2 ];
+      radLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Double [ 257 ];
+      radLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Double [ 257 ];
+      raiLUT        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+    }
+  }
+}
+Void
+  CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
+{
+  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
+  Int     iLog2DivChroma = iLog2DivLuma + 1;
+  iOffset <<= m_uiBitDepthForLUT;
+  Double dScale  = (Double) iScale  / (( Double ) ( 1 << iLog2DivLuma ));
+  Double dOffset = (Double) iOffset / (( Double ) ( 1 << iLog2DivLuma ));
+  // offsets including rounding offsets
+  Int64 iOffsetLuma   = iOffset + ( ( 1 << iLog2DivLuma   ) >> 1 );
+  Int64 iOffsetChroma = iOffset + ( ( 1 << iLog2DivChroma ) >> 1 );
+  for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
+  {
+    // real-valued look-up tables
+    Double  dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
+    Double  dShiftChroma    = dShiftLuma / 2;
+    radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = dShiftLuma;
+    radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = dShiftChroma;
+    // integer-valued look-up tables
+    Int64   iTempScale      = (Int64)uiDepthValue * iScale;
+    Int64   iShiftLuma      = ( iTempScale + iOffsetLuma   ) >> iLog2DivLuma;
+    Int64   iShiftChroma    = ( iTempScale + iOffsetChroma ) >> iLog2DivChroma;
+    raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = (Int)iShiftLuma;
+    raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = (Int)iShiftChroma;
+    // maximum deviation
+    //dMaxDispDev     = Max( dMaxDispDev,    fabs( Double( (Int) iTestScale   ) - dShiftLuma * Double( 1 << iLog2DivLuma ) ) / Double( 1 << iLog2DivLuma ) );
+    //dMaxRndDispDvL  = Max( dMaxRndDispDvL, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) );
+    //dMaxRndDispDvC  = Max( dMaxRndDispDvC, fabs( Double( (Int) iShiftChroma ) - dShiftChroma ) );
+  }
+  radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+  raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+}
+#endif // end MERL_VSP_C0152
 Void
 …
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
+#if MERL_VSP_C0152
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+#endif
+      }
       else
 …
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseId ];
+#if MERL_VSP_C0152
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+#endif
+      }
+    }
 …
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
+#if MERL_VSP_C0152
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+#endif
+      }
+    }
 …
   m_iMaxRefPicNum = 0;
   m_uiValidPS = 0;
-#if SONY_COLPIC_AVAILABILITY
-  m_iViewOrderIdx = 0;
-#endif
 #if ENC_DEC_TRACE
   g_hTrace = fopen( "TraceDec.txt", "wb" );
+  if(!g_hTrace) g_hTrace = fopen( "TraceDec.txt", "wb" );
   g_bJustDoIt = g_bEncDecTraceDisable;
   g_nSymbolCounter = 0;
 …
+{
 #if ENC_DEC_TRACE
+  fclose( g_hTrace );
+  if(g_hTrace) fclose( g_hTrace );
+  g_hTrace=NULL;
 #endif
+}
 …
   m_cDepthMapGenerator.destroy();
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_cResidualGenerator.destroy();
 #endif
+}
 …
                     , &m_cDepthMapGenerator
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
                     , &m_cResidualGenerator
 #endif
 …
 #endif
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_cResidualGenerator.init( &m_cTrQuant, &m_cDepthMapGenerator );
 #endif
 …
+}
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TDecTop::deleteExtraPicBuffers( Int iPoc )
 …
   xUpdateGopSize(pcSlice);
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()) + 1; // +1 to have space for the picture currently being decoded
-#else
-  m_iMaxRefPicNum = pcSlice->getSPS()->getMaxNumberOfReferencePictures()+pcSlice->getSPS()->getNumReorderFrames() + 1; // +1 to have space for the picture currently being decoded
-#endif
 #if DEPTH_MAP_GENERATION
 …
+  }
-#if !LCU_SYNTAX_ALF
-  // create ALF temporary buffer
-  m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
-#endif
   m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
   m_cLoopFilter.        create( g_uiMaxCUDepth );
+}
-#if SKIPFRAME_BUGFIX
 Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
-#else
-Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int iSkipFrame, Int iPOCLastDisplay )
-#endif
+{
   TComPic*&   pcPic         = m_pcPic;
 …
+  }
-#if SONY_COLPIC_AVAILABILITY
-  m_apcSlicePilot->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx());
-#endif
-#if NAL_REF_FLAG
   m_apcSlicePilot->setReferenced(nalu.m_nalRefFlag);
+  m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
+  // ALF CU parameters should be part of the slice header -> needs to be fixed
+#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam(), m_cGopDecoder.getAlfParamSet(),m_apcSlicePilot->getVPS()->getDepthFlag(nalu.m_layerId));
 #else
-  m_apcSlicePilot->setReferenced(nalu.m_nalRefIDC != NAL_REF_IDC_PRIORITY_LOWEST);
-#endif
-  m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
-  // ALF CU parameters should be part of the slice header -> needs to be fixed
-#if LCU_SYNTAX_ALF
   m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam(), m_cGopDecoder.getAlfParamSet());
-#else
-  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam() );
 #endif
   // byte align
 …
   if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence)
+  {
-#if START_DECODING_AT_CRA
     if (m_prevPOC >= m_pocRandomAccess)
+    {
 …
+    }
     m_prevPOC = m_apcSlicePilot->getPOC();
-#else
-    m_prevPOC = m_apcSlicePilot->getPOC();
-    return true;
-#endif
+  }
   // actual decoding starts here
 …
+  }
   //detect lost reference picture and insert copy of earlier frame.
-#if START_DECODING_AT_CRA
   while(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true, m_pocRandomAccess) > 0)
-#else
-  while(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true) > 0)
-#endif
+  {
     xCreateLostPicture(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), false)-1);
 …
     xGetNewPicBuffer (m_apcSlicePilot, pcPic);
+#if SONY_COLPIC_AVAILABILITY
+    pcPic->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx() );
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    pcPic->setViewOrderIdx( m_apcSlicePilot->getVPS()->getViewOrderIdx(nalu.m_layerId) );    // will be changed to view_id
+#endif
     /* transfer any SEI messages that have been received to the picture */
     pcPic->setSEIs(m_SEIs);
 …
+    }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     m_cResidualGenerator.create( true, m_apcSlicePilot->getSPS()->getPicWidthInLumaSamples(), m_apcSlicePilot->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiBitDepth + g_uiBitIncrement );
 #endif
 …
   UInt i, j, p;
-#if !REMOVE_TILE_DEPENDENCE
-  //set the TileBoundaryIndependenceIdr
-  if(pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)
+  {
-    pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getTileBoundaryIndependenceIdr() );
+  }
-  else
+  {
-    pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getSPS()->getTileBoundaryIndependenceIdr() );
+  }
-#endif
   if( pcSlice->getPPS()->getColumnRowInfoPresent() == 1 )
 …
 #endif
 #if SONY_COLPIC_AVAILABILITY
+#if INTER_VIEW_VECTOR_SCALING_C0115
 #if VIDYO_VPS_INTEGRATION
     pcSlice->setViewOrderIdx( pcSlice->getVPS()->getViewOrderIdx(nalu.m_layerId) );
+    pcSlice->setViewOrderIdx( pcSlice->getVPS()->getViewOrderIdx(nalu.m_layerId) );        // will be changed to view_id
 #else
     pcSlice->setViewOrderIdx( pcPic->getViewOrderIdx() );
 #endif
+#endif
+#if INTER_VIEW_VECTOR_SCALING_C0115
+    pcSlice->setIVScalingFlag( pcSlice->getVPS()->getIVScalingFlag());
 #endif
 …
 #endif
+#if MERL_VSP_C0152 // set BW LUT
+  if( m_pcCamParsCollector ) // Initialize the LUT elements
+  {
+    m_pcCamParsCollector->setSlice( pcSlice );
+  }
+  if( pcSlice->getViewId() !=0 )
+  {
+    TComPic* pcBaseTxtPic = m_tAppDecTop->getPicFromView(  0, pcSlice->getPOC(), false );  // get base view reconstructed texture
+    TComPic* pcBaseDepthPic = m_tAppDecTop->getPicFromView(  0, pcSlice->getPOC(), true ); // get base view reconstructed depth
+     pcSlice->setRefPicBaseTxt(pcBaseTxtPic);
+     pcSlice->setRefPicBaseDepth(pcBaseDepthPic);
+  }
+  getTAppDecTop()->setBWVSPLUT( pcSlice, pcSlice->getViewId(),  pcSlice->getPOC() ); // get the LUT for backward warping
+#endif
   //  Decode a picture
   m_cGopDecoder.decompressGop(nalu.m_Bitstream, pcPic, false);
 …
+{
   TComSPS* sps = new TComSPS();
-#if RPS_IN_SPS
   TComRPSList* rps = new TComRPSList();
   sps->setRPSList(rps);
+#endif
+#if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   m_cEntropyDecoder.decodeSPS( sps, m_isDepth );
 #else
 …
 #endif
   m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
-#if LCU_SYNTAX_ALF
   m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
-#endif
+}
 Void TDecTop::xDecodePPS()
+{
-#if !RPS_IN_SPS
-  TComRPSList* rps = new TComRPSList();
-#endif
   TComPPS* pps = new TComPPS();
-#if !RPS_IN_SPS
-  pps->setRPSList(rps);
-#endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   m_cEntropyDecoder.decodePPS( pps, &m_parameterSetManagerDecoder );
-#else
-  m_cEntropyDecoder.decodePPS( pps );
-#endif
   m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
 …
     case NAL_UNIT_CODED_SLICE:
     case NAL_UNIT_CODED_SLICE_IDR:
-#if H0566_TLA
 #if !QC_REM_IDV_B0046
     case NAL_UNIT_CODED_SLICE_IDV:
 …
     case NAL_UNIT_CODED_SLICE_CRA:
     case NAL_UNIT_CODED_SLICE_TLA:
-#else
-    case NAL_UNIT_CODED_SLICE_CDR:
-#endif
       return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
       break;
 …
   sps = pSPSV0;
   m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
-#if LCU_SYNTAX_ALF
   m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
-#endif
+}
 …
   else if (m_pocRandomAccess == MAX_INT) // start of random access point, m_pocRandomAccess has not been set yet.
+  {
-#if H0566_TLA
     if( m_apcSlicePilot->getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA )
-#else
-    if( m_apcSlicePilot->getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR )
-#endif
+    {
       m_pocRandomAccess = m_apcSlicePilot->getPOC(); // set the POC random access since we need to skip the reordered pictures in CRA.
 …
     else
+    {
-#if START_DECODING_AT_CRA
       static bool warningMessage = false;
       if(!warningMessage)
 …
+      }
       return true;
-#else
-      printf("\nUnsafe random access point. Decoder may crash.");
-      m_pocRandomAccess = 0;
-#endif
+    }
+  }
 …
   m_cSAO.allocSaoParam(pAPS->getSaoParam());
   pAPS->createAlfParam();
-#if !LCU_SYNTAX_ALF
-  m_cAdaptiveLoopFilter.allocALFParam(pAPS->getAlfParam());
-#endif
+}

trunk/source/Lib/TLibDecoder/TDecTop.h

-                      r210
+                      r296
   Bool  isInitialized() const { return m_bInitialized; }
+#if MERL_VSP_C0152
+  Int**** getBaseViewShiftLUTI()  { return m_aiBaseViewShiftLUT;   }
+#endif
 private:
   Bool  xIsComplete ();
 …
   Int     m_iLastPOC;
   UInt    m_uiMaxViewId;
+#if MERL_VSP_C0152
+  UInt    m_uiBitDepthForLUT;
+  UInt    m_iLog2Precision;
+  UInt    m_uiInputBitDepth;
+  // look-up tables
+  Double****   m_adBaseViewShiftLUT;       ///< Disparity LUT
+  Int****      m_aiBaseViewShiftLUT;       ///< Disparity LUT
+  Void xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT);
+  Void xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT);
+  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize1, UInt uiSize2, UInt uiSize3 );
+  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize1, UInt uiSize2 );
+  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize );
+#endif
 };
+#if MERL_VSP_C0152
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2, UInt uiSize3 )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
+    {
+      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
+      {
+        for( UInt uiM = 0; uiM < uiSize3; uiM++ )
+        {
+          delete[] rpt[ uiK ][ uiL ][ uiM ];
+        }
+        delete[] rpt[ uiK ][ uiL ];
+      }
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2 )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
+    {
+      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
+      {
+        delete[] rpt[ uiK ][ uiL ];
+      }
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize; uiK++ )
+    {
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+#endif
 /// decoder class
 …
   SEImessages *m_SEIs; ///< "all" SEI messages.  If not NULL, we own the object.
-#if SONY_COLPIC_AVAILABILITY
-  Int                     m_iViewOrderIdx;
-#endif
   // functional classes
 …
   TComDepthMapGenerator   m_cDepthMapGenerator;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   TComResidualGenerator   m_cResidualGenerator;
 #endif
 …
   Void      xCopyVPS( TComVPS* pVPSV0);
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void      deleteExtraPicBuffers   ( Int iPoc );
 #endif
 …
   Int  getViewId()                { return m_viewId  ;}
   Void setIsDepth( Bool isDepth ) { m_isDepth = isDepth; }
-#if SONY_COLPIC_AVAILABILITY
-  Void setViewOrderIdx(Int i)     { m_iViewOrderIdx = i ;}
-  Int  getViewOrderIdx()          { return m_iViewOrderIdx ; }
-#endif
 #if DEPTH_MAP_GENERATION
 …
   ParameterSetManagerDecoder* xGetParaSetDec ()        {return  &m_parameterSetManagerDecoder;}
 #endif
 protected:
   Void  xGetNewPicBuffer  (TComSlice* pcSlice, TComPic*& rpcPic);
 …
   Void      decodeAPS( TComAPS* cAPS) { m_cEntropyDecoder.decodeAPS(cAPS); };
   Void      xActivateParameterSets();
-#if SKIPFRAME_BUGFIX
   Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
-#else
-  Bool      xDecodeSlice(InputNALUnit &nalu, Int iSkipFrame, Int iPOCLastDisplay);
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   Void      xDecodeVPS();

trunk/source/Lib/TLibEncoder/NALwrite.cpp

-                      r210
+                      r296
   bsNALUHeader.write(0,1); // forbidden_zero_flag
-#if NAL_REF_FLAG
   bsNALUHeader.write(nalu.m_nalRefFlag? 1 : 0, 1); // nal_ref_flag
   bsNALUHeader.write(nalu.m_nalUnitType, 6);          // nal_unit_type
-#else
-  bsNALUHeader.write(nalu.m_nalRefIDC, 2); // nal_ref_idc
-  bsNALUHeader.write(nalu.m_nalUnitType, 5); // nal_unit_type
-#endif
 #if QC_MVHEVC_B0046
 …
   bsNALUHeader.write(nalu.m_layerId + 1, 5); // layer_id_plus1
 #else
-#if H0388
   bsNALUHeader.write(nalu.m_temporalId, 3); // temporal_id
  // bsNALUHeader.write(1, 5); // reserved_one_5bits
   bsNALUHeader.write(nalu.m_viewId+1,4);
   bsNALUHeader.write(nalu.m_isDepth,1);
-#else
-  switch (nalu.m_nalUnitType)
+  {
-  case NAL_UNIT_CODED_SLICE:
-  case NAL_UNIT_CODED_SLICE_IDR:
-#if H0566_TLA
-#if !QC_REM_IDV_B0046
-  case NAL_UNIT_CODED_SLICE_IDV:
-#endif
-  case NAL_UNIT_CODED_SLICE_CRA:
-  case NAL_UNIT_CODED_SLICE_TLA:
-#else
-  case NAL_UNIT_CODED_SLICE_CDR:
-#endif
-    bsNALUHeader.write(nalu.m_temporalId, 3); // temporal_id
-    bsNALUHeader.write(nalu.m_OutputFlag, 1); // output_flag
-  //  bsNALUHeader.write(1, 4); // reserved_one_4bits
-    bsNALUHeader.write(nalu.m_viewId+1,3);
-    bsNALUHeader.write(nalu.m_isDepth,1);
-    break;
-  default: break;
+  }
-#endif
 #endif
 #endif
 …
+{
   naluDest.m_nalUnitType = naluSrc.m_nalUnitType;
-#if NAL_REF_FLAG
   naluDest.m_nalRefFlag  = naluSrc.m_nalRefFlag;
-#else
-  naluDest.m_nalRefIDC   = naluSrc.m_nalRefIDC;
-#endif
 #if !VIDYO_VPS_INTEGRATION
   naluDest.m_viewId      = naluSrc.m_viewId;
 …
 #else
-#if !H0388
-  naluDest.m_OutputFlag  = naluSrc.m_OutputFlag;
-#endif
 #endif
   naluDest.m_Bitstream   = naluSrc.m_Bitstream;

trunk/source/Lib/TLibEncoder/NALwrite.h

-                      r210
+                      r296
    * written to the bitstream.
    */
-#if H0388
   OutputNALUnit(
     NalUnitType nalUnitType,
-#if NAL_REF_FLAG
     Bool nalRefFlag,
-#else
-    NalRefIdc nalRefIDC,
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
     unsigned layerId,
 …
 #endif
     unsigned temporalID = 0)
-#if NAL_REF_FLAG
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   : NALUnit(nalUnitType, nalRefFlag, layerId, temporalID)
 …
   : NALUnit(nalUnitType, nalRefFlag, viewId, isDepth, temporalID)
 #endif
-#else
-#if VIDYO_VPS_INTEGRATION
-  : NALUnit(nalUnitType, nalRefIDC, layerId, temporalID)
-#else
-  : NALUnit(nalUnitType, nalRefIDC, viewId, isDepth, temporalID)
-#endif
-#endif
   , m_Bitstream()
   {}
-#else
-  OutputNALUnit(
-    NalUnitType nalUnitType,
-    NalRefIdc nalRefIDC,
-    Int viewId,
-    Bool isDepth,
-    unsigned temporalID = 0,
-    bool outputFlag = true)
-  : NALUnit(nalUnitType, nalRefIDC, viewId, isDepth, temporalID, outputFlag)
-  , m_Bitstream()
-  {}
-#endif
   OutputNALUnit(const NALUnit& src)

trunk/source/Lib/TLibEncoder/TEncAdaptiveLoopFilter.cpp

-                      r56
+                      r296
 // Constants
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 #define ALF_NUM_OF_REDESIGN 1
-#else
-#define ALF_NUM_OF_REDESIGN 3
-#endif
 // ====================================================================================================================
 // Tables
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 const Int TEncAdaptiveLoopFilter::m_alfNumPartsInRowTab[5] =
+{
 …
 ,  //level 4
 };
-#endif
 // ====================================================================================================================
 // Constructor / destructor
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 ///AlfCorrData
 AlfCorrData::AlfCorrData()
 …
   return *this;
+}
-#endif
 TEncAdaptiveLoopFilter::TEncAdaptiveLoopFilter()
+{
-#if !LCU_SYNTAX_ALF
-  m_ppdAlfCorr = NULL;
-  m_ppdAlfCorrCb = NULL;
-  m_ppdAlfCorrCr = NULL;
-  m_pdDoubleAlfCoeff = NULL;
-#endif
   m_pcEntropyCoder = NULL;
-#if !LCU_SYNTAX_ALF
-  m_pcBestAlfParam = NULL;
-  m_pcTempAlfParam = NULL;
-#endif
   m_pcPicYuvBest = NULL;
   m_pcPicYuvTmp = NULL;
-#if !LCU_SYNTAX_ALF
-  pcAlfParamShape0 = NULL;
-  pcAlfParamShape1 = NULL;
-  pcPicYuvRecShape0 = NULL;
-  pcPicYuvRecShape1 = NULL;
-  m_pcSliceYuvTmp = NULL;
-#endif
   m_iALFMaxNumberFilters = NO_FILTERS;
 …
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 /** convert Level Row Col to Idx
  * \param   level,  row,  col
 …
+}
-#else
-/** create ALF global buffers
- * \param iALFEncodePassReduction 0: 16-pass encoding, 1: 1-pass encoding, 2: 2-pass encoding
- * This function is used to create the filter buffers to perform time-delay filtering.
- */
-Void TEncAdaptiveLoopFilter::createAlfGlobalBuffers(Int iALFEncodePassReduction)
+{
-  if(iALFEncodePassReduction)
+  {
-    Int iNumOfBuffer = m_iGOPSize +1;
-    for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+    {
-      m_mergeTableSavedMethods[i] = new Int*[iNumOfBuffer];
-      m_aiFilterCoeffSavedMethods[i] = new Int**[iNumOfBuffer];
-      for(Int j=0; j< iNumOfBuffer; j++)
+      {
-        m_mergeTableSavedMethods[i][j] = new Int[NO_VAR_BINS];
-        m_aiFilterCoeffSavedMethods[i][j] = new Int*[NO_VAR_BINS];
-        for(Int k=0; k< NO_VAR_BINS; k++)
+        {
-          m_aiFilterCoeffSavedMethods[i][j][k] = new Int[ALF_MAX_NUM_COEF];
+        }
+      }
-      m_iPreviousFilterShapeMethods[i] = new Int[iNumOfBuffer];
+    }
+  }
+}
-/** destroy ALF global buffers
- * This function is used to destroy the filter buffers.
- */
-Void TEncAdaptiveLoopFilter::destroyAlfGlobalBuffers()
+{
-  if(m_iALFEncodePassReduction)
+  {
-    for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+    {
-      for(Int j=0; j< m_iGOPSize+1; j++)
+      {
-        for(Int k=0; k< NO_VAR_BINS; k++)
+        {
-          delete[] m_aiFilterCoeffSavedMethods[i][j][k];
+        }
-        delete[] m_aiFilterCoeffSavedMethods[i][j];
-        delete[] m_mergeTableSavedMethods[i][j];
+      }
-      delete[] m_aiFilterCoeffSavedMethods[i];
-      delete[] m_iPreviousFilterShapeMethods[i];
-      delete[] m_mergeTableSavedMethods[i];
+    }
+  }
+}
-#endif
 /**
  \param pcPic           picture (TComPic) pointer
 …
+{
   m_pcEntropyCoder = pcEntropyCoder;
-#if !LCU_SYNTAX_ALF
-  xInitParam();
-#endif
   xCreateTmpAlfCtrlFlags();
 …
   m_pcPicYuvTmp->createLuma(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
   m_pcPicYuvBest = pcPic->getPicYuvPred();
-#if !LCU_SYNTAX_ALF
-  m_pcBestAlfParam = new ALFParam;
-  m_pcTempAlfParam = new ALFParam;
-  allocALFParam(m_pcBestAlfParam);
-  allocALFParam(m_pcTempAlfParam);
-  pcPicYuvRecShape0 = new TComPicYuv();
-  pcPicYuvRecShape0->createLuma(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
-  pcPicYuvRecShape1 = new TComPicYuv();
-  pcPicYuvRecShape1->createLuma(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
-  pcAlfParamShape0 = new ALFParam;
-  pcAlfParamShape1 = new ALFParam;
-  allocALFParam(pcAlfParamShape0);
-  allocALFParam(pcAlfParamShape1);
-  // init qc_filter
-  initMatrix4D_double(&m_EGlobalSym, NUM_ALF_FILTER_SHAPE+1,  NO_VAR_BINS, MAX_SQR_FILT_LENGTH, MAX_SQR_FILT_LENGTH);
-  initMatrix3D_double(&m_yGlobalSym, NUM_ALF_FILTER_SHAPE+1, NO_VAR_BINS, MAX_SQR_FILT_LENGTH);
-#endif
   initMatrix_int(&m_filterCoeffSymQuant, NO_VAR_BINS, ALF_MAX_NUM_COEF);
-#if !LCU_SYNTAX_ALF
-  m_pixAcc = (double *) calloc(NO_VAR_BINS, sizeof(double));
-#endif
   initMatrix_Pel(&m_maskImg, m_img_height, m_img_width);
   initMatrix_double(&m_E_temp, MAX_SQR_FILT_LENGTH, MAX_SQR_FILT_LENGTH);//
 …
   initMatrix_int(&m_FilterCoeffQuantTemp, NO_VAR_BINS, ALF_MAX_NUM_COEF);//
-#if LCU_SYNTAX_ALF
   m_tempALFp = new ALFParam(ALF_Y);
-#else
-  m_tempALFp = new ALFParam;
-  allocALFParam(m_tempALFp);
-  if( m_bUseNonCrossALF )
+  {
-    m_pcSliceYuvTmp = new TComPicYuv();
-    m_pcSliceYuvTmp->create(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
+  }
-#endif
+}
 Void TEncAdaptiveLoopFilter::endALFEnc()
+{
-#if !LCU_SYNTAX_ALF
-  xUninitParam();
-#endif
   xDestroyTmpAlfCtrlFlags();
 …
   m_pcPic = NULL;
   m_pcEntropyCoder = NULL;
-#if !LCU_SYNTAX_ALF
-  freeALFParam(m_pcBestAlfParam);
-  freeALFParam(m_pcTempAlfParam);
-  delete m_pcBestAlfParam;
-  delete m_pcTempAlfParam;
-  pcPicYuvRecShape0->destroyLuma();
-  delete pcPicYuvRecShape0;
-  pcPicYuvRecShape0 = NULL;
-  pcPicYuvRecShape1->destroyLuma();
-  delete pcPicYuvRecShape1;
-  pcPicYuvRecShape1 = NULL;
-  freeALFParam(pcAlfParamShape0);
-  freeALFParam(pcAlfParamShape1);
-  delete pcAlfParamShape0;
-  delete pcAlfParamShape1;
-  // delete qc filters
-  destroyMatrix4D_double(m_EGlobalSym, NUM_ALF_FILTER_SHAPE+1,  NO_VAR_BINS);
-  destroyMatrix3D_double(m_yGlobalSym, NUM_ALF_FILTER_SHAPE+1);
-#endif
   destroyMatrix_int(m_filterCoeffSymQuant);
-#if !LCU_SYNTAX_ALF
-  free(m_pixAcc);
-#endif
   destroyMatrix_Pel(m_maskImg);
   destroyMatrix3D_double(m_E_merged, NO_VAR_BINS);
 …
   destroyMatrix_int(m_FilterCoeffQuantTemp);
-#if LCU_SYNTAX_ALF
   delete m_tempALFp;
+#else
+  freeALFParam(m_tempALFp);
+  delete m_tempALFp;
+  if(m_bUseNonCrossALF)
+  {
+    m_pcSliceYuvTmp->destroy();
+    delete m_pcSliceYuvTmp;
+    m_pcSliceYuvTmp = NULL;
+  }
+#endif
+}
+#if LCU_SYNTAX_ALF
+}
 /** Assign output ALF parameters
 …
 #endif
-#if ALF_SINGLE_FILTER_SHAPE
         calcCorrOneCompRegionChma(pPicOrg, pPicSrc, stride, ypos, xpos, height, width, alfCorr->ECorr[0], alfCorr->yCorr[0], isLastBlock);
-#endif
+      }
+    }
 …
 #endif
-#if ALF_SINGLE_FILTER_SHAPE
         calcCorrOneCompRegionLuma(pPicOrg, pPicSrc, stride, ypos, xpos, height, width, alfCorr->ECorr, alfCorr->yCorr, alfCorr->pixAcc, forceCollection, isLastBlock);
-#endif
+      }
+    }
 …
-#if ALF_SINGLE_FILTER_SHAPE
 /** Gather correlations for one region for chroma component
  * \param [in] imgOrg picture buffer for original picture
 …
+}
+#endif
+#else
+#if ALF_CHROMA_LAMBDA
+/**
+ \param pcAlfParam           ALF parameter
+ \param [out] pvAlfCtrlParam ALF CU control parameters container for slices
+ \param dLambdaLuma          luma lambda value for RD cost computation
+ \param dLambdaChroma        chroma lambda value for RD cost computation
+ \retval ruiDist             distortion
+ \retval ruiBits             required bits
+ \retval ruiMaxAlfCtrlDepth  optimal partition depth
+ */
+#if HHI_INTERVIEW_SKIP
+Void TEncAdaptiveLoopFilter::ALFProcess( ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambdaLuma, Double dLambdaChroma, UInt64& ruiDist, UInt64& ruiBits, Bool bInterviewSkip)
+#else
+Void TEncAdaptiveLoopFilter::ALFProcess( ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambdaLuma, Double dLambdaChroma, UInt64& ruiDist, UInt64& ruiBits)
+#endif
+#else
+/**
+ \param pcAlfParam           ALF parameter
+ \param dLambda              lambda value for RD cost computation
+ \retval ruiDist             distortion
+ \retval ruiBits             required bits
+ \retval ruiMaxAlfCtrlDepth  optimal partition depth
+ */
+#if HHI_INTERVIEW_SKIP
+Void TEncAdaptiveLoopFilter::ALFProcess( ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambda, UInt64& ruiDist, UInt64& ruiBits, Bool bInterviewSkip)
+#else
+Void TEncAdaptiveLoopFilter::ALFProcess( ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambda, UInt64& ruiDist, UInt64& ruiBits)
+#endif
+#endif
+{
+  // set lambda
+#if ALF_CHROMA_LAMBDA
+  m_dLambdaLuma   = dLambdaLuma;
+  m_dLambdaChroma = dLambdaChroma;
+#else
+  m_dLambdaLuma   = dLambda;
+  m_dLambdaChroma = dLambda;
+#endif
+  m_lcuHeight = m_pcPic->getSlice(0)->getSPS()->getMaxCUHeight();
+#if ALF_SINGLE_FILTER_SHAPE
+  m_lineIdxPadBot = m_lcuHeight - 4 - 3; // DFRegion, Vertical Taps
+#else
+  m_lineIdxPadBot = m_lcuHeight - 4 - 4; // DFRegion, Vertical Taps
+#endif
+  m_lineIdxPadTop = m_lcuHeight - 4; // DFRegion
+  m_lcuHeightChroma = m_lcuHeight>>1;
+#if ALF_SINGLE_FILTER_SHAPE
+  m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 3; // DFRegion, Vertical Taps
+#else
+  m_lineIdxPadBotChroma = m_lcuHeightChroma - 2 - 4; // DFRegion, Vertical Taps
+#endif
+  m_lineIdxPadTopChroma = m_lcuHeightChroma - 2 ; // DFRegion
+  TComPicYuv* pcPicOrg = m_pcPic->getPicYuvOrg();
+  // extend image for filtering
+  TComPicYuv* pcPicYuvRec    = m_pcPic->getPicYuvRec();
+  TComPicYuv* pcPicYuvExtRec = m_pcTempPicYuv;
+#if HHI_INTERVIEW_SKIP
+  TComPicYuv* pcUsedPelMap   = m_pcPic->getUsedPelsMap() ;
+  if(bInterviewSkip)
+    assert( pcUsedPelMap ) ;
+#endif
+  pcPicYuvRec->copyToPic(pcPicYuvExtRec);
+  if(!m_bUseNonCrossALF)
+  {
+  pcPicYuvExtRec->setBorderExtension( false );
+  pcPicYuvExtRec->extendPicBorder   ();
+  }
+  // set min cost
+  UInt64 uiMinRate = MAX_INT;
+  UInt64 uiMinDist = MAX_INT;
+  Double dMinCost  = MAX_DOUBLE;
+  UInt64  uiOrigRate;
+  UInt64  uiOrigDist;
+  Double  dOrigCost;
+  // calc original cost
+#if HHI_INTERVIEW_SKIP
+  xCalcRDCost( pcPicOrg, pcPicYuvRec, pcUsedPelMap, NULL, uiOrigRate, uiOrigDist, dOrigCost );
+#else
+  xCalcRDCost( pcPicOrg, pcPicYuvRec, NULL, uiOrigRate, uiOrigDist, dOrigCost );
+#endif
+  m_pcBestAlfParam->alf_flag = 0;
+  // initialize temp_alfps
+  m_pcTempAlfParam->alf_flag        = 1;
+  m_pcTempAlfParam->chroma_idc      = 0;
+  m_bAlfCUCtrlEnabled = (pvAlfCtrlParam != NULL)?true:false;
+  if(m_bAlfCUCtrlEnabled)
+  {
+    m_vBestAlfCUCtrlParam.resize(m_uiNumSlicesInPic);
+    for(Int s=0; s< m_uiNumSlicesInPic; s++)
+    {
+      m_vBestAlfCUCtrlParam[s].cu_control_flag = 0;
+    }
+  }
+  else
+  {
+    m_vBestAlfCUCtrlParam.clear();
+  }
+  setALFEncodingParam(m_pcPic);
+  // adaptive in-loop wiener filtering
+#if HHI_INTERVIEW_SKIP
+  xEncALFLuma( pcPicOrg, pcPicYuvExtRec, pcPicYuvRec, uiMinRate, uiMinDist, dMinCost, bInterviewSkip );
+#else
+  xEncALFLuma( pcPicOrg, pcPicYuvExtRec, pcPicYuvRec, uiMinRate, uiMinDist, dMinCost );
+#endif
+  // cu-based filter on/off control
+#if HHI_INTERVIEW_SKIP
+  xCUAdaptiveControl_qc( pcPicOrg, pcPicYuvExtRec, pcPicYuvRec, pcUsedPelMap, uiMinRate, uiMinDist, dMinCost );
+#else
+  xCUAdaptiveControl_qc( pcPicOrg, pcPicYuvExtRec, pcPicYuvRec, uiMinRate, uiMinDist, dMinCost );
+#endif
+  // compare RD cost to non-ALF case
+  if( dMinCost < dOrigCost )
+  {
+    m_pcBestAlfParam->alf_flag = 1;
+    ruiBits = uiMinRate;
+    ruiDist = uiMinDist;
+  }
+  else
+  {
+    m_pcBestAlfParam->alf_flag        = 0;
+    uiMinRate = uiOrigRate;
+    uiMinDist = uiOrigDist;
+    m_pcEntropyCoder->setAlfCtrl(false);
+    if(m_bAlfCUCtrlEnabled)
+    {
+      for(Int s=0; s< m_uiNumSlicesInPic; s++)
+      {
+        m_vBestAlfCUCtrlParam[s].cu_control_flag = 0;
+      }
+    }
+    pcPicYuvExtRec->copyToPicLuma(pcPicYuvRec);
+    ruiBits = uiOrigRate;
+    ruiDist = uiOrigDist;
+  }
+  // if ALF works
+  if( m_pcBestAlfParam->alf_flag )
+  {
+    // do additional ALF process for chroma
+    xFilterTapDecisionChroma( uiMinRate, pcPicOrg, pcPicYuvExtRec, pcPicYuvRec, ruiDist, ruiBits );
+  }
+  // copy to best storage
+  copyALFParam(pcAlfParam, m_pcBestAlfParam);
+  if(m_bAlfCUCtrlEnabled)
+  {
+    for(Int s=0; s< m_uiNumSlicesInPic; s++)
+    {
+      (*pvAlfCtrlParam)[s]= m_vBestAlfCUCtrlParam[s];
+    }
+  }
+}
+#endif
 /** PCM LF disable process.
 …
 // Private member functions
 // ====================================================================================================================
-#if !LCU_SYNTAX_ALF
-Void TEncAdaptiveLoopFilter::xInitParam()
+{
-  Int i, j;
-  if (m_ppdAlfCorr != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorr[i][j] = 0;
+      }
+    }
+  }
-  else
+  {
-    m_ppdAlfCorr = new Double*[ALF_MAX_NUM_COEF];
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      m_ppdAlfCorr[i] = new Double[ALF_MAX_NUM_COEF+1];
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorr[i][j] = 0;
+      }
+    }
+  }
-  if (m_pdDoubleAlfCoeff != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      m_pdDoubleAlfCoeff[i] = 0;
+    }
+  }
-  else
+  {
-    m_pdDoubleAlfCoeff = new Double[ALF_MAX_NUM_COEF];
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      m_pdDoubleAlfCoeff[i] = 0;
+    }
+  }
-  if (m_ppdAlfCorrCb != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorrCb[i][j] = 0;
+      }
+    }
+  }
-  else
+  {
-    m_ppdAlfCorrCb = new Double*[ALF_MAX_NUM_COEF];
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      m_ppdAlfCorrCb[i] = new Double[ALF_MAX_NUM_COEF+1];
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorrCb[i][j] = 0;
+      }
+    }
+  }
-  if (m_ppdAlfCorrCr != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorrCr[i][j] = 0;
+      }
+    }
+  }
-  else
+  {
-    m_ppdAlfCorrCr = new Double*[ALF_MAX_NUM_COEF];
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      m_ppdAlfCorrCr[i] = new Double[ALF_MAX_NUM_COEF+1];
-      for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
+      {
-        m_ppdAlfCorrCr[i][j] = 0;
+      }
+    }
+  }
+}
-Void TEncAdaptiveLoopFilter::xUninitParam()
+{
-  Int i;
-  if (m_ppdAlfCorr != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      delete[] m_ppdAlfCorr[i];
-      m_ppdAlfCorr[i] = NULL;
+    }
-    delete[] m_ppdAlfCorr;
-    m_ppdAlfCorr = NULL;
+  }
-  if (m_pdDoubleAlfCoeff != NULL)
+  {
-    delete[] m_pdDoubleAlfCoeff;
-    m_pdDoubleAlfCoeff = NULL;
+  }
-  if (m_ppdAlfCorrCb != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      delete[] m_ppdAlfCorrCb[i];
-      m_ppdAlfCorrCb[i] = NULL;
+    }
-    delete[] m_ppdAlfCorrCb;
-    m_ppdAlfCorrCb = NULL;
+  }
-  if (m_ppdAlfCorrCr != NULL)
+  {
-    for (i = 0; i < ALF_MAX_NUM_COEF; i++)
+    {
-      delete[] m_ppdAlfCorrCr[i];
-      m_ppdAlfCorrCr[i] = NULL;
+    }
-    delete[] m_ppdAlfCorrCr;
-    m_ppdAlfCorrCr = NULL;
+  }
+}
-#endif
 Void TEncAdaptiveLoopFilter::xCreateTmpAlfCtrlFlags()
+{
 …
+}
-#if !LCU_SYNTAX_ALF
-Void TEncAdaptiveLoopFilter::xCalcCorrelationFunc(Int ypos, Int xpos, Pel* pImgOrg, Pel* pImgPad, Int filtNo, Int iWidth, Int iHeight, Int iOrgStride, Int iCmpStride, Bool bSymmCopyBlockMatrix)
+{
-  Int     yposEnd = ypos + iHeight -1;
-  Int     xposEnd = xpos + iWidth  -1;
-  Int     N       = m_sqrFiltLengthTab[filtNo];
-  Int imgHeightChroma = m_img_height>>1;
-  Int yLineInLCU;
-  Int paddingline ;
-  Int ELocal[ALF_MAX_NUM_COEF];
-  Pel *pImgPad1, *pImgPad2, *pImgPad3, *pImgPad4;
-  Int i, j, k, l;
-  Int yLocal;
-  pImgPad += (ypos*iCmpStride);
-  pImgOrg += (ypos*iOrgStride);
-  switch(filtNo)
+  {
-#if !ALF_SINGLE_FILTER_SHAPE
-  case ALF_STAR5x5:
+    {
-      for (i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeightChroma;
-        if (yLineInLCU < m_lineIdxPadBotChroma || i-yLineInLCU+m_lcuHeightChroma >= imgHeightChroma )
+        {
-          pImgPad1 = pImgPad +   iCmpStride;
-          pImgPad2 = pImgPad -   iCmpStride;
-          pImgPad3 = pImgPad + 2*iCmpStride;
-          pImgPad4 = pImgPad - 2*iCmpStride;
+        }
-        else if (yLineInLCU < m_lineIdxPadTopChroma)
+        {
-          paddingline = - yLineInLCU + m_lineIdxPadTopChroma - 1;
-          pImgPad1 = pImgPad + min(paddingline, 1)*iCmpStride;
-          pImgPad2 = pImgPad -   iCmpStride;
-          pImgPad3 = pImgPad + min(paddingline, 2)*iCmpStride;
-          pImgPad4 = pImgPad - 2*iCmpStride;
+        }
-        else
+        {
-          paddingline = yLineInLCU - m_lineIdxPadTopChroma ;
-          pImgPad1 = pImgPad +   iCmpStride;
-          pImgPad2 = pImgPad - min(paddingline, 1)*iCmpStride;
-          pImgPad3 = pImgPad + 2*iCmpStride;
-          pImgPad4 = pImgPad - min(paddingline, 2)*iCmpStride;
+        }
-        if ( (yLineInLCU == m_lineIdxPadTopChroma || yLineInLCU == m_lineIdxPadTopChroma-1) && i-yLineInLCU+m_lcuHeightChroma < imgHeightChroma )
+        {
-          pImgPad+= iCmpStride;
-          pImgOrg+= iOrgStride;
-          continue;
+        }
-        else
+        {
-        for (j= xpos; j<= xposEnd; j++)
+        {
-          memset(ELocal, 0, N*sizeof(Int));
-          ELocal[0] = (pImgPad3[j+2] + pImgPad4[j-2]);
-          ELocal[1] = (pImgPad3[j  ] + pImgPad4[j  ]);
-          ELocal[2] = (pImgPad3[j-2] + pImgPad4[j+2]);
-          ELocal[3] = (pImgPad1[j+1] + pImgPad2[j-1]);
-          ELocal[4] = (pImgPad1[j  ] + pImgPad2[j  ]);
-          ELocal[5] = (pImgPad1[j-1] + pImgPad2[j+1]);
-          ELocal[6] = (pImgPad[j+2] + pImgPad[j-2]);
-          ELocal[7] = (pImgPad[j+1] + pImgPad[j-1]);
-          ELocal[8] = (pImgPad[j  ]);
-          yLocal= (Int)pImgOrg[j];
-          for(k=0; k<N; k++)
+          {
-            m_ppdAlfCorr[k][k] += ELocal[k]*ELocal[k];
-            for(l=k+1; l<N; l++)
+            {
-              m_ppdAlfCorr[k][l] += ELocal[k]*ELocal[l];
+            }
-            m_ppdAlfCorr[k][N] += yLocal*ELocal[k];
+          }
+        }
-        pImgPad+= iCmpStride;
-        pImgOrg+= iOrgStride;
+      }
+      }
+    }
-    break;
-  case ALF_CROSS9x9:
+    {
-      Pel *pImgPad5, *pImgPad6, *pImgPad7, *pImgPad8;
-#else
-  case ALF_CROSS9x7_SQUARE3x3:
+    {
-      Pel *pImgPad5, *pImgPad6;
-#endif
-      for (i= ypos; i<= yposEnd; i++)
+      {
-        yLineInLCU = i % m_lcuHeightChroma;
-        if (yLineInLCU<2 && i> 2)
+        {
-          paddingline = yLineInLCU + 2 ;
-          pImgPad1 = pImgPad +   iCmpStride;
-          pImgPad2 = pImgPad -   iCmpStride;
-          pImgPad3 = pImgPad + 2*iCmpStride;
-          pImgPad4 = pImgPad - 2*iCmpStride;
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + 3*iCmpStride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - min(paddingline, 3)*iCmpStride;;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = (paddingline < 4) ? pImgPad : pImgPad + 4*iCmpStride;
-          pImgPad8 = (paddingline < 4) ? pImgPad : pImgPad - min(paddingline, 4)*iCmpStride;;
-#endif
+        }
-        else if (yLineInLCU < m_lineIdxPadBotChroma || i-yLineInLCU+m_lcuHeightChroma >= imgHeightChroma )
+        {
-          pImgPad1 = pImgPad +   iCmpStride;
-          pImgPad2 = pImgPad -   iCmpStride;
-          pImgPad3 = pImgPad + 2*iCmpStride;
-          pImgPad4 = pImgPad - 2*iCmpStride;
-          pImgPad5 = pImgPad + 3*iCmpStride;
-          pImgPad6 = pImgPad - 3*iCmpStride;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = pImgPad + 4*iCmpStride;
-          pImgPad8 = pImgPad - 4*iCmpStride;
-#endif
+        }
-        else if (yLineInLCU < m_lineIdxPadTopChroma)
+        {
-          paddingline = - yLineInLCU + m_lineIdxPadTopChroma - 1;
-          pImgPad1 = (paddingline < 1) ? pImgPad : pImgPad + min(paddingline, 1)*iCmpStride;
-          pImgPad2 = (paddingline < 1) ? pImgPad : pImgPad -   iCmpStride;
-          pImgPad3 = (paddingline < 2) ? pImgPad : pImgPad + min(paddingline, 2)*iCmpStride;
-          pImgPad4 = (paddingline < 2) ? pImgPad : pImgPad - 2*iCmpStride;
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + min(paddingline, 3)*iCmpStride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - 3*iCmpStride;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = (paddingline < 4) ? pImgPad : pImgPad + min(paddingline, 4)*iCmpStride;
-          pImgPad8 = (paddingline < 4) ? pImgPad : pImgPad - 4*iCmpStride;
-#endif
+        }
-        else
+        {
-          paddingline = yLineInLCU - m_lineIdxPadTopChroma ;
-          pImgPad1 = (paddingline < 1) ? pImgPad : pImgPad +   iCmpStride;
-          pImgPad2 = (paddingline < 1) ? pImgPad : pImgPad - min(paddingline, 1)*iCmpStride;
-          pImgPad3 = (paddingline < 2) ? pImgPad : pImgPad + 2*iCmpStride;
-          pImgPad4 = (paddingline < 2) ? pImgPad : pImgPad - min(paddingline, 2)*iCmpStride;
-          pImgPad5 = (paddingline < 3) ? pImgPad : pImgPad + 3*iCmpStride;
-          pImgPad6 = (paddingline < 3) ? pImgPad : pImgPad - min(paddingline, 3)*iCmpStride;
-#if !ALF_SINGLE_FILTER_SHAPE
-          pImgPad7 = (paddingline < 4) ? pImgPad : pImgPad + 4*iCmpStride;
-          pImgPad8 = (paddingline < 4) ? pImgPad : pImgPad - min(paddingline, 4)*iCmpStride;
-#endif
+        }
-        for (j= xpos; j<= xposEnd; j++)
+        {
-          memset(ELocal, 0, N*sizeof(Int));
-#if ALF_SINGLE_FILTER_SHAPE
-          ELocal[0] = (pImgPad5[j]+pImgPad6[j]);
-          ELocal[1] = (pImgPad3[j]+pImgPad4[j]);
-          ELocal[2] = (pImgPad1[j-1]+pImgPad2[j+1]);
-          ELocal[3] = (pImgPad1[j]+pImgPad2[j]);
-          ELocal[4] = (pImgPad1[j+1]+pImgPad2[j-1]);
-          ELocal[5] = (pImgPad[j+4]+pImgPad[j-4]);
-          ELocal[6] = (pImgPad[j+3]+pImgPad[j-3]);
-          ELocal[7] = (pImgPad[j+2]+pImgPad[j-2]);
-          ELocal[8] = (pImgPad[j+1]+pImgPad[j-1]);
-          ELocal[9] = (pImgPad[j  ]);
-#else
-          ELocal[0] = (pImgPad7[j] + pImgPad8[j]);
-          ELocal[1] = (pImgPad5[j] + pImgPad6[j]);
-          ELocal[2] = (pImgPad3[j] + pImgPad4[j]);
-          ELocal[3] = (pImgPad1[j] + pImgPad2[j]);
-          ELocal[4] = (pImgPad[j+4] + pImgPad[j-4]);
-          ELocal[5] = (pImgPad[j+3] + pImgPad[j-3]);
-          ELocal[6] = (pImgPad[j+2] + pImgPad[j-2]);
-          ELocal[7] = (pImgPad[j+1] + pImgPad[j-1]);
-          ELocal[8] = (pImgPad[j  ] );
-#endif
-          yLocal= (Int)pImgOrg[j];
-          for(k=0; k<N; k++)
+          {
-            m_ppdAlfCorr[k][k] += ELocal[k]*ELocal[k];
-            for(l=k+1; l<N; l++)
+            {
-              m_ppdAlfCorr[k][l] += ELocal[k]*ELocal[l];
+            }
-            m_ppdAlfCorr[k][N] += yLocal*ELocal[k];
+          }
+        }
-        pImgPad+= iCmpStride;
-        pImgOrg+= iOrgStride;
+      }
+    }
-    break;
-  default:
+    {
-      printf("Not a supported filter shape\n");
-      assert(0);
-      exit(1);
+    }
+  }
-  if(bSymmCopyBlockMatrix)
+  {
-    for(j=0; j<N-1; j++)
+    {
-      for(i=j+1; i<N; i++)
+      {
-        m_ppdAlfCorr[i][j] = m_ppdAlfCorr[j][i];
+      }
+    }
+  }
+}
-#endif
 #if IBDI_DISTORTION
 #if HHI_INTERVIEW_SKIP
 …
   Int    *nc;
   const Int    *pFiltMag;
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   Int alfPrecisionBit = getAlfPrecisionBit( m_alfQP );
 #endif
   N = m_sqrFiltLengthTab[tap];
-#if ALF_SINGLE_FILTER_SHAPE
   pFiltMag = weightsShape1Sym;
-#else
-  // star shape
-  if(tap == 0)
+  {
-    pFiltMag = weightsShape0Sym;
+  }
-  // cross shape
-  else
+  {
-    pFiltMag = weightsShape1Sym;
+  }
-#endif
   dh = new Double[N];
   nc = new Int[N];
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   max_value =   (1<<(1+alfPrecisionBit))-1;
   min_value = 0-(1<<(1+alfPrecisionBit));
 …
     if(h[i]>=0.0)
+    {
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
       qh[i] =  (Int)( h[i]*(1<<alfPrecisionBit)+0.5);
 #else
 …
     else
+    {
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
       qh[i] = -(Int)(-h[i]*(1<<alfPrecisionBit)+0.5);
 #else
 …
+    }
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
     dh[i] = (Double)qh[i]/(Double)(1<<alfPrecisionBit) - h[i];
 #else
 …
   // modification of quantized filter coefficients
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   total_gain = (Int)(dbl_total_gain*(1<<alfPrecisionBit)+0.5);
 #else
 …
   nc = NULL;
+}
-#if !LCU_SYNTAX_ALF
-Void TEncAdaptiveLoopFilter::xClearFilterCoefInt(Int* qh, Int N)
+{
-  // clear
-  memset( qh, 0, sizeof( Int ) * N );
-  // center pos
-  qh[N-1]  = 1<<ALF_NUM_BIT_SHIFT;
+}
-/** Calculate RD cost
- * \param [in] pAlfParam ALF parameters
- * \param [out] ruiRate coding bits
- * \param [in] uiDist distortion
- * \param [out] rdCost rate-distortion cost
- * \param [in] pvAlfCUCtrlParam ALF CU control parameters
- */
-Void TEncAdaptiveLoopFilter::xCalcRDCost(ALFParam* pAlfParam, UInt64& ruiRate, UInt64 uiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam)
+{
-  if(pAlfParam != NULL)
+  {
-    m_pcEntropyCoder->resetEntropy();
-    m_pcEntropyCoder->resetBits();
-    m_pcEntropyCoder->encodeAlfParam(pAlfParam);
-    ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
-    if(pvAlfCUCtrlParam != NULL)
+    {
-      for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+      {
-        if(!m_pcPic->getValidSlice(s))
+        {
-          continue;
+        }
-        m_pcEntropyCoder->resetEntropy();
-        m_pcEntropyCoder->resetBits();
-        m_pcEntropyCoder->encodeAlfCtrlParam( (*pvAlfCUCtrlParam)[s], m_uiNumCUsInFrame);
-        ruiRate += m_pcEntropyCoder->getNumberOfWrittenBits();
+      }
+    }
-    else
+    {
-      ruiRate += m_uiNumSlicesInPic;
+    }
+  }
-  else
+  {
-    ruiRate = 1;
+  }
-  rdCost      = (Double)(ruiRate) * m_dLambdaLuma + (Double)(uiDist);
+}
-/** Calculate RD cost
- * \param [in] pcPicOrg original picture buffer
- * \param [in] pcPicCmp compared picture buffer
- * \param [in] pAlfParam ALF parameters
- * \param [out] ruiRate coding bits
- * \param [out] ruiDist distortion
- * \param [out] rdCost rate-distortion cost
- * \param [in] pvAlfCUCtrlParam ALF CU control parameters
- */
-#if HHI_INTERVIEW_SKIP
-Void TEncAdaptiveLoopFilter::xCalcRDCost(TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, TComPicYuv* pcUsedPelMap, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam)
-#else
-Void TEncAdaptiveLoopFilter::xCalcRDCost(TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam)
-#endif
+{
-  if(pAlfParam != NULL)
+  {
-    m_pcEntropyCoder->resetEntropy();
-    m_pcEntropyCoder->resetBits();
-    m_pcEntropyCoder->encodeAlfParam(pAlfParam);
-    ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
-    if(pvAlfCUCtrlParam != NULL)
+    {
-      for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+      {
-        if(! m_pcPic->getValidSlice(s))
+        {
-          continue;
+        }
-        m_pcEntropyCoder->resetEntropy();
-        m_pcEntropyCoder->resetBits();
-        m_pcEntropyCoder->encodeAlfCtrlParam( (*pvAlfCUCtrlParam)[s], m_uiNumCUsInFrame);
-        ruiRate += m_pcEntropyCoder->getNumberOfWrittenBits();
+      }
+    }
-    else
+    {
-      ruiRate += m_uiNumSlicesInPic;
+    }
+  }
-  else
+  {
-    ruiRate = 1;
+  }
-  ruiDist     = xCalcSSD(pcPicOrg->getLumaAddr(), pcPicCmp->getLumaAddr(), pcPicOrg->getWidth(), pcPicOrg->getHeight(), pcPicOrg->getStride());
-  rdCost      = (Double)(ruiRate) * m_dLambdaLuma + (Double)(ruiDist);
+}
-/** Calculate RD cost for chroma ALF
- * \param pcPicOrg original picture buffer
- * \param pcPicCmp compared picture buffer
- * \param pAlfParam ALF parameters
- * \returns ruiRate bitrate
- * \returns uiDist distortion
- * \returns rdCost RD cost
- */
-Void TEncAdaptiveLoopFilter::xCalcRDCostChroma(TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost)
+{
-  if(pAlfParam->chroma_idc)
+  {
-    ruiRate = xCalcRateChroma(pAlfParam);
+  }
-  ruiDist = 0;
-  ruiDist += xCalcSSD(pcPicOrg->getCbAddr(), pcPicCmp->getCbAddr(), (pcPicOrg->getWidth()>>1), (pcPicOrg->getHeight()>>1), pcPicOrg->getCStride());
-  ruiDist += xCalcSSD(pcPicOrg->getCrAddr(), pcPicCmp->getCrAddr(), (pcPicOrg->getWidth()>>1), (pcPicOrg->getHeight()>>1), pcPicOrg->getCStride());
-  rdCost  = (Double)(ruiRate) * m_dLambdaChroma + (Double)(ruiDist);
+}
-Void TEncAdaptiveLoopFilter::xFilteringFrameChroma(ALFParam* pcAlfParam, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest)
+{
-  Int filtNo = pcAlfParam->filter_shape_chroma;
-  Int *coeff = pcAlfParam->coeff_chroma;
-  Int iChromaFormatShift = 1; //4:2:0
-  if ((pcAlfParam->chroma_idc>>1)&0x01)
+  {
-    if(!m_bUseNonCrossALF)
+    {
-      Int iStride   = pcPicRest->getCStride();
-      Pel* pDec  = pcPicDec->getCbAddr();
-      Pel* pRest = pcPicRest->getCbAddr();
-      filterChroma(pRest, pDec, iStride, 0, (Int)(m_img_height>>1) -1, 0, (Int)(m_img_width>>1)-1, filtNo,  coeff);
+    }
-    else
+    {
-      xFilterChromaSlices(ALF_Cb, pcPicDec, pcPicRest, coeff, filtNo, iChromaFormatShift);
+    }
+  }
-  if ((pcAlfParam->chroma_idc)&0x01)
+  {
-    if(!m_bUseNonCrossALF)
+    {
-      Int iStride   = pcPicRest->getCStride();
-      Pel* pDec  = pcPicDec->getCrAddr();
-      Pel* pRest = pcPicRest->getCrAddr();
-      filterChroma(pRest, pDec, iStride, 0, (Int)(m_img_height>>1) -1, 0, (Int)(m_img_width>>1)-1, filtNo,  coeff);
+    }
-    else
+    {
-      xFilterChromaSlices(ALF_Cr, pcPicDec, pcPicRest, coeff, filtNo, iChromaFormatShift);
+    }
+  }
-  if(pcAlfParam->chroma_idc<3)
+  {
-    if(pcAlfParam->chroma_idc==1)
+    {
-      pcPicDec->copyToPicCb(pcPicRest);
+    }
-    if(pcAlfParam->chroma_idc==2)
+    {
-      pcPicDec->copyToPicCr(pcPicRest);
+    }
+  }
+}
-#endif
-#if LCU_SYNTAX_ALF
 /** Restore the not-filtered pixels
  * \param [in] imgDec picture buffer before filtering
 …
  */
 Void TEncAdaptiveLoopFilter::xCopyDecToRestCUs(Pel* imgDec, Pel* imgRest, Int stride)
-#else
-/** Restore the not-filtered pixels
- * \param pcPicDec picture buffer before filtering
- * \param pcPicRest picture buffer after filtering
- */
-Void TEncAdaptiveLoopFilter::xCopyDecToRestCUs(TComPicYuv* pcPicDec, TComPicYuv* pcPicRest)
-#endif
+{
   if(m_uiNumSlicesInPic > 1)
+  {
-#if LCU_SYNTAX_ALF
     Pel* pPicDecLuma  = imgDec;
     Pel* pPicRestLuma = imgRest;
-#else
-    Pel* pPicDecLuma  = pcPicDec->getLumaAddr();
-    Pel* pPicRestLuma = pcPicRest->getLumaAddr();
-    Int  stride       = pcPicDec->getStride();
-#endif
     UInt SUWidth      = m_pcPic->getMinCUWidth();
     UInt SUHeight     = m_pcPic->getMinCUHeight();
 …
+  {
     TComDataCU* pcCU = m_pcPic->getCU( uiCUAddr );
-#if LCU_SYNTAX_ALF
     xCopyDecToRestCU(pcCU, 0, 0, imgDec, imgRest, stride);
+#else
+    xCopyDecToRestCU(pcCU, 0, 0, pcPicDec, pcPicRest);
+#endif
+  }
+}
+#if LCU_SYNTAX_ALF
+  }
+}
 Void TEncAdaptiveLoopFilter::xCopyDecToRestCU(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Pel* imgDec, Pel* imgRest, Int stride)
-#else
-Void TEncAdaptiveLoopFilter::xCopyDecToRestCU(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest)
-#endif
+{
   Bool bBoundary = false;
 …
       if( ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() ) )
-#if LCU_SYNTAX_ALF
         xCopyDecToRestCU(pcCU, uiAbsPartIdx, uiDepth+1, imgDec, imgRest, stride);
-#else
-        xCopyDecToRestCU(pcCU, uiAbsPartIdx, uiDepth+1, pcPicDec, pcPicRest);
-#endif
+    }
     return;
 …
   if (!pcCU->getAlfCtrlFlag(uiAbsPartIdx))
+  {
-#if !LCU_SYNTAX_ALF
-    UInt uiCUAddr = pcCU->getAddr();
-#endif
     Int iWidth = pcCU->getWidth(uiAbsPartIdx);
     Int iHeight = pcCU->getHeight(uiAbsPartIdx);
-#if LCU_SYNTAX_ALF
     copyPixelsInOneRegion(imgRest, imgDec, stride, (Int)uiTPelY, iHeight, (Int)uiLPelX, iWidth);
-#else
-    Pel* pRec = pcPicDec->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-    Pel* pFilt = pcPicRest->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-    Int iRecStride = pcPicDec->getStride();
-    Int iFiltStride = pcPicRest->getStride();
-    for (Int y = 0; y < iHeight; y++)
+    {
-      for (Int x = 0; x < iWidth; x++)
+      {
-        pFilt[x] = pRec[x];
+      }
-      pRec += iRecStride;
-      pFilt += iFiltStride;
+    }
-#endif
+  }
+}
 …
 Void TEncAdaptiveLoopFilter::predictALFCoeffLumaEnc(ALFParam* pcAlfParam, Int **pfilterCoeffSym, Int filter_shape)
+{
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   Int alfPrecisionBit = getAlfPrecisionBit( m_alfQP );
 #endif
 …
     if((pcAlfParam->predMethod==0)|(ind==0))
+    {
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
       coeffPred = ((1<<alfPrecisionBit)-sum) >> 2;
 #else
 …
     if((pcAlfParam->predMethod==0)|(ind==0))
+    {
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
       coeffPred = (1<<alfPrecisionBit)-sum;
 #else
 …
     *pDepthInt=NULL, kMinTab[MAX_SCAN_VAL], bitsCoeffScan[MAX_SCAN_VAL][MAX_EXP_GOLOMB],
   minKStart, minBitsKStart, bitsKStart;
-#if ALF_SINGLE_FILTER_SHAPE
   Int minScanVal = MIN_SCAN_POS_CROSS;
-#else
-  int minScanVal = (fl==ALF_STAR5x5) ? 0 : MIN_SCAN_POS_CROSS;
-#endif
   pDepthInt = pDepthIntTabShapes[fl];
 …
   // Coding parameters
   //  len += lengthFilterCodingParams(minKStart, maxScanVal, kMinTab, createBitstream);
-#if LCU_SYNTAX_ALF
   if (filters_per_group == 1)
+  {
 …
   else
+  {
-#endif
   len += (3 + maxScanVal);
 …
   len += lengthFilterCoeffs(sqrFiltLength, filters_per_group, pDepthInt, pDiffQFilterCoeffIntPP,
                             kMinTab, createBitstream);
+#if LCU_SYNTAX_ALF
+  }
+#endif
+  }
   return len;
 …
+    {
       scanPos = pDepthInt[i] - 1;
-#if LCU_SYNTAX_ALF
       Int k = (filters_per_group == 1) ? kMinTab[i] : kMinTab[scanPos];
       bit_cnt += lengthGolomb(abs(FilterCoeff[ind][i]), k);
-#else
-      bit_cnt += lengthGolomb(abs(FilterCoeff[ind][i]), kMinTab[scanPos]);
-#endif
+    }
+  }
 …
+}
+#if !LCU_SYNTAX_ALF
+Void   TEncAdaptiveLoopFilter::xEncALFLuma ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiMinRate, UInt64& ruiMinDist, Double& rdMinCost )
+{
+  //pcPicDec: extended decoded
+  //pcPicRest: original decoded: filtered signal will be stored
+  UInt64  uiRate;
+  UInt64  uiDist;
+  Double dCost;
+  Int    LumaStride = pcPicOrg->getStride();
+  Pel* pOrg  = pcPicOrg->getLumaAddr();
+  Pel* pRest = pcPicRest->getLumaAddr();
+  Pel* pDec  = pcPicDec->getLumaAddr();
+  Double    dMinMethodCost  = MAX_DOUBLE;
+  UInt64    uiMinMethodDist = MAX_UINT;
+  UInt64    uiMinMethodRate = MAX_UINT;
+  Int       iBestClassMethod = ALF_RA;
+  Double    adExtraCostReduction[NUM_ALF_CLASS_METHOD];
+  ALFParam  cFrmAlfParam        [NUM_ALF_CLASS_METHOD];
+  ALFParam* pcAlfParam = NULL;
+  for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+  {
+    pcAlfParam = &(cFrmAlfParam[i]);
+    allocALFParam(pcAlfParam);
+    pcAlfParam->alf_flag        = 1;
+    pcAlfParam->chroma_idc      = 0;
+    switch(i)
+    {
+    case ALF_RA:
+      {
+        adExtraCostReduction[i] = (double)(m_img_height * m_img_width) * m_dLambdaLuma * 2.0 / 4096.0;
+      }
+      break;
+    case ALF_BA:
+      {
+        adExtraCostReduction[i] = 0.0;
+      }
+      break;
+    default:
+      {
+        printf("Not a support adaptation method\n");
+        assert(0);
+        exit(-1);
+      }
+    }
+  }
+  for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+  {
+    m_uiVarGenMethod = i;
+    pcAlfParam       = &(cFrmAlfParam[m_uiVarGenMethod]);
+    m_varImg         = m_varImgMethods[m_uiVarGenMethod];
+    pcAlfParam->alf_pcr_region_flag = m_uiVarGenMethod;
+    setInitialMask(pcPicOrg, pcPicDec);
+    if(m_iALFEncodePassReduction == 0)
+    {
+      static Int best_filter_shape = 0;
+      if (m_uiVarGenMethod == 0)
+      {
+        UInt64 MinRate_Shape0 = MAX_INT;
+        UInt64 MinDist_Shape0 = MAX_INT;
+        Double MinCost_Shape0 = MAX_DOUBLE;
+        UInt64 MinRate_Shape1 = MAX_INT;
+        UInt64 MinDist_Shape1 = MAX_INT;
+        Double MinCost_Shape1 = MAX_DOUBLE;
+#if ALF_SINGLE_FILTER_SHAPE
+        Int filter_shape = 0;
+#else
+        for (Int filter_shape = 0; filter_shape < 2 ;filter_shape ++)
+#endif
+        {
+          pcAlfParam->filter_shape = filter_shape;
+          pcAlfParam->num_coeff = m_pcTempAlfParam->num_coeff = m_sqrFiltLengthTab[filter_shape];
+          xFirstFilteringFrameLuma(pOrg, pDec, m_pcPicYuvTmp->getLumaAddr(), pcAlfParam, pcAlfParam->filter_shape, LumaStride);
+          xCalcRDCost(pcPicOrg, m_pcPicYuvTmp, pcAlfParam, uiRate, uiDist, dCost);
+          if (filter_shape == 0)
+          {
+            // copy Shape0
+            MinRate_Shape0 = uiRate;
+            MinDist_Shape0 = uiDist;
+            MinCost_Shape0 = dCost;
+            m_pcPicYuvTmp->copyToPicLuma(pcPicYuvRecShape0);
+            copyALFParam(pcAlfParamShape0, pcAlfParam);
+          }
+          else //if (filter_shape == 1)
+          {
+            // copy Shape1
+            MinRate_Shape1 = uiRate;
+            MinDist_Shape1 = uiDist;
+            MinCost_Shape1  = dCost;
+            m_pcPicYuvTmp->copyToPicLuma(pcPicYuvRecShape1);
+            copyALFParam(pcAlfParamShape1, pcAlfParam);
+          }
+        }
+        if (MinCost_Shape0 <= MinCost_Shape1)
+        {
+          pcPicYuvRecShape0->copyToPicLuma(m_pcPicYuvTmp);
+          copyALFParam(pcAlfParam, pcAlfParamShape0);
+          uiRate = MinRate_Shape0;
+          uiDist = MinDist_Shape0;
+          dCost = MinCost_Shape0;
+          best_filter_shape = 0;
+        }
+        else //if (MinCost_Shape1 < MinCost_Shape0)
+        {
+          pcPicYuvRecShape1->copyToPicLuma(m_pcPicYuvTmp);
+          copyALFParam(pcAlfParam, pcAlfParamShape1);
+          uiRate = MinRate_Shape1;
+          uiDist = MinDist_Shape1;
+          dCost = MinCost_Shape1;
+          best_filter_shape = 1;
+        }
+      }
+      else
+      {
+        pcAlfParam->filter_shape = best_filter_shape;
+        pcAlfParam->num_coeff = m_pcTempAlfParam->num_coeff = m_sqrFiltLengthTab[best_filter_shape];
+        xFirstFilteringFrameLuma(pOrg, pDec, m_pcPicYuvTmp->getLumaAddr(), pcAlfParam, best_filter_shape, LumaStride);
+        xCalcRDCost(pcPicOrg, m_pcPicYuvTmp, pcAlfParam, uiRate, uiDist, dCost);
+      }
+    }
+    else
+    {
+      decideFilterShapeLuma(pOrg, pDec, LumaStride, pcAlfParam, uiRate, uiDist, dCost);
+    }
+    dCost -= adExtraCostReduction[m_uiVarGenMethod];
+    if(dCost < dMinMethodCost)
+    {
+      iBestClassMethod = m_uiVarGenMethod;
+      dMinMethodCost = dCost;
+      uiMinMethodRate= uiRate;
+      uiMinMethodDist = uiDist;
+      if(m_iALFEncodePassReduction == 0)
+      {
+        m_pcPicYuvTmp->copyToPicLuma(pcPicRest);
+      }
+    }
+  }
+  m_uiVarGenMethod = iBestClassMethod;
+  dMinMethodCost += adExtraCostReduction[m_uiVarGenMethod];
+  m_varImg= m_varImgMethods[m_uiVarGenMethod];
+  pcAlfParam = &(cFrmAlfParam[m_uiVarGenMethod]);
+  ALFParam  cAlfParamWithBestMethod;
+  allocALFParam(&cAlfParamWithBestMethod);
+  if(m_iALFEncodePassReduction ==0)
+  {
+    copyALFParam(&cAlfParamWithBestMethod, pcAlfParam);
+  }
+  else
+  {
+    cAlfParamWithBestMethod.alf_flag = 1;
+    cAlfParamWithBestMethod.chroma_idc = 0;
+    cAlfParamWithBestMethod.alf_pcr_region_flag = m_uiVarGenMethod;
+    cAlfParamWithBestMethod.filter_shape= pcAlfParam->filter_shape;
+    cAlfParamWithBestMethod.num_coeff = m_sqrFiltLengthTab[cAlfParamWithBestMethod.filter_shape];
+    decodeFilterSet(pcAlfParam, m_varIndTab, m_filterCoeffSym);
+    if(!m_bUseNonCrossALF)
+    {
+      filterLuma(pRest, pDec, LumaStride, 0, m_img_height-1, 0, m_img_width-1,  pcAlfParam->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+    }
+    else
+    {
+      xfilterSlicesEncoder(pDec, pRest, LumaStride, pcAlfParam->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+    }
+    xcodeFiltCoeff(m_filterCoeffSym, pcAlfParam->filter_shape, m_varIndTab, pcAlfParam->filters_per_group,&cAlfParamWithBestMethod);
+    xCalcRDCost(pcPicOrg, pcPicRest, &cAlfParamWithBestMethod, uiMinMethodRate, uiMinMethodDist, dMinMethodCost);
+  }
+  if(dMinMethodCost < rdMinCost )
+  {
+    ruiMinRate = uiMinMethodRate;
+    ruiMinDist = uiMinMethodDist;
+    rdMinCost =  dMinMethodCost;
+    copyALFParam(m_pcBestAlfParam, &cAlfParamWithBestMethod);
+  }
+  freeALFParam(&cAlfParamWithBestMethod);
+  for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+  {
+    freeALFParam(&cFrmAlfParam[i]);
+  }
+}
+Void   TEncAdaptiveLoopFilter::xFirstFilteringFrameLuma(Pel* imgOrg, Pel* imgDec, Pel* imgRest, ALFParam* ALFp, Int filtNo, Int stride)
+{
+  if(!m_bUseNonCrossALF)
+  {
+    xstoreInBlockMatrix(0, 0, m_img_height, m_img_width, true, true, imgOrg, imgDec, filtNo, stride);
+  }
+  else
+  {
+    xstoreInBlockMatrixforSlices(imgOrg, imgDec, filtNo, stride);
+  }
+  xFilteringFrameLuma(imgOrg, imgDec, imgRest, ALFp, filtNo, stride);
+}
+Void   TEncAdaptiveLoopFilter::xstoreInBlockMatrix(Int ypos, Int xpos, Int iheight, Int iwidth, Bool bResetBlockMatrix, Bool bSymmCopyBlockMatrix, Pel* pImgOrg, Pel* pImgPad, Int filtNo, Int stride)
+{
+  Pel  regionOfInterested = (m_iDesignCurrentFilter ==1)?(1):(0);
+  Int     sqrFiltLength      = (filtNo == 2)?((Int)(MAX_SQR_FILT_LENGTH)):(m_sqrFiltLengthTab[filtNo]);
+  Int     yposEnd            = ypos + iheight -1;
+  Int     xposEnd            = xpos + iwidth  -1;
+  Double ***EShape           = m_EGlobalSym[filtNo];
+  Double **yShape            = m_yGlobalSym[filtNo];
+  Int ELocal[MAX_SQR_FILT_LENGTH];
+  Pel *pImgPad1, *pImgPad2, *pImgPad3, *pImgPad4;
+  Int i,j,k,l,varInd, yLocal;
+  double **E,*yy;
+  static Int numValidPels;
+  if(bResetBlockMatrix)
+  {
+    numValidPels = 0;
+    memset( m_pixAcc, 0,sizeof(double)*NO_VAR_BINS);
+    for (varInd=0; varInd<NO_VAR_BINS; varInd++)
+    {
+      memset(yShape[varInd],0,sizeof(double)*MAX_SQR_FILT_LENGTH);
+      for (k=0; k<sqrFiltLength; k++)
+      {
+        memset(EShape[varInd][k],0,sizeof(double)*MAX_SQR_FILT_LENGTH);
+      }
+    }
+    for (i = 0; i < m_img_height; i++)
+    {
+      for (j = 0; j < m_img_width; j++)
+      {
+        if (m_maskImg[i][j] == regionOfInterested)
+        {
+          numValidPels++;
+        }
+      }
+    }
+  }
+  Int yLineInLCU;
+  Int paddingLine ;
+  pImgPad += (ypos* stride);
+  pImgOrg += (ypos* stride);
+  switch(filtNo)
+  {
+#if !ALF_SINGLE_FILTER_SHAPE
+  case ALF_STAR5x5:
+    {
+      for (i= ypos; i<= yposEnd; i++)
+      {
+        yLineInLCU = i % m_lcuHeight;
+        if (yLineInLCU < m_lineIdxPadBot || i-yLineInLCU+m_lcuHeight >= m_img_height )
+        {
+          pImgPad1 = pImgPad +   stride;
+          pImgPad2 = pImgPad -   stride;
+          pImgPad3 = pImgPad + 2*stride;
+          pImgPad4 = pImgPad - 2*stride;
+        }
+        else if (yLineInLCU < m_lineIdxPadTop)
+        {
+          paddingLine = - yLineInLCU + m_lineIdxPadTop - 1;
+          pImgPad1 = pImgPad + min(paddingLine, 1)*stride;
+          pImgPad2 = pImgPad -   stride;
+          pImgPad3 = pImgPad + min(paddingLine, 2)*stride;
+          pImgPad4 = pImgPad - 2*stride;
+        }
+        else
+        {
+          paddingLine = yLineInLCU - m_lineIdxPadTop;
+          pImgPad1 = pImgPad +   stride;
+          pImgPad2 = pImgPad - min(paddingLine, 1)*stride;
+          pImgPad3 = pImgPad + 2*stride;
+          pImgPad4 = pImgPad - min(paddingLine, 2)*stride;
+        }
+        if ( (yLineInLCU == m_lineIdxPadTop || yLineInLCU == m_lineIdxPadTop-1) && i-yLineInLCU+m_lcuHeight < m_img_height )
+        {
+          pImgPad+= stride;
+          pImgOrg+= stride;
+          continue;
+        }
+        else
+        {
+        for (j= xpos; j<= xposEnd; j++)
+        {
+          if ( (m_maskImg[i][j] == regionOfInterested) || (numValidPels == 0) )
+          {
+            varInd = m_varImg[i/VAR_SIZE_H][j/VAR_SIZE_W];
+            memset(ELocal, 0, 10*sizeof(Int));
+            ELocal[0] = (pImgPad3[j+2] + pImgPad4[j-2]);
+            ELocal[1] = (pImgPad3[j  ] + pImgPad4[j  ]);
+            ELocal[2] = (pImgPad3[j-2] + pImgPad4[j+2]);
+            ELocal[3] = (pImgPad1[j+1] + pImgPad2[j-1]);
+            ELocal[4] = (pImgPad1[j  ] + pImgPad2[j  ]);
+            ELocal[5] = (pImgPad1[j-1] + pImgPad2[j+1]);
+            ELocal[6] = (pImgPad[j+2] + pImgPad[j-2]);
+            ELocal[7] = (pImgPad[j+1] + pImgPad[j-1]);
+            ELocal[8] = (pImgPad[j  ]);
+            yLocal= pImgOrg[j];
+            m_pixAcc[varInd]+=(yLocal*yLocal);
+            E= EShape[varInd];
+            yy= yShape[varInd];
+            for (k=0; k<10; k++)
+            {
+              for (l=k; l<10; l++)
+              {
+                E[k][l]+=(double)(ELocal[k]*ELocal[l]);
+              }
+              yy[k]+=(double)(ELocal[k]*yLocal);
+            }
+          }
+        }
+        pImgPad+= stride;
+        pImgOrg+= stride;
+        }
+      }
+    }
+    break;
+  case ALF_CROSS9x9:
+    {
+      Pel *pImgPad5, *pImgPad6, *pImgPad7, *pImgPad8;
+#else
+  case ALF_CROSS9x7_SQUARE3x3:
+    {
+      Pel *pImgPad5, *pImgPad6;
+#endif
+      for (i= ypos; i<= yposEnd; i++)
+      {
+        yLineInLCU = i % m_lcuHeight;
+        if (yLineInLCU<m_lineIdxPadBot || i-yLineInLCU+m_lcuHeight >= m_img_height)
+        {
+          pImgPad1 = pImgPad +   stride;
+          pImgPad2 = pImgPad -   stride;
+          pImgPad3 = pImgPad + 2*stride;
+          pImgPad4 = pImgPad - 2*stride;
+          pImgPad5 = pImgPad + 3*stride;
+          pImgPad6 = pImgPad - 3*stride;
+#if !ALF_SINGLE_FILTER_SHAPE
+          pImgPad7 = pImgPad + 4*stride;
+          pImgPad8 = pImgPad - 4*stride;
+#endif
+        }
+        else if (yLineInLCU<m_lineIdxPadTop)
+        {
+          paddingLine = - yLineInLCU + m_lineIdxPadTop - 1;
+          pImgPad1 = (paddingLine < 1) ? pImgPad : pImgPad + min(paddingLine, 1)*stride;
+          pImgPad2 = (paddingLine < 1) ? pImgPad : pImgPad -   stride;
+          pImgPad3 = (paddingLine < 2) ? pImgPad : pImgPad + min(paddingLine, 2)*stride;
+          pImgPad4 = (paddingLine < 2) ? pImgPad : pImgPad - 2*stride;
+          pImgPad5 = (paddingLine < 3) ? pImgPad : pImgPad + min(paddingLine, 3)*stride;
+          pImgPad6 = (paddingLine < 3) ? pImgPad : pImgPad - 3*stride;
+#if !ALF_SINGLE_FILTER_SHAPE
+          pImgPad7 = (paddingLine < 4) ? pImgPad : pImgPad + min(paddingLine, 4)*stride;
+          pImgPad8 = (paddingLine < 4) ? pImgPad : pImgPad - 4*stride;
+#endif
+        }
+        else
+        {
+          paddingLine = yLineInLCU - m_lineIdxPadTop;
+          pImgPad1 = (paddingLine < 1) ? pImgPad : pImgPad +   stride;
+          pImgPad2 = (paddingLine < 1) ? pImgPad : pImgPad - min(paddingLine, 1)*stride;
+          pImgPad3 = (paddingLine < 2) ? pImgPad : pImgPad + 2*stride;
+          pImgPad4 = (paddingLine < 2) ? pImgPad : pImgPad - min(paddingLine, 2)*stride;
+          pImgPad5 = (paddingLine < 3) ? pImgPad : pImgPad + 3*stride;
+          pImgPad6 = (paddingLine < 3) ? pImgPad : pImgPad - min(paddingLine, 3)*stride;
+#if !ALF_SINGLE_FILTER_SHAPE
+          pImgPad7 = (paddingLine < 4) ? pImgPad : pImgPad + 4*stride;
+          pImgPad8 = (paddingLine < 4) ? pImgPad : pImgPad - min(paddingLine, 4)*stride;
+#endif
+        }
+        for (j= xpos; j<= xposEnd; j++)
+        {
+          if ( (m_maskImg[i][j] == regionOfInterested) || (numValidPels == 0) )
+          {
+            varInd = m_varImg[i/VAR_SIZE_H][j/VAR_SIZE_W];
+#if ALF_SINGLE_FILTER_SHAPE
+            memset(ELocal, 0, (sqrFiltLength+1)*sizeof(Int));
+            ELocal[0] = (pImgPad5[j]+pImgPad6[j]);
+            ELocal[1] = (pImgPad3[j]+pImgPad4[j]);
+            ELocal[2] = (pImgPad1[j-1]+pImgPad2[j+1]);
+            ELocal[3] = (pImgPad1[j]+pImgPad2[j]);
+            ELocal[4] = (pImgPad1[j+1]+pImgPad2[j-1]);
+            ELocal[5] = (pImgPad[j+4]+pImgPad[j-4]);
+            ELocal[6] = (pImgPad[j+3]+pImgPad[j-3]);
+            ELocal[7] = (pImgPad[j+2]+pImgPad[j-2]);
+            ELocal[8] = (pImgPad[j+1]+pImgPad[j-1]);
+            ELocal[9] = (pImgPad[j  ]);
+#else
+            memset(ELocal, 0, 10*sizeof(Int));
+            ELocal[0] = (pImgPad7[j] + pImgPad8[j]);
+            ELocal[1] = (pImgPad5[j] + pImgPad6[j]);
+            ELocal[2] = (pImgPad3[j] + pImgPad4[j]);
+            ELocal[3] = (pImgPad1[j] + pImgPad2[j]);
+            ELocal[4] = (pImgPad[j+4] + pImgPad[j-4]);
+            ELocal[5] = (pImgPad[j+3] + pImgPad[j-3]);
+            ELocal[6] = (pImgPad[j+2] + pImgPad[j-2]);
+            ELocal[7] = (pImgPad[j+1] + pImgPad[j-1]);
+            ELocal[8] = (pImgPad[j  ] );
+#endif
+            yLocal= pImgOrg[j];
+            m_pixAcc[varInd]+=(yLocal*yLocal);
+            E= EShape[varInd];
+            yy= yShape[varInd];
+#if ALF_SINGLE_FILTER_SHAPE
+            for (k=0; k<(sqrFiltLength+1); k++)
+            {
+              for (l=k; l<(sqrFiltLength+1); l++)
+              {
+                E[k][l]+=(double)(ELocal[k]*ELocal[l]);
+              }
+              yy[k]+=(double)(ELocal[k]*yLocal);
+            }
+#else
+            for (k=0; k<10; k++)
+            {
+              for (l=k; l<10; l++)
+              {
+                E[k][l]+=(double)(ELocal[k]*ELocal[l]);
+              }
+              yy[k]+=(double)(ELocal[k]*yLocal);
+            }
+#endif
+          }
+        }
+        pImgPad+= stride;
+        pImgOrg+= stride;
+      }
+    }
+    break;
+  default:
+    {
+      printf("Not a supported filter shape\n");
+      assert(0);
+      exit(1);
+    }
+  }
+  if(bSymmCopyBlockMatrix)
+  {
+    for (varInd=0; varInd<NO_VAR_BINS; varInd++)
+    {
+      double **pE = EShape[varInd];
+      for (k=1; k<sqrFiltLength; k++)
+      {
+        for (l=0; l<k; l++)
+        {
+          pE[k][l]=pE[l][k];
+        }
+      }
+    }
+  }
+}
+Void   TEncAdaptiveLoopFilter::xFilteringFrameLuma(Pel* imgOrg, Pel* imgPad, Pel* imgFilt, ALFParam* ALFp, Int filtNo, Int stride)
+{
+  static double **ySym, ***ESym;
+  Int  filters_per_fr;
+  Int lambdaVal = (Int) m_dLambdaLuma;
+  lambdaVal = lambdaVal * (1<<(2*g_uiBitIncrement));
+  ESym=m_EGlobalSym[filtNo];
+  ySym=m_yGlobalSym[filtNo];
+  xfindBestFilterVarPred(ySym, ESym, m_pixAcc, m_filterCoeffSym, m_filterCoeffSymQuant, filtNo, &filters_per_fr,m_varIndTab, NULL, m_varImg, m_maskImg, NULL, lambdaVal);
+  if(!m_bUseNonCrossALF)
+  {
+    filterLuma(imgFilt, imgPad, stride, 0, m_img_height-1, 0, m_img_width-1,  ALFp->filter_shape, m_filterCoeffSym, m_varIndTab, m_varImg);
+  }
+  else
+  {
+    xfilterSlicesEncoder(imgPad, imgFilt, stride, filtNo, m_filterCoeffSym, m_varIndTab, m_varImg);
+  }
+  xcodeFiltCoeff(m_filterCoeffSymQuant, filtNo, m_varIndTab, filters_per_fr,ALFp);
+}
+#endif
+#if LCU_SYNTAX_ALF
 Void TEncAdaptiveLoopFilter::xfindBestFilterVarPred(double **ySym, double ***ESym, double *pixAcc, Int **filterCoeffSym, Int **filterCoeffSymQuant, Int filter_shape, Int *filters_per_fr_best, Int varIndTab[], Pel **imgY_rec, Pel **varImg, Pel **maskImg, Pel **imgY_pad, double lambda_val, Int numMaxFilters)
-#else
-Void TEncAdaptiveLoopFilter::xfindBestFilterVarPred(double **ySym, double ***ESym, double *pixAcc, Int **filterCoeffSym, Int **filterCoeffSymQuant, Int filter_shape, Int *filters_per_fr_best, Int varIndTab[], Pel **imgY_rec, Pel **varImg, Pel **maskImg, Pel **imgY_pad, double lambda_val)
-#endif
+{
   Int filters_per_fr, firstFilt, interval[NO_VAR_BINS][2], intervalBest[NO_VAR_BINS][2];
 …
     lagrangian=xfindBestCoeffCodMethod(filterCoeffSymQuant, filter_shape, sqrFiltLength, filters_per_fr, errorForce0CoeffTab, lambda_val);
-#if LCU_SYNTAX_ALF
     if (lagrangian<lagrangianMin || firstFilt==1 || filters_per_fr == numMaxFilters)
-#else
-    if (lagrangian<lagrangianMin || firstFilt==1 || filters_per_fr == m_iALFMaxNumberFilters)
-#endif
+    {
       firstFilt=0;
 …
     filters_per_fr--;
+  }
-#if !ALF_16_BA_GROUPS
-  if ( (m_uiVarGenMethod == ALF_BA) && ((*filters_per_fr_best) > 1) )
+  {
-    Int iLastFilter = (*filters_per_fr_best)-1;
-    if (intervalBest[iLastFilter][0] == NO_VAR_BINS-1)
+    {
-      intervalBest[iLastFilter-1][1] = NO_VAR_BINS-1;
-      (*filters_per_fr_best) = iLastFilter;
+    }
+  }
-#endif
   findFilterCoeff(ESym, ySym, pixAcc, filterCoeffSym, filterCoeffSymQuant, intervalBest,
     varIndTab, sqrFiltLength, (*filters_per_fr_best), weights, errorForce0CoeffTab);
 …
  * \param [in,out]vAlfCUCtrlParam ALF CU control parameters
  */
-#if LCU_SYNTAX_ALF
 #if HHI_INTERVIEW_SKIP
 Void TEncAdaptiveLoopFilter::setCUAlfCtrlFlags(UInt uiAlfCtrlDepth, Pel* imgOrg, Pel* imgDec, Pel* imgRest, Pel* imgUsed, Int stride, UInt64& ruiDist, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam)
 …
 Void TEncAdaptiveLoopFilter::setCUAlfCtrlFlags(UInt uiAlfCtrlDepth, Pel* imgOrg, Pel* imgDec, Pel* imgRest, Int stride, UInt64& ruiDist, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam)
 #endif
-#else
-#if HHI_INTERVIEW_SKIP
-Void TEncAdaptiveLoopFilter::xSetCUAlfCtrlFlags_qc(UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, TComPicYuv* pUsedPelMap, UInt64& ruiDist, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam)
-#else
-Void TEncAdaptiveLoopFilter::xSetCUAlfCtrlFlags_qc(UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam)
-#endif
-#endif
+{
   ruiDist = 0;
 …
+  {
     TComDataCU* pcCU = m_pcPic->getCU( CUAddr );
-#if LCU_SYNTAX_ALF
 #if HHI_INTERVIEW_SKIP
     setCUAlfCtrlFlag(pcCU, 0, 0, uiAlfCtrlDepth, imgOrg, imgDec, imgRest, imgUsed, stride, ruiDist, vAlfCUCtrlParam[0].alf_cu_flag);
 #else
     setCUAlfCtrlFlag(pcCU, 0, 0, uiAlfCtrlDepth, imgOrg, imgDec, imgRest, stride, ruiDist, vAlfCUCtrlParam[0].alf_cu_flag);
-#endif
-#else
-#if HHI_INTERVIEW_SKIP
-    xSetCUAlfCtrlFlag_qc(pcCU, 0, 0, uiAlfCtrlDepth, pcPicOrg, pcPicDec, pcPicRest,imgUsed, ruiDist, vAlfCUCtrlParam[0].alf_cu_flag);
-#else
-    xSetCUAlfCtrlFlag_qc(pcCU, 0, 0, uiAlfCtrlDepth, pcPicOrg, pcPicDec, pcPicRest, ruiDist, vAlfCUCtrlParam[0].alf_cu_flag);
-#endif
 #endif
+  }
 …
+}
-#if LCU_SYNTAX_ALF
 #if HHI_INTERVIEW_SKIP
 Void TEncAdaptiveLoopFilter::setCUAlfCtrlFlag(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiAlfCtrlDepth, Pel* imgOrg, Pel* imgDec, Pel* imgRest, Pel* imgUsed, Int stride, UInt64& ruiDist, std::vector<UInt>& vCUCtrlFlag)
 #else
 Void TEncAdaptiveLoopFilter::setCUAlfCtrlFlag(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiAlfCtrlDepth, Pel* imgOrg, Pel* imgDec, Pel* imgRest, Int stride, UInt64& ruiDist, std::vector<UInt>& vCUCtrlFlag)
-#endif
-#else
-#if HHI_INTERVIEW_SKIP
-Void TEncAdaptiveLoopFilter::xSetCUAlfCtrlFlag_qc(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, TComPicYuv* pcUsedPelMap, UInt64& ruiDist, std::vector<UInt>& vCUCtrlFlag)
-#else
-Void TEncAdaptiveLoopFilter::xSetCUAlfCtrlFlag_qc(TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, std::vector<UInt>& vCUCtrlFlag)
-#endif
 #endif
+{
 …
       if( ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() ) )
-#if LCU_SYNTAX_ALF
 #if HHI_INTERVIEW_SKIP
         setCUAlfCtrlFlag(pcCU, uiAbsPartIdx, uiDepth+1, uiAlfCtrlDepth, imgOrg, imgDec, imgRest, imgUsed, stride, ruiDist, vCUCtrlFlag);
 …
         setCUAlfCtrlFlag(pcCU, uiAbsPartIdx, uiDepth+1, uiAlfCtrlDepth, imgOrg, imgDec, imgRest, stride, ruiDist, vCUCtrlFlag);
 #endif
-#else
-#if HHI_INTERVIEW_SKIP
-        xSetCUAlfCtrlFlag_qc(pcCU, uiAbsPartIdx, uiDepth+1, uiAlfCtrlDepth, pcPicOrg, pcPicDec, pcPicRest, imgUsed, ruiDist, vCUCtrlFlag);
-#else
-        xSetCUAlfCtrlFlag_qc(pcCU, uiAbsPartIdx, uiDepth+1, uiAlfCtrlDepth, pcPicOrg, pcPicDec, pcPicRest, ruiDist, vCUCtrlFlag);
-#endif
-#endif
+    }
     return;
 …
     return;
+  }
-#if !LCU_SYNTAX_ALF
-  UInt uiCUAddr = pcCU->getAddr();
-#endif
   UInt64 uiRecSSD = 0;
   UInt64 uiFiltSSD = 0;
 …
+  }
-#if LCU_SYNTAX_ALF
   Int  offset = uiTPelY*stride + uiLPelX;
   Pel* pOrg  = imgOrg  + offset;
 …
   uiFiltSSD += xCalcSSD( pOrg, pFilt, iWidth, iHeight, stride );
 #endif
-#else
-  Pel* pOrg = pcPicOrg->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-  Pel* pRec = pcPicDec->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-  Pel* pFilt = pcPicRest->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-#if HHI_INTERVIEW_SKIP
-  Pel* pUsed = pcUsedPelMap->getLumaAddr(uiCUAddr, uiAbsPartIdx);
-  uiRecSSD  += xCalcSSD( pOrg, pRec, pUsed, iWidth, iHeight, pcPicOrg->getStride() );
-  uiFiltSSD += xCalcSSD( pOrg, pFilt, pUsed, iWidth, iHeight, pcPicOrg->getStride() );
-#else
-  uiRecSSD  += xCalcSSD( pOrg, pRec,  iWidth, iHeight, pcPicOrg->getStride() );
-  uiFiltSSD += xCalcSSD( pOrg, pFilt, iWidth, iHeight, pcPicOrg->getStride() );
-#endif
-#endif
   if (uiFiltSSD < uiRecSSD)
+  {
 …
     vCUCtrlFlag.push_back(1);
-#if LCU_SYNTAX_ALF
     for (int i=uiTPelY ;i<=min(uiBPelY,(unsigned int)(m_img_height-1))  ;i++)
+    {
       for (int j=uiLPelX ;j<=min(uiRPelX,(unsigned int)(m_img_width-1)) ;j++)
+      {
-#else
-    for (int i=uiTPelY ;i<=min(uiBPelY,(unsigned int)(pcPicOrg->getHeight()-1))  ;i++)
+    {
-      for (int j=uiLPelX ;j<=min(uiRPelX,(unsigned int)(pcPicOrg->getWidth()-1)) ;j++)
+      {
-#endif
         m_maskImg[i][j]=1;
+      }
 …
     pcCU->setAlfCtrlFlagSubParts(0, uiAbsPartIdx, uiSetDepth);
     vCUCtrlFlag.push_back(0);
-#if LCU_SYNTAX_ALF
     for (int i=uiTPelY ;i<=min(uiBPelY,(unsigned int)(m_img_height-1))  ;i++)
+    {
       for (int j=uiLPelX ;j<=min(uiRPelX,(unsigned int)(m_img_width-1)) ;j++)
+      {
-#else
-    for (int i=uiTPelY ;i<=min(uiBPelY,(unsigned int)(pcPicOrg->getHeight()-1))  ;i++)
+    {
-      for (int j=uiLPelX ;j<=min(uiRPelX,(unsigned int)(pcPicOrg->getWidth()-1)) ;j++)
+      {
-#endif
         m_maskImg[i][j]=0;
+      }
 …
+}
-#if !LCU_SYNTAX_ALF
-Void TEncAdaptiveLoopFilter::xReDesignFilterCoeff_qc(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, Bool bReadCorr)
+{
-  Int tap = m_pcTempAlfParam->filter_shape;
-  Int    LumaStride = pcPicOrg->getStride();
-  Pel* pOrg  = pcPicOrg->getLumaAddr();
-  Pel* pDec  = pcPicDec->getLumaAddr();
-  Pel* pRest = pcPicRest->getLumaAddr();
-  xFirstFilteringFrameLuma(pOrg, pDec, pRest, m_pcTempAlfParam, tap, LumaStride);
-  if (m_iALFEncodePassReduction)
+  {
-    if(!m_iUsePreviousFilter)
+    {
-      saveFilterCoeffToBuffer(m_filterCoeffSym, m_pcTempAlfParam->filters_per_group, m_varIndTab, m_pcTempAlfParam->alf_pcr_region_flag, tap);
+    }
+  }
+}
-Void TEncAdaptiveLoopFilter::xCUAdaptiveControl_qc(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiMinRate, UInt64& ruiMinDist, Double& rdMinCost)
+{
-  if(!m_bAlfCUCtrlEnabled) return;
-  Bool bChanged = false;
-  std::vector<AlfCUCtrlInfo> vAlfCUCtrlParamTemp(m_vBestAlfCUCtrlParam);
-  Pel** maskImgTemp;
-  if(m_iALFEncodePassReduction == 2)
+  {
-    initMatrix_Pel(&maskImgTemp, m_img_height, m_img_width);
+  }
-  m_pcEntropyCoder->setAlfCtrl(true);
-  UInt uiBestDepth = 0;
-  ALFParam cFrmAlfParam;
-  allocALFParam(&cFrmAlfParam);
-  copyALFParam(&cFrmAlfParam, m_pcBestAlfParam);
-  for (UInt uiDepth = 0; uiDepth < g_uiMaxCUDepth; uiDepth++)
+  {
-    m_pcEntropyCoder->setMaxAlfCtrlDepth(uiDepth);
-    pcPicRest->copyToPicLuma(m_pcPicYuvTmp);
-    copyALFParam(m_pcTempAlfParam, &cFrmAlfParam);
-    for (UInt uiRD = 0; uiRD <= m_iALFNumOfRedesign; uiRD++)
+    {
-      if (uiRD)
+      {
-        // re-design filter coefficients
-        xReDesignFilterCoeff_qc(pcPicOrg, pcPicDec, m_pcPicYuvTmp, true); //use filtering of mine
+      }
-      UInt64 uiRate, uiDist;
-      Double dCost;
-     //m_pcPicYuvTmp: filtered signal, pcPicDec: orig reconst
-      xSetCUAlfCtrlFlags_qc(uiDepth, pcPicOrg, pcPicDec, m_pcPicYuvTmp, uiDist, vAlfCUCtrlParamTemp);
-      xCalcRDCost(m_pcTempAlfParam, uiRate, uiDist, dCost, &vAlfCUCtrlParamTemp);
-      if (dCost < rdMinCost)
+      {
-        bChanged = true;
-        m_vBestAlfCUCtrlParam = vAlfCUCtrlParamTemp;
-        uiBestDepth = uiDepth;
-        rdMinCost = dCost;
-        ruiMinDist = uiDist;
-        ruiMinRate = uiRate;
-        m_pcPicYuvTmp->copyToPicLuma(m_pcPicYuvBest);
-        copyALFParam(m_pcBestAlfParam, m_pcTempAlfParam);
-        //save maskImg
-        xCopyTmpAlfCtrlFlagsFrom();
-        if(m_iALFEncodePassReduction == 2)
+        {
-          ::memcpy(maskImgTemp[0], m_maskImg[0], sizeof(Pel)*m_img_height* m_img_width);
+        }
+      }
+    }
+  }
-  if(bChanged)
+  {
-    if(m_iALFEncodePassReduction == 2)
+    {
-      UInt uiDepth = uiBestDepth;
-      ::memcpy(m_maskImg[0], maskImgTemp[0], sizeof(Pel)*m_img_height* m_img_width);
-      xCopyTmpAlfCtrlFlagsTo();
-      copyALFParam(&cFrmAlfParam, m_pcBestAlfParam);
-      m_pcEntropyCoder->setAlfCtrl(true);
-      m_pcEntropyCoder->setMaxAlfCtrlDepth(uiDepth);
-      copyALFParam(m_pcTempAlfParam, &cFrmAlfParam);
-      xReDesignFilterCoeff_qc(pcPicOrg, pcPicDec, m_pcPicYuvTmp, true); //use filtering of mine
-      UInt64 uiRate, uiDist;
-      Double dCost;
-      xSetCUAlfCtrlFlags_qc(uiDepth, pcPicOrg, pcPicDec, m_pcPicYuvTmp, uiDist, vAlfCUCtrlParamTemp);
-      xCalcRDCost(m_pcTempAlfParam, uiRate, uiDist, dCost, &vAlfCUCtrlParamTemp);
-      if (dCost < rdMinCost)
+      {
-        rdMinCost = dCost;
-        ruiMinDist = uiDist;
-        ruiMinRate = uiRate;
-        m_pcPicYuvTmp->copyToPicLuma(m_pcPicYuvBest);
-        copyALFParam(m_pcBestAlfParam, m_pcTempAlfParam);
-        xCopyTmpAlfCtrlFlagsFrom();
-        m_vBestAlfCUCtrlParam = vAlfCUCtrlParamTemp;
+      }
+    }
-    m_pcEntropyCoder->setAlfCtrl(true);
-    m_pcEntropyCoder->setMaxAlfCtrlDepth(uiBestDepth);
-    xCopyTmpAlfCtrlFlagsTo();
-    m_pcPicYuvBest->copyToPicLuma(pcPicRest);//copy m_pcPicYuvBest to pcPicRest
-    xCopyDecToRestCUs(pcPicDec, pcPicRest); //pcPicRest = pcPicDec
+  }
-  else
+  {
-    m_pcEntropyCoder->setAlfCtrl(false);
-    m_pcEntropyCoder->setMaxAlfCtrlDepth(0);
+  }
-  freeALFParam(&cFrmAlfParam);
-  if(m_iALFEncodePassReduction == 2)
+  {
-    destroyMatrix_Pel(maskImgTemp);
+  }
+}
-#endif
 #define ROUND(a)  (((a) < 0)? (int)((a) - 0.5) : (int)((a) + 0.5))
 …
+{
   double error;
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   Int factor = (1<<(getAlfPrecisionBit(m_alfQP)));
 #else
 …
+}
-#if !LCU_SYNTAX_ALF
-/** Save redesigned filter set to buffer
- * \param filterCoeffPrevSelected filter set buffer
- */
-Void TEncAdaptiveLoopFilter::saveFilterCoeffToBuffer(Int **filterSet, Int numFilter, Int* mergeTable, Int mode, Int filtNo)
+{
-  Int iBufferIndex = m_iCurrentPOC % m_iGOPSize;
-  static Bool bFirst = true;
-  static Bool* pbFirstAccess;
-  if(bFirst)
+  {
-    pbFirstAccess = new Bool[NUM_ALF_CLASS_METHOD];
-    for(Int i=0; i< NUM_ALF_CLASS_METHOD; i++)
+    {
-      pbFirstAccess[i]= true;
+    }
-    bFirst = false;
+  }
-  if(iBufferIndex == 0)
+  {
-    if(pbFirstAccess[mode])
+    {
-      //store merge table
-      ::memcpy(m_mergeTableSavedMethods[mode][m_iGOPSize], mergeTable, sizeof(Int)*NO_VAR_BINS);
-      //store coefficients
-      for(Int varInd=0; varInd< numFilter; varInd++)
+      {
-        ::memcpy(m_aiFilterCoeffSavedMethods[mode][m_iGOPSize][varInd],filterSet[varInd], sizeof(Int)*ALF_MAX_NUM_COEF );
+      }
-      //store filter shape
-      m_iPreviousFilterShapeMethods[mode][m_iGOPSize]= filtNo;
-      pbFirstAccess[mode] = false;
+    }
-    //store merge table
-    ::memcpy(m_mergeTableSavedMethods[mode][0         ], m_mergeTableSavedMethods[mode][m_iGOPSize], sizeof(Int)*NO_VAR_BINS);
-    ::memcpy(m_mergeTableSavedMethods[mode][m_iGOPSize], mergeTable,                          sizeof(Int)*NO_VAR_BINS);
-    //store coefficients
-    for(Int varInd=0; varInd< NO_VAR_BINS; varInd++)
+    {
-      ::memcpy(m_aiFilterCoeffSavedMethods[mode][0][varInd],m_aiFilterCoeffSavedMethods[mode][m_iGOPSize][varInd], sizeof(Int)*ALF_MAX_NUM_COEF );
+    }
-    for(Int varInd=0; varInd< numFilter; varInd++)
+    {
-      ::memcpy(m_aiFilterCoeffSavedMethods[mode][m_iGOPSize][varInd],filterSet[varInd], sizeof(Int)*ALF_MAX_NUM_COEF );
+    }
-    //store filter shape
-    m_iPreviousFilterShapeMethods[mode][0]= m_iPreviousFilterShapeMethods[mode][m_iGOPSize];
-    m_iPreviousFilterShapeMethods[mode][m_iGOPSize]= filtNo;
+  }
-  else
+  {
-    //store merge table
-    ::memcpy(m_mergeTableSavedMethods[mode][iBufferIndex], mergeTable, sizeof(Int)*NO_VAR_BINS);
-    //store coefficients
-    for(Int varInd=0; varInd< numFilter; varInd++)
+    {
-      ::memcpy(m_aiFilterCoeffSavedMethods[mode][iBufferIndex][varInd],filterSet[varInd], sizeof(Int)*ALF_MAX_NUM_COEF );
+    }
-    //store filter_shape
-    m_iPreviousFilterShapeMethods[mode][iBufferIndex]= filtNo;
+  }
+}
-/** set initial m_maskImg with previous (time-delayed) filters
- * \param pcPicOrg original picture
- * \param pcPicDec reconstructed picture after deblocking
- */
-Void TEncAdaptiveLoopFilter::setMaskWithTimeDelayedResults(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec)
+{
-  static Pel** bestImgMask;
-  static Bool bFirst = true;
-  if(bFirst)
+  {
-    initMatrix_Pel(&bestImgMask, m_img_height, m_img_width);
-    bFirst = false;
+  }
-  Pel*    pDec       = pcPicDec->getLumaAddr();
-  Pel*    pOrg       = pcPicOrg->getLumaAddr();
-  Pel*    pRest      = m_pcPicYuvTmp->getLumaAddr();
-  Int     LumaStride = pcPicOrg->getStride();
-  Int***   pppCoeffSaved     = m_aiFilterCoeffSavedMethods  [m_uiVarGenMethod];
-  Int**    ppMergeTableSaved = m_mergeTableSavedMethods     [m_uiVarGenMethod];
-  Int*     pFilterShapeSaved = m_iPreviousFilterShapeMethods[m_uiVarGenMethod];
-  Int      iBufIdx;
-  UInt64    uiRate, uiDist;
-  Double    dCost, dMinCost = MAX_DOUBLE;
-  ALFParam  cAlfParam;
-  allocALFParam(&cAlfParam);
-  cAlfParam.alf_flag        = 0;
-  cAlfParam.chroma_idc      = 0;
-  //filter frame with the previous time-delayed filters
-  Int filtNo;
-  Int maxDepth = (pcPicOrg->getWidth() < 1000) ?(2):(g_uiMaxCUDepth);
-  m_pcEntropyCoder->setAlfCtrl(true);
-  m_pcTempAlfParam->alf_flag = 1;
-  m_pcTempAlfParam->alf_pcr_region_flag = m_uiVarGenMethod;
-  for (Int index=0; index<2; index++)
+  {
-    iBufIdx = setFilterIdx(index);
-    filtNo = m_pcTempAlfParam->filter_shape = pFilterShapeSaved[iBufIdx];
-#if ALF_SINGLE_FILTER_SHAPE
-    assert(filtNo == ALF_CROSS9x7_SQUARE3x3);
-#else
-    assert(filtNo == ALF_STAR5x5 || filtNo == ALF_CROSS9x9);
-#endif
-    m_pcTempAlfParam->num_coeff = m_sqrFiltLengthTab[filtNo];
-    if(!m_bUseNonCrossALF)
+    {
-      filterLuma(pRest, pDec, LumaStride, 0, m_img_height-1, 0, m_img_width-1,  filtNo, pppCoeffSaved[iBufIdx], ppMergeTableSaved[iBufIdx], m_varImg);
+    }
-    else
+    {
-      xfilterSlicesEncoder(pDec, pRest, LumaStride, filtNo, pppCoeffSaved[iBufIdx], ppMergeTableSaved[iBufIdx], m_varImg);
+    }
-    for (UInt uiDepth = 0; uiDepth < maxDepth; uiDepth++)
+    {
-      m_pcEntropyCoder->setMaxAlfCtrlDepth(uiDepth);
-      std::vector<AlfCUCtrlInfo> vAlfCUCtrlParamTemp(m_uiNumSlicesInPic);
-      xSetCUAlfCtrlFlags_qc(uiDepth, pcPicOrg, pcPicDec, m_pcPicYuvTmp, uiDist, vAlfCUCtrlParamTemp);
-      m_pcEntropyCoder->resetEntropy();
-      m_pcEntropyCoder->resetBits();
-      xEncodeCUAlfCtrlFlags(vAlfCUCtrlParamTemp);
-      uiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
-      dCost  = (Double)(uiRate) * m_dLambdaLuma + (Double)(uiDist);
-      if (dCost < dMinCost)
+      {
-        dMinCost    = dCost;
-        copyALFParam(&cAlfParam, m_pcTempAlfParam);
-        ::memcpy(bestImgMask[0], m_maskImg[0], sizeof(Pel)*m_img_height* m_img_width);
+      }
+    }
+  }
-  filtNo = cAlfParam.filter_shape;
-  ::memcpy(m_maskImg[0], bestImgMask[0], sizeof(Pel)*m_img_height* m_img_width);
-  m_pcEntropyCoder->setAlfCtrl(false);
-  m_pcEntropyCoder->setMaxAlfCtrlDepth(0);
-  // generate filters for future reference
-  m_iDesignCurrentFilter = 0;
-  int  filters_per_fr;
-  int  lambda_val = (Int)m_dLambdaLuma;
-  lambda_val = lambda_val * (1<<(2*g_uiBitIncrement));
-  if(!m_bUseNonCrossALF)
+  {
-    xstoreInBlockMatrix(0, 0, m_img_height, m_img_width, true, true, pOrg, pDec, cAlfParam.filter_shape, LumaStride);
+  }
-  else
+  {
-    xstoreInBlockMatrixforSlices(pOrg, pDec, cAlfParam.filter_shape, LumaStride);
+  }
-  xfindBestFilterVarPred(m_yGlobalSym[filtNo], m_EGlobalSym[filtNo], m_pixAcc,
-    m_filterCoeffSym, m_filterCoeffSymQuant,
-    filtNo, &filters_per_fr,
-    m_varIndTab, NULL, m_varImg, m_maskImg, NULL, lambda_val);
-  saveFilterCoeffToBuffer(m_filterCoeffSym, filters_per_fr, m_varIndTab, cAlfParam.alf_pcr_region_flag, filtNo);
-  m_iDesignCurrentFilter = 1;
-  freeALFParam(&cAlfParam);
+}
-/** set ALF encoding parameters
- * \param pcPic picture pointer
- */
-Void TEncAdaptiveLoopFilter::setALFEncodingParam(TComPic *pcPic)
+{
-  if(m_iALFEncodePassReduction)
+  {
-    m_iALFNumOfRedesign = 0;
-    m_iCurrentPOC = m_pcPic->getPOC();
-    if((pcPic->getSlice(0)->getSliceType() == I_SLICE) || (m_iGOPSize==8 && (m_iCurrentPOC % 4 == 0)))
+    {
-      m_iUsePreviousFilter = 0;
+    }
-    else
+    {
-      m_iUsePreviousFilter = 1;
+    }
+  }
-  else
+  {
-    m_iALFNumOfRedesign = ALF_NUM_OF_REDESIGN;
+  }
-  m_iDesignCurrentFilter = 1;
+}
-/** set filter buffer index
- * \param index the processing order of time-delayed filtering
- */
-Int TEncAdaptiveLoopFilter::setFilterIdx(Int index)
+{
-  Int iBufIdx;
-  if (m_iGOPSize == 8)
+  {
-    switch(m_iCurrentPOC % m_iGOPSize)
+    {
-    case 0:
+      {
-        iBufIdx = (index == 0)?0:m_iGOPSize;
+      }
-      break;
-    case 1:
+      {
-        iBufIdx = (index == 0)?0:2;
+      }
-      break;
-    case 2:
+      {
-        iBufIdx = (index == 0)?0:4;
+      }
-      break;
-    case 3:
+      {
-        iBufIdx = (index == 0)?2:4;
+      }
-      break;
-    case 4:
+      {
-        iBufIdx = (index == 0)?0:m_iGOPSize;
+      }
-      break;
-    case 5:
+      {
-        iBufIdx = (index == 0)?4:6;
+      }
-      break;
-    case 6:
+      {
-        iBufIdx = (index == 0)?4:m_iGOPSize;
+      }
-      break;
-    case 7:
+      {
-        iBufIdx = (index == 0)?6:m_iGOPSize;
+      }
-      break;
-    default:
+      {
-        printf("error\n");
-        assert(0);
+      }
+    }
+  }
-  else
+  {
-    iBufIdx = (index == 0)?0:m_iGOPSize;
+  }
-  return iBufIdx;
+}
-/** set initial m_maskImg
- * \param pcPicOrg original picture pointer
- * \param pcPicDec reconstructed picture pointer
- */
-Void TEncAdaptiveLoopFilter::setInitialMask(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec)
+{
-  Int Height = pcPicOrg->getHeight();
-  Int Width = pcPicOrg->getWidth();
-  Int LumaStride = pcPicOrg->getStride();
-  Pel* pDec = pcPicDec->getLumaAddr();
-  calcVar(m_varImg, pDec, LumaStride, m_uiVarGenMethod);
-  if(!m_iALFEncodePassReduction || !m_iUsePreviousFilter)
+  {
-    for(Int y=0; y<Height; y++)
+    {
-      for(Int x=0; x<Width; x++)
+      {
-        m_maskImg[y][x] = 1;
+      }
+    }
+  }
-  else
+  {
-    setMaskWithTimeDelayedResults(pcPicOrg, pcPicDec);
+  }
+}
-/** Estimate RD cost of all filter size & store the best one
- * \param ImgOrg original picture
- * \param ImgDec reconstructed picture after deblocking
- * \param Sride  line buffer size of picture buffer
- * \param pcAlfSaved the best Alf parameters
- * \returns ruiDist             estimated distortion
- * \returns ruiRate             required bits
- * \returns rdCost              estimated R-D cost
- */
-Void  TEncAdaptiveLoopFilter::decideFilterShapeLuma(Pel* ImgOrg, Pel* ImgDec, Int Stride, ALFParam* pcAlfSaved, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost)
+{
-  static Double **ySym, ***ESym;
-  Int    lambda_val = ((Int) m_dLambdaLuma) * (1<<(2*g_uiBitIncrement));
-  Int    filtNo, filters_per_fr;
-  Int64  iEstimatedDist;
-  UInt64 uiRate;
-  Double dEstimatedCost, dEstimatedMinCost = MAX_DOUBLE;;
-  UInt   uiBitShift = (g_uiBitIncrement<<1);
-  Int64  iEstimateDistBeforeFilter;
-  Int*   coeffNoFilter[NUM_ALF_FILTER_SHAPE][NO_VAR_BINS];
-  for(Int filter_shape = 0; filter_shape < NUM_ALF_FILTER_SHAPE; filter_shape++)
+  {
-    for(Int i=0; i< NO_VAR_BINS; i++)
+    {
-      coeffNoFilter[filter_shape][i]= new Int[ALF_MAX_NUM_COEF];
-      ::memset(coeffNoFilter[filter_shape][i], 0, sizeof(Int)*ALF_MAX_NUM_COEF);
-      coeffNoFilter[filter_shape][i][ m_sqrFiltLengthTab[filter_shape]-1 ] = (1 << ((Int)ALF_NUM_BIT_SHIFT));
+    }
+  }
-  m_pcTempAlfParam->alf_flag = 1;
-  m_pcTempAlfParam->chroma_idc = 0;
-  m_pcTempAlfParam->alf_pcr_region_flag = m_uiVarGenMethod;
-  for (int filter_shape = 0; filter_shape < NUM_ALF_FILTER_SHAPE ;filter_shape ++)
+  {
-    m_pcTempAlfParam->filter_shape = filtNo = filter_shape;
-    m_pcTempAlfParam->num_coeff = m_sqrFiltLengthTab[filtNo] ;
-    ESym     = m_EGlobalSym     [filtNo];
-    ySym     = m_yGlobalSym     [filtNo];
-    if(!m_bUseNonCrossALF)
+    {
-      xstoreInBlockMatrix(0, 0, m_img_height, m_img_width, true, true, ImgOrg, ImgDec, filter_shape, Stride);
+    }
-    else
+    {
-      xstoreInBlockMatrixforSlices(ImgOrg, ImgDec, filter_shape, Stride);
+    }
-    xfindBestFilterVarPred(ySym, ESym, m_pixAcc, m_filterCoeffSym, m_filterCoeffSymQuant, filtNo, &filters_per_fr, m_varIndTab, NULL, m_varImg, m_maskImg, NULL, lambda_val);
-    //estimate R-D cost
-    uiRate         = xcodeFiltCoeff(m_filterCoeffSymQuant, filtNo, m_varIndTab, filters_per_fr, m_pcTempAlfParam);
-    iEstimatedDist = xEstimateFiltDist(filters_per_fr, m_varIndTab, ESym, ySym, m_filterCoeffSym, m_pcTempAlfParam->num_coeff);
-    iEstimateDistBeforeFilter = xEstimateFiltDist(filters_per_fr, m_varIndTab, ESym, ySym, coeffNoFilter[filter_shape], m_pcTempAlfParam->num_coeff);
-    iEstimatedDist -= iEstimateDistBeforeFilter;
-    dEstimatedCost = (Double)(uiRate) * m_dLambdaLuma + (Double)(iEstimatedDist);
-    if(dEstimatedCost < dEstimatedMinCost)
+    {
-      dEstimatedMinCost   = dEstimatedCost;
-      copyALFParam(pcAlfSaved, m_pcTempAlfParam);
-      iEstimatedDist += iEstimateDistBeforeFilter;
-      for(Int i=0; i< filters_per_fr; i++ )
+      {
-        iEstimatedDist += (((Int64)m_pixAcc_merged[i]) >> uiBitShift);
+      }
-      ruiDist = (iEstimatedDist > 0)?((UInt64)iEstimatedDist):(0);
-      rdCost  = dEstimatedMinCost + (Double)(ruiDist);
-      ruiRate = uiRate;
+    }
+  }
-  if (!m_iUsePreviousFilter)
+  {
-    decodeFilterSet(pcAlfSaved, m_varIndTab, m_filterCoeffSym);
-    saveFilterCoeffToBuffer(m_filterCoeffSym, pcAlfSaved->filters_per_group, m_varIndTab, pcAlfSaved->alf_pcr_region_flag, pcAlfSaved->filter_shape);
+  }
-  if( m_iUsePreviousFilter )
+  {
-    UInt64 uiOffRegionDistortion = 0;
-    Int    iPelDiff;
-    Pel*   pOrgTemp = (Pel*)ImgOrg;
-    Pel*   pDecTemp = (Pel*)ImgDec;
-    for(Int y=0; y< m_img_height; y++)
+    {
-      for(Int x=0; x< m_img_width; x++)
+      {
-        if(m_maskImg[y][x] == 0)
+        {
-          iPelDiff = pOrgTemp[x] - pDecTemp[x];
-          uiOffRegionDistortion += (UInt64)(  (iPelDiff*iPelDiff) >> uiBitShift );
+        }
+      }
-      pOrgTemp += Stride;
-      pDecTemp += Stride;
-      ruiDist += uiOffRegionDistortion;
-      rdCost  += (Double)uiOffRegionDistortion;
+    }
+  }
-#if !ALF_SINGLE_FILTER_SHAPE
-  // if ALF_STAR5x5 is selected, the distortion of 2 skipped lines per LCU should be added.
-  if(pcAlfSaved->filter_shape == ALF_STAR5x5)
+  {
-    Int    iPelDiff;
-    UInt64  uiSkipPelsDistortion = 0;
-    Pel   *pOrgTemp, *pDecTemp;
-    for(Int y= m_lineIdxPadTop-1; y< m_img_height - m_lcuHeight ; y += m_lcuHeight)
+    {
-      pOrgTemp = ImgOrg + y*Stride;
-      pDecTemp = ImgDec + y*Stride;
-      for(Int x=0; x< m_img_width; x++)
+      {
-        if(m_maskImg[y][x] == 1)
+        {
-          iPelDiff = pOrgTemp[x] - pDecTemp[x];
-          uiSkipPelsDistortion += (UInt64)(  (iPelDiff*iPelDiff) >> uiBitShift );
+        }
+      }
-      pOrgTemp += Stride;
-      pDecTemp += Stride;
-      for(Int x=0; x< m_img_width; x++)
+      {
-        if(m_maskImg[y+1][x] == 1)
+        {
-          iPelDiff = pOrgTemp[x] - pDecTemp[x];
-          uiSkipPelsDistortion += (UInt64)(  (iPelDiff*iPelDiff) >> uiBitShift );
+        }
+      }
+    }
-    ruiDist += uiSkipPelsDistortion;
-    rdCost  += (Double)uiSkipPelsDistortion;
+  }
-#endif
-  for(Int filter_shape = 0; filter_shape < NUM_ALF_FILTER_SHAPE; filter_shape++)
+  {
-    for(Int i=0; i< NO_VAR_BINS; i++)
+    {
-      delete[] coeffNoFilter[filter_shape][i];
+    }
+  }
+}
-#endif
 /** Estimate filtering distortion by correlation values and filter coefficients
 …
   Int64  iDist;
   Double dDist, dsum;
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
   Int alfPrecisionBit = getAlfPrecisionBit( m_alfQP );
 #endif
 …
   for(i=0; i< iFiltLength; i++)
+  {
 #if LCU_SYNTAX_ALF && LCUALF_QP_DEPENDENT_BITS
+#if LCUALF_QP_DEPENDENT_BITS
     pdcoeff[i]= (Double)piCoeff[i] / (Double)(1<<alfPrecisionBit);
 #else
 …
-#if !LCU_SYNTAX_ALF
-/** Estimate total filtering cost of all groups
- * \param filters_per_fr number of filters for the slice
- * \param VarIndTab merge index of all groups
- * \param pppdE  auto-correlation matrix pointer for all groups
- * \param ppdy cross-correlation array pointer for all groups
- * \returns estimated distortion
- */
-Int64 TEncAdaptiveLoopFilter::xEstimateFiltDist(Int filters_per_fr, Int* VarIndTab,
-                                                Double*** pppdE, Double** ppdy,
-                                                Int** ppiCoeffSet, Int iFiltLength)
+{
-  Int64     iDist;
-  Double**  ppdDstE;
-  Double**  ppdSrcE;
-  Double*   pdDsty;
-  Double*   pdSrcy;
-  Int       f, j, i, varInd;
-  Int*      piCoeff;
-  //clean m_E_merged & m_y_merged
-  for(f=0; f< filters_per_fr; f++)
+  {
-    for(j =0; j < iFiltLength; j++)
+    {
-      //clean m_E_merged one line
-      for(i=0; i < iFiltLength; i++)
+      {
-        m_E_merged[f][j][i] = 0;
+      }
-      //clean m_y_merged
-      m_y_merged[f][j] = 0;
+    }
-    m_pixAcc_merged[f] = 0;
+  }
-  //merge correlation values
-  for (varInd=0; varInd< NO_VAR_BINS; varInd++)
+  {
-    ppdSrcE = pppdE[varInd];
-    ppdDstE = m_E_merged[ VarIndTab[varInd] ];
-    pdSrcy  = ppdy[varInd];
-    pdDsty  = m_y_merged[ VarIndTab[varInd] ];
-    for(j=0; j< iFiltLength; j++)
+    {
-      for(i=0; i< iFiltLength; i++)
+      {
-        ppdDstE[j][i] += ppdSrcE[j][i];
+      }
-      pdDsty[j] += pdSrcy[j];
+    }
-    m_pixAcc_merged[ VarIndTab[varInd]  ] += m_pixAcc[varInd];
+  }
-  //estimate distortion reduction by using FFDE (JCTVC-C143)
-  iDist = 0;
-  for(f=0; f< filters_per_fr; f++)
+  {
-    piCoeff = ppiCoeffSet[f];
-    ppdDstE = m_E_merged [f];
-    pdDsty  = m_y_merged [f];
-    iDist += xFastFiltDistEstimation(ppdDstE, pdDsty, piCoeff, iFiltLength);
+  }
-  return iDist;
+}
-/** Calculate ALF grouping indices for ALF slices
- * \param varmap grouping indices buffer
- * \param imgY_Dec picture buffer
- * \param pad_size (max. filter tap)/2
- * \param fl  VAR_SIZE
- * \param img_stride picture buffer stride
- */
-Void TEncAdaptiveLoopFilter::xfilterSlicesEncoder(Pel* ImgDec, Pel* ImgRest, Int iStride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg)
+{
-  Pel* pPicSrc   = (Pel *)ImgDec;
-  Pel* pPicSlice = m_pcSliceYuvTmp->getLumaAddr();
-  for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+  {
-    if(!m_pcPic->getValidSlice(s))
+    {
-      continue;
+    }
-    std::vector< std::vector<AlfLCUInfo*> > & vpSliceTileAlfLCU = m_pvpSliceTileAlfLCU[s];
-    for(Int t=0; t< (Int)vpSliceTileAlfLCU.size(); t++)
+    {
-      std::vector<AlfLCUInfo*> & vpAlfLCU = vpSliceTileAlfLCU[t];
-      copyRegion(vpAlfLCU, pPicSlice, pPicSrc, iStride);
-      extendRegionBorder(vpAlfLCU, pPicSlice, iStride);
-      filterLumaRegion(vpAlfLCU, pPicSlice, ImgRest, iStride, filtNo, filterCoeff, mergeTable, varImg);
+    }
+  }
+}
-/** Calculate block autocorrelations and crosscorrelations for ALF slices
- * \param ImgOrg original picture
- * \param ImgDec picture before filtering
- * \param tap  filter tap size
- * \param iStride picture buffer stride
- */
-Void   TEncAdaptiveLoopFilter::xstoreInBlockMatrixforSlices(Pel* ImgOrg, Pel* ImgDec, Int tap, Int iStride)
+{
-  Pel* pPicSrc   = (Pel *)ImgDec;
-  Pel* pPicSlice = m_pcSliceYuvTmp->getLumaAddr();
-  UInt iLastValidSliceID =0;
-  for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+  {
-    if(m_pcPic->getValidSlice(s))
+    {
-      iLastValidSliceID = s;
+    }
+  }
-  for(UInt s=0; s<= iLastValidSliceID; s++)
+  {
-    if(!m_pcPic->getValidSlice(s))
+    {
-      continue;
+    }
-    std::vector< std::vector<AlfLCUInfo*> > & vpSliceTileAlfLCU = m_pvpSliceTileAlfLCU[s];
-    Int numValidTilesInSlice = (Int)vpSliceTileAlfLCU.size();
-    for(Int t=0; t< numValidTilesInSlice; t++)
+    {
-      std::vector<AlfLCUInfo*> & vpAlfLCU = vpSliceTileAlfLCU[t];
-      copyRegion(vpAlfLCU, pPicSlice, pPicSrc, iStride);
-      extendRegionBorder(vpAlfLCU, pPicSlice, iStride);
-      xstoreInBlockMatrixforRegion(vpAlfLCU, ImgOrg, pPicSlice, tap, iStride, (s==0)&&(t==0), (s== iLastValidSliceID)&&(t==numValidTilesInSlice-1));
+    }
+  }
+}
-/** Calculate block autocorrelations and crosscorrelations for one ALF region
- * \param vpAlfLCU ALF LCU data container
- * \param ImgOrg original picture
- * \param ImgDec picture before filtering
- * \param tap  filter tap size
- * \param iStride picture buffer stride
- * \param bFirstSlice  true for the first processing slice of the picture
- * \param bLastSlice true for the last processing slice of the picture
- */
-Void   TEncAdaptiveLoopFilter::xstoreInBlockMatrixforRegion(std::vector< AlfLCUInfo* > &vpAlfLCU,
-                                                              Pel* ImgOrg, Pel* ImgDec,
-                                                              Int tap, Int iStride,
-                                                              Bool bFirstSlice,
-                                                              Bool bLastSlice
+                                                              )
+{
-  UInt uiNumLCUs = (UInt)vpAlfLCU.size();
-  Int iHeight, iWidth;
-  Int ypos, xpos;
-  Bool bFirstLCU, bLastLCU;
-  Bool bFirstSGU, bLastSGU;
-  UInt numSGUs;
-  for(UInt i=0; i< uiNumLCUs; i++)
+  {
-    bFirstLCU = (i==0);
-    bLastLCU  = (i== uiNumLCUs -1);
-    AlfLCUInfo& cAlfLCU = *(vpAlfLCU[i]);
-    numSGUs = cAlfLCU.numSGU;
-    for(UInt j=0; j< numSGUs; j++)
+    {
-      bFirstSGU= (j ==0);
-      bLastSGU = (j == numSGUs -1);
-      ypos    = (Int)(cAlfLCU[j].posY  );
-      xpos    = (Int)(cAlfLCU[j].posX  );
-      iHeight = (Int)(cAlfLCU[j].height);
-      iWidth  = (Int)(cAlfLCU[j].width );
-      xstoreInBlockMatrix(ypos, xpos, iHeight, iWidth,
-        (bFirstSlice && bFirstLCU && bFirstSGU),(bLastSlice && bLastLCU && bLastSGU),
-        ImgOrg, ImgDec,tap, iStride);
+    }
+  }
+}
-/** Calculate autocorrelations and crosscorrelations for chroma slices
- * \param ComponentID Cb or Cr
- * \param pOrg original picture
- * \param pCmp picture before filtering
- * \param iTap  filter tap size
- * \param iOrgStride picture buffer stride for pOrg
- * \param iCmpStride picture buffer stride for pCmp
- */
-Void TEncAdaptiveLoopFilter::xCalcCorrelationFuncforChromaSlices(Int ComponentID, Pel* pOrg, Pel* pCmp, Int iTap, Int iOrgStride, Int iCmpStride)
+{
-  assert(iOrgStride == iCmpStride);
-  Pel* pPicSrc   = pCmp;
-  Pel* pPicSlice = (ComponentID == ALF_Cb)?(m_pcSliceYuvTmp->getCbAddr()):(m_pcSliceYuvTmp->getCrAddr());
-  Int chromaFormatShift = 1;
-  UInt iLastValidSliceID =0;
-  for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+  {
-    if(m_pcPic->getValidSlice(s))
+    {
-      iLastValidSliceID = s;
+    }
+  }
-  for(UInt s=0; s<= iLastValidSliceID; s++)
+  {
-    if(!m_pcPic->getValidSlice(s))
+    {
-      continue;
+    }
-    std::vector< std::vector<AlfLCUInfo*> > & vpSliceTileAlfLCU = m_pvpSliceTileAlfLCU[s];
-    Int numValidTilesInSlice = (Int)vpSliceTileAlfLCU.size();
-    for(Int t=0; t< numValidTilesInSlice; t++)
+    {
-      std::vector<AlfLCUInfo*> & vpAlfLCU = vpSliceTileAlfLCU[t];
-      copyRegion(vpAlfLCU, pPicSlice, pPicSrc, iCmpStride, chromaFormatShift);
-      extendRegionBorder(vpAlfLCU, pPicSlice, iCmpStride, chromaFormatShift);
-      xCalcCorrelationFuncforChromaRegion(vpAlfLCU, pOrg, pPicSlice, iTap, iCmpStride,(s== iLastValidSliceID)&&(t== numValidTilesInSlice-1), chromaFormatShift);
+    }
+  }
+}
-/** Calculate autocorrelations and crosscorrelations for one chroma slice
- * \param vpAlfLCU ALF LCU data container
- * \param pOrg original picture
- * \param pCmp picture before filtering
- * \param iTap  filter tap size
- * \param iStride picture buffer stride
- * \param bLastSlice the last processing slice of picture
- */
-Void TEncAdaptiveLoopFilter::xCalcCorrelationFuncforChromaRegion(std::vector< AlfLCUInfo* > &vpAlfLCU, Pel* pOrg, Pel* pCmp, Int filtNo, Int iStride, Bool bLastSlice, Int iFormatShift)
+{
-  UInt uiNumLCUs = (UInt)vpAlfLCU.size();
-  Int iHeight, iWidth;
-  Int ypos, xpos;
-  Bool bLastLCU;
-  Bool bLastSGU;
-  UInt numSGUs;
-  for(UInt i=0; i< uiNumLCUs; i++)
+  {
-    bLastLCU  = (i== uiNumLCUs -1);
-    AlfLCUInfo& cAlfLCU = *(vpAlfLCU[i]);
-    numSGUs = cAlfLCU.numSGU;
-    for(UInt j=0; j< numSGUs; j++)
+    {
-      bLastSGU = (j == numSGUs -1);
-      ypos    = (Int)(cAlfLCU[j].posY   >> iFormatShift);
-      xpos    = (Int)(cAlfLCU[j].posX   >> iFormatShift);
-      iHeight = (Int)(cAlfLCU[j].height >> iFormatShift);
-      iWidth  = (Int)(cAlfLCU[j].width  >> iFormatShift);
-      xCalcCorrelationFunc(ypos, xpos, pOrg, pCmp, filtNo, iWidth, iHeight, iStride, iStride, (bLastSlice && bLastLCU && bLastSGU) );
+    }
+  }
+}
-// ====================================================================================================================
-// Protected member functions
-// ====================================================================================================================
-Void TEncAdaptiveLoopFilter::xFilterTapDecisionChroma( UInt64 uiLumaRate, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, UInt64& ruiBits )
+{
-  Int   iShape, num_coeff;
-  Int64 iOrgDistCb, iOrgDistCr, iFiltDistCb, iFiltDistCr, iDist;
-  Bool  bChanged = false;
-  Int*  qh = m_pcTempAlfParam->coeff_chroma;
-  UInt64 uiMinRate = uiLumaRate;
-  UInt64 uiMinDist = MAX_INT;
-  Double dMinCost  = MAX_DOUBLE;
-  Double dLocalMinCost = MAX_DOUBLE;
-  copyALFParam(m_pcTempAlfParam, m_pcBestAlfParam);
-  xCalcRDCostChroma(pcPicOrg, pcPicRest, m_pcTempAlfParam, uiMinRate, uiMinDist, dMinCost);
-#if ALF_SINGLE_FILTER_SHAPE
-  iShape = 0;
-#else
-  for(iShape = 0; iShape < 2; iShape++)
-#endif
+  {
-    // set global variables
-    num_coeff = m_sqrFiltLengthTab[iShape];
-    m_pcTempAlfParam->chroma_idc = 3;
-    m_pcTempAlfParam->filter_shape_chroma = iShape;
-    m_pcTempAlfParam->num_coeff_chroma = num_coeff;
-    // keep original corr pointer
-    Double **ppdTmpCorr = m_ppdAlfCorr;
-    // calc Cb matrix
-    m_pcTempAlfParam->chroma_idc = 2;
-    m_ppdAlfCorr = m_ppdAlfCorrCb;
-    for(Int i=0; i<ALF_MAX_NUM_COEF; i++)
+    {
-      ::memset(m_ppdAlfCorr[i], 0, sizeof(Double) * (ALF_MAX_NUM_COEF + 1));
+    }
-    Pel *pOrg = pcPicOrg->getCbAddr();
-    Pel *pCmp = pcPicDec->getCbAddr();
-    if(!m_bUseNonCrossALF)
+    {
-      xCalcCorrelationFunc(0, 0, pOrg, pCmp, iShape, (pcPicOrg->getWidth()>>1), (pcPicOrg->getHeight()>>1), pcPicOrg->getCStride(), pcPicDec->getCStride(), true);
+    }
-    else
+    {
-      xCalcCorrelationFuncforChromaSlices(ALF_Cb, pOrg, pCmp, iShape, pcPicOrg->getCStride(), pcPicDec->getCStride());
+    }
-    // calc Cr matrix
-    m_pcTempAlfParam->chroma_idc = 1;
-    m_ppdAlfCorr = m_ppdAlfCorrCr;
-    for(Int i=0; i<ALF_MAX_NUM_COEF; i++)
+    {
-      ::memset(m_ppdAlfCorr[i], 0, sizeof(Double) * (ALF_MAX_NUM_COEF + 1));
+    }
-    pOrg = pcPicOrg->getCrAddr();
-    pCmp = pcPicDec->getCrAddr();
-    if(!m_bUseNonCrossALF)
+    {
-      xCalcCorrelationFunc(0, 0, pOrg, pCmp, iShape, (pcPicOrg->getWidth()>>1), (pcPicOrg->getHeight()>>1), pcPicOrg->getCStride(), pcPicDec->getCStride(), true);
+    }
-    else
+    {
-      xCalcCorrelationFuncforChromaSlices(ALF_Cr, pOrg, pCmp, iShape, pcPicOrg->getCStride(), pcPicDec->getCStride());
+    }
-    // restore original corr pointer
-    m_ppdAlfCorr = ppdTmpCorr;
-    // calc original dist
-    memset(qh, 0, sizeof(Int)*num_coeff);
-    qh[num_coeff-1] = 1<<((Int)ALF_NUM_BIT_SHIFT);
-    iOrgDistCb = xFastFiltDistEstimationChroma(m_ppdAlfCorrCb, qh, num_coeff);
-    iOrgDistCr = xFastFiltDistEstimationChroma(m_ppdAlfCorrCr, qh, num_coeff);
-    for(Int iCmp=1; iCmp<=3; iCmp++)
+    {
-      m_pcTempAlfParam->chroma_idc = iCmp;
-      xCalcALFCoeffChroma(iCmp, iShape, qh);
-      iFiltDistCb = ((iCmp>>1)&0x1) ? xFastFiltDistEstimationChroma(m_ppdAlfCorrCb, qh, num_coeff) : iOrgDistCb;
-      iFiltDistCr = ((iCmp)   &0x1) ? xFastFiltDistEstimationChroma(m_ppdAlfCorrCr, qh, num_coeff) : iOrgDistCr;
-      iDist = iFiltDistCb + iFiltDistCr;
-      UInt64 uiRate = xCalcRateChroma(m_pcTempAlfParam);
-      Double dCost  = (Double)iDist + m_dLambdaChroma * (Double)uiRate;
-      if(dCost < dLocalMinCost)
+      {
-        dLocalMinCost = dCost;
-        copyALFParam(m_pcBestAlfParam, m_pcTempAlfParam);
-        bChanged = true;
+      }
+    }
+  }
-  copyALFParam(m_pcTempAlfParam, m_pcBestAlfParam);
-  if(!bChanged)
+  {
-    m_pcBestAlfParam->chroma_idc = 0;
-    return;
+  }
-  // Adaptive in-loop wiener filtering for chroma
-  xFilteringFrameChroma(m_pcTempAlfParam, pcPicOrg, pcPicDec, pcPicRest);
-  // filter on/off decision for chroma
-  Int iCWidth = (pcPicOrg->getWidth()>>1);
-  Int iCHeight = (pcPicOrg->getHeight()>>1);
-  Int iCStride = pcPicOrg->getCStride();
-  UInt64 uiFiltDistCb = xCalcSSD(pcPicOrg->getCbAddr(), pcPicRest->getCbAddr(), iCWidth, iCHeight, iCStride);
-  UInt64 uiFiltDistCr = xCalcSSD(pcPicOrg->getCrAddr(), pcPicRest->getCrAddr(), iCWidth, iCHeight, iCStride);
-  UInt64 uiOrgDistCb  = xCalcSSD(pcPicOrg->getCbAddr(), pcPicDec->getCbAddr(), iCWidth, iCHeight, iCStride);
-  UInt64 uiOrgDistCr  = xCalcSSD(pcPicOrg->getCrAddr(), pcPicDec->getCrAddr(), iCWidth, iCHeight, iCStride);
-  if(((m_pcTempAlfParam->chroma_idc)>>1 & 0x1) && (uiOrgDistCb<=uiFiltDistCb))
+  {
-    m_pcTempAlfParam->chroma_idc -= 2;
-    pcPicDec->copyToPicCb(pcPicRest);
+  }
-  if(((m_pcTempAlfParam->chroma_idc)    & 0x1) && (uiOrgDistCr<=uiFiltDistCr))
+  {
-    m_pcTempAlfParam->chroma_idc -= 1;
-    pcPicDec->copyToPicCr(pcPicRest);
+  }
-  if(m_pcTempAlfParam->chroma_idc)
+  {
-    UInt64 uiRate, uiDist;
-    Double dCost;
-    xCalcRDCostChroma(pcPicOrg, pcPicRest, m_pcTempAlfParam, uiRate, uiDist, dCost);
-    if( dCost < dMinCost )
+    {
-      copyALFParam(m_pcBestAlfParam, m_pcTempAlfParam);
-      predictALFCoeffChroma(m_pcBestAlfParam);
-      ruiBits += uiRate;
-      ruiDist += uiDist;
+    }
-    else
+    {
-      m_pcBestAlfParam->chroma_idc = 0;
-      if((m_pcTempAlfParam->chroma_idc>>1)&0x01)
+      {
-        pcPicDec->copyToPicCb(pcPicRest);
+      }
-      if(m_pcTempAlfParam->chroma_idc&0x01)
+      {
-        pcPicDec->copyToPicCr(pcPicRest);
+      }
-      ruiBits += uiMinRate;
-      ruiDist += uiMinDist;
+    }
+  }
-  else
+  {
-    m_pcBestAlfParam->chroma_idc = 0;
-    ruiBits += uiMinRate;
-    ruiDist += uiMinDist;
-    pcPicDec->copyToPicCb(pcPicRest);
-    pcPicDec->copyToPicCr(pcPicRest);
+  }
+}
-Int64 TEncAdaptiveLoopFilter::xFastFiltDistEstimationChroma(Double** ppdCorr, Int* piCoeff, Int iSqrFiltLength)
+{
-  Double pdcoeff[ALF_MAX_NUM_COEF];
-  Int    i,j;
-  Int64  iDist;
-  Double dDist, dsum;
-  for(i=0; i< iSqrFiltLength; i++)
+  {
-    pdcoeff[i]= (Double)piCoeff[i] / (Double)(1<< ((Int)ALF_NUM_BIT_SHIFT) );
+  }
-  dDist =0;
-  for(i=0; i< iSqrFiltLength; i++)
+  {
-    dsum= ((Double)ppdCorr[i][i]) * pdcoeff[i];
-    for(j=i+1; j< iSqrFiltLength; j++)
+    {
-      dsum += (Double)(2*ppdCorr[i][j])* pdcoeff[j];
+    }
-    dDist += ((dsum - 2.0 * ppdCorr[i][iSqrFiltLength])* pdcoeff[i] );
+  }
-  UInt uiShift = g_uiBitIncrement<<1;
-  if(dDist < 0)
+  {
-    iDist = -(((Int64)(-dDist + 0.5)) >> uiShift);
+  }
-  else //dDist >=0
+  {
-    iDist= ((Int64)(dDist+0.5)) >> uiShift;
+  }
-  return iDist;
+}
-Void TEncAdaptiveLoopFilter::xCalcALFCoeffChroma(Int iChromaIdc, Int iShape, Int* piCoeff)
+{
-  Int iSqrFiltLength = m_sqrFiltLengthTab[iShape];
-  for(Int i=0; i<iSqrFiltLength; i++)
+  {
-    memset(m_ppdAlfCorr[i], 0, sizeof(Double)*(iSqrFiltLength + 1));
+  }
-  // retrive
-  if((iChromaIdc>>1) & 0x1)
+  {
-    for(Int i=0; i<iSqrFiltLength; i++)
+    {
-      for(Int j=i; j<iSqrFiltLength+1; j++)
+      {
-        m_ppdAlfCorr[i][j] += m_ppdAlfCorrCb[i][j];
+      }
+    }
+  }
-  if(iChromaIdc & 0x1)
+  {
-    for(Int i=0; i<iSqrFiltLength; i++)
+    {
-      for(Int j=i; j<iSqrFiltLength+1; j++)
+      {
-        m_ppdAlfCorr[i][j] += m_ppdAlfCorrCr[i][j];
+      }
+    }
+  }
-  // copy
-  for(Int i=1; i<iSqrFiltLength; i++)
+  {
-    for(Int j=0; j<i; j++)
+    {
-      m_ppdAlfCorr[i][j] = m_ppdAlfCorr[j][i];
+    }
+  }
-  Double *corr = new Double[iSqrFiltLength];
-  for(Int i=0; i<iSqrFiltLength; i++)
+  {
-    corr[i] = m_ppdAlfCorr[i][iSqrFiltLength];
+  }
-  // calc coeff
-  gnsSolveByChol(m_ppdAlfCorr, corr, m_pdDoubleAlfCoeff, iSqrFiltLength);
-  xQuantFilterCoef(m_pdDoubleAlfCoeff, piCoeff, iShape, g_uiBitDepth + g_uiBitIncrement);
-  delete [] corr;
+}
-UInt64 TEncAdaptiveLoopFilter::xCalcRateChroma(ALFParam* pAlfParam)
+{
-  UInt64 uiRate;
-  Int* piTmpCoef;
-  piTmpCoef = new Int[ALF_MAX_NUM_COEF];
-  memcpy(piTmpCoef, pAlfParam->coeff_chroma, sizeof(Int)*pAlfParam->num_coeff_chroma);
-  predictALFCoeffChroma(pAlfParam);
-  m_pcEntropyCoder->resetEntropy();
-  m_pcEntropyCoder->resetBits();
-  m_pcEntropyCoder->encodeAlfParam(pAlfParam);
-  uiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
-  if (m_vBestAlfCUCtrlParam.size() != 0)
+  {
-    for(UInt s=0; s< m_uiNumSlicesInPic; s++)
+    {
-      if(!m_pcPic->getValidSlice(s))
+      {
-        continue;
+      }
-      m_pcEntropyCoder->resetEntropy();
-      m_pcEntropyCoder->resetBits();
-      m_pcEntropyCoder->encodeAlfCtrlParam( m_vBestAlfCUCtrlParam[s], m_uiNumCUsInFrame);
-      uiRate += m_pcEntropyCoder->getNumberOfWrittenBits();
+    }
+  }
-  else
+  {
-    uiRate += m_uiNumSlicesInPic;
+  }
-  memcpy(pAlfParam->coeff_chroma, piTmpCoef, sizeof(int)*pAlfParam->num_coeff_chroma);
-  delete[] piTmpCoef;
-  piTmpCoef = NULL;
-  return uiRate;
+}
-#endif
 //! \}

trunk/source/Lib/TLibEncoder/TEncAdaptiveLoopFilter.h

-                      r56
+                      r296
 //! \{
-#if LCU_SYNTAX_ALF
 #define LCUALF_FILTER_BUDGET_CONTROL_ENC        1 //!< filter budget control
 #define LCUALF_AVOID_USING_BOTTOM_LINES_ENCODER 1 //!< avoid using LCU bottom lines when lcu-based encoder RDO is used
-#endif
 // ====================================================================================================================
 …
 // ====================================================================================================================
-#if LCU_SYNTAX_ALF
 /// correlation info
 struct AlfCorrData
 …
 };
-#endif
 …
   /// variables for correlation calculation
   ///
-#if !LCU_SYNTAX_ALF
-  Double** m_ppdAlfCorr;
-  Double* m_pdDoubleAlfCoeff;
-  Double** m_ppdAlfCorrCb;
-  Double** m_ppdAlfCorrCr;
-  double ***m_yGlobalSym;
-  double ****m_EGlobalSym;
-  double *m_pixAcc;
-#endif
   double **m_y_merged;
   double ***m_E_merged;
 …
   double *m_y_temp;
   double **m_E_temp;
-#if LCU_SYNTAX_ALF
   static const Int  m_alfNumPartsInRowTab[5];
   static const Int  m_alfNumPartsLevelTab[5];
 …
   Int    m_alfUsedFilterNum;
 #endif
-#endif
   ///
   /// ALF parameters
   ///
-#if !LCU_SYNTAX_ALF
-  ALFParam* m_pcBestAlfParam;
-  ALFParam* m_pcTempAlfParam;
-  ALFParam* pcAlfParamShape0;
-  ALFParam* pcAlfParamShape1;
-#endif
   ALFParam *m_tempALFp;
 …
   TComPicYuv* m_pcPicYuvBest;
   TComPicYuv* m_pcPicYuvTmp;
-#if !LCU_SYNTAX_ALF
-  TComPicYuv* pcPicYuvRecShape0;
-  TComPicYuv* pcPicYuvRecShape1;
-#endif
   ///
 …
   Int    **m_diffFilterCoeffQuant;
   Int    **m_FilterCoeffQuantTemp;
-#if !LCU_SYNTAX_ALF
-  Int**  m_mergeTableSavedMethods[NUM_ALF_CLASS_METHOD];
-  Int*** m_aiFilterCoeffSavedMethods[NUM_ALF_CLASS_METHOD];  //!< time-delayed filter set buffer
-  Int*   m_iPreviousFilterShapeMethods[NUM_ALF_CLASS_METHOD];
-#endif
   ///
   /// coding control parameters
 …
   Double m_dLambdaLuma;
   Double m_dLambdaChroma;
-#if !LCU_SYNTAX_ALF
-  Int  m_iUsePreviousFilter;     //!< for N-pass encoding- 1: time-delayed filtering is allowed. 0: not allowed.
-  Int  m_iDesignCurrentFilter;   //!< for N-pass encoding- 1: design filters for current slice. 0: design filters for future slice reference
-  Int  m_iGOPSize;                //!< GOP size
-  Int  m_iCurrentPOC;             //!< POC
-#endif
   Int  m_iALFEncodePassReduction; //!< 0: 16-pass encoding, 1: 1-pass encoding, 2: 2-pass encoding
 …
 private:
-#if LCU_SYNTAX_ALF
   Void disableComponentAlfParam(Int compIdx, AlfParamSet* alfParamSet, AlfUnitParam* alfUnitPic);
   Void copyAlfParamSet(AlfParamSet* dst, AlfParamSet* src);
 …
   Void xCopyDecToRestCUs( Pel* imgDec, Pel* imgRest, Int stride );
   Void xCopyDecToRestCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Pel* imgDec, Pel* imgRest, Int stride );
-#if ALF_SINGLE_FILTER_SHAPE
   Void calcCorrOneCompRegionChma(Pel* imgOrg, Pel* imgPad, Int stride, Int yPos, Int xPos, Int height, Int width, Double **eCorr, Double *yCorr, Bool isSymmCopyBlockMatrix); //!< Calculate correlations for chroma
   Void calcCorrOneCompRegionLuma(Pel* imgOrg, Pel* imgPad, Int stride, Int yPos, Int xPos, Int height, Int width, Double ***eCorr, Double **yCorr, Double *pixAcc, Bool isforceCollection, Bool isSymmCopyBlockMatrix);
-#endif
   //LCU-based mode decision
 …
   Void transferToAlfParamSet(Int compIdx, AlfUnitParam* alfUnitPic, AlfParamSet* & alfParamSet);
   Int  calculateAlfParamSetRateRDO(Int compIdx, AlfParamSet* alfParamSet, std::vector<AlfCUCtrlInfo>* alfCUCtrlParam);
-#endif
-#if !LCU_SYNTAX_ALF
-  // init / uninit internal variables
-  Void xInitParam      ();
-  Void xUninitParam    ();
-#endif
   // ALF on/off control related functions
   Void xCreateTmpAlfCtrlFlags   ();
 …
   Void xEncodeCUAlfCtrlFlags  (std::vector<AlfCUCtrlInfo> &vAlfCUCtrlParam);
   Void xEncodeCUAlfCtrlFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth);
-#if !LCU_SYNTAX_ALF
-  Void xCUAdaptiveControl_qc           ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiMinRate, UInt64& ruiMinDist, Double& rdMinCost );
-  Void xSetCUAlfCtrlFlags_qc            (UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, std::vector<AlfCUCtrlInfo>& vAlfCUCtrlParam);
-  Void xSetCUAlfCtrlFlag_qc             (TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiAlfCtrlDepth, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, std::vector<UInt>& vCUCtrlFlag);
-  // functions related to correlation computation
-  Void xstoreInBlockMatrix(Int ypos, Int xpos, Int iheight, Int iwidth, Bool bResetBlockMatrix, Bool bSymmCopyBlockMatrix, Pel* pImgOrg, Pel* pImgPad, Int filtNo, Int stride); //!< Calculate correlations for luma
-  Void xstoreInBlockMatrixforRegion(std::vector< AlfLCUInfo* > &vpAlfLCU, Pel* ImgOrg, Pel* ImgDec, Int tap, Int iStride, Bool bFirstSlice, Bool bLastSlice); //!< Calculate block autocorrelations and crosscorrelations for one ALF slice
-  Void xstoreInBlockMatrixforSlices  (Pel* ImgOrg, Pel* ImgDec, Int tap, Int iStride); //!< Calculate block autocorrelations and crosscorrelations for ALF slices
-  Void xCalcCorrelationFunc(Int ypos, Int xpos, Pel* pImgOrg, Pel* pImgPad, Int filtNo, Int iWidth, Int iHeight, Int iOrgStride, Int iCmpStride, Bool bSymmCopyBlockMatrix); //!< Calculate correlations for chroma
-  Void xCalcCorrelationFuncforChromaRegion(std::vector< AlfLCUInfo* > &vpAlfLCU, Pel* pOrg, Pel* pCmp, Int filtNo, Int iStride, Bool bLastSlice, Int iFormatShift); //!< Calculate autocorrelations and crosscorrelations for one chroma slice
-  Void xCalcCorrelationFuncforChromaSlices  (Int ComponentID, Pel* pOrg, Pel* pCmp, Int iTap, Int iOrgStride, Int iCmpStride); //!< Calculate autocorrelations and crosscorrelations for chroma slices
-#endif
   // functions related to filtering
   Void xFilterCoefQuickSort   ( Double *coef_data, Int *coef_num, Int upper, Int lower );
   Void xQuantFilterCoef       ( Double* h, Int* qh, Int tap, int bit_depth );
-#if !LCU_SYNTAX_ALF
-  Void xClearFilterCoefInt    ( Int* qh, Int N );
-  Void xCopyDecToRestCUs      ( TComPicYuv* pcPicDec, TComPicYuv* pcPicRest );
-  Void xCopyDecToRestCU       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest );
-  Void xFilteringFrameChroma  (ALFParam* pcAlfParam, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest);
-  Int  setFilterIdx(Int index); //!< set filter buffer index
-  Void setInitialMask(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec); //!< set initial m_maskImg
-  Void saveFilterCoeffToBuffer(Int **filterSet, Int numFilter, Int* mergeTable, Int mode, Int filtNo); //!< save filter coefficients to buffer
-  Void setMaskWithTimeDelayedResults(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec); //!< set initial m_maskImg with previous (time-delayed) filters
-  Void decideFilterShapeLuma(Pel* ImgOrg, Pel* ImgDec, Int Stride, ALFParam* pcAlfSaved, UInt64& ruiRate, UInt64& ruiDist,Double& rdCost); //!< Estimate RD cost of all filter size & store the best one
-  Void   xFilterTapDecisionChroma      (UInt64 uiLumaRate, TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiDist, UInt64& ruiBits);
-  Int64  xFastFiltDistEstimationChroma (Double** ppdCorr, Int* piCoeff, Int iSqrFiltLength);
-  Void  xfilterSlicesEncoder(Pel* ImgDec, Pel* ImgRest, Int iStride, Int filtNo, Int** filterCoeff, Int* mergeTable, Pel** varImg); //!< Calculate ALF grouping indices for ALF slices
-  Void  setALFEncodingParam(TComPic *pcPic); //!< set ALF encoding parameters
-  Void xReDesignFilterCoeff_qc          (TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec,  TComPicYuv* pcPicRest, Bool bReadCorr);
-  Void xFirstFilteringFrameLuma (Pel* imgOrg, Pel* imgDec, Pel* imgRest, ALFParam* ALFp, Int filtNo, Int stride);
-  Void xFilteringFrameLuma(Pel* imgOrg, Pel* imgPad, Pel* imgFilt, ALFParam* ALFp, Int filtNo, Int stride);
-  Void xEncALFLuma  ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicRest, UInt64& ruiMinRate, UInt64& ruiMinDist, Double& rdMinCost ); //!< estimate adaptation mode and filter shape
-#endif
   // distortion / misc functions
 #if HHI_INTERVIEW_SKIP
 …
   UInt64 xCalcSSD             ( Pel* pOrg, Pel* pCmp, Int iWidth, Int iHeight, Int iStride );
 #endif
-#if !LCU_SYNTAX_ALF
-#if HHI_INTERVIEW_SKIP
-  Void  xCalcRDCost          ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam = NULL);
-  Void  xCalcRDCost          ( ALFParam* pAlfParam, UInt64& ruiRate, UInt64 uiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam = NULL);
-  Void  xCalcRDCostChroma    ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost );
-#else
-  Void  xCalcRDCost          ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam = NULL);
-  Void  xCalcRDCost          ( ALFParam* pAlfParam, UInt64& ruiRate, UInt64 uiDist, Double& rdCost, std::vector<AlfCUCtrlInfo>* pvAlfCUCtrlParam = NULL);
-  Void  xCalcRDCostChroma    ( TComPicYuv* pcPicOrg, TComPicYuv* pcPicCmp, ALFParam* pAlfParam, UInt64& ruiRate, UInt64& ruiDist, Double& rdCost );
-#endif
-#endif
   Int64 xFastFiltDistEstimation(Double** ppdE, Double* pdy, Int* piCoeff, Int iFiltLength); //!< Estimate filtering distortion by correlation values and filter coefficients
-#if !LCU_SYNTAX_ALF
-  Int64 xEstimateFiltDist      (Int filters_per_fr, Int* VarIndTab, Double*** pppdE, Double** ppdy, Int** ppiCoeffSet, Int iFiltLength); //!< Estimate total filtering cost of all groups
-  UInt64 xCalcRateChroma               (ALFParam* pAlfParam);
-  Void   xCalcALFCoeffChroma           (Int iChromaIdc, Int iShape, Int* piCoeff);
-#endif
   /// code filter coefficients
   UInt xcodeFiltCoeff(Int **filterCoeffSymQuant, Int filter_shape, Int varIndTab[], Int filters_per_fr_best, ALFParam* ALFp);
-#if LCU_SYNTAX_ALF
   Void xfindBestFilterVarPred(double **ySym, double ***ESym, double *pixAcc, Int **filterCoeffSym, Int **filterCoeffSymQuant,Int filter_shape, Int *filters_per_fr_best, Int varIndTab[], Pel **imgY_rec, Pel **varImg, Pel **maskImg, Pel **imgY_pad, double lambda_val, Int numMaxFilters = NO_FILTERS);
-#else
-  Void xfindBestFilterVarPred(double **ySym, double ***ESym, double *pixAcc, Int **filterCoeffSym, Int **filterCoeffSymQuant,Int filter_shape, Int *filters_per_fr_best, Int varIndTab[], Pel **imgY_rec, Pel **varImg, Pel **maskImg, Pel **imgY_pad, double lambda_val);
-#endif
   double xfindBestCoeffCodMethod(int **filterCoeffSymQuant, int filter_shape, int sqrFiltLength, int filters_per_fr, double errorForce0CoeffTab[NO_VAR_BINS][2], double lambda);
   Int xsendAllFiltersPPPred(int **FilterCoeffQuant, int filter_shape, int sqrFiltLength, int filters_per_group, int createBistream, ALFParam* ALFp);
 …
   Void startALFEnc(TComPic* pcPic, TEncEntropy* pcEntropyCoder); //!< allocate temporal memory
   Void endALFEnc(); //!< destroy temporal memory
-#if LCU_SYNTAX_ALF
 #if ALF_CHROMA_LAMBDA
 #if HHI_INTERVIEW_SKIP
 …
   Void resetPicAlfUnit();
   Void setAlfCoefInSlice(Bool b) {m_alfCoefInSlice = b;}
-#else
-#if ALF_CHROMA_LAMBDA
-#if HHI_INTERVIEW_SKIP
-  Void ALFProcess(ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambdaLuma, Double dLambdaChroma, UInt64& ruiDist, UInt64& ruiBits, Bool bInterviewSkip); //!< estimate ALF parameters
-#else
-  Void ALFProcess(ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambdaLuma, Double dLambdaChroma, UInt64& ruiDist, UInt64& ruiBits); //!< estimate ALF parameters
-#endif
-#else
-#if HHI_INTERVIEW_SKIP
-  Void ALFProcess(ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambda, UInt64& ruiDist, UInt64& ruiBits, Bool bInterviewSkip); //!< estimate ALF parameters
-#else
-  Void ALFProcess(ALFParam* pcAlfParam, std::vector<AlfCUCtrlInfo>* pvAlfCtrlParam, Double dLambda, UInt64& ruiDist, UInt64& ruiBits); //!< estimate ALF parameters
-#endif
-#endif
-  Void setGOPSize(Int val) { m_iGOPSize = val; } //!< set GOP size
-#endif
   Void setALFEncodePassReduction (Int iVal) {m_iALFEncodePassReduction = iVal;} //!< set N-pass encoding. 0: 16(14)-pass encoding, 1: 1-pass encoding, 2: 2-pass encoding
   Void setALFMaxNumberFilters    (Int iVal) {m_iALFMaxNumberFilters = iVal;} //!< set ALF Max Number of Filters
-#if LCU_SYNTAX_ALF
   Void createAlfGlobalBuffers(); //!< create ALF global buffers
   Void initPicQuadTreePartition(Bool isPicBasedEncode);
-#else
-  Void createAlfGlobalBuffers(Int iALFEncodePassReduction); //!< create ALF global buffers
-#endif
   Void destroyAlfGlobalBuffers(); //!< destroy ALF global buffers
   Void PCMLFDisableProcess (TComPic* pcPic);

trunk/source/Lib/TLibEncoder/TEncBinCoder.h

-                      r56
+                      r296
   virtual Void  finish            ()                                          = 0;
   virtual Void  copyState         ( TEncBinIf* pcTEncBinIf )                  = 0;
-#if OL_FLUSH
   virtual Void  flush            ()                                           = 0;
-#endif
   virtual Void  encodeFlush     (Bool bEnd) = 0;
   virtual Void  resetBac          ()                                          = 0;
-#if BURST_IPCM
   virtual Void  encodeNumSubseqIPCM( Int numSubseqIPCM )                   = 0;
-#endif
   virtual Void  encodePCMAlignBits()                                          = 0;
   virtual Void  xWritePCMCode     ( UInt uiCode, UInt uiLength )              = 0;

trunk/source/Lib/TLibEncoder/TEncBinCoderCABAC.cpp

r56	r296
105	105	}
106	106
107		~~#if OL_FLUSH~~
108	107	Void TEncBinCABAC::flush()
109	108	{
…	…
117	116	start();
118	117	}
119		~~#endif~~
120	118
121	119	/** Reset BAC register and counter values.
…	…
127	125	}
128	126
129		~~#if BURST_IPCM~~
130	127	/** Encode # of subsequent IPCM blocks.
131	128	* \param numSubseqIPCM
…	…
153	150	}
154	151	}
155		~~#endif~~
156	152
157	153	/** Encode PCM alignment zero bits.
…	…
160	156	Void TEncBinCABAC::encodePCMAlignBits()
161	157	{
162		~~#if !BURST_IPCM~~
163		~~finish();~~
164		~~m_pcTComBitIf->write( 1, 1 ); // stop bit~~
165		~~#endif~~
166	158	m_pcTComBitIf->writeAlignZero(); // pcm align zero
167	159	}

trunk/source/Lib/TLibEncoder/TEncBinCoderCABAC.h

-                      r56
+                      r296
   Void  finish            ();
   Void  copyState         ( TEncBinIf* pcTEncBinIf );
-#if OL_FLUSH
   Void  flush            ();
-#endif
   Void  resetBac          ();
-#if BURST_IPCM
   Void  encodeNumSubseqIPCM( Int numSubseqIPCM );
-#endif
   Void  encodePCMAlignBits();
   Void  xWritePCMCode     ( UInt uiCode, UInt uiLength );

trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

-                      r210
+                      r296
   //DF flag
   WRITE_FLAG(pcAPS->getLoopFilterOffsetInAPS()?1:0, "aps_deblocking_filter_flag");
+#if !SAO_UNIT_INTERLEAVING
+  //SAO flag
+  WRITE_FLAG( pcAPS->getSaoEnabled()?1:0, "aps_sample_adaptive_offset_flag");
+#endif
+#if !LCU_SYNTAX_ALF
+  //ALF flag
+  WRITE_FLAG( pcAPS->getAlfEnabled()?1:0, "aps_adaptive_loop_filter_flag");
+#endif
+}
+#if LCU_SYNTAX_ALF
+}
 Void TEncCavlc::codeAPSAlflag(UInt uiCode)
+{
   WRITE_FLAG(uiCode, "aps_adaptive_loop_filter_flag");
+}
-#endif
 Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName)
 …
+}
-#if RPS_IN_SPS
 Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps )
-#else
-Void TEncCavlc::codeShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps )
-#endif
+{
 #if PRINT_RPS_INFO
 …
   xTracePPSHeader (pcPPS);
 #endif
-#if !RPS_IN_SPS
-  TComRPSList* rpsList = pcPPS->getRPSList();
-#endif
   WRITE_UVLC( pcPPS->getPPSId(),                             "pic_parameter_set_id" );
   WRITE_UVLC( pcPPS->getSPSId(),                             "seq_parameter_set_id" );
-#if MULTIBITS_DATA_HIDING
   WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
   if( pcPPS->getSignHideFlag() )
 …
     WRITE_CODE(pcPPS->getTSIG(), 4, "sign_hiding_threshold");
+  }
-#endif
 #if CABAC_INIT_FLAG
   WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0,   "cabac_init_present_flag" );
-#endif
-#if !RPS_IN_SPS
-  // RPS is put before entropy_coding_mode_flag
-  // since entropy_coding_mode_flag will probably be removed from the WD
-  TComReferencePictureSet*      rps;
-  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
-  for(UInt i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
+  {
-    rps = rpsList->getReferencePictureSet(i);
-    codeShortTermRefPicSet(pcPPS,rps);
+  }
-  WRITE_FLAG( pcPPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
 #endif
   // entropy_coding_mode_flag
 …
   if (pcPPS->getEntropyCodingMode())
+  {
+#if !WPP_SIMPLIFICATION
+    WRITE_UVLC( pcPPS->getEntropyCodingSynchro(),            "entropy_coding_synchro" );
+    WRITE_FLAG( pcPPS->getCabacIstateReset() ? 1 : 0,        "cabac_istate_reset" );
+#endif
+#if !TILES_OR_ENTROPY_SYNC_IDC
+#if !WPP_SIMPLIFICATION
+    if ( pcPPS->getEntropyCodingSynchro() )
+#endif
+    {
+      WRITE_UVLC( pcPPS->getNumSubstreams()-1,               "num_substreams_minus1" );
+    }
+#endif
+  }
+#if !H0566_TLA
+  WRITE_UVLC( pcPPS->getNumTLayerSwitchingFlags(),           "num_temporal_layer_switching_point_flags" );
+  for( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
+  {
+    WRITE_FLAG( pcPPS->getTLayerSwitchingFlag( i ) ? 1 : 0 , "temporal_layer_switching_point_flag" );
+  }
+#endif
+  }
   //   num_ref_idx_l0_default_active_minus1
   //   num_ref_idx_l1_default_active_minus1
 …
   WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0,  "weighted_pred_flag" );   // Use of Weighting Prediction (P_SLICE)
   WRITE_CODE( pcPPS->getWPBiPredIdc(), 2, "weighted_bipred_idc" );  // Use of Weighting Bi-Prediction (B_SLICE)
-#if H0388
   WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,  "output_flag_present_flag" );
-#endif
-#if TILES_OR_ENTROPY_SYNC_IDC
   if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==1)
+  {
-#endif
     WRITE_FLAG( pcPPS->getColumnRowInfoPresent(),           "tile_info_present_flag" );
     WRITE_FLAG( pcPPS->getTileBehaviorControlPresentFlag(),  "tile_control_present_flag");
 …
       if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0)
+      {
-#if !REMOVE_TILE_DEPENDENCE
-        WRITE_FLAG( pcPPS->getTileBoundaryIndependenceIdr(),                         "tile_boundary_independence_flag" );
-        if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
+        {
-#endif
           WRITE_FLAG( pcPPS->getLFCrossTileBoundaryFlag()?1 : 0,            "loop_filter_across_tile_flag");
+#if !REMOVE_TILE_DEPENDENCE
+        }
+#endif
+      }
+    }
+#if TILES_OR_ENTROPY_SYNC_IDC
+      }
+    }
+  }
   else if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==2)
 …
     WRITE_UVLC( pcPPS->getNumSubstreams()-1,               "num_substreams_minus1" );
+  }
+#endif
+#if DBL_CONTROL
   WRITE_FLAG( pcPPS->getDeblockingFilterControlPresent()?1 : 0, "deblocking_filter_control_present_flag");
-#endif
-#if PARALLEL_MERGE
   WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
-#endif
   WRITE_FLAG( 0, "pps_extension_flag" );
+}
 …
+      }
+    }
+#if INTER_VIEW_VECTOR_SCALING_C0115
+      WRITE_FLAG( pcVPS->getIVScalingFlag(),                      "inter_view_vector_scaling_flag" );
+#endif
+  }
 …
 #endif
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
 Void TEncCavlc::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
 #else
 …
   WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
   WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
-#if PIC_CROPPING
   WRITE_FLAG( pcSPS->getPicCroppingFlag(),          "pic_cropping_flag" );
   if (pcSPS->getPicCroppingFlag())
 …
     WRITE_UVLC( pcSPS->getPicCropBottomOffset(),    "pic_crop_bottom_offset" );
+  }
-#endif
 #if FULL_NBIT
 …
   WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
+  {
 …
     WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "max_latency_increase[i]" );
+  }
-#else
-  WRITE_UVLC( pcSPS->getMaxNumberOfReferencePictures(), "max_num_ref_pics" );
-  WRITE_UVLC( pcSPS->getNumReorderFrames(),             "num_reorder_frames" );
-  WRITE_UVLC(pcSPS->getMaxDecFrameBuffering(),          "max_dec_frame_buffering" );
-  WRITE_UVLC(pcSPS->getMaxLatencyIncrease(),            "max_latency_increase"    );
-#endif
   assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
 …
+  }
-#if H0412_REF_PIC_LIST_RESTRICTION
   WRITE_FLAG( pcSPS->getRestrictedRefPicListsFlag(),                                 "restricted_ref_pic_lists_flag" );
   if( pcSPS->getRestrictedRefPicListsFlag() )
 …
     WRITE_FLAG( pcSPS->getListsModificationPresentFlag(),                            "lists_modification_present_flag" );
+  }
-#endif
   WRITE_UVLC( log2MinCUSize - 3,                                                     "log2_min_coding_block_size_minus3" );
   WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth,                                 "log2_diff_max_min_coding_block_size" );
 …
   WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0,                                            "sample_adaptive_offset_enabled_flag");
   WRITE_FLAG( pcSPS->getUseALF () ? 1 : 0,                                           "adaptive_loop_filter_enabled_flag");
-#if LCU_SYNTAX_ALF
   if(pcSPS->getUseALF())
+  {
     WRITE_FLAG( (pcSPS->getUseALFCoefInSlice()) ? 1 : 0,                             "alf_coef_in_slice_flag");
+  }
-#endif
   if( pcSPS->getUsePCM() )
 …
   WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0,                             "temporal_id_nesting_flag" );
-#if RPS_IN_SPS
   TComRPSList* rpsList = pcSPS->getRPSList();
   TComReferencePictureSet*      rps;
 …
+  }
   WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
-#endif
-#if !PIC_CROPPING
-  //!!!KS: Syntax not in WD !!!
-  xWriteUvlc  ( pcSPS->getPad (0) );
-  xWriteUvlc  ( pcSPS->getPad (1) );
-#endif
   // AMVP mode for each depth
   for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
 …
+  }
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   Int tilesOrEntropyCodingSyncIdc = 0;
   if ( pcSPS->getNumColumnsMinus1() > 0 || pcSPS->getNumRowsMinus1() > 0)
 …
   pcSPS->setTilesOrEntropyCodingSyncIdc( tilesOrEntropyCodingSyncIdc );
   WRITE_CODE(tilesOrEntropyCodingSyncIdc, 2, "tiles_or_entropy_coding_sync_idc");
+#endif
+#if TILES_OR_ENTROPY_SYNC_IDC
   if(tilesOrEntropyCodingSyncIdc == 1)
+  {
-#endif
     WRITE_UVLC( pcSPS->getNumColumnsMinus1(),                           "num_tile_columns_minus1" );
     WRITE_UVLC( pcSPS->getNumRowsMinus1(),                              "num_tile_rows_minus1" );
 …
     if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0)
+    {
-#if !REMOVE_TILE_DEPENDENCE
-      WRITE_FLAG( pcSPS->getTileBoundaryIndependenceIdr(),                "tile_boundary_independence_flag" );
-      if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
+      {
-#endif
         WRITE_FLAG( pcSPS->getLFCrossTileBoundaryFlag()?1 : 0,            "loop_filter_across_tile_flag");
+#if !REMOVE_TILE_DEPENDENCE
+      }
+#endif
+    }
+#if TILES_OR_ENTROPY_SYNC_IDC
+  }
+#endif
+    }
+  }
   WRITE_FLAG( 1, "sps_extension_flag" );
 #if !QC_MVHEVC_B0046
 …
           WRITE_SVLC( pcSPS->getPdmOffset       ()[ uiId ], "Pdm_offset" );
+        }
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
         WRITE_UVLC( pcSPS->getMultiviewMvPredMode(), "multi_view_mv_pred_mode" );
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
         WRITE_FLAG  ( pcSPS->getMultiviewResPredMode(), "multi_view_residual_pred_mode" );
 #endif
 …
   if (address==0)
+  {
+    if( pcSlice->getSPS()->getViewId() && !pcSlice->getIsDepth() )
+    if( pcSlice->getSPS()->getViewId()
+#if !LGE_ILLUCOMP_DEPTH_C0046
+        && !pcSlice->getIsDepth()
+#endif
+        )
+    {
       WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "applying IC flag" );
 …
     WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "pic_parameter_set_id" );
 #endif
-#if H0388
     if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
+    {
       WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
+    }
-#endif
 #if QC_REM_IDV_B0046
     if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && pcSlice->getViewId() == 0)
 …
+        {
           WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
-#if RPS_IN_SPS
           codeShortTermRefPicSet(pcSlice->getSPS(), rps);
-#else
-          codeShortTermRefPicSet(pcSlice->getPPS(), rps);
-#endif
+        }
         else
 …
           WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
+        }
-#if RPS_IN_SPS
         if(pcSlice->getSPS()->getLongTermRefsPresent())
-#else
-        if(pcSlice->getPPS()->getLongTermRefsPresent())
-#endif
+        {
           WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
           Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
           Int prev = 0;
-#if LTRP_MULT
           Int prevDeltaPocLt=0;
           Int currDeltaPocLt=0;
-#endif
           for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
+          {
             WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
-#if LTRP_MULT
             currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
 …
+            }
             prevDeltaPocLt=currDeltaPocLt;
-#endif
             prev = rps->getDeltaPOC(i);
             WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
 …
+        {
           WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
-#if RPS_IN_SPS
           codeShortTermRefPicSet(pcSlice->getSPS(), rps);
-#else
-          codeShortTermRefPicSet(pcSlice->getPPS(), rps);
-#endif
+        }
         else
 …
           WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
+        }
-#if RPS_IN_SPS
         if(pcSlice->getSPS()->getLongTermRefsPresent())
-#else
-        if(pcSlice->getPPS()->getLongTermRefsPresent())
-#endif
+        {
           WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
           Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
           Int prev = 0;
-#if LTRP_MULT
           Int prevDeltaPocLt=0;
           Int currDeltaPocLt=0;
-#endif
           for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
+          {
             WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
-#if LTRP_MULT
             currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
 …
+            }
             prevDeltaPocLt=currDeltaPocLt;
-#endif
             prev = rps->getDeltaPOC(i);
             WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
 …
       if (pcSlice->getSPS()->getUseALF())
+      {
-#if !LCU_SYNTAX_ALF
-         if (pcSlice->getAlfEnabledFlag())
+         {
-           assert (pcSlice->getAPS()->getAlfEnabled());
+         }
-#endif
          WRITE_FLAG( pcSlice->getAlfEnabledFlag(), "ALF on/off flag in slice header" );
+      }
       if (pcSlice->getSPS()->getUseSAO())
+      {
-#if SAO_UNIT_INTERLEAVING
         WRITE_FLAG( pcSlice->getSaoInterleavingFlag(), "SAO interleaving flag" );
-#endif
          assert (pcSlice->getSaoEnabledFlag() == pcSlice->getAPS()->getSaoEnabled());
          WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "SAO on/off flag in slice header" );
-#if SAO_UNIT_INTERLEAVING
          if (pcSlice->getSaoInterleavingFlag()&&pcSlice->getSaoEnabledFlag() )
+         {
 …
            WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[2], "SAO on/off flag for Cr in slice header" );
+         }
-#endif
+      }
       WRITE_UVLC( pcSlice->getAPS()->getAPSID(), "aps_id");
 …
       pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
+    }
-#if H0412_REF_PIC_LIST_RESTRICTION
     if( pcSlice->getSPS()->getListsModificationPresentFlag() )
+    {
-#endif
     TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
-#if H0137_0138_LIST_MODIFICATION
     if( !pcSlice->isIntra() )
+    {
 …
+      }
+    }
+#else
+      if(!pcSlice->isIntra())
+      {
+        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0,       "ref_pic_list_modification_flag" );
+        for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL0(); i++)
+        {
+          WRITE_UVLC( refPicListModification->getListIdcL0(i), "ref_pic_list_modification_idc");
+          WRITE_UVLC( refPicListModification->getRefPicSetIdxL0(i), "ref_pic_set_idx");
+        }
+        if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
+          WRITE_UVLC( 3, "ref_pic_list_modification_idc");
+      }
+      if(pcSlice->isInterB())
+      {
+        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0,       "ref_pic_list_modification_flag" );
+        for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL1(); i++)
+        {
+          WRITE_UVLC( refPicListModification->getListIdcL1(i), "ref_pic_list_modification_idc");
+          WRITE_UVLC( refPicListModification->getRefPicSetIdxL1(i), "ref_pic_set_idx");
+        }
+        if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
+          WRITE_UVLC( 3, "ref_pic_list_modification_idc");
+      }
+#endif
+    }
+#if H0412_REF_PIC_LIST_RESTRICTION
+  }
+#endif
+    }
+  }
   // ref_pic_list_combination( )
   // maybe move to own function?
 …
       WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1,          "num_ref_idx lc_active_minus1");
-#if H0412_REF_PIC_LIST_RESTRICTION
       if( pcSlice->getSPS()->getListsModificationPresentFlag() )
+      {
-#endif
         WRITE_FLAG( pcSlice->getRefPicListModificationFlagLC() ? 1 : 0, "ref_pic_list_modification_flag_lc" );
         if(pcSlice->getRefPicListModificationFlagLC())
 …
+          {
             WRITE_FLAG( pcSlice->getListIdFromIdxOfLC(i),               "pic_from_list_0_flag" );
-#if H0137_0138_LIST_MODIFICATION
           if (((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_0) && pcSlice->getNumRefIdx( REF_PIC_LIST_0 )>1 ) || ((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_1) && pcSlice->getNumRefIdx( REF_PIC_LIST_1 )>1 ) )
+          {
             WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i),               "ref_idx_list_curr" );
+          }
-#else
-            WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i),               "ref_idx_list_curr" );
-#endif
+          }
+        }
+#if H0412_REF_PIC_LIST_RESTRICTION
+      }
+#endif
+      }
+    }
+  }
-#if H0111_MVD_L1_ZERO
   if (pcSlice->isInterB())
+  {
     WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0,   "mvd_l1_zero_flag");
+  }
-#endif
   if(pcSlice->getPPS()->getEntropyCodingMode() && !pcSlice->isIntra())
 …
     Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
     WRITE_SVLC( iCode, "slice_qp_delta" );
-#if DBL_CONTROL
     if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
+    {
 …
         WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
+      }
-#else
-    WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
-#endif
       if (!pcSlice->getInheritDblParamFromAPS())
+      {
 …
+        }
+      }
+#if DBL_CONTROL
+    }
+#endif
+    }
     if ( pcSlice->getSliceType() == B_SLICE )
+    {
 …
+  }
 #if ( HHI_MPI || HHI_INTER_VIEW_MOTION_PRED )
   #if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
+#if ( HHI_MPI || H3D_IVMP )
+  #if ( HHI_MPI && H3D_IVMP )
   const int iExtraMergeCandidates = ( pcSlice->getSPS()->getUseMVI() || pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0;
   #elif HHI_MPI
   const int iExtraMergeCandidates = pcSlice->getSPS()->getUseMVI() ? 1 : 0;
+  #elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
+  const int iExtraMergeCandidates = ( pcSlice->getIsDepth() || pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0;
   #else
   const int iExtraMergeCandidates = pcSlice->getSPS()->getMultiviewMvPredMode() ? 1 : 0;
 …
  \param pcSlice Where we find the substream size information.
  */
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
 Void  TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
+{
 …
   delete [] entryPointOffset;
+}
-#else
-Void TEncCavlc::codeSliceHeaderSubstreamTable( TComSlice* pcSlice )
+{
-  UInt uiNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
-  UInt*puiSubstreamSizes = pcSlice->getSubstreamSizes();
-  // Write header information for all substreams except the last.
-  for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
+  {
-    UInt uiNumbits = puiSubstreamSizes[ui];
-    //the 2 first bits are used to give the size of the header
-    if ( uiNumbits < (1<<8) )
+    {
-      xWriteCode(0,         2  );
-      xWriteCode(uiNumbits, 8  );
+    }
-    else if ( uiNumbits < (1<<16) )
+    {
-      xWriteCode(1,         2  );
-      xWriteCode(uiNumbits, 16 );
+    }
-    else if ( uiNumbits < (1<<24) )
+    {
-      xWriteCode(2,         2  );
-      xWriteCode(uiNumbits, 24 );
+    }
-    else if ( uiNumbits < (1<<31) )
+    {
-      xWriteCode(3,         2  );
-      xWriteCode(uiNumbits, 32 );
+    }
-    else
+    {
-      printf("Error in codeSliceHeaderTable\n");
-      exit(-1);
+    }
+  }
+}
-#endif
 Void TEncCavlc::codeTerminatingBit      ( UInt uilsLast )
 …
+}
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
 Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
 #else
 …
+}
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
 Void
 TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
 …
+}
-#if BURST_IPCM
 /** Code I_PCM information.
  * \param pcCU pointer to CU
 …
   assert(0);
+}
-#else
-/** Code I_PCM information.
- * \param pcCU pointer to CU
- * \param uiAbsPartIdx CU index
- * \returns Void
+ *
- * If I_PCM flag indicates that the CU is I_PCM, code its PCM alignment bits and codes.
- */
-Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx)
+{
-  UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
-  xWriteFlag(uiIPCM);
-  if (uiIPCM)
+  {
-    xWritePCMAlignZero();
-    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
-    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
-    UInt uiChromaOffset = uiLumaOffset>>2;
-    Pel* piPCMSample;
-    UInt uiWidth;
-    UInt uiHeight;
-    UInt uiSampleBits;
-    UInt uiX, uiY;
-    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx);
-    uiHeight = pcCU->getHeight(uiAbsPartIdx);
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample = piPCMSample[uiX];
-        xWriteCode(uiSample, uiSampleBits);
+      }
-      piPCMSample += uiWidth;
+    }
-    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
-    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample = piPCMSample[uiX];
-        xWriteCode(uiSample, uiSampleBits);
+      }
-      piPCMSample += uiWidth;
+    }
-    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
-    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
-    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
-    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
-    for(uiY = 0; uiY < uiHeight; uiY++)
+    {
-      for(uiX = 0; uiX < uiWidth; uiX++)
+      {
-        UInt uiSample = piPCMSample[uiX];
-        xWriteCode(uiSample, uiSampleBits);
+      }
-      piPCMSample += uiWidth;
+    }
+  }
+}
-#endif
 Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
 …
   Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
-#if H0736_AVC_STYLE_QP_RANGE
   Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
   iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
-#endif
   xWriteSvlc( iDQp );
 …
   xWriteSvlc( iCode );
+}
-#if LCU_SYNTAX_ALF
 /** Code the fixed length code (smaller than one max value) in OSALF
  * \param idx:  coded value
 …
+  }
+}
-#endif
 Void TEncCavlc::codeSaoFlag( UInt uiCode )
 …
     xWriteSvlc( iCode );
+}
-#if SAO_UNIT_INTERLEAVING
 /** Code SAO run.
  * \param uiCode
 …
   WRITE_CODE( uiCode, uiLength, "sao_run_diff");
+}
-#endif
 Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
 …
 Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
+{
-#if SCALING_LIST
   Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
   UInt* scan    = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2];
-#else
-  Int coefNum = (Int)g_scalingListSize[sizeId];
-  UInt* scan    = g_auiFrameScanXY [ sizeId + 1];
-#endif
   Int nextCoef = SCALING_LIST_START_VALUE;
   Int data;
   Int *src = scalingList->getScalingListAddress(sizeId, listId);
-#if SCALING_LIST
   if(sizeId > SCALING_LIST_8x8 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
+  {
 …
+    }
+  }
-#else
-  for(Int i=0;i<coefNum;i++)
+  {
-    data = src[scan[i]] - nextCoef;
-    nextCoef = src[scan[i]];
-    if(data > 127)
+    {
-      data = data - 256;
+    }
-    if(data < -128)
+    {
-      data = data + 256;
+    }
-    WRITE_SVLC( data,  "delta_coef");
+  }
-#endif
+}
 Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
 …
   for(Int predListIdx = (Int)listId -1 ; predListIdx >= 0; predListIdx--)
+  {
-#if SCALING_LIST
     if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
      && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
-#else
-    if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*(Int)g_scalingListSize[sizeId])) // check value of matrix
-#endif
+    {
       setRefMatrixId(sizeId, listId, predListIdx);

trunk/source/Lib/TLibEncoder/TEncCavlc.h

-                      r210
+                      r296
   Void  xWriteUnaryMaxSymbol  ( UInt uiSymbol, UInt uiMaxSymbol );
-#if RPS_IN_SPS
   Void codeShortTermRefPicSet              ( TComSPS* pcSPS, TComReferencePictureSet* pcRPS );
-#else
-  Void codeShortTermRefPicSet              ( TComPPS* pcPPS, TComReferencePictureSet* pcRPS );
-#endif
   UInt  xConvertToUInt        ( Int iValue ) {  return ( iValue <= 0) ? -iValue<<1 : (iValue<<1)-1; }
 …
 #endif
 #if HHI_MPI
+#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
   Void  codeSPS                 ( TComSPS* pcSPS, Bool bIsDepth );
 #else
 …
   Void codeTileMarkerFlag(TComSlice* pcSlice);
-#if TILES_WPP_ENTRY_POINT_SIGNALLING
   Void  codeTilesWPPEntryPoint( TComSlice* pSlice );
-#else
-  Void  codeSliceHeaderSubstreamTable( TComSlice* pcSlice );
-#endif
   Void  codeTerminatingBit      ( UInt uilsLast );
   Void  codeSliceFinish         ();
 …
   Void  encodeStart             () {}
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum );
 #else
 …
   Void codeAlfSvlc       ( Int   iCode );
   Void codeAlfCtrlDepth();
-#if LCU_SYNTAX_ALF
   Void codeAPSAlflag(UInt uiCode);
   Void codeAlfFixedLengthIdx( UInt idx, UInt numFilterSetsInBuffer);
-#endif
   Void codeSaoFlag       ( UInt uiCode );
   Void codeSaoUvlc       ( UInt uiCode );
   Void codeSaoSvlc       ( Int   iCode );
-#if SAO_UNIT_INTERLEAVING
   Void codeSaoRun        ( UInt uiCode, UInt maxValue  );
   Void codeSaoMergeLeft  ( UInt uiCode, UInt compIdx ){;}
 …
   Void codeSaoTypeIdx    ( UInt uiCode ){ xWriteUvlc(uiCode   );}
   Void codeSaoUflc       ( UInt uiCode ){ assert(uiCode < 32); xWriteCode(uiCode, 5);}
-#endif
   Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
 …
   Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
   Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx );
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void codeResPredFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx );
 #endif
 …
   Void codePredMode      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
-#if BURST_IPCM
   Void codeIPCMInfo      ( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag);
-#else
-  Void codeIPCMInfo      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
-#endif
   Void codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx );

trunk/source/Lib/TLibEncoder/TEncCfg.h

-                      r210
+                      r296
   Int       m_iSourceWidth;
   Int       m_iSourceHeight;
-#if PIC_CROPPING
   Int       m_croppingMode;
   Int       m_cropLeft;
 …
   Int       m_cropTop;
   Int       m_cropBottom;
-#endif
   Int       m_iFrameToBeEncoded;
   Double    m_adLambdaModifier[ MAX_TLAYER ];
 …
   GOPEntryMvc m_GOPList[MAX_GOP+1];
   Int       m_extraRPSs;
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Int       m_maxDecPicBuffering[MAX_TLAYER];
   Int       m_numReorderPics[MAX_TLAYER];
-#else
-  Int       m_maxNumberOfReferencePictures;
-  Int       m_numReorderFrames;
-#endif
   Int       m_iQP;                              //  if (AdaptiveQP == OFF)
 …
                                                  // TODO: We need to have a common sliding mechanism used by both the encoder and decoder
-#if H0566_TLA
   Int       m_maxTempLayer;                      ///< Max temporal layer
-#else
-  Bool      m_bTLayering;                        ///< indicates whether temporal IDs are set based on the hierarchical coding structure
-  Bool      m_abTLayerSwitchingFlag[MAX_TLAYER]; ///< temporal layer switching flags corresponding to temporal layer
-#endif
   Bool      m_bDisInter4x4;
   Bool m_useAMP;
 …
   Int       m_loopFilterBetaOffsetDiv2;
   Int       m_loopFilterTcOffsetDiv2;
-#if DBL_CONTROL
   Bool      m_DeblockingFilterControlPresent;
-#endif
   Bool      m_bUseSAO;
 #if LGE_ILLUCOMP_B0045
   Bool      m_bUseIC;
 #endif
+#if SAO_UNIT_INTERLEAVING
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Bool      m_bUseIVS;
+#endif
   Int       m_maxNumOffsetsPerPic;
   Bool      m_saoInterleavingFlag;
-#endif
   //====== Lossless ========
 …
   Int       m_iALFMaxNumberFilters;
-#if LCU_SYNTAX_ALF
   Bool      m_bALFParamInSlice;
   Bool      m_bALFPicBasedEncode;
-#endif
   Bool      m_bUseASR;
 …
   Bool      m_bLCMod;
   Bool      m_bUseRDOQ;
-#if !PIC_CROPPING
-  Bool      m_bUsePAD;
-#endif
   Bool      m_bUseFastEnc;
   Bool      m_bUseEarlyCU;
-#if FAST_DECISION_FOR_MRG_RD_COST
   Bool      m_useFastDecisionForMerge;
-#endif
   Bool      m_bUseCbfFastMode;
   Bool      m_bUseLMChroma;
 …
   Bool      m_bEnableTMVP;
-#if MULTIBITS_DATA_HIDING
   Int       m_signHideFlag;
   Int       m_signHidingThreshold;
-#endif
 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   UInt        m_uiMultiviewMvPredMode;
   UInt        m_uiMultiviewMvRegMode;
   Double      m_dMultiviewMvRegLambdaScale;
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   UInt        m_uiMultiviewResPredMode;
 #endif
 …
   Void      setSourceWidth                  ( Int   i )      { m_iSourceWidth = i; }
   Void      setSourceHeight                 ( Int   i )      { m_iSourceHeight = i; }
-#if PIC_CROPPING
   Void      setCroppingMode                 ( Int   i )      { m_croppingMode = i; }
   Void      setCropLeft                     ( Int   i )      { m_cropLeft = i; }
 …
   Void      setCropTop                      ( Int   i )      { m_cropTop = i; }
   Void      setCropBottom                   ( Int   i )      { m_cropBottom = i; }
-#endif
   Void      setFrameToBeEncoded             ( Int   i )      { m_iFrameToBeEncoded = i; }
 …
   Void      setExtraRPSs                    ( Int   i )      { m_extraRPSs = i; }
   GOPEntryMvc getGOPEntry                   ( Int   i )      { return m_GOPList[i]; }
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Void      setMaxDecPicBuffering           ( UInt u, UInt tlayer ) { m_maxDecPicBuffering[tlayer] = u;    }
   Void      setNumReorderPics               ( Int  i, UInt tlayer ) { m_numReorderPics[tlayer] = i;    }
-#else
-  Void      setMaxNumberOfReferencePictures ( Int u )       { m_maxNumberOfReferencePictures = u;    }
-  Void      setNumReorderFrames             ( Int  i )       { m_numReorderFrames = i;    }
-#endif
 #if HHI_INTERVIEW_SKIP
 …
   Void      setMaxRefPicNum                 ( Int iMaxRefPicNum )           { m_iMaxRefPicNum = iMaxRefPicNum;  }
-#if H0566_TLA
   Bool      getMaxTempLayer                 ()                              { return m_maxTempLayer;              }
   Void      setMaxTempLayer                 ( Int maxTempLayer )            { m_maxTempLayer = maxTempLayer;      }
-#else
-  Bool      getTLayering                    ()                              { return m_bTLayering;              }
-  Void      setTLayering                    ( Bool bTLayering )             { m_bTLayering = bTLayering;        }
-  Bool      getTLayerSwitchingFlag          ( UInt uiTLayer )               { assert (uiTLayer < MAX_TLAYER ); return  m_abTLayerSwitchingFlag[uiTLayer];                   }
-  Void      setTLayerSwitchingFlag          ( Bool* pbTLayerSwitchingFlag ) { for ( Int i = 0; i < MAX_TLAYER; i++ ) m_abTLayerSwitchingFlag[i] = pbTLayerSwitchingFlag[i]; }
-#endif
   Bool      getDisInter4x4                  ()              { return m_bDisInter4x4;        }
 …
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   Void      setMultiviewMvPredMode          ( UInt  u )      { m_uiMultiviewMvPredMode      = u; }
   Void      setMultiviewMvRegMode           ( UInt  u )      { m_uiMultiviewMvRegMode       = u; }
   Void      setMultiviewMvRegLambdaScale    ( Double d)      { m_dMultiviewMvRegLambdaScale = d; }
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   Void      setMultiviewResPredMode         ( UInt  u )      { m_uiMultiviewResPredMode     = u; }
 #endif
 …
   Void      setLoopFilterBetaOffset         ( Int   i )      { m_loopFilterBetaOffsetDiv2  = i; }
   Void      setLoopFilterTcOffset           ( Int   i )      { m_loopFilterTcOffsetDiv2    = i; }
-#if DBL_CONTROL
   Void      setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; }
-#endif
   //====== Motion search ========
 …
   Void      setVerticalDisparitySearchRange ( Int   i )      { m_iVerticalDisparitySearchRange = i; }
 #endif
 #if HHI_INTER_VIEW_MOTION_PRED
+#if H3D_IVMP
   UInt      getMultiviewMvRegMode           ()      { return  m_uiMultiviewMvRegMode; }
   Double    getMultiviewMvRegLambdaScale    ()      { return  m_dMultiviewMvRegLambdaScale; }
 …
   Int       getSourceWidth                  ()      { return  m_iSourceWidth; }
   Int       getSourceHeight                 ()      { return  m_iSourceHeight; }
-#if PIC_CROPPING
   Int       getCroppingMode                 ()      { return  m_croppingMode; }
   Int       getCropLeft                     ()      { return  m_cropLeft; }
 …
   Int       getCropTop                      ()      { return  m_cropTop; }
   Int       getCropBottom                   ()      { return  m_cropBottom; }
-#endif
   Int       getFrameToBeEncoded             ()      { return  m_iFrameToBeEncoded; }
   void setLambdaModifier                    ( UInt uiIndex, Double dValue ) { m_adLambdaModifier[ uiIndex ] = dValue; }
 …
   UInt      getDecodingRefreshType          ()      { return  m_uiDecodingRefreshType; }
   Int       getGOPSize                      ()      { return  m_iGOPSize; }
-#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
   Int       getMaxDecPicBuffering           (UInt tlayer) { return m_maxDecPicBuffering[tlayer]; }
   Int       getNumReorderPics               (UInt tlayer) { return m_numReorderPics[tlayer]; }
-#else
-  Int      getMaxNumberOfReferencePictures ()      { return m_maxNumberOfReferencePictures; }
-  Int       geNumReorderFrames              ()      { return m_numReorderFrames; }
-#endif
   Int       getQP                           ()      { return  m_iQP; }
 …
   Int       getLoopFilterBetaOffset         ()      { return m_loopFilterBetaOffsetDiv2; }
   Int       getLoopFilterTcOffset           ()      { return m_loopFilterTcOffsetDiv2; }
-#if DBL_CONTROL
   Bool      getDeblockingFilterControlPresent()  { return  m_DeblockingFilterControlPresent; }
-#endif
   //==== Motion search ========
 …
   Void      setLCMod                        ( Bool  b )     { m_bLCMod   = b;    }
   Void      setUseRDOQ                      ( Bool  b )     { m_bUseRDOQ    = b; }
-#if !PIC_CROPPING
-  Void      setUsePAD                       ( Bool  b )     { m_bUsePAD     = b; }
-#endif
 #if HHI_VSO
   Void      setUseVSO                       ( Bool  b )     { m_bUseVSO     = b; }
 …
   Void      setUseFastEnc                   ( Bool  b )     { m_bUseFastEnc = b; }
   Void      setUseEarlyCU                   ( Bool  b )     { m_bUseEarlyCU = b; }
-#if FAST_DECISION_FOR_MRG_RD_COST
   Void      setUseFastDecisionForMerge      ( Bool  b )     { m_useFastDecisionForMerge = b; }
-#endif
   Void      setUseCbfFastMode            ( Bool  b )     { m_bUseCbfFastMode = b; }
   Void      setUseConstrainedIntraPred      ( Bool  b )     { m_bUseConstrainedIntraPred = b; }
 …
   Void      setALFMaxNumberFilters          (Int i)  { m_iALFMaxNumberFilters = i; }
   Int       getALFMaxNumberFilters          ()       { return m_iALFMaxNumberFilters; }
-#if LCU_SYNTAX_ALF
   Void      setALFParamInSlice              (Bool b) {m_bALFParamInSlice = b;}
   Bool      getALFParamInSlice              ()       {return m_bALFParamInSlice;}
   Void      setALFPicBasedEncode            (Bool b) {m_bALFPicBasedEncode = b;}
   Bool      getALFPicBasedEncode            ()       {return m_bALFPicBasedEncode;}
-#endif
   Bool      getUseLComb                     ()      { return m_bUseLComb;   }
   Bool      getLCMod                        ()      { return m_bLCMod; }
   Bool      getUseRDOQ                      ()      { return m_bUseRDOQ;    }
-#if !PIC_CROPPING
-  Bool      getUsePAD                       ()      { return m_bUsePAD;     }
-#endif
 #if HHI_VSO
 …
   Bool      getUseFastEnc                   ()      { return m_bUseFastEnc; }
   Bool      getUseEarlyCU                   ()      { return m_bUseEarlyCU; }
-#if FAST_DECISION_FOR_MRG_RD_COST
   Bool      getUseFastDecisionForMerge      ()      { return m_useFastDecisionForMerge; }
-#endif
   Bool      getUseCbfFastMode           ()      { return m_bUseCbfFastMode; }
   Bool      getUseConstrainedIntraPred      ()      { return m_bUseConstrainedIntraPred; }
 …
   Bool  getUseIC                       ()              {return m_bUseIC;}
 #endif
+#if SAO_UNIT_INTERLEAVING
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Void  setUseIVS                       ( Bool bVal )   {m_bUseIVS = bVal;}
+  Bool  getUseIVS                       ()              {return m_bUseIVS;}
+#endif
   Void  setMaxNumOffsetsPerPic                   (Int iVal)            { m_maxNumOffsetsPerPic = iVal; }
   Int   getMaxNumOffsetsPerPic                   ()                    { return m_maxNumOffsetsPerPic; }
   Void  setSaoInterleavingFlag                   (bool bVal)           { m_saoInterleavingFlag = bVal; }
   Bool  getSaoInterleavingFlag                   ()                    { return m_saoInterleavingFlag; }
-#endif
   Void  setTileBehaviorControlPresentFlag        ( Int i )             { m_iTileBehaviorControlPresentFlag = i;    }
   Int   getTileBehaviorControlPresentFlag        ()                    { return m_iTileBehaviorControlPresentFlag; }
 …
   Void  setUniformSpacingIdr           ( Int i )           { m_iUniformSpacingIdr = i; }
   Int   getUniformSpacingIdr           ()                  { return m_iUniformSpacingIdr; }
-#if !REMOVE_TILE_DEPENDENCE
-  Void  setTileBoundaryIndependenceIdr ( Int i )           { m_iTileBoundaryIndependenceIdr = i; }
-  Int   getTileBoundaryIndependenceIdr ()                  { return m_iTileBoundaryIndependenceIdr; }
-#endif
   Void  setNumColumnsMinus1            ( Int i )           { m_iNumColumnsMinus1 = i; }
   Int   getNumColumnsMinus1            ()                  { return m_iNumColumnsMinus1; }
 …
   Void      setEnableTMVP          ( Bool b )    { m_bEnableTMVP = b;    }
   Bool      getEnableTMVP          ()            { return m_bEnableTMVP; }
-#if MULTIBITS_DATA_HIDING
   Void      setSignHideFlag( Int signHideFlag )  { m_signHideFlag = signHideFlag; }
   Void      setTSIG( Int tsig )                  { m_signHidingThreshold = tsig; }
   Int       getSignHideFlag()                    { return m_signHideFlag; }
   Int       getTSIG()                            { return m_signHidingThreshold; }
-#endif
 #if VIDYO_VPS_INTEGRATION |QC_MVHEVC_B0046
   Void      setLayerId             ( UInt layerId )   { m_layerId = layerId; }
 …
   Void      setCodedOffset                  ( Int** p )      { m_aaiCodedOffset         = p; }
 #if SONY_COLPIC_AVAILABILITY
   Int       getViewOrderIdx                 ()      { return  m_iViewOrderIdx; }
+#if INTER_VIEW_VECTOR_SCALING_C0115
+  Int       getViewOrderIdx                 ()      { return  m_iViewOrderIdx; }    // will be changed to view_id
 #endif
 };

trunk/source/Lib/TLibEncoder/TEncCu.cpp

-                      r189
+                      r296
   m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
   m_ppcOrigYuv     = new TComYuv*[m_uhTotalDepth-1];
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   m_ppcResPredTmp  = new TComYuv*[m_uhTotalDepth-1];
 #endif
 …
     m_ppcOrigYuv    [i] = new TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight);
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     m_ppcResPredTmp [i] = new TComYuv; m_ppcResPredTmp [i]->create(uiWidth, uiHeight);
 #endif
 …
   m_bEncodeDQP = false;
-#if BURST_IPCM
   m_checkBurstIPCMFlag = false;
-#endif
   // initialize partition order.
 …
       m_ppcOrigYuv[i]->destroy();     delete m_ppcOrigYuv[i];     m_ppcOrigYuv[i] = NULL;
+    }
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
     if(m_ppcResPredTmp[i])
+    {
 …
     m_ppcOrigYuv = NULL;
+  }
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
   if(m_ppcResPredTmp)
+  {
 …
+  }
-#if BURST_IPCM
   TComPic* pcPic = pcCU->getPic();
   Bool checkBurstIPCMFlag = (pcPic->getSlice(0)->getSPS()->getUsePCM())? true : false;
 …
   pcCU->setNumSucIPCM(0);
   pcCU->setLastCUSucIPCMFlag(false);
-#endif
   // Encode CU data
   xEncodeCU( pcCU, 0, 0 );
-#if OL_FLUSH
   bool bTerminateSlice = bForceTerminate;
   UInt uiCUAddr = pcCU->getAddr();
     /* If at the end of an LCU line but not at the end of a substream, perform CABAC flush */
-#if WPP_SIMPLIFICATION
     if (!bTerminateSlice && pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
-#else
-    if (!bTerminateSlice && pcCU->getSlice()->getPPS()->getCabacIstateReset())
-#endif
+    {
       Int iNumSubstreams = pcCU->getSlice()->getPPS()->getNumSubstreams();
 …
       UInt uiCol     = uiCUAddr % uiWidthInLCUs;
       UInt uiLin     = uiCUAddr / uiWidthInLCUs;
-#if !REMOVE_TILE_DEPENDENCE
-      Int iBreakDep = pcCU->getPic()->getPicSym()->getTileBoundaryIndependenceIdr();
-#endif
       UInt uiTileStartLCU = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
       UInt uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
 …
       UInt uiTileHeight = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getTileHeight();
       Int iNumSubstreamsPerTile = iNumSubstreams;
+#if !REMOVE_TILE_DEPENDENCE
+#if WPP_SIMPLIFICATION
+      if (iBreakDep && pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
+#else
+      if (iBreakDep && pcCU->getSlice()->getPPS()->getEntropyCodingSynchro())
+#endif
+      if (pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
+      {
         iNumSubstreamsPerTile /= pcCU->getPic()->getPicSym()->getNumTiles();
       if ((iBreakDep && (uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
           || (!iBreakDep && (uiCol == uiWidthInLCUs-1) && (uiLin+iNumSubstreams < pcCU->getPic()->getFrameHeightInCU())))
+      }
+      if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
+      {
         m_pcEntropyCoder->encodeFlush();
+      }
+#else
+#if WPP_SIMPLIFICATION
+      if (pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
+#else
+      if (pcCU->getSlice()->getPPS()->getEntropyCodingSynchro())
+#endif
+      {
+        iNumSubstreamsPerTile /= pcCU->getPic()->getPicSym()->getNumTiles();
+      }
+      if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
+      {
+        m_pcEntropyCoder->encodeFlush();
+      }
+#endif
+    }
+#endif // OL_FLUSH
+    }
+}
 …
   Bool  bIntraSliceDetect = (rpcBestCU->getSlice()->getSliceType() == I_SLICE);
+#if HHI_QTLPC_RAU_OFF_C0160
+  Bool rapPic     = (rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
+#endif
   Bool bTry2NxN = true;
   Bool bTryNx2N = true;
 …
 #if LGE_ILLUCOMP_B0045
+  Bool bICEnabled = (!rpcTempCU->getSlice()->getIsDepth() && rpcTempCU->getSlice()->getViewId());
+  Bool bICEnabled = (
+#if !LGE_ILLUCOMP_DEPTH_C0046
+      !rpcTempCU->getSlice()->getIsDepth() &&
+#endif
+      rpcTempCU->getSlice()->getViewId());
   bICEnabled = bICEnabled && rpcTempCU->getSlice()->getApplyIC();
 …
 #if LOSSLESS_CODING
   Bool isAddLowestQP = false;
-#if H0736_AVC_STYLE_QP_RANGE
   Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
-#else
-  Int lowestQP = 0;
-#endif
 #endif
 …
+  {
     Int idQP = m_pcEncCfg->getMaxDeltaQP();
-#if H0736_AVC_STYLE_QP_RANGE
     iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
     iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
 …
+    }
-#endif
-#else
-    iMinQP = Clip3( MIN_QP, MAX_QP, iBaseQP-idQP );
-    iMaxQP = Clip3( MIN_QP, MAX_QP, iBaseQP+idQP );
-#if LOSSLESS_CODING
-    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
+    {
-      isAddLowestQP = true;
-      iMinQP = iMinQP - 1;
+    }
-#endif
 #endif
+  }
 …
 #if OL_QTLIMIT_PREDCODING_B0068
       //logic for setting bTrySplit using the partition information that is stored of the texture colocated CU
+#if HHI_QTLPC_RAU_OFF_C0160
+      if(depthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
+#else
       if(depthMapDetect && !bIntraSliceDetect && sps->getUseQTLPC())
+#endif
+      {
         TComDataCU* pcTextureCU = pcTexture->getCU( rpcBestCU->getAddr() ); //Corresponding texture LCU
 …
       if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
+      {
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
+#if MTK_MDIVRP_C0138
+        Bool  bResPredAvailable   = false;
+        UInt uiResPrdId = 0;
+#else
         // check availability of residual prediction
         Bool  bResPredAvailable   = false;
 …
         if( bResPredAllowed )
+        {
+          bResPredAvailable       = rpcBestCU->getResidualSamples( 0,
+#if QC_SIMPLIFIEDIVRP_M24938
+            true ,
+#endif
+            m_ppcResPredTmp[uiDepth] );
+          bResPredAvailable       = rpcBestCU->getResidualSamples( 0, true , m_ppcResPredTmp[uiDepth] );
+        }
         for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
+#endif
+        {
           Bool bResPredFlag  = ( uiResPrdId > 0 );
 …
 #endif
 #endif
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
           rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
 #endif
 …
           if ( !bEarlySkip )
+          {
 #if HHI_INTER_VIEW_RESIDUAL_PRED
+#if H3D_IVRP
             rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
+#endif
+#if FIX_LGE_ILLUCOMP_B0045
+            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
 #endif
 #if HHI_INTERVIEW_SKIP

Context navigation

Changeset 296 in 3DVCSoftware for trunk

Legend: