Changeset 446 for branches/HTM-DEV-0.2-dev/source/Lib – JCT-3V 3D-HEVC

branches/HTM-DEV-0.2-dev/source/Lib/TAppCommon/TAppComCamPara.cpp

-                      r438
+                      r446
 #include <functional>
 #include <string>
+#if H_3D
 …
   AOF( radShiftParams == NULL && raiShiftParams == NULL && radLUT == NULL && raiLUT == NULL );
   uiNumberSourceViews = max( 1, uiNumberSourceViews );
   uiNumberTargetViews = Max( 1, uiNumberTargetViews );
+  uiNumberSourceViews = std::max( (UInt) 1, uiNumberSourceViews );
+  uiNumberTargetViews = std::max( (UInt) 1, uiNumberTargetViews );
   radShiftParams = new Double** [ uiNumberSourceViews ];
 …
         // 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 ) );
+        dMaxDispDev     = std::max( dMaxDispDev,    fabs( Double( (Int) iTestScale   ) - dShiftLuma * Double( 1 << iLog2DivLuma ) ) / Double( 1 << iLog2DivLuma ) );
+        dMaxRndDispDvL  = std::max( dMaxRndDispDvL, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) );
+        dMaxRndDispDvC  = std::max( dMaxRndDispDvC, fabs( Double( (Int) iShiftChroma ) - dShiftChroma ) );
+      }
 …
   AOF( iMinAbsVOIId != 0 && iMinAbsVOI != 0 );
   xGetCameraShifts( 0, iMinAbsVOIId, m_uiFirstFrameId, dCamPosShift, dPicPosShift );
+#if H_3D_PDM_CAM_PARAS
   Double  dCamPosShiftVOI01     = dCamPosShift / Double( iMinVOI );
+#endif
   //--- determine maximum absolute camera position shift, precision, and base scale ---
 …
+    }
+  }
+#if H_3D_PDM_CAM_PARAS
   Int     iPrecision  = 0;
 #if 0 // enabling this lines might be reasonable, but produces different results for the 2 view and 3 view test cases
 …
+    }
+  }
+#endif
+}
 …
   m_aaiScaleAndOffsetSet      = 0;
+#if H_3D_PDM_CAM_PARAS
   m_iPdmPrecision             = 0;
   m_aaiPdmScaleNomDelta       = 0;
   m_aaiPdmOffset              = 0;
+#endif
   m_adBaseViewShiftParameter  = 0;
 …
   xDeleteArray( m_aiBaseViewShiftLUT,        m_iNumberOfBaseViews, m_iNumberOfBaseViews,  2 );
   xDeleteArray( m_adSynthViewShiftParameter, m_iNumberOfBaseViews, Max(1,m_iNumberOfSynthViews));
   xDeleteArray( m_aiSynthViewShiftParameter, m_iNumberOfBaseViews, Max(1,m_iNumberOfSynthViews));
   xDeleteArray( m_adSynthViewShiftLUT,       m_iNumberOfBaseViews, Max(1,m_iNumberOfSynthViews), 2 );
   xDeleteArray( m_aiSynthViewShiftLUT,       m_iNumberOfBaseViews, Max(1,m_iNumberOfSynthViews), 2 );
+  xDeleteArray( m_adSynthViewShiftParameter, m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews));
+  xDeleteArray( m_aiSynthViewShiftParameter, m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews));
+  xDeleteArray( m_adSynthViewShiftLUT,       m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews), 2 );
+  xDeleteArray( m_aiSynthViewShiftLUT,       m_iNumberOfBaseViews, std::max( (Int)1 ,m_iNumberOfSynthViews), 2 );
   xDeleteArray( m_aaiCodedScale,             m_iNumberOfBaseViews );
 …
   xDeleteArray( m_aaiScaleAndOffsetSet,      m_iNumberOfBaseViews );
+#if H_3D_PDM_CAM_PARAS
   xDeleteArray( m_aaiPdmScaleNomDelta,       m_iNumberOfBaseViews );
   xDeleteArray( m_aaiPdmOffset,              m_iNumberOfBaseViews );
+#endif
+}
 …
     Int iViewOrderIdx  = (Int)( m_aadCameraParameters[ uiRow ][ 1 ] );
     iMinViewOrderIdx   = Min( iViewOrderIdx, iMinViewOrderIdx );
+    iMinViewOrderIdx   = std::min( iViewOrderIdx, iMinViewOrderIdx );
     aiViewOrderIdx     .push_back( iViewOrderIdx );
 …
     m_aiBaseId2SortedId.push_back( iCurBaseView );
     m_aiBaseSortedId2Id.push_back( iCurBaseView );
+  }
 …
   xInit2dArray  ( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiScaleAndOffsetSet, 0 );
+#if H_3D_PDM_CAM_PARAS
   xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiPdmScaleNomDelta     );
   xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiPdmOffset            );
 …
   //===== init disparity to virtual depth conversion parameters =====
   xSetPdmConversionParams();
+#endif
   //===== init arrays for first frame =====
 …
+    }
+    Bool bInterpolateFirst = true;
+    Bool bAnyInterpolated  = false;
     for( UInt uiERView = 0; uiERView < m_aiSynthViews.size() && !m_bSetupFromCoded; uiERView++ )
+    {
 …
         bInterpolated |= bInterpolatedCur;
+      }
       if( bInterpolated )
+      {
+        std::cout << "Interpolating Camera Parameters for View " << (Double)m_aiSynthViews[ uiERView ] / m_dViewNumPrec << std::endl;
+      }
+    }
+        bAnyInterpolated = true;
+        if ( bInterpolateFirst )
+        {
+          std::cout << "Interpolating Camera Parameters for View(s) " ;
+            bInterpolateFirst = false;
+        }
+        std::cout << (Double)m_aiSynthViews[ uiERView ] / m_dViewNumPrec << " " ;
+      }
+    }
+    if ( bAnyInterpolated )
+      std::cout << std::endl;
+  }
 …
+}
 #if SAIT_VSO_EST_A0033
 Void
 TAppComCamPara::xSetDispCoeff( UInt uiFrameId, Int iViewIdx )
+#if H_3D_VSO
+Void
+TAppComCamPara::setDispCoeff( UInt uiFrameId, Int iViewIdx )
+{
   UInt uiFrame = m_uiFirstFrameId + uiFrameId;
 …
     xGetZNearZFar   ( iSourceViewNum, uiFrame, dZN1, dZF1 );
     dBaseLine = ( Max( dPos[0], Max( dPos[1], dPos[2] ) ) - Min( dPos[0], Min( dPos[1], dPos[2] ) ) ) / 2.0;
+    dBaseLine = ( std::max( dPos[0], std::max( dPos[1], dPos[2] ) ) - std::min( dPos[0], std::min( dPos[1], dPos[2] ) ) ) / 2.0;
+  }
   else if( m_iNumberOfBaseViews == 2 )
 …
     dBaseLine = dPos[0] - dPos[1];
+  }
   m_dDispCoeff = fabs( dFL1 * ( dBaseLine / 2.0 ) / 255.0 * ( 1.0/dZN1 - 1.0/dZF1 ) );
 …
   return xGetViewId(m_aiRelSynthViewsNum, iRelNum );
+}
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TAppCommon/TAppComCamPara.h

-                      r438
+                      r446
   Bool                m_bSetupFromCoded;                      ///< setup from coded parameter file
   Bool                m_bCamParsCodedPrecSet;                 ///< Coded Cam Para precision set for current frame;
 #if SAIT_VSO_EST_A0033
+  //SAIT_VSO_EST_A0033
   Double              m_dDispCoeff;
-#endif
   // view lists
 …
   Int**               m_aaiScaleAndOffsetSet;                 ///< array indicating whether scale and offset have been set
+#if H_3D_PDM_CAM_PARAS
   // parameters for virtual depth map generation
   Int                 m_iPdmPrecision;                        ///< additional precision for disparity - virtual depth conversion
   Int**               m_aaiPdmScaleNomDelta;                  ///< [TargetView][RefView] delta for nominator of scale factor
   Int**               m_aaiPdmOffset;                         ///< [TargetView][RefView] offset parameter
+#endif
   // scale and offset parameters
 …
   Int                 synthRelNum2Idx           ( Int iRelNum );
   Bool getLeftRightBaseView( Int iSynthViewIdx, Int &riLeftViewIdx, Int &riRightViewIdx, Int &riRelDistToLeft, Bool& rbIsBaseView );
+  Bool                getLeftRightBaseView      ( Int iSynthViewIdx, Int &riLeftViewIdx, Int &riRightViewIdx, Int &riRelDistToLeft, Bool& rbIsBaseView );
   Int                 getRelDistLeft            ( Int iSynthViewIdx, Int   iLeftViewIdx, Int iRightViewIdx );
   UInt                getCurFrameId             ()  { return m_iCurrentFrameId;   }
   static Void         convertNumberString       ( Char* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec );
+#if SAIT_VSO_EST_A0033
+  Void xSetDispCoeff( UInt uiStartFrameId, Int iViewIdx );
+  Double getDispCoeff() { return m_dDispCoeff; }
+#if H_3D_VSO
+  // SAIT_VSO_EST_A033
+  Void                setDispCoeff              ( UInt uiStartFrameId, Int iViewIdx );
+  Double              getDispCoeff              () { return m_dDispCoeff; }
 #endif
 …
   Int**               getCodedOffset            ()  { return m_aaiCodedOffset;          }
+#if H_3D_PDM_CAM_PARAS
   // parameters for virtual depth map generation
   Int                 getPdmPrecision           ()  { return m_iPdmPrecision;           }
   Int**               getPdmScaleNomDelta       ()  { return m_aaiPdmScaleNomDelta;     }
   Int**               getPdmOffset              ()  { return m_aaiPdmOffset;            }
+#endif
 };

branches/HTM-DEV-0.2-dev/source/Lib/TAppCommon/program_options_lite.h

-                      r438
+                      r446
 #endif
 #endif
 //! \ingroup TAppCommon
 //! \{
 …
+    }
 #endif
     /** Option class for argument handling using a user provided function */
     struct OptionFunc : public OptionBase
 …
+      }
 #endif
       /**
        * Add option described by name to the parent Options list,

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/CommonDef.h

-                      r439
+                      r446
 #if H_MV
 #define NV_VERSION        "0.3"                 ///< Current software version
+#define NV_VERSION        "0.1"                 ///< Current software version
 #define HM_VERSION        "10.1"                ///<
 #else
 #define NV_VERSION        "10.0"                 ///< Current software version
+#define NV_VERSION        "10.1"                 ///< Current software version
 #endif
 …
 #define MAX_NUM_REF_PICS            16          ///< max. number of pictures used for reference
 #define MAX_NUM_REF                 16          ///< max. number of entries in picture reference list
+#if !L0034_COMBINED_LIST_CLEANUP
 #define MAX_NUM_REF_LC              MAX_NUM_REF_PICS  // TODO: remove this macro definition (leftover from combined list concept)
+#endif
 #define MAX_UINT                    0xFFFFFFFFU ///< max. value of unsigned 32-bit integer
 #define MAX_INT                     2147483647  ///< max. value of signed 32-bit integer
+#if H_3D
+#define MIN_INT                     (-2147483647-1) // < min. value of signed 32-bit integer
+#endif
 #define MAX_INT64                   0x7FFFFFFFFFFFFFFFLL  ///< max. value of signed 64-bit integer
 #define MAX_DOUBLE                  1.7e+308    ///< max. value of double-type value
 …
 template <typename T> inline T ClipY(T x) { return std::min<T>(T((1 << g_bitDepthY)-1), std::max<T>( T(0), x)); }
 template <typename T> inline T ClipC(T x) { return std::min<T>(T((1 << g_bitDepthC)-1), std::max<T>( T(0), x)); }
-template <typename T> inline T Clip(T x) { return std::min<T>(T((1 << g_bitDepthY)-1), std::max<T>( T(0), x)); }
 /** clip a, such that minVal <= a <= maxVal */
 …
+}
+#endif
+#define AOT( exp )            \
+{                             \
+  if( ( exp ) )               \
+{                           \
+  assert( 0 );              \
+}                           \
+}
+template <typename T>
+__inline T gSign(const T& t)
+{
+  if( t == 0 )
+    return T(0);
+  else
+    return (t < 0) ? T(-1) : T(1);
+}
+#define RemoveBitIncrement( exp ) ( exp >> ( g_bitDepthY - 8 ) )
+#endif
 // ====================================================================================================================
 …
   NAL_UNIT_CODED_SLICE_TSA_N,     // 2
   NAL_UNIT_CODED_SLICE_TLA,       // 3   // Current name in the spec: TSA_R
+  NAL_UNIT_CODED_SLICE_TLA_R,       // 3
   NAL_UNIT_CODED_SLICE_STSA_N,    // 4
 …
   NAL_UNIT_CODED_SLICE_RADL_N,    // 6
   NAL_UNIT_CODED_SLICE_DLP,       // 7 // Current name in the spec: RADL_R
+  NAL_UNIT_CODED_SLICE_RADL_R,      // 7
   NAL_UNIT_CODED_SLICE_RASL_N,    // 8
   NAL_UNIT_CODED_SLICE_TFD,       // 9 // Current name in the spec: RASL_R
   NAL_UNIT_RESERVED_10,
   NAL_UNIT_RESERVED_11,
   NAL_UNIT_RESERVED_12,
   NAL_UNIT_RESERVED_13,
   NAL_UNIT_RESERVED_14,
   NAL_UNIT_RESERVED_15,
   NAL_UNIT_CODED_SLICE_BLA,       // 16   // Current name in the spec: BLA_W_LP
   NAL_UNIT_CODED_SLICE_BLANT,     // 17   // Current name in the spec: BLA_W_DLP
+  NAL_UNIT_CODED_SLICE_RASL_R,      // 9
+  NAL_UNIT_RESERVED_VCL_N10,
+  NAL_UNIT_RESERVED_VCL_R11,
+  NAL_UNIT_RESERVED_VCL_N12,
+  NAL_UNIT_RESERVED_VCL_R13,
+  NAL_UNIT_RESERVED_VCL_N14,
+  NAL_UNIT_RESERVED_VCL_R15,
+  NAL_UNIT_CODED_SLICE_BLA_W_LP,    // 16
+  NAL_UNIT_CODED_SLICE_BLA_W_RADL,  // 17
   NAL_UNIT_CODED_SLICE_BLA_N_LP,  // 18
   NAL_UNIT_CODED_SLICE_IDR,       // 19  // Current name in the spec: IDR_W_DLP
+  NAL_UNIT_CODED_SLICE_IDR_W_RADL,  // 19
   NAL_UNIT_CODED_SLICE_IDR_N_LP,  // 20
   NAL_UNIT_CODED_SLICE_CRA,       // 21
   NAL_UNIT_RESERVED_22,
   NAL_UNIT_RESERVED_23,
   NAL_UNIT_RESERVED_24,
   NAL_UNIT_RESERVED_25,
   NAL_UNIT_RESERVED_26,
   NAL_UNIT_RESERVED_27,
   NAL_UNIT_RESERVED_28,
   NAL_UNIT_RESERVED_29,
   NAL_UNIT_RESERVED_30,
   NAL_UNIT_RESERVED_31,
+  NAL_UNIT_RESERVED_IRAP_VCL22,
+  NAL_UNIT_RESERVED_IRAP_VCL23,
+  NAL_UNIT_RESERVED_VCL24,
+  NAL_UNIT_RESERVED_VCL25,
+  NAL_UNIT_RESERVED_VCL26,
+  NAL_UNIT_RESERVED_VCL27,
+  NAL_UNIT_RESERVED_VCL28,
+  NAL_UNIT_RESERVED_VCL29,
+  NAL_UNIT_RESERVED_VCL30,
+  NAL_UNIT_RESERVED_VCL31,
   NAL_UNIT_VPS,                   // 32
 …
   NAL_UNIT_EOB,                   // 37
   NAL_UNIT_FILLER_DATA,           // 38
   NAL_UNIT_SEI,                   // 39 Prefix SEI
   NAL_UNIT_SEI_SUFFIX,            // 40 Suffix SEI
   NAL_UNIT_RESERVED_41,
   NAL_UNIT_RESERVED_42,
   NAL_UNIT_RESERVED_43,
   NAL_UNIT_RESERVED_44,
   NAL_UNIT_RESERVED_45,
   NAL_UNIT_RESERVED_46,
   NAL_UNIT_RESERVED_47,
+  NAL_UNIT_PREFIX_SEI,              // 39
+  NAL_UNIT_SUFFIX_SEI,              // 40
+  NAL_UNIT_RESERVED_NVCL41,
+  NAL_UNIT_RESERVED_NVCL42,
+  NAL_UNIT_RESERVED_NVCL43,
+  NAL_UNIT_RESERVED_NVCL44,
+  NAL_UNIT_RESERVED_NVCL45,
+  NAL_UNIT_RESERVED_NVCL46,
+  NAL_UNIT_RESERVED_NVCL47,
   NAL_UNIT_UNSPECIFIED_48,
   NAL_UNIT_UNSPECIFIED_49,
 …
 };
+#if H_3D
+//PICYUV
+#define PICYUV_PAD         16
+//RENDERER
+#define REN_LUMA_MARGIN   ( g_uiMaxCUWidth + PICYUV_PAD )
+#define REN_VDWEIGHT_PREC  8
+#define REN_IS_FILLED     ( 1 << REN_VDWEIGHT_PREC )
+#define REN_USED_PEL       ( (1 << g_bitDepthY) - 1 )
+#define REN_UNUSED_PEL     0
+#define REN_IS_HOLE        0
+// CAMERA PARAMETERS
+#define LOG2_DISP_PREC_LUT           2           ///< log2 of disparity precision used in integer disparity LUTs
+#define STD_CAM_PARAMETERS_PRECISION 5        ///< quarter luma sample accuarcy for derived disparities (as default)
+#endif // end of H_3D
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/NAL.h

-                      r438
+                      r446
   NalUnitType m_nalUnitType; ///< nal_unit_type
   UInt        m_temporalId;  ///< temporal_id
 #if H_MV
   Int         m_layerId;     ///< layer id
 …
     return m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLANT
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_DLP
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TFD;
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R;
+  }
 #if L0045_NON_NESTED_SEI_RESTRICTIONS
   Bool isSei()
+  {
     return m_nalUnitType == NAL_UNIT_SEI
         || m_nalUnitType == NAL_UNIT_SEI_SUFFIX;
+    return m_nalUnitType == NAL_UNIT_PREFIX_SEI
+        || m_nalUnitType == NAL_UNIT_SUFFIX_SEI;
+  }

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/SEI.cpp

-                      r438
+                      r446
 #include "CommonDef.h"
 #include "SEI.h"
+#if J0149_TONE_MAPPING_SEI
+//Table D-7 Meaning of camera iso sensitivity indicator and exposure index rating indicator
+Int  Table_exp_indicator[32] = {0, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, -1};
+#endif
 SEIMessages getSeisByType(SEIMessages &seiList, SEI::PayloadType seiType)

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/SEI.h

-                      r438
+                      r446
 };
+#if L0208_SOP_DESCRIPTION_SEI
+class SEISOPDescription : public SEI
+{
+public:
+  PayloadType payloadType() const { return SOP_DESCRIPTION; }
+  SEISOPDescription() {}
+  virtual ~SEISOPDescription() {}
+  UInt m_sopSeqParameterSetId;
+  UInt m_numPicsInSopMinus1;
+  UInt m_sopDescVclNaluType[MAX_NUM_PICS_IN_SOP];
+  UInt m_sopDescTemporalId[MAX_NUM_PICS_IN_SOP];
+  UInt m_sopDescStRpsIdx[MAX_NUM_PICS_IN_SOP];
+  Int m_sopDescPocDelta[MAX_NUM_PICS_IN_SOP];
+};
+#endif
+#if J0149_TONE_MAPPING_SEI
+class SEIToneMappingInfo : public SEI
+{
+public:
+  PayloadType payloadType() const { return TONE_MAPPING_INFO; }
+  SEIToneMappingInfo() {}
+  virtual ~SEIToneMappingInfo() {}
+  Int    m_toneMapId;
+  Bool   m_toneMapCancelFlag;
+  Bool   m_toneMapPersistenceFlag;
+  Int    m_codedDataBitDepth;
+  Int    m_targetBitDepth;
+  Int    m_modelId;
+  Int    m_minValue;
+  Int    m_maxValue;
+  Int    m_sigmoidMidpoint;
+  Int    m_sigmoidWidth;
+  std::vector<Int> m_startOfCodedInterval;
+  Int    m_numPivots;
+  std::vector<Int> m_codedPivotValue;
+  std::vector<Int> m_targetPivotValue;
+  Int    m_cameraIsoSpeedIdc;
+  Int    m_cameraIsoSpeedValue;
+  Int    m_exposureCompensationValueSignFlag;
+  Int    m_exposureCompensationValueNumerator;
+  Int    m_exposureCompensationValueDenomIdc;
+  Int    m_refScreenLuminanceWhite;
+  Int    m_extendedRangeWhiteLevel;
+  Int    m_nominalBlackLevelLumaCodeValue;
+  Int    m_nominalWhiteLevelLumaCodeValue;
+  Int    m_extendedWhiteLevelLumaCodeValue;
+};
+#endif
 typedef std::list<SEI*> SEIMessages;
 …
 Void deleteSEIs (SEIMessages &seiList);
+#if K0180_SCALABLE_NESTING_SEI
+class SEIScalableNesting : public SEI
+{
+public:
+  PayloadType payloadType() const { return SCALABLE_NESTING; }
+  SEIScalableNesting() {}
+  virtual ~SEIScalableNesting()
+  {
+    if (!m_callerOwnsSEIs)
+    {
+      deleteSEIs(m_nestedSEIs);
+    }
+  }
+  Bool  m_bitStreamSubsetFlag;
+  Bool  m_nestingOpFlag;
+  Bool  m_defaultOpFlag;                             //value valid if m_nestingOpFlag != 0
+  UInt  m_nestingNumOpsMinus1;                       // -"-
+  UInt  m_nestingMaxTemporalIdPlus1[MAX_TLAYER];     // -"-
+  UInt  m_nestingOpIdx[MAX_NESTING_NUM_OPS];         // -"-
+  Bool  m_allLayersFlag;                             //value valid if m_nestingOpFlag == 0
+  UInt  m_nestingNoOpMaxTemporalIdPlus1;             //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0
+  UInt  m_nestingNumLayersMinus1;                    //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0
+  UChar m_nestingLayerId[MAX_NESTING_NUM_LAYER];     //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0. This can e.g. be a static array of 64 unsigned char values
+  Bool  m_callerOwnsSEIs;
+  SEIMessages m_nestedSEIs;
+};
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComBitStream.cpp

-                      r438
+                      r446
+  }
+}
 Void TComOutputBitstream::writeByteAlignment()
+{
 …
   writeAlignZero();
+}
+Int TComOutputBitstream::countStartCodeEmulations()
+{
+  UInt cnt = 0;
+  vector<uint8_t>& rbsp   = getFIFO();
+  for (vector<uint8_t>::iterator it = rbsp.begin(); it != rbsp.end();)
+  {
+    vector<uint8_t>::iterator found = it;
+    do
+    {
+      // find the next emulated 00 00 {00,01,02,03}
+      // NB, end()-1, prevents finding a trailing two byte sequence
+      found = search_n(found, rbsp.end()-1, 2, 0);
+      found++;
+      // if not found, found == end, otherwise found = second zero byte
+      if (found == rbsp.end())
+      {
+        break;
+      }
+      if (*(++found) <= 3)
+      {
+        break;
+      }
+    } while (true);
+    it = found;
+    if (found != rbsp.end())
+    {
+      cnt++;
+    }
+  }
+  return cnt;
+}
 /**
  * read #uiNumberOfBits# from bitstream without updating the bitstream

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComBitStream.h

-                      r438
+                      r446
   Void          addSubstream    ( TComOutputBitstream* pcSubstream );
   Void writeByteAlignment();
+  //! returns the number of start code emulations contained in the current buffer
+  Int countStartCodeEmulations();
 };
 …
+{
   std::vector<uint8_t> *m_fifo; /// FIFO for storage of complete bytes
+  std::vector<UInt> m_emulationPreventionByteLocation;
 protected:
 …
   UInt  getNumBitsRead() { return m_numBitsRead; }
   Void readByteAlignment();
+  Void      pushEmulationPreventionByteLocation ( UInt pos )                  { m_emulationPreventionByteLocation.push_back( pos ); }
+  UInt      numEmulationPreventionBytesRead     ()                            { return (UInt) m_emulationPreventionByteLocation.size();    }
+  std::vector<UInt>  getEmulationPreventionByteLocation  ()                   { return m_emulationPreventionByteLocation;           }
+  UInt      getEmulationPreventionByteLocation  ( UInt idx )                  { return m_emulationPreventionByteLocation[ idx ];    }
+  Void      clearEmulationPreventionByteLocation()                            { m_emulationPreventionByteLocation.clear();          }
+  Void      setEmulationPreventionByteLocation  ( std::vector<UInt> vec )     { m_emulationPreventionByteLocation = vec;            }
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComDataCU.cpp

-                      r438
+                      r446
   Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getIsLongTerm();
   Bool bIsNeibRefLongTerm = false;
   //---------------  V1 (END) ------------------//
   if( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0)
 …
+}
+#if H_3D
+Void TComDataCU::getPosInPic( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY )
+{
+  riPosX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelX();
+  riPosY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelY();
+}
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComDataCU.h

-                      r324
+                      r446
   Bool          m_bDecSubCu;          ///< indicates decoder-mode
   Double        m_dTotalCost;         ///< sum of partition RD costs
+#if H_3D_VSO
+  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
 …
   Void          setDepthSubParts      ( UInt uiDepth, UInt uiAbsPartIdx );
+#if H_3D
+  Void          getPosInPic           ( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY );
+#endif
   // -------------------------------------------------------------------------------------------------------------------
 …
   Double&       getTotalCost()                  { return m_dTotalCost;        }
+#if H_3D_VSO
+  Dist&         getTotalDistortion()            { return m_uiTotalDistortion; }
+#else
   UInt&         getTotalDistortion()            { return m_uiTotalDistortion; }
+#endif
   UInt&         getTotalBits()                  { return m_uiTotalBits;       }
   UInt&         getTotalNumPart()               { return m_uiNumPartition;    }

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComLoopFilter.cpp

-                      r438
+                      r446
 // ====================================================================================================================
 const UChar tctable_8x8[54] =
+const UChar TComLoopFilter::sm_tcTable[54] =
+{
 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,5,5,6,6,7,8,9,10,11,13,14,16,18,20,22,24
 };
 const UChar betatable_8x8[52] =
+const UChar TComLoopFilter::sm_betaTable[52] =
+{
 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,7,8,9,10,11,12,13,14,15,16,17,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64
 …
       Int iIndexB = Clip3(0, MAX_QP, iQP + (betaOffsetDiv2 << 1));
       Int iTc =  tctable_8x8[iIndexTC]*iBitdepthScale;
       Int iBeta = betatable_8x8[iIndexB]*iBitdepthScale;
+      Int iTc =  sm_tcTable[iIndexTC]*iBitdepthScale;
+      Int iBeta = sm_betaTable[iIndexB]*iBitdepthScale;
       Int iSideThreshold = (iBeta+(iBeta>>1))>>3;
       Int iThrCut = iTc*10;
 …
         Int iIndexTC = Clip3(0, MAX_QP+DEFAULT_INTRA_TC_OFFSET, iQP + DEFAULT_INTRA_TC_OFFSET*(ucBs - 1) + (tcOffsetDiv2 << 1));
         Int iTc =  tctable_8x8[iIndexTC]*iBitdepthScale;
+        Int iTc =  sm_tcTable[iIndexTC]*iBitdepthScale;
         for ( UInt uiStep = 0; uiStep < uiPelsInPartChroma; uiStep++ )

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComLoopFilter.h

-                      r438
+                      r446
   __inline Int xCalcDQ( Pel* piSrc, Int iOffset);
+  static const UChar sm_tcTable[54];
+  static const UChar sm_betaTable[52];
 public:
   TComLoopFilter();
 …
   /// picture-level deblocking filter
   Void loopFilterPic( TComPic* pcPic );
+  static Int getBeta( Int qp )
+  {
+    Int indexB = Clip3( 0, MAX_QP, qp );
+    return sm_betaTable[ indexB ];
+  }
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComPic.cpp

-                      r438
+                      r446
 , m_viewId                                (0)
 #if H_3D
+, m_viewIndex                             (0)
 , m_isDepth                               (false)
+, m_aaiCodedScale                         (0)
+, m_aaiCodedOffset                        (0)
 #endif
 #endif
 …
     std::cout  << getLayerId() << "\t" << getPOC()<< "\t" << getReconMark() << "\t" << getSlice(0)->isReferenced() << "\t" << getIsLongTerm() << std::endl;
+}
+#endif
+TComPic* TComPicLists::getPic( Int layerIdInNuh, Int poc )
+{
+  TComPic* pcPic = NULL;
+  for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() && pcPic == NULL ); itL++)
+  {
+    for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() && pcPic == NULL ); itP++)
+    {
+      TComPic* currPic = (*itP);
+      if ( ( currPic->getPOC() == poc ) && ( currPic->getLayerId() == layerIdInNuh ) )
+      {
+        pcPic = currPic ;
+      }
+    }
+  }
+  return pcPic;
+}
+#if H_3D
+TComPic* TComPicLists::getPic( Int viewIndex, Bool depthFlag, Int poc )
+{
+  return getPic   ( m_vps->getLayerIdInNuh( viewIndex, depthFlag ), poc );
+}
+Void TComPicLists::print()
+{
+  Bool first = true;
+  for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() ); itL++)
+  {
+    for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() ); itP++)
+    {
+      if ( first )
+      {
+        (*itP)->print( true );
+        first = false;
+      }
+      (*itP)->print( false );
+    }
+  }
+}
+TComPicYuv* TComPicLists::getPicYuv( Int layerIdInNuh, Int poc, Bool reconFlag )
+{
+  TComPic*    pcPic = getPic( layerIdInNuh, poc );
+  TComPicYuv* pcPicYuv = NULL;
+  if (pcPic != NULL)
+  {
+    if( reconFlag )
+    {
+      if ( pcPic->getReconMark() )
+      {
+        pcPicYuv = pcPic->getPicYuvRec();
+      }
+    }
+    else
+    {
+      pcPicYuv = pcPic->getPicYuvOrg();
+    }
+  };
+  return pcPicYuv;
+}
+TComPicYuv* TComPicLists::getPicYuv( Int viewIndex, Bool depthFlag, Int poc, Bool recon )
+{
+  Int layerIdInNuh = m_vps->getLayerIdInNuh( viewIndex, depthFlag );
+  return getPicYuv( layerIdInNuh, poc, recon );
+}
+#endif // H_3D
+#endif // H_MV
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComPic.h

-                      r438
+                      r446
   Int                   m_viewId;
 #if H_3D
+  Int                   m_viewIndex;
   Bool                  m_isDepth;
+#endif
+#endif
+  Int**                 m_aaiCodedScale;
+  Int**                 m_aaiCodedOffset;
+#endif
+#endif
 public:
   TComPic();
 …
   Int           getViewId             ()                 { return m_viewId;     }
 #if H_3D
+  Void          setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
+  Int           getViewIndex          ()                 { return m_viewIndex;     }
   Void          setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
   Bool          getIsDepth            ()                 { return m_isDepth; }
+#endif
+#endif
+  Void          setScaleOffset( Int** pS, Int** pO )  { m_aaiCodedScale = pS; m_aaiCodedOffset = pO; }
+  Int**         getCodedScale ()                      { return m_aaiCodedScale;  }
+  Int**         getCodedOffset()                      { return m_aaiCodedOffset; }
+#endif
+#endif
   Bool          getUsedByCurr()             { return m_bUsedByCurr; }
   Void          setUsedByCurr( Bool bUsed ) { m_bUsedByCurr = bUsed; }
 …
   Void          print( Bool legend );
 #endif
   /** transfer ownership of seis to this picture */
   void setSEIs(SEIMessages& seis) { m_SEIs = seis; }
 …
 private:
   TComList<TComList<TComPic*>*> m_lists;
+#if H_3D
+  TComVPS*                     m_vps;
+#endif
 public:
+  Void push_back( TComList<TComPic*>* list ) { m_lists.push_back( list ); }
+  Int  size     ()                           { return (Int) m_lists.size    (); }
+  TComPic* getPic( Int layerIdInNuh, Int poc )
+  {
+    TComPic* pcPic = NULL;
+    for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() && pcPic == NULL ); itL++)
+    {
+      for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() && pcPic == NULL ); itP++)
+      {
+        if ( ( (*itP)->getPOC() == poc ) && ( (*itP)->getLayerId() == layerIdInNuh ) )
+        {
+          pcPic = *itP ;
+        }
+      }
+    }
+    return pcPic;
+  }
+  Void print( )
+  {
+    Bool first = true;
+    for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() ); itL++)
+    {
+      for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() ); itP++)
+      {
+        if ( first )
+        {
+          (*itP)->print( true );
+          first = false;
+        }
+        (*itP)->print( false );
+      }
+    }
+  }
+  Void        push_back( TComList<TComPic*>* list ) { m_lists.push_back( list );   }
+  Int         size     ()                           { return (Int) m_lists.size(); }
+  TComPic*    getPic   ( Int layerIdInNuh,              Int poc );
+  TComPicYuv* getPicYuv( Int layerIdInNuh,              Int poc, Bool recon );
+#if H_3D
+  Void        setVPS   ( TComVPS* vps ) { m_vps = vps;  };
+  TComPic*    getPic   ( Int viewIndex, Bool depthFlag, Int poc );
+  TComPicYuv* getPicYuv( Int viewIndex, Bool depthFlag, Int poc, Bool recon );
+#endif
+  Void print( );
 }; // END CLASS DEFINITION TComPicLists

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComPicYuv.cpp

-                      r324
+                      r446
+}
+#if H_3D
+Void TComPicYuv::setLumaTo( Pel pVal )
+{
+  xSetPels( getLumaAddr(), getStride(), getWidth(), getHeight(), pVal );
+}
+Void TComPicYuv::setChromaTo( Pel pVal )
+{
+  xSetPels( getCbAddr(), getCStride(), getWidth() >> 1, getHeight() >> 1, pVal );
+  xSetPels( getCrAddr(), getCStride(), getWidth() >> 1, getHeight() >> 1, pVal );
+}
+Void TComPicYuv::xSetPels( Pel* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Pel iVal )
+{
+  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
+  {
+    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
+    {
+      piPelSource[iXPos] = iVal;
+    }
+    piPelSource += iSourceStride;
+  }
+}
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComPicYuv.h

-                      r324
+                      r446
 protected:
   Void  xExtendPicCompBorder (Pel* piTxt, Int iStride, Int iWidth, Int iHeight, Int iMarginX, Int iMarginY);
+#if H_3D
+  Void  xSetPels( Pel* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Pel iVal );
+#endif
 public:
 …
   // Set border extension flag
   Void  setBorderExtension(Bool b) { m_bIsBorderExtended = b; }
+#if H_3D
+  // Set Function
+  Void  setLumaTo    ( Pel pVal );
+  Void  setChromaTo  ( Pel pVal );
+#endif
 };// END CLASS DEFINITION TComPicYuv

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComPrediction.cpp

-                      r438
+                      r446
   if( m_piYuvExt == NULL )
+  {
     Int extWidth  = g_uiMaxCUWidth + 16;
     Int extHeight = g_uiMaxCUHeight + 1;
+    Int extWidth  = MAX_CU_SIZE + 16;
+    Int extHeight = MAX_CU_SIZE + 1;
     Int i, j;
     for (i = 0; i < 4; i++)
 …
+      }
+    }
     m_iYuvExtHeight  = ((g_uiMaxCUHeight + 2) << 4);
     m_iYuvExtStride = ((g_uiMaxCUWidth  + 8) << 4);
+    m_iYuvExtHeight  = ((MAX_CU_SIZE + 2) << 4);
+    m_iYuvExtStride = ((MAX_CU_SIZE  + 8) << 4);
     m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
     // new structure
     m_acYuvPred[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
     m_acYuvPred[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
     m_cYuvPredTemp.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
+  }
   if (m_iLumaRecStride != (g_uiMaxCUWidth>>1) + 1)
+  {
     m_iLumaRecStride =  (g_uiMaxCUWidth>>1) + 1;
+    m_acYuvPred[0] .create( MAX_CU_SIZE, MAX_CU_SIZE );
+    m_acYuvPred[1] .create( MAX_CU_SIZE, MAX_CU_SIZE );
+    m_cYuvPredTemp.create( MAX_CU_SIZE, MAX_CU_SIZE );
+  }
+  if (m_iLumaRecStride != (MAX_CU_SIZE>>1) + 1)
+  {
+    m_iLumaRecStride =  (MAX_CU_SIZE>>1) + 1;
     if (!m_pLumaRecBuffer)
+    {

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComRdCost.cpp

-                      r324
+                      r446
 #include "TComRom.h"
 #include "TComRdCost.h"
+#if H_3D
+#include "TComDataCU.h"
+#endif
 //! \ingroup TLibCommon
 //! \{
+#if H_3D_VSO
+// SAIT_VSO_EST_A0033
+Double TComRdCost::m_dDisparityCoeff = 1.0;
+#endif
 TComRdCost::TComRdCost()
+{
 …
 // Calculate RD functions
+#if H_3D_VSO
+Double TComRdCost::calcRdCost( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
+#else
 Double TComRdCost::calcRdCost( UInt uiBits, UInt uiDistortion, Bool bFlag, DFunc eDFunc )
+#endif
+{
   Double dRdCost = 0.0;
 …
+}
+#if H_3D_VSO
+Double TComRdCost::calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag, DFunc eDFunc )
+#else
 Double TComRdCost::calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag, DFunc eDFunc )
+#endif
+{
   Double dRdCost = 0.0;
 …
   m_afpDistortFunc[27] = TComRdCost::xGetHADs;
   m_afpDistortFunc[28] = TComRdCost::xGetHADs;
+#if H_3D_VSO
+  // SAIT_VSO_EST_A0033
+  m_afpDistortFunc[29]  = TComRdCost::xGetVSD;
+  m_afpDistortFunc[30]  = TComRdCost::xGetVSD4;
+  m_afpDistortFunc[31]  = TComRdCost::xGetVSD8;
+  m_afpDistortFunc[32]  = TComRdCost::xGetVSD16;
+  m_afpDistortFunc[33]  = TComRdCost::xGetVSD32;
+  m_afpDistortFunc[34]  = TComRdCost::xGetVSD64;
+  m_afpDistortFunc[35]  = TComRdCost::xGetVSD16N;
+#endif
 #if !FIX203
   m_puiComponentCostOriginP = NULL;
 …
 #if !FIX203
   m_iSearchLimit            = 0xdeaddead;
+#endif
+#if H_3D_VSO
+  m_bUseVSO                 = false;
+  m_uiVSOMode               = 0;
+  m_fpDistortFuncVSO        = NULL;
+  m_pcRenModel              = NULL;
+  // SAIT_VSO_EST_A0033
+  m_bUseEstimatedVSD        = false;
 #endif
+}
 …
 #endif
+}
+#if H_3D_VSO
+// SAIT_VSO_EST_A0033
+UInt TComRdCost::getDistPartVSD( TComDataCU* pcCU, UInt uiPartOffset, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight,  Bool bHAD, DFunc eDFunc )
+{
+  AOT( ( m_dDisparityCoeff <= 0 ) || ( m_dDisparityCoeff > 10 ) );
+  Pel* piVirRec  = m_pcVideoRecPicYuv->getLumaAddr(pcCU->getAddr(),pcCU->getZorderIdxInCU()+uiPartOffset);
+  Pel* piVirOrg  = m_pcDepthPicYuv   ->getLumaAddr(pcCU->getAddr(),pcCU->getZorderIdxInCU()+uiPartOffset);
+  Int iVirStride = m_pcVideoRecPicYuv->getStride();
+  DistParam cDtParam;
+  setDistParam( uiBlkWidth, uiBlkHeight, eDFunc, cDtParam );
+  cDtParam.pOrg       = piOrg;
+  cDtParam.pCur       = piCur;
+  cDtParam.pVirRec    = piVirRec;
+  cDtParam.pVirOrg    = piVirOrg;
+  cDtParam.iStrideVir = iVirStride;
+  cDtParam.iStrideOrg = iOrgStride;
+  cDtParam.iStrideCur = iCurStride;
+  cDtParam.iStep      = 1;
+  cDtParam.bApplyWeight = false;
+  cDtParam.uiComp       = 255;    // just for assert: to be sure it was set before use, since only values 0,1 or 2 are allowed.
+  Dist dist = cDtParam.DistFunc( &cDtParam );
+  if ( m_bUseWVSO )
+  {
+    Int iDWeight   = m_iDWeight   * m_iDWeight;
+    Int iVSOWeight = m_iVSDWeight * m_iVSDWeight;
+    Dist distDepth;
+    if ( !bHAD )
+    {
+      distDepth = (Dist) getDistPart( g_bitDepthY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
+    }
+    else
+    {
+      distDepth = (Dist) calcHAD( g_bitDepthY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
+    }
+    dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
+  }
+  return dist;
+}
+#endif
 #if RATE_CONTROL_LAMBDA_DOMAIN
 …
   return ( uiSum );
+}
+#if H_3D_VSO
+//SAIT_VSO_EST_A0033
+UInt TComRdCost::getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y )
+{
+  Double dD;
+  Int iTemp;
+  dD = ( (Double) ( dDM >> DISTORTION_PRECISION_ADJUSTMENT( g_bitDepthY - 8 ) ) ) * m_dDisparityCoeff;
+  Double dTemp = ( 0.5 * fabs(dD) * ( abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x-1+y*iVirStride ] ) + abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x+1+y*iVirStride ] ) ) );
+  iTemp = (Int) (((dTemp) < 0)? (Int)((dTemp) - 0.5) : (Int)((dTemp) + 0.5));
+  return (UInt) ( (iTemp*iTemp)>>1 );
+}
+UInt TComRdCost::xGetVSD( DistParam* pcDtParam )
+{
+  Pel* piOrg    = pcDtParam->pOrg;
+  Pel* piCur    = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows    = pcDtParam->iRows;
+  Int  iCols    = pcDtParam->iCols;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < iCols; x++ )
+    {
+      dDM = (Int) ( piOrg[x  ] - piCur[x  ] );
+      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD4( DistParam* pcDtParam )
+{
+  Pel* piOrg   = pcDtParam->pOrg;
+  Pel* piCur   = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows   = pcDtParam->iRows;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    dDM = (Int) ( piOrg[0] - piCur[0] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 0, y ) ) >> uiShift;
+    dDM = (Int) ( piOrg[1] - piCur[1] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 1, y ) ) >> uiShift;
+    dDM = (Int) ( piOrg[2] - piCur[2] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 2, y ) ) >> uiShift;
+    dDM = (Int) ( piOrg[3] - piCur[3] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 3, y ) ) >> uiShift;
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD8( DistParam* pcDtParam )
+{
+  Pel* piOrg   = pcDtParam->pOrg;
+  Pel* piCur   = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows   = pcDtParam->iRows;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < 8; x++ )
+    {
+      dDM = (Int) ( piOrg[x] - piCur[x] );
+      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD16( DistParam* pcDtParam )
+{
+  Pel* piOrg   = pcDtParam->pOrg;
+  Pel* piCur   = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows   = pcDtParam->iRows;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < 16; x++ )
+    {
+      dDM = (Int) ( piOrg[x] - piCur[x] );
+      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD16N( DistParam* pcDtParam )
+{
+  Pel* piOrg   = pcDtParam->pOrg;
+  Pel* piCur   = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows   = pcDtParam->iRows;
+  Int  iCols   = pcDtParam->iCols;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < iCols; x+=16 )
+    {
+      for ( Int k = 0 ; k < 16 ; k++ )
+      {
+        dDM = (Int) ( piOrg[x+k] - piCur[x+k] );
+        uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x+k, y ) >> uiShift;
+      }
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD32( DistParam* pcDtParam )
+{
+  Pel* piOrg   = pcDtParam->pOrg;
+  Pel* piCur   = pcDtParam->pCur;
+  Pel* piVirRec = pcDtParam->pVirRec;
+  Pel* piVirOrg = pcDtParam->pVirOrg;
+  Int  iRows   = pcDtParam->iRows;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < 32 ; x++ )
+    {
+      dDM = (Int) ( piOrg[x] - piCur[x] );
+      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+UInt TComRdCost::xGetVSD64( DistParam* pcDtParam )
+{
+  Pel* piOrg      = pcDtParam->pOrg;
+  Pel* piCur      = pcDtParam->pCur;
+  Pel* piVirRec   = pcDtParam->pVirRec;
+  Pel* piVirOrg   = pcDtParam->pVirOrg;
+  Int  iRows      = pcDtParam->iRows;
+  Int  iStrideOrg = pcDtParam->iStrideOrg;
+  Int  iStrideCur = pcDtParam->iStrideCur;
+  Int  iStrideVir = pcDtParam->iStrideVir;
+  UInt uiSum = 0;
+  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
+  Int dDM;
+  for ( Int y = 0 ; y < iRows ; y++ )
+  {
+    for (Int x = 0; x < 64; x++ )
+    {
+      dDM = (Int) ( piOrg[x] - piCur[x] );
+      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
+    }
+    piOrg += iStrideOrg;
+    piCur += iStrideCur;
+  }
+  return ( uiSum );
+}
+#endif
 // --------------------------------------------------------------------------------------------------------------------
 …
   return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
+}
+#if H_3D_VSO
+Void TComRdCost::setLambdaVSO( Double dLambdaVSO )
+{
+  m_dLambdaVSO           = dLambdaVSO;
+  m_dSqrtLambdaVSO       = sqrt(m_dLambdaVSO);
+  m_uiLambdaMotionSADVSO = (UInt)floor(65536.0 *       m_dSqrtLambdaVSO);
+  m_uiLambdaMotionSSEVSO = (UInt)floor(65536.0 *       m_dLambdaVSO    );
+}
+Dist TComRdCost::xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
+{
+  AOT(bSAD);
+#if H_3D_VSO_EARLY_SKIP
+  RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur, piOrg, iOrgStride);
+#else
+  RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur );
+#endif
+  RMDist iDistMin = (RMDist) RDO_DIST_MIN;
+  iDistMin = m_bAllowNegDist ? RDO_DIST_MIN : 0;
+  iDist = std::min( iDist, (RMDist) RDO_DIST_MAX);
+  iDist = std::max( iDist, iDistMin);
+  return (Dist) iDist;
+}
+Dist TComRdCost::getDistPartVSO( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHAD )
+{
+  assert( m_bUseVSO );
+  assert( this->m_fpDistortFuncVSO != 0 );
+  Int iPosX;
+  Int iPosY;
+  pcCU->getPosInPic( uiAbsPartIndex, iPosX, iPosY );
+  Dist dist = (this->*m_fpDistortFuncVSO) ( iPosX, iPosY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, bHAD );
+  if ( m_bUseWVSO )
+  {
+    Int iDWeight   = m_iDWeight   * m_iDWeight;
+    Int iVSOWeight = m_iVSOWeight * m_iVSOWeight;
+    Dist distDepth;
+    if ( !bHAD )
+    {
+       distDepth = (Dist) getDistPart( g_bitDepthY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
+    }
+    else
+    {
+       distDepth = (Dist) calcHAD( g_bitDepthY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
+    }
+    dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
+  }
+  return dist;
+};
+Void TComRdCost::setVSOMode( UInt uiIn )
+{
+  m_uiVSOMode = uiIn;
+  switch (m_uiVSOMode )
+  {
+  case   4:
+    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode4;
+    break;
+  default:
+    assert(0);
+    break;
+  }
+}
+Double TComRdCost::calcRdCostVSO( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
+{
+  assert( m_bUseLambdaScaleVSO );
+  Double dRdCost = 0.0;
+  Double dLambda = 0.0;
+  switch ( eDFunc )
+  {
+  case DF_SSE:
+    assert(0);
+    break;
+  case DF_SAD:
+    dLambda = (Double)m_uiLambdaMotionSADVSO;
+    break;
+  case DF_DEFAULT:
+    dLambda =         m_dLambdaVSO;
+    break;
+  case DF_SSE_FRAME:
+    dLambda =         m_dFrameLambdaVSO;
+    break;
+  default:
+    assert (0);
+    break;
+  }
+  if (bFlag)
+  {
+    // Intra8x8, Intra4x4 Block only...
+#if SEQUENCE_LEVEL_LOSSLESS
+    dRdCost = (Double)(uiBits);
+#else
+    dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
+#endif
+  }
+  else
+  {
+    if (eDFunc == DF_SAD)
+    {
+      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)>>16));
+      dRdCost = (Double)(Dist)floor(dRdCost);
+    }
+    else
+    {
+#if SEQUENCE_LEVEL_LOSSLESS
+      dRdCost = (Double)(uiBits);
+#else
+      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)));
+      dRdCost = (Double)(Dist)floor(dRdCost);
+#endif
+    }
+  }
+  return dRdCost;
+}
+Void TComRdCost::setRenModelData( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight )
+{
+  UInt iBlkX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]];
+  UInt iBlkY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]];
+  Int iStartPosX = iBlkX + pcCU->getCUPelX();
+  Int iStartPosY = iBlkY + pcCU->getCUPelY();
+  m_pcRenModel->setData( iStartPosX, iStartPosY, iBlkWidth, iBlkHeight, iStride, piData );
+}
+Void TComRdCost::setAllowNegDist( Bool bAllowNegDist )
+{
+  m_bAllowNegDist = bAllowNegDist;
+}
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComRdCost.h

-                      r324
+                      r446
 #include "TComSlice.h"
 #include "TComRdCostWeightPrediction.h"
+#if H_3D
+#include "../TLibRenderer/TRenModel.h"
+#endif
 //! \ingroup TLibCommon
 …
 class DistParam;
 class TComPattern;
+#if H_3D
+class TComRdCost;
+#endif
 // ====================================================================================================================
 …
 typedef UInt (*FpDistFunc) (DistParam*);
+#if H_3D
+#if H_3D_VSO
+typedef Dist (TComRdCost::*FpDistFuncVSO) ( Int, Int, Pel*, Int, Pel*, Int, UInt, UInt, Bool );
+#endif
+#endif
 // ====================================================================================================================
 // Class definition
 …
   Int   iStrideOrg;
   Int   iStrideCur;
+#if H_3D_VSO
+  // SAIT_VSO_EST_A0033
+  Pel*  pVirRec;
+  Pel*  pVirOrg;
+  Int   iStrideVir;
+#endif
   Int   iRows;
   Int   iCols;
 …
     bUseNSHAD = false;
 #endif
+#if H_3D_VSO
+    // SAIT_VSO_EST_A0033
+    pVirRec = NULL;
+    pVirOrg = NULL;
+    iStrideVir = 0;
+#endif
+  }
 };
 …
   UInt                    m_uiLambdaMotionSSE;
   Double                  m_dFrameLambda;
+#if H_3D_VSO
+  // SAIT_VSO_EST_A0033
+  static Double           m_dDisparityCoeff;
+#endif
   // for motion cost
 …
   TComRdCost();
   virtual ~TComRdCost();
+#if H_3D_VSO
+  Double  calcRdCost  ( UInt   uiBits, Dist   uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
+  Double  calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
+#else
   Double  calcRdCost  ( UInt   uiBits, UInt   uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
   Double  calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
+#endif
 #if WEIGHTED_CHROMA_DISTORTION
 …
   Double  getSqrtLambda ()   { return m_sqrtLambda; }
+#if H_3D_VSO
+  // SAIT_VSO_EST_A0033
+  Void    setDisparityCoeff( Double dDisparityCoeff ) { m_dDisparityCoeff = dDisparityCoeff; }
+  Double  getDisparityCoeff()                         { return m_dDisparityCoeff; }
+#endif
 #if RATE_CONTROL_LAMBDA_DOMAIN
 …
   static UInt xGetSAD16N        ( DistParam* pcDtParam );
+#if H_3D_VSO
+  static UInt xGetVSD           ( DistParam* pcDtParam );
+  static UInt xGetVSD4          ( DistParam* pcDtParam );
+  static UInt xGetVSD8          ( DistParam* pcDtParam );
+  static UInt xGetVSD16         ( DistParam* pcDtParam );
+  static UInt xGetVSD32         ( DistParam* pcDtParam );
+  static UInt xGetVSD64         ( DistParam* pcDtParam );
+  static UInt xGetVSD16N        ( DistParam* pcDtParam );
+#endif
 #if AMP_SAD
   static UInt xGetSAD12         ( DistParam* pcDtParam );
 …
   UInt   getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height );
 #endif
+#if H_3D_VSO
+  // SAIT_VSO_EST_A0033
+  UInt        getDistPartVSD( TComDataCU* pcCu, UInt uiPartOffset, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHad, DFunc eDFunc = DF_VSD);
+  static UInt getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y );
+private:
+  Double                  m_dLambdaVSO;
+  Double                  m_dSqrtLambdaVSO;
+  UInt                    m_uiLambdaMotionSADVSO;
+  UInt                    m_uiLambdaMotionSSEVSO;
+  Double                  m_dFrameLambdaVSO;
+  Bool                    m_bAllowNegDist;
+  Bool                    m_bUseVSO;
+  Bool                    m_bUseLambdaScaleVSO;
+  UInt                    m_uiVSOMode;
+  FpDistFuncVSO           m_fpDistortFuncVSO;
+  TRenModel*              m_pcRenModel;
+  // SAIT_VSO_EST_A0033
+  TComPicYuv *            m_pcVideoRecPicYuv;
+  TComPicYuv *            m_pcDepthPicYuv;
+  Bool                    m_bUseEstimatedVSD;
+  // LGE_WVSO_A0119
+  Int                     m_iDWeight;
+  Int                     m_iVSOWeight;
+  Int                     m_iVSDWeight;
+  Bool                    m_bUseWVSO;
+public:
+  Void    setRenModel       ( TRenModel* pcRenModel ) { m_pcRenModel = pcRenModel; }
+  TRenModel* getRenModel    ( )                       { return m_pcRenModel; }
+  Void    setRenModelData   ( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight );
+  Void    setLambdaVSO      ( Double dLambda );
+  Void    setFrameLambdaVSO ( Double dLambda ) { m_dFrameLambdaVSO = dLambda; };
+  Void    setUseVSO ( Bool bIn )         { m_bUseVSO = bIn; };
+  Bool    getUseVSO ( )                  { return m_bUseVSO;};
+  Bool    getUseRenModel ( )             { return (m_bUseVSO && m_uiVSOMode == 4); };
+  Void    setUseLambdaScaleVSO(Bool bIn) { m_bUseLambdaScaleVSO = bIn; };
+  Bool    getUseLambdaScaleVSO( )        { return m_bUseLambdaScaleVSO; };
+  Void    setVSOMode( UInt uiIn);
+  UInt    getVSOMode( )                  { return m_uiVSOMode; }
+  Void    setAllowNegDist ( Bool bAllowNegDist );
+  Double  getSqrtLambdaVSO ()   { return m_dSqrtLambdaVSO; }
+  Double  getLambdaVSO ()       { return m_dLambdaVSO; }
+  Dist   getDistPartVSO( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD );
+  Double calcRdCostVSO ( UInt   uiBits, Dist   uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
+  // SAIT_VSO_EST_A0033
+  Bool    getUseEstimatedVSD( )           { return m_bUseEstimatedVSD; };
+  Void    setUseEstimatedVSD( Bool bIn )  { m_bUseEstimatedVSD = bIn; };
+  TComPicYuv* getVideoRecPicYuv ()                               { return m_pcVideoRecPicYuv; };
+  Void        setVideoRecPicYuv ( TComPicYuv* pcVideoRecPicYuv ) { m_pcVideoRecPicYuv = pcVideoRecPicYuv; };
+  TComPicYuv* getDepthPicYuv    ()                               { return m_pcDepthPicYuv; };
+  Void        setDepthPicYuv    ( TComPicYuv* pcDepthPicYuv )    { m_pcDepthPicYuv = pcDepthPicYuv; };
+  // LGE_WVSO_A0119
+  Void    setUseWVSO ( Bool bIn )         { m_bUseWVSO = bIn; };
+  Bool    getUseWVSO ( )                  { return m_bUseWVSO;};
+  Void    setDWeight   ( Int iDWeight   ) { m_iDWeight = iDWeight; };
+  Int     getDWeight   ()                 { return m_iDWeight; };
+  Void    setVSOWeight ( Int iVSOWeight ) { m_iVSOWeight = iVSOWeight; };
+  Int     getVSOWeight ()                 { return m_iVSOWeight; };
+  Void    setVSDWeight ( Int iVSDWeight ) { m_iVSDWeight = iVSDWeight; };
+  Int     getVSDWeight ()                 { return m_iVSDWeight; };
+private:
+  Dist xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD );
+#endif // H_3D_VSO
 };// END CLASS DEFINITION TComRdCost

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComRom.cpp

-                      r438
+                      r446
   g_aucConvertToBit[ i ] = c;
-  // g_auiFrameScanXY[ g_aucConvertToBit[ transformSize ] ]: zigzag scan array for transformSize
   c=2;
   for ( i=0; i<MAX_CU_DEPTH; i++ )
 …
 Void destroyROM()
+{
+  Int i;
+  for ( i=0; i<MAX_CU_DEPTH; i++ )
+  for (Int i=0; i<MAX_CU_DEPTH; i++ )
+  {
     delete[] g_auiSigLastScan[0][i];

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComSlice.cpp

-                      r438
+                      r446
 , m_iPOC                          ( 0 )
 , m_iLastIDR                      ( 0 )
 , m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR )
+, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
 , m_eSliceType                    ( I_SLICE )
 , m_iSliceQp                      ( 0 )
 …
 , m_deblockingFilterBetaOffsetDiv2 ( 0 )
 , m_deblockingFilterTcOffsetDiv2   ( 0 )
+#if !L0034_COMBINED_LIST_CLEANUP
 , m_bRefPicListModificationFlagLC ( false )
 , m_bRefPicListCombinationFlag    ( false )
+#endif
 , m_bCheckLDC                     ( false )
 , m_iSliceQpDelta                 ( 0 )
 …
 , m_dLambda                       ( 0.0 )
 #endif
+#if !L0034_COMBINED_LIST_CLEANUP
 , m_bNoBackPredFlag               ( false )
+#endif
 , m_uiTLayer                      ( 0 )
 , m_bTLayerSwitchingFlag          ( false )
 …
 , m_viewId                        (0)
 #if H_3D
+, m_viewIndex                     (0)
 , m_isDepth                       (false)
 #endif
 #endif
+{
+#if L0034_COMBINED_LIST_CLEANUP
+  m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = 0;
+#else
   m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = m_aiNumRefIdx[2] = 0;
+#endif
   initEqualRef();
+#if L0034_COMBINED_LIST_CLEANUP
+  for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
+  {
+    m_list1IdxToList0Idx[idx] = -1;
+  }
+#else
   for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
+  {
 …
     m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
+  }
+#endif
   for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
+  {
 …
 #endif
+  }
   resetWpScaling(m_weightPredTable);
+  resetWpScaling();
   initWpAcDcParam();
   m_saoEnabledFlag = false;
 …
   m_colRefIdx = 0;
   initEqualRef();
+#if !L0034_COMBINED_LIST_CLEANUP
   m_bNoBackPredFlag = false;
   m_bRefPicListCombinationFlag = false;
   m_bRefPicListModificationFlagLC = false;
+#endif
   m_bCheckLDC = false;
   m_iSliceQpDeltaCb = 0;
   m_iSliceQpDeltaCr = 0;
+#if !L0034_COMBINED_LIST_CLEANUP
   m_aiNumRefIdx[REF_PIC_LIST_C]      = 0;
+#endif
   m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
 …
 Bool TComSlice::getRapPicFlag()
+{
   return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR
+  return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
+      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
+      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
+}
 …
+TComPic* TComSlice::xGetLongTermRefPic (TComList<TComPic*>& rcListPic,
+                                        Int                 poc)
+TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
+{
   TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
   TComPic*                      pcPic = *(iterPic);
   TComPic*                      pcStPic = pcPic;
+  Int pocCycle = 1 << getSPS()->getBitsForPOC();
+  if (!pocHasMsb)
+  {
+    poc = poc % pocCycle;
+  }
   while ( iterPic != rcListPic.end() )
+  {
     pcPic = *(iterPic);
+    if(pcPic && (pcPic->getPOC()%(1<<getSPS()->getBitsForPOC())) == (poc%(1<<getSPS()->getBitsForPOC())))
+    if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
+    {
+      Int picPoc = pcPic->getPOC();
+      if (!pocHasMsb)
+      {
+        picPoc = picPoc % pocCycle;
+      }
+      if (poc == picPoc)
+    {
       if(pcPic->getIsLongTerm())
 …
       break;
+    }
+    }
     iterPic++;
+  }
   return  pcStPic;
+}
 …
+}
+#if L0034_COMBINED_LIST_CLEANUP
+Void TComSlice::setList1IdxToList0Idx()
+{
+  Int idxL0, idxL1;
+  for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
+  {
+    m_list1IdxToList0Idx[idxL1] = -1;
+    for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
+    {
+      if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
+      {
+        m_list1IdxToList0Idx[idxL1] = idxL0;
+        break;
+      }
+    }
+  }
+}
+#else
 Void TComSlice::generateCombinedList()
+{
 …
+  }
+}
+#endif
 #if H_MV
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer )
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
+#else
+#if FIX1071
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
 #else
 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
 #endif
+{
+  if (m_eSliceType == I_SLICE)
+  {
+    ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+    ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+#endif
+{
+#if FIX1071
+  if (!checkNumPocTotalCurr)
+#endif
+  {
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+      return;
+    }
-    return;
+  }
 #if !H_MV
+  m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+  m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+#endif
+    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+#endif
+  }
   TComPic*  pcRefPic= NULL;
 …
 #endif
   Int i;
   for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
+  {
 …
+    }
+  }
   for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
+  {
 …
+    }
+  }
   for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
+  {
     if(m_pcRPS->getUsed(i))
+    {
       pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i));
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
       pcRefPic->setIsLongTerm(1);
       pcRefPic->getPicYuvRec()->extendPicBorder();
 …
     if(pcRefPic==NULL)
+    {
       pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i));
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
+    }
     pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
 …
   Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
 #endif
+  {
+    Int cIdx = 0;
+    for ( i=0; i<NumPocStCurr0; i++, cIdx++)
+    {
+      rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
+    }
+    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
+    {
+      rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
+    }
+    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
+    {
+      rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
+    }
+#if FIX1071
+  if (checkNumPocTotalCurr)
+  {
+    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
 #if H_MV
+    for ( i=0; i<numDirectRefLayers;  i++, cIdx++)
+    {
+      if( cIdx <= MAX_NUM_REF )
+      {
+        rpsCurrList0[cIdx] = refPicSetInterLayer[i];
+      }
+    }
+#endif
+  }
+    // – If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    if ( getRapPicFlag() && m_layerId == 0 )
+#else
+    // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    if (getRapPicFlag())
+#endif
+    {
+      assert(numPocTotalCurr == 0);
+    }
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+      return;
+    }
+    assert(numPocTotalCurr != 0);
+    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+  }
+#endif
+  Int cIdx = 0;
+  for ( i=0; i<NumPocStCurr0; i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
+  }
+  for ( i=0; i<NumPocStCurr1; i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
+  }
+  for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
+  }
+#if H_MV
+  for ( i=0; i<numDirectRefLayers;  i++, cIdx++)
+  {
+    if( cIdx <= MAX_NUM_REF )
+    {
+      rpsCurrList0[cIdx] = refPicSetInterLayer[i];
+    }
+  }
+#endif
   if (m_eSliceType==B_SLICE)
+  {
     Int cIdx = 0;
+    cIdx = 0;
     for ( i=0; i<NumPocStCurr1; i++, cIdx++)
+    {
 …
+}
+#if H_MV
+// Temporary fix for FIX1071 should be removed later
+Int TComSlice::getNumRpsCurrTempList( TComReferencePictureSet* rps /* = 0 */)
+#else
 Int TComSlice::getNumRpsCurrTempList()
+{
+#endif
+{
   Int numRpsCurrTempList = 0;
 …
     return 0;
+  }
+#if H_MV
+// Temporary fix for FIX1071 should be removed later
+  if (rps == NULL)
+  {
+    rps = m_pcRPS;
+  }
+  for(UInt i=0; i < rps->getNumberOfNegativePictures()+ rps->getNumberOfPositivePictures() + rps->getNumberOfLongtermPictures(); i++)
+  {
+    if(rps->getUsed(i))
+#else
   for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
+  {
     if(m_pcRPS->getUsed(i))
+#endif
+    {
       numRpsCurrTempList++;
 …
+  }
+}
+#if H_3D
+Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
+{
+  if( m_pcSPS->hasCamParInSliceHeader() )
+  {
+    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
+    {
+      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     m_viewIndex ];
+      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     m_viewIndex ][ uiBaseViewIndex ];
+      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     m_viewIndex ];
+      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     m_viewIndex ][ uiBaseViewIndex ];
+    }
+  }
+}
+#endif
 Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
 …
+}
 Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA)
+Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList<TComPic *>& rcListPic)
+{
   for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
 …
     if(pocCRA < MAX_UINT && getPOC() > pocCRA)
+    {
+      if (!pReferencePictureSet->getCheckLTMSBPresent(i))
+      {
+        assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
+      }
+      else
+      {
       assert(pReferencePictureSet->getPOC(i) >= pocCRA);
+    }
+  }
+  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
+  }
+  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
+  {
     pocCRA = getPOC();
 …
     prevRAPisBLA = false;
+  }
   else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
          || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
+  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
          || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
+  {
 …
   Int pocCurr = getPOC();
   if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
     || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
+  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
     || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
     || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR
+    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
     || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )  // IDR or BLA picture
+  {
 …
       iterPic++;
+    }
     if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
+    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
       || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
+    {
 …
+      {
         rpcPic = *(iterPic);
+        if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA) rpcPic->getSlice(0)->setReferenced(false);
+        if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
+        {
+          rpcPic->getSlice(0)->setReferenced(false);
+        }
         iterPic++;
+      }
 …
   m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
+#if L0034_COMBINED_LIST_CLEANUP
+  for (i = 0; i < 2; i++)
+#else
   for (i = 0; i < 3; i++)
+#endif
+  {
     m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
+  }
+#if L0034_COMBINED_LIST_CLEANUP
+  for (i = 0; i < MAX_NUM_REF; i++)
+  {
+    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
+  }
+#else
   for (i = 0; i < 2; i++)
+  {
 …
   m_bRefPicListModificationFlagLC = pSrc->m_bRefPicListModificationFlagLC;
   m_bRefPicListCombinationFlag    = pSrc->m_bRefPicListCombinationFlag;
+#endif
   m_bCheckLDC             = pSrc->m_bCheckLDC;
   m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
 …
+  }
+#if !L0034_COMBINED_LIST_CLEANUP
   m_bNoBackPredFlag      = pSrc->m_bNoBackPredFlag;
+#endif
   m_uiTLayer                      = pSrc->m_uiTLayer;
   m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
 …
 Int TComSlice::m_prevPOC = 0;
 /** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
  * \param uiTLayer Temporal layer ID of the current slice
 …
   Int i, isReference;
-  Int j = 0;
   // loop through all pictures in the reference picture buffer
   TComList<TComPic*>::iterator iterPic = rcListPic.begin();
   while ( iterPic != rcListPic.end())
+  {
-    j++;
     rpcPic = *(iterPic++);
+    if(!rpcPic->getSlice( 0 )->isReferenced())
+    {
+      continue;
+    }
     isReference = 0;
 …
+    {
       rpcPic->getSlice( 0 )->setReferenced( false );
+      rpcPic->setUsedByCurr(0);
       rpcPic->setIsLongTerm(0);
+    }
 …
     assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
     //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
     if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
+    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
+    {
       assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
+    }
     //check that pictures marked as temporal layer non-reference pictures are not used for reference
     if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
 …
+{
   TComPic* rpcPic;
   Int i, isAvailable, j;
+  Int i, isAvailable;
   Int atLeastOneLost = 0;
   Int atLeastOneRemoved = 0;
 …
   for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
+  {
-    j = 0;
     isAvailable = 0;
     // loop through all pictures in the reference picture buffer
 …
     while ( iterPic != rcListPic.end())
+    {
-      j++;
       rpcPic = *(iterPic++);
       if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
 …
       while ( iterPic != rcListPic.end())
+      {
-        j++;
         rpcPic = *(iterPic++);
+        if((rpcPic->getPicSym()->getSlice(0)->getPOC()%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC())) == (this->getPOC() + pReferencePictureSet->getDeltaPOC(i))%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC()) && rpcPic->getSlice(0)->isReferenced())
+        Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
+        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
+        Int refPoc = pReferencePictureSet->getPOC(i);
+        if (!pReferencePictureSet->getCheckLTMSBPresent(i))
+        {
+          curPoc = curPoc % pocCycle;
+          refPoc = refPoc % pocCycle;
+        }
+        if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
+        {
           isAvailable = 1;
 …
   for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
+  {
-    j = 0;
     isAvailable = 0;
     // loop through all pictures in the reference picture buffer
 …
     while ( iterPic != rcListPic.end())
+    {
-      j++;
       rpcPic = *(iterPic++);
 …
+        {
           if(printErrors)
+          {
             printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
+          }
           atLeastOneRemoved = 1;
+        }
 …
+        {
           if(printErrors)
+          {
             printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
+          }
           atLeastOneLost = 1;
           iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
 …
  * \returns Void
  */
 Void  TComSlice::resetWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
+Void  TComSlice::resetWpScaling()
+{
   for ( Int e=0 ; e<2 ; e++ )
 …
       for ( Int yuv=0 ; yuv<3 ; yuv++ )
+      {
         wpScalingParam  *pwp = &(wp[e][i][yuv]);
+        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
         pwp->bPresentFlag      = false;
         pwp->uiLog2WeightDenom = 0;
 …
 Void  TComSlice::initWpScaling()
+{
-  initWpScaling(m_weightPredTable);
+}
-/** set WP tables
- * \param wpScalingParam
- * \returns Void
- */
-Void  TComSlice::initWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
+{
   for ( Int e=0 ; e<2 ; e++ )
+  {
 …
       for ( Int yuv=0 ; yuv<3 ; yuv++ )
+      {
+        wpScalingParam  *pwp = &(wp[e][i][yuv]);
+        if ( !pwp->bPresentFlag ) {
+        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
+        if ( !pwp->bPresentFlag )
+        {
           // Inferring values not present :
           pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
 …
 , m_cprmsPresentFlag          (NULL)
+{
   for( Int i = 0; i < MAX_TLAYER; i++)
+  {
     m_numReorderPics[i] = 0;
+#if L0323_DPB
+    m_uiMaxDecPicBuffering[i] = 1;
+#else
     m_uiMaxDecPicBuffering[i] = 0;
+#endif
     m_uiMaxLatencyIncrease[i] = 0;
+  }
 …
     m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1;
     m_numDirectRefLayers[i] = 0;
+#if H_3D
+    m_viewIndex         [i] = -1;
+#endif
     for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
 …
       m_dimensionId[i][j] = 0;
+    }
+  }
 #endif
 …
 TComVPS::~TComVPS()
+{
   if( m_hrdParameters    != NULL )     delete m_hrdParameters;
   if( m_hrdOpSetIdx      != NULL )     delete m_hrdOpSetIdx;
   if( m_cprmsPresentFlag != NULL )     delete m_cprmsPresentFlag;
+if( m_hrdParameters    != NULL )     delete[] m_hrdParameters;
+  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
+  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
+}
 …
+{
   for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ )
     setScalabilityMask( scalType, ( val & (1 << scalType ) ) == 1 );
+    setScalabilityMask( scalType, ( val & (1 << scalType ) ) != 0 );
+}
 …
 Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
+{
+  return ( ( layerIdInVps != 0 )&& getScalabilityMask( scalType ) ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
+}
+#endif
+  return getScalabilityMask( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
+}
+#if H_3D
+Void TComVPS::initViewIndex()
+{
+  Int viewIdList   [ MAX_NUM_LAYERS ]; // ed. should be changed to MAX_VIEW_ID
+  Int viewIndexList[ MAX_NUM_LAYERS ];
+  Int numViewIds = 0;
+  for ( Int i = 0 ; i  <  m_uiMaxLayers; i++ )
+  {
+    Int currViewId = getViewId( i );
+    Bool viewIdInListFlag = false;
+    for ( Int j = 0; j < numViewIds; j ++ )
+    {
+      viewIdInListFlag  = viewIdInListFlag || ( currViewId  == viewIdList[ j ]  );
+    }
+    if ( !viewIdInListFlag )
+    {
+      viewIdList   [ numViewIds ] = currViewId;
+      viewIndexList[ currViewId ] = numViewIds;
+      numViewIds++;
+    }
+    m_viewIndex[ i ] = viewIndexList[ currViewId ];
+  }
+}
+Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
+{
+  Int foundlayerId = -1;
+  for (Int layer = 0 ; layer < m_uiMaxLayers; layer++ )
+  {
+    if( ( getViewIndex( layer ) == viewIndex ) && ( getDepthId( layer ) == ( depthFlag ? 1 : 0 ) )  )
+    {
+      foundlayerId = layer;
+      break;
+    }
+  }
+  assert( foundlayerId != -1 );
+  return getLayerIdInNuh( foundlayerId );
+}
+#endif // H_3D
+#endif // H_MV
 // ------------------------------------------------------------------------------------------------
 …
 , m_picWidthInLumaSamples     (352)
 , m_picHeightInLumaSamples    (288)
+, m_log2MinCodingBlockSize    (  0)
+, m_log2DiffMaxMinCodingBlockSize (0)
 , m_uiMaxCUWidth              ( 32)
 , m_uiMaxCUHeight             ( 32)
 , m_uiMaxCUDepth              (  3)
-, m_uiMinTrDepth              (  0)
-, m_uiMaxTrDepth              (  1)
 , m_bLongTermRefsPresent      (false)
 , m_uiQuadtreeTULog2MaxSize   (  0)
 …
 , m_pcmLog2MaxSize            (  5)
 , m_uiPCMLog2MinSize          (  7)
+#if !L0034_COMBINED_LIST_CLEANUP
 , m_bUseLComb                 (false)
+#endif
 , m_bitDepthY                 (  8)
 , m_bitDepthC                 (  8)
 …
 , m_vuiParametersPresentFlag  (false)
 , m_vuiParameters             ()
+#if H_MV
+, m_interViewMvVertConstraintFlag (false)
+#endif
+#if H_3D
+, m_bCamParInSliceHeader      (false)
+#endif
+{
   for ( Int i = 0; i < MAX_TLAYER; i++ )
+  {
     m_uiMaxLatencyIncrease[i] = 0;
+#if L0323_DPB
+    m_uiMaxDecPicBuffering[i] = 1;
+#else
     m_uiMaxDecPicBuffering[i] = 0;
+#endif
     m_numReorderPics[i]       = 0;
+  }
 …
   m_RPSList.create(numRPS);
+}
 Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
+{
 …
+}
+#if H_3D
+Void
+TComSPS::initCamParaSPS( UInt uiViewIndex, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
+{
+  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) );
+  m_uiCamParPrecision     = ( uiViewIndex ? uiCamParPrecision : 0 );
+  m_bCamParInSliceHeader  = ( uiViewIndex ? bCamParSlice  : false );
+  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
+  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
+  if( !m_bCamParInSliceHeader )
+  {
+    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
+    {
+      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
+      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
+      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
+      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
+    }
+  }
+}
+#endif
 TComReferencePictureSet::TComReferencePictureSet()
 : m_numberOfPictures (0)
 …
   return m_POC[bufferNum];
+}
 Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
+{
   m_POC[bufferNum] = POC;
+}
 Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
+{
   return m_bCheckLTMSB[bufferNum];
+}
 Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
+{
 …
+}
 #endif
 /** get scaling matrix from RefMatrixID
  * \param sizeId size index
 …
   ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
+}
 /** parse syntax infomation
  *  \param pchFile syntax infomation
 …
   m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
+}
 /** destroy quantization matrix array
  */
 …
+  }
+}
 /** get default address of quantization matrix
  * \param sizeId size index
 …
   return src;
+}
 /** process of default matrix
  * \param sizeId size index
 …
   setScalingListDC(sizeId,listId,SCALING_LIST_DC);
+}
 /** check DC value of matrix for default matrix signaling
  */
 …
 //! activate a PPS and depending on isIDR parameter also SPS and VPS
 //! \returns true, if activation is successful
 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIDR)
+Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
+{
   TComPPS *pps = m_ppsMap.getPS(ppsId);
 …
     // active parameter sets per layer should be used here
 #else
     if (!isIDR && (spsId != m_activeSPSId))
+    {
       printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
+    if (!isIRAP && (spsId != m_activeSPSId))
+    {
+      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
       return false;
+    }
 …
+    {
       Int vpsId = sps->getVPSId();
       if (!isIDR && (vpsId != m_activeVPSId))
+      {
         printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
+      if (!isIRAP && (vpsId != m_activeVPSId))
+      {
+        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
         return false;
+      }
 …
+}
 #endif
 #if SIGNAL_BITRATE_PICRATE_IN_VPS
 TComBitRatePicRateInfo::TComBitRatePicRateInfo()

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComSlice.h

-                      r438
+                      r446
   ProfileTierLevel* getGeneralPTL()  { return &m_generalPTL; }
   ProfileTierLevel* getSubLayerPTL(Int i)  { return &m_subLayerPTL[i]; }
 #if H_MV
   Void copyLevelFrom( TComPTL* source );
 …
   Int         m_layerIdInVps             [MAX_NUM_LAYERS   ];
   Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES];
+#if H_3D
+  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
+#endif
 …
 #endif
 public:
   TComVPS();
 …
   TComPTL* getPTL() { return &m_pcPTL; }
 #endif
 #if SIGNAL_BITRATE_PICRATE_IN_VPS
   TComBitRatePicRateInfo *getBitratePicrateInfo() { return &m_bitRatePicRateInfo; }
 …
   TimingInfo* getTimingInfo() { return &m_timingInfo; }
 #endif
 #if H_MV
   Void    setAvcBaseLayerFlag( Bool val )                                  { m_avcBaseLayerFlag = val;  }
 …
   Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
 #if H_3D
+  Int     getDepthId ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
+  Void    initViewIndex();
+  Int     getViewIndex    ( Int layerIdInVps )                             { return m_viewIndex[ layerIdInVps ]; }
+  Int     getDepthId      ( Int layerIdInVps )                             { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
+  Int     getLayerIdInNuh( Int viewIndex, Bool depthFlag );
 #endif
 …
   UInt        m_picHeightInLumaSamples;
   Window      m_conformanceWindow;
+  Int         m_log2MinCodingBlockSize;
+  Int         m_log2DiffMaxMinCodingBlockSize;
   UInt        m_uiMaxCUWidth;
   UInt        m_uiMaxCUHeight;
   UInt        m_uiMaxCUDepth;
+  UInt        m_uiMinTrDepth;
+  UInt        m_uiMaxTrDepth;
+  Window      m_conformanceWindow;
   TComRPSList m_RPSList;
   Bool        m_bLongTermRefsPresent;
 …
   Bool        m_useAMP;
+#if !L0034_COMBINED_LIST_CLEANUP
   Bool        m_bUseLComb;
+#endif
   // Parameter
 …
   static const Int   m_winUnitY[MAX_CHROMA_FORMAT_IDC+1];
   TComPTL     m_pcPTL;
+#if H_MV
+  Bool        m_interViewMvVertConstraintFlag;
+#endif
+#if H_3D
+  UInt        m_uiCamParPrecision;
+  Bool        m_bCamParInSliceHeader;
+  Int         m_aaiCodedScale [2][MAX_NUM_LAYERS];
+  Int         m_aaiCodedOffset[2][MAX_NUM_LAYERS];
+#endif
 public:
   TComSPS();
 …
   Bool getUsedByCurrPicLtSPSFlag(Int i)        {return m_usedByCurrPicLtSPSFlag[i];}
   Void setUsedByCurrPicLtSPSFlag(Int i, Bool x)      { m_usedByCurrPicLtSPSFlag[i] = x;}
+  Int  getLog2MinCodingBlockSize() const           { return m_log2MinCodingBlockSize; }
+  Void setLog2MinCodingBlockSize(Int val)          { m_log2MinCodingBlockSize = val; }
+  Int  getLog2DiffMaxMinCodingBlockSize() const    { return m_log2DiffMaxMinCodingBlockSize; }
+  Void setLog2DiffMaxMinCodingBlockSize(Int val)   { m_log2DiffMaxMinCodingBlockSize = val; }
   Void setMaxCUWidth  ( UInt u ) { m_uiMaxCUWidth = u;      }
   UInt getMaxCUWidth  ()         { return  m_uiMaxCUWidth;  }
 …
   Bool getUseAMP() { return m_useAMP; }
   Void setUseAMP( Bool b ) { m_useAMP = b; }
-  Void setMinTrDepth  ( UInt u ) { m_uiMinTrDepth = u;      }
-  UInt getMinTrDepth  ()         { return  m_uiMinTrDepth;  }
-  Void setMaxTrDepth  ( UInt u ) { m_uiMaxTrDepth = u;      }
-  UInt getMaxTrDepth  ()         { return  m_uiMaxTrDepth;  }
   Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u;    }
   UInt getQuadtreeTULog2MaxSize()         { return m_uiQuadtreeTULog2MaxSize; }
 …
   // Tool list
+#if !L0034_COMBINED_LIST_CLEANUP
   Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
   Bool getUseLComb    ()         { return m_bUseLComb;      }
+#endif
   Bool getUseLossless ()         { return m_useLossless; }
 …
   TComPTL* getPTL()     { return &m_pcPTL; }
+#if H_MV
+  Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
+  Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
+#endif
+#if H_3D
+  Void initCamParaSPS      (  UInt uiViewIndex, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
+  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
+  Bool hasCamParInSliceHeader()  { return m_bCamParInSliceHeader; }
+  Int* getCodedScale         ()  { return m_aaiCodedScale [0]; }
+  Int* getCodedOffset        ()  { return m_aaiCodedOffset[0]; }
+  Int* getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
+  Int* getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
+#endif
 };
 …
   Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
   UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
 #if H_MV
   // Why not an listIdx for all members, would avoid code duplication??
 …
   Int         m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
   Int         m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
+#if L0034_COMBINED_LIST_CLEANUP
+  Int         m_list1IdxToList0Idx[MAX_NUM_REF];
+  Int         m_aiNumRefIdx   [2];    //  for multiple reference of current slice
+#else
   Int         m_aiNumRefIdx   [3];    //  for multiple reference of current slice
 …
   Bool        m_bRefPicListModificationFlagLC;
   Bool        m_bRefPicListCombinationFlag;
+#endif
   Bool        m_bCheckLDC;
 …
   Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
+#if !L0034_COMBINED_LIST_CLEANUP
   Bool        m_bNoBackPredFlag;
+#endif
   UInt        m_uiTLayer;
   Bool        m_bTLayerSwitchingFlag;
 …
   Bool       m_enableTMVPFlag;
 #if H_MV
   Int        m_layerId;
   Int        m_viewId;
 #if H_3D
+  Int        m_viewIndex;
   Bool       m_isDepth;
+#endif
+#endif
+  Int        m_aaiCodedScale [2][MAX_NUM_LAYERS];
+  Int        m_aaiCodedOffset[2][MAX_NUM_LAYERS];
+#endif
+#endif
 public:
   TComSlice();
 …
   Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
   Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
+#if H_MV  // This is a temporary fix of the temporary fix L0177
+  Int       getNumRpsCurrTempList( TComReferencePictureSet* rps = NULL );
+#else
   Int       getNumRpsCurrTempList();
+#endif
+#if L0034_COMBINED_LIST_CLEANUP
+  Int       getList1IdxToList0Idx ( Int list1Idx )               { return m_list1IdxToList0Idx[list1Idx]; }
+#else
   Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
   Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
 …
   Bool      getRefPicListCombinationFlag()                      {return m_bRefPicListCombinationFlag;}
   Void      setRefPicListCombinationFlag(Bool bflag)            {m_bRefPicListCombinationFlag=bflag;}
+#endif
   Void      setReferenced(Bool b)                               { m_bRefenced = b; }
   Bool      isReferenced()                                      { return m_bRefenced; }
   Void      setPOC              ( Int i )                       { m_iPOC              = i; if(getTLayer()==0) m_prevPOC=i; }
   Void      setNalUnitType      ( NalUnitType e )               { m_eNalUnitType      = e;      }
   NalUnitType getNalUnitType    ()                              { return m_eNalUnitType;        }
+  NalUnitType getNalUnitType    () const                        { return m_eNalUnitType;        }
   Bool      getRapPicFlag       ();
+  Bool      getIdrPicFlag       ()                              { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
+  Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA);
+  Bool      getIdrPicFlag       ()                              { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
+  Bool      isIRAP              () const                        { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23); }
+  Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList<TComPic *>& rcListPic);
   Void      decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
   Void      setSliceType        ( SliceType e )                 { m_eSliceType        = e;      }
 …
 #endif
 #if H_MV
+  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet );
+  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
+#else
+#if FIX1071
+  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
 #else
   Void      setRefPicList       ( TComList<TComPic*>& rcListPic );
+#endif
 #endif
   Void      setRefPOCList       ();
 …
   static Void      sortPicList         ( TComList<TComPic*>& rcListPic );
+#if L0034_COMBINED_LIST_CLEANUP
+  Void setList1IdxToList0Idx();
+#else
   Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
   Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
   Void generateCombinedList       ();
+#endif
   UInt getTLayer             ()                            { return m_uiTLayer;                      }
 …
   Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
   Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
 #if H_MV
   Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
 …
   Void xPrintRefPicList();
 #endif
   Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
   Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
 …
   Void  getWpScaling    ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
+  Void  resetWpScaling  (wpScalingParam  wp[2][MAX_NUM_REF][3]);
+  Void  initWpScaling    (wpScalingParam  wp[2][MAX_NUM_REF][3]);
+  Void  resetWpScaling  ();
   Void  initWpScaling   ();
   inline Bool applyWP   () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPred()) ); }
 …
   Int       getViewId             ()                 { return m_viewId;     }
 #if H_3D
+  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
+  Int       getViewIndex          ()                 { return m_viewIndex;     }
   Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
   Bool      getIsDepth            ()                 { return m_isDepth; }
+#endif
+#endif
+  Void      setCamparaSlice       ( Int** aaiScale = 0, Int** aaiOffset = 0 );
+  Int*      getCodedScale         ()  { return m_aaiCodedScale [0]; }
+  Int*      getCodedOffset        ()  { return m_aaiCodedOffset[0]; }
+  Int*      getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
+  Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
+#endif
+#endif
 protected:
   TComPic*  xGetRefPic  (TComList<TComPic*>& rcListPic,
                          Int                 poc);
+  TComPic*  xGetLongTermRefPic  (TComList<TComPic*>& rcListPic,
+                         Int                 poc);
+TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
 #if H_MV
   TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId );
 …
   //! activate a PPS and depending on isIDR parameter also SPS and VPS
   //! \returns true, if activation is successful
   Bool activatePPS(Int ppsId, Bool isIDR);
+  Bool activatePPS(Int ppsId, Bool isIRAP);
   TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComTrQuant.cpp

r438	r446
1986	1986	}
1987	1987
1988		if(pi~~QCoef[minPos] == 32767 \|\| piQCoe~~f[minPos] == -32768)
	1988	if(piDstCoeff[minPos] == 32767 \|\| piDstCoeff[minPos] == -32768)
1989	1989	{
1990	1990	finalChange = -1;

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComYuv.cpp

-                      r324
+                      r446
+  }
+}
+#if H_3D
+Void TComYuv::addClipPartLuma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize )
+{
+  Int x, y;
+  Pel* pSrc0 = pcYuvSrc0->getLumaAddr( uiTrUnitIdx);
+  Pel* pSrc1 = pcYuvSrc1->getLumaAddr( uiTrUnitIdx);
+  Pel* pDst  = getLumaAddr( uiTrUnitIdx);
+  UInt iSrc0Stride = pcYuvSrc0->getStride();
+  UInt iSrc1Stride = pcYuvSrc1->getStride();
+  UInt iDstStride  = getStride();
+  for ( y = uiPartSize-1; y >= 0; y-- )
+  {
+    for ( x = uiPartSize-1; x >= 0; x-- )
+    {
+      pDst[x] = ClipY( pSrc0[x] + pSrc1[x] );
+    }
+    pSrc0 += iSrc0Stride;
+    pSrc1 += iSrc1Stride;
+    pDst  += iDstStride;
+  }
+}
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TComYuv.h

-                      r324
+                      r446
   UInt    getCHeight  ()    { return  m_iCHeight; }
   UInt    getCWidth   ()    { return  m_iCWidth;  }
+#if H_3D
+  Void addClipPartLuma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize );
+#endif
 };// END CLASS DEFINITION TComYuv

branches/HTM-DEV-0.2-dev/source/Lib/TLibCommon/TypeDef.h

-                      r438
+                      r446
 //! \{
+#define H_MV                        1
+#if H_MV
+#define H_3D                        0
+#endif
+///// ***** HM 10.0 *********
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////// EXTENSION SELECTION ///////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+/* HEVC_EXT might be defined by compiler/makefile options.
+   Linux makefiles support the following settings:
+   make             -> HEVC_EXT not defined
+   make HEVC_EXT=0  -> H_MV=0 H_3D=0   --> plain HM
+   make HEVC_EXT=1  -> H_MV=1 H_3D=0   --> MV only
+   make HEVC_EXT=2  -> H_MV=1 H_3D=1   --> full 3D
+*/
+#ifndef HEVC_EXT
+#define HEVC_EXT                    2
+#endif
+#if ( HEVC_EXT < 0 )||( HEVC_EXT > 2 )
+#error HEVC_EXT must be in the range of 0 to 2, inclusive.
+#endif
+#define H_MV          ( HEVC_EXT != 0)
+#define H_3D          ( HEVC_EXT == 2)
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////   MAJOR DEFINES   ///////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+#if H_3D
+#define H_3D_PDM_CAM_PARAS                0 ///< PDM related parts of camera parameters, should be removed if not used anymore.
+#define H_3D_VSO                          1   // VSO, View synthesis optimization, includes:
+                                              // HHI_VSO
+                                              // HHI_VSO_LS_TABLE_M23714 enable table base Lagrange multiplier optimization
+                                              // SAIT_VSO_EST_A0033, JCT3V-A0033 modification 3
+                                              // LGE_WVSO_A0119
+#endif
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////   DERIVED DEFINES ///////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+///// ***** VIEW SYNTHESIS OPTIMIZAION *********
+#if H_3D_VSO
+#define H_3D_VSO_DIST_INT                 1   // Allow negative synthesized view distortion change
+#define H_3D_VSO_COLOR_PLANES             1   // Compute VSO distortion on color planes
+#define H_3D_VSO_EARLY_SKIP               1   // LGE_VSO_EARLY_SKIP_A0093, A0093 modification 4
+#define H_3D_VSO_RM_ASSERTIONS            0   // Output VSO assertions
+#define H_3D_VSO_SYNTH_DIST_OUT           0   // Output of synthesized view distortion instead of depth distortion in encoder output
+#endif
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////   HM RELATED DEFINES ////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+#define FIX1071 1 ///< Temporary fix for issue #1071
+#define L0208_SOP_DESCRIPTION_SEI     1 ///< L0208: add SOP descrioption SEI
+#define MAX_NUM_PICS_IN_SOP           1024
+#define K0180_SCALABLE_NESTING_SEI  1   ///JCTVC-K0180 scalable nesting sei message
+#define MAX_NESTING_NUM_OPS         1024
+#define MAX_NESTING_NUM_LAYER       64
+#define J0149_TONE_MAPPING_SEI        1 ///< J0149: Tone mapping information SEI
 #define L0363_DU_BIT_RATE             1 ///< L0363: add bit_rate_du_value_minus1 to HRD parameters
 #define L0328_SPLICING                1 ///< L0328: splicing support in HRD
 …
 #define SIGNAL_BITRATE_PICRATE_IN_VPS               0  ///< K0125: Signal bit_rate and pic_rate in VPS
 #define L0232_RD_PENALTY           1  ///< L0232: RD-penalty for 32x32 TU for intra in non-intra slices
+#define L0386_DB_METRIC            1  ///< L0386: non-normative blockiness metric (automatically configures deblocking parameters in bitstream)
+#define L0323_DPB                     1 ///< L0323: Specification of active reference indices and decoded picture buffer
+#define L0034_COMBINED_LIST_CLEANUP 1
 #define MAX_VPS_NUM_HRD_PARAMETERS                1
 #define MAX_VPS_OP_SETS_PLUS1                     1024
 #if H_MV
 #define MAX_VPS_NUH_LAYER_ID_PLUS1  64
 …
 #define MAX_CPB_CNT                     32  ///< Upper bound of (cpb_cnt_minus1 + 1)
 #define MAX_NUM_LAYER_IDS               64
+#if H_MV
 #define MAX_NUM_LAYERS                  64
+#endif
 #define COEF_REMAIN_BIN_REDUCTION        3 ///< indicates the level at which the VLC
 …
 typedef       Int             TCoeff;     ///< transform coefficient
+#if H_3D_VSO
+// ====================================================================================================================
+// Define Distortion Types
+// ====================================================================================================================
+typedef       Int64           RMDist;     ///< renderer model distortion
+#if H_3D_VSO_DIST_INT
+typedef       Int              Dist;       ///< RDO distortion
+typedef       Int64            Dist64;
+#define       RDO_DIST_MIN     MIN_INT
+#define       RDO_DIST_MAX     MAX_INT
+#else
+typedef       UInt             Dist;       ///< RDO distortion
+typedef       UInt64           Dist;
+#define       RDO_DIST_MIN     0
+#define       RDO_DIST_MAX     MAX_UINT
+#endif
+#endif
 /// parameters for adaptive loop filter
 class TComPicSym;
 …
   REF_PIC_LIST_0 = 0,   ///< reference list 0
   REF_PIC_LIST_1 = 1,   ///< reference list 1
+#if !L0034_COMBINED_LIST_CLEANUP
   REF_PIC_LIST_C = 2,   ///< combined reference list for uni-prediction in B-Slices
+#endif
   REF_PIC_LIST_X = 100  ///< special mark
 };
 …
   DF_HADS64   = 27,     ///<  64xM HAD with step
   DF_HADS16N  = 28,     ///< 16NxM HAD with step
+#if H_3D_VSO
+  DF_VSD      = 29,      ///< general size VSD
+  DF_VSD4     = 30,      ///<   4xM VSD
+  DF_VSD8     = 31,      ///<   8xM VSD
+  DF_VSD16    = 32,      ///<  16xM VSD
+  DF_VSD32    = 33,      ///<  32xM VSD
+  DF_VSD64    = 34,      ///<  64xM VSD
+  DF_VSD16N   = 35,      ///< 16NxM VSD
+#endif
 #if AMP_SAD
   DF_SAD12    = 43,
 …
     VIEW_ID  = 0,
 #if H_3D
     DEPTH_ID = 1,
+    DEPTH_ID = 1,
 #endif
   };
 #endif
+#endif
+#if H_3D
+  // Renderer
+  enum BlenMod
+  {
+    BLEND_NONE  = -1,
+    BLEND_AVRG  = 0,
+    BLEND_LEFT  = 1,
+    BLEND_RIGHT = 2,
+    BLEND_GEN   =  3
+  };
+  enum
+  {
+    VIEWPOS_INVALID = -1,
+    VIEWPOS_LEFT    = 0,
+    VIEWPOS_RIGHT   = 1,
+    VIEWPOS_MERGED  = 2
+  };
+#endif
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/AnnexBread.h

r324	r446
43	43	#include <vector>
44	44
45		#include "TLibCommon/TypeDef.h"
	45	#include "../TLibCommon/TypeDef.h"
46	46
47	47	//! \ingroup TLibDecoder

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/NALread.cpp

-                      r438
+                      r446
 //! \ingroup TLibDecoder
 //! \{
 static void convertPayloadToRBSP(vector<uint8_t>& nalUnitBuf, Bool isVclNalUnit)
+static void convertPayloadToRBSP(vector<uint8_t>& nalUnitBuf, TComInputBitstream *bitstream, Bool isVclNalUnit)
+{
   UInt zeroCount = 0;
   vector<uint8_t>::iterator it_read, it_write;
+  for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++)
+  UInt pos = 0;
+  bitstream->clearEmulationPreventionByteLocation();
+  for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++, pos++)
+  {
     assert(zeroCount < 2 || *it_read >= 0x03);
     if (zeroCount == 2 && *it_read == 0x03)
+    {
+      bitstream->pushEmulationPreventionByteLocation( pos );
+      pos++;
       it_read++;
       zeroCount = 0;
 …
   if ( nalu.m_temporalId )
+  {
     assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLANT
+    assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_W_LP
+         && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_W_RADL
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_N_LP
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR
+         && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR_W_RADL
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR_N_LP
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_CRA
 …
   else
+  {
     assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TLA
+    assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TLA_R
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TSA_N
          && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_STSA_R
 …
   /* perform anti-emulation prevention */
   TComInputBitstream *pcBitstream = new TComInputBitstream(NULL);
   convertPayloadToRBSP(nalUnitBuf, (nalUnitBuf[0] & 64) == 0);
+  convertPayloadToRBSP(nalUnitBuf, pcBitstream, (nalUnitBuf[0] & 64) == 0);
   nalu.m_Bitstream = new TComInputBitstream(&nalUnitBuf);
+  nalu.m_Bitstream->setEmulationPreventionByteLocation(pcBitstream->getEmulationPreventionByteLocation());
   delete pcBitstream;
   readNalUnitHeader(nalu);

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/NALread.h

-                      r324
+                      r446
 #pragma once
 #include "TLibCommon/TypeDef.h"
 #include "TLibCommon/TComBitStream.h"
 #include "TLibCommon/NAL.h"
+#include "../TLibCommon/TypeDef.h"
+#include "../TLibCommon/TComBitStream.h"
+#include "../TLibCommon/NAL.h"
 //! \ingroup TLibDecoder

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/SEIread.cpp

-                      r438
+                      r446
     fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
     break;
+#if J0149_TONE_MAPPING_SEI
+  case SEI::TONE_MAPPING_INFO:
+    fprintf( g_hTrace, "===========Tone Mapping Info SEI message ===========\n");
+    break;
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+  case SEI::SOP_DESCRIPTION:
+    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
+    break;
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  case SEI::SCALABLE_NESTING:
+    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
+    break;
+#endif
   default:
     fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
 …
   SEI *sei = NULL;
   if(nalUnitType == NAL_UNIT_SEI)
+  if(nalUnitType == NAL_UNIT_PREFIX_SEI)
+  {
     switch (payloadType)
 …
       xParseSEIGradualDecodingRefreshInfo((SEIGradualDecodingRefreshInfo&) *sei, payloadSize);
       break;
+#if J0149_TONE_MAPPING_SEI
+    case SEI::TONE_MAPPING_INFO:
+      sei = new SEIToneMappingInfo;
+      xParseSEIToneMappingInfo((SEIToneMappingInfo&) *sei, payloadSize);
+      break;
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+    case SEI::SOP_DESCRIPTION:
+      sei = new SEISOPDescription;
+      xParseSEISOPDescription((SEISOPDescription&) *sei, payloadSize);
+      break;
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+    case SEI::SCALABLE_NESTING:
+      sei = new SEIScalableNesting;
+      xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, sps);
+      break;
+#endif
     default:
       for (UInt i = 0; i < payloadSize; i++)
 …
+    {
       UInt reservedPayloadExtensionData;
       READ_CODE (1, reservedPayloadExtensionData, "reserved_payload_extension_data");
+      READ_FLAG (reservedPayloadExtensionData, "reserved_payload_extension_data");
+    }
     UInt dummy;
+    READ_CODE (1, dummy, "payload_bit_equal_to_one");
+    READ_CODE (payloadBitsRemaining-1, dummy, "payload_bit_equal_to_zero");
+    READ_FLAG (dummy, "payload_bit_equal_to_one"); payloadBitsRemaining--;
+    while (payloadBitsRemaining)
+    {
+      READ_FLAG (dummy, "payload_bit_equal_to_zero"); payloadBitsRemaining--;
+    }
+  }
 …
+}
+#if J0149_TONE_MAPPING_SEI
+Void SEIReader::xParseSEIToneMappingInfo(SEIToneMappingInfo& sei, UInt /*payloadSize*/)
+{
+  Int i;
+  UInt val;
+  READ_UVLC( val, "tone_map_id" );                         sei.m_toneMapId = val;
+  READ_FLAG( val, "tone_map_cancel_flag" );                sei.m_toneMapCancelFlag = val;
+  if ( !sei.m_toneMapCancelFlag )
+  {
+    READ_FLAG( val, "tone_map_persistence_flag" );         sei.m_toneMapPersistenceFlag = val;
+    READ_CODE( 8, val, "coded_data_bit_depth" );           sei.m_codedDataBitDepth = val;
+    READ_CODE( 8, val, "target_bit_depth" );               sei.m_targetBitDepth = val;
+    READ_UVLC( val, "model_id" );                          sei.m_modelId = val;
+    switch(sei.m_modelId)
+    {
+    case 0:
+      {
+        READ_CODE( 32, val, "min_value" );                 sei.m_minValue = val;
+        READ_CODE( 32, val, "max_value" );                 sei.m_maxValue = val;
+        break;
+      }
+    case 1:
+      {
+        READ_CODE( 32, val, "sigmoid_midpoint" );          sei.m_sigmoidMidpoint = val;
+        READ_CODE( 32, val, "sigmoid_width" );             sei.m_sigmoidWidth = val;
+        break;
+      }
+    case 2:
+      {
+        UInt num = 1u << sei.m_targetBitDepth;
+        sei.m_startOfCodedInterval.resize(num+1);
+        for(i = 0; i < num; i++)
+        {
+          READ_CODE( ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "start_of_coded_interval" );
+          sei.m_startOfCodedInterval[i] = val;
+        }
+        sei.m_startOfCodedInterval[num] = 1u << sei.m_codedDataBitDepth;
+        break;
+      }
+    case 3:
+      {
+        READ_CODE( 16, val,  "num_pivots" );                       sei.m_numPivots = val;
+        sei.m_codedPivotValue.resize(sei.m_numPivots);
+        sei.m_targetPivotValue.resize(sei.m_numPivots);
+        for(i = 0; i < sei.m_numPivots; i++ )
+        {
+          READ_CODE( ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "coded_pivot_value" );
+          sei.m_codedPivotValue[i] = val;
+          READ_CODE( ((( sei.m_targetBitDepth + 7 ) >> 3 ) << 3),    val, "target_pivot_value" );
+          sei.m_targetPivotValue[i] = val;
+        }
+        break;
+      }
+    case 4:
+      {
+        READ_CODE( 8, val, "camera_iso_speed_idc" );                     sei.m_cameraIsoSpeedValue = val;
+        if( sei.m_cameraIsoSpeedValue == 255) //Extended_ISO
+        {
+          READ_CODE( 32,   val,   "camera_iso_speed_value" );            sei.m_cameraIsoSpeedValue = val;
+        }
+        READ_FLAG( val, "exposure_compensation_value_sign_flag" );       sei.m_exposureCompensationValueSignFlag = val;
+        READ_CODE( 16, val, "exposure_compensation_value_numerator" );   sei.m_exposureCompensationValueNumerator = val;
+        READ_CODE( 16, val, "exposure_compensation_value_denom_idc" );   sei.m_exposureCompensationValueDenomIdc = val;
+        READ_CODE( 32, val, "ref_screen_luminance_white" );              sei.m_refScreenLuminanceWhite = val;
+        READ_CODE( 32, val, "extended_range_white_level" );              sei.m_extendedRangeWhiteLevel = val;
+        READ_CODE( 16, val, "nominal_black_level_luma_code_value" );     sei.m_nominalBlackLevelLumaCodeValue = val;
+        READ_CODE( 16, val, "nominal_white_level_luma_code_value" );     sei.m_nominalWhiteLevelLumaCodeValue= val;
+        READ_CODE( 16, val, "extended_white_level_luma_code_value" );    sei.m_extendedWhiteLevelLumaCodeValue = val;
+        break;
+      }
+    default:
+      {
+        assert(!"Undefined SEIToneMapModelId");
+        break;
+      }
+    }//switch model id
+  }// if(!sei.m_toneMapCancelFlag)
+  xParseByteAlign();
+}
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+Void SEIReader::xParseSEISOPDescription(SEISOPDescription &sei, UInt payloadSize)
+{
+  Int iCode;
+  UInt uiCode;
+  READ_UVLC( uiCode,           "sop_seq_parameter_set_id"            ); sei.m_sopSeqParameterSetId = uiCode;
+  READ_UVLC( uiCode,           "num_pics_in_sop_minus1"              ); sei.m_numPicsInSopMinus1 = uiCode;
+  for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
+  {
+    READ_CODE( 6, uiCode,                     "sop_desc_vcl_nalu_type" );  sei.m_sopDescVclNaluType[i] = uiCode;
+    READ_CODE( 3, sei.m_sopDescTemporalId[i], "sop_desc_temporal_id"   );  sei.m_sopDescTemporalId[i] = uiCode;
+    if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
+    {
+      READ_UVLC( sei.m_sopDescStRpsIdx[i],    "sop_desc_st_rps_idx"    ); sei.m_sopDescStRpsIdx[i] = uiCode;
+    }
+    if (i > 0)
+    {
+      READ_SVLC( iCode,                       "sop_desc_poc_delta"     ); sei.m_sopDescPocDelta[i] = iCode;
+    }
+  }
+  xParseByteAlign();
+}
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps)
+{
+  UInt uiCode;
+  SEIMessages seis;
+  READ_FLAG( uiCode,            "bitstream_subset_flag"         ); sei.m_bitStreamSubsetFlag = uiCode;
+  READ_FLAG( uiCode,            "nesting_op_flag"               ); sei.m_nestingOpFlag = uiCode;
+  if (sei.m_nestingOpFlag)
+  {
+    READ_FLAG( uiCode,            "default_op_flag"               ); sei.m_defaultOpFlag = uiCode;
+    READ_UVLC( uiCode,            "nesting_num_ops_minus1"        ); sei.m_nestingNumOpsMinus1 = uiCode;
+    for (UInt i = sei.m_defaultOpFlag; i <= sei.m_nestingNumOpsMinus1; i++)
+    {
+      READ_CODE( 3,        uiCode,  "nesting_max_temporal_id_plus1"   ); sei.m_nestingMaxTemporalIdPlus1[i] = uiCode;
+      READ_UVLC( uiCode,            "nesting_op_idx"                  ); sei.m_nestingOpIdx[i] = uiCode;
+    }
+  }
+  else
+  {
+    READ_FLAG( uiCode,            "all_layers_flag"               ); sei.m_allLayersFlag       = uiCode;
+    if (!sei.m_allLayersFlag)
+    {
+      READ_CODE( 3,        uiCode,  "nesting_no_op_max_temporal_id_plus1"  ); sei.m_nestingNoOpMaxTemporalIdPlus1 = uiCode;
+      READ_UVLC( uiCode,            "nesting_num_layers_minus1"            ); sei.m_nestingNumLayersMinus1        = uiCode;
+      for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
+      {
+        READ_CODE( 6,           uiCode,     "nesting_layer_id"      ); sei.m_nestingLayerId[i]   = uiCode;
+      }
+    }
+  }
+  // byte alignment
+  while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
+  {
+    UInt code;
+    READ_FLAG( code, "nesting_zero_bit" );
+  }
+  sei.m_callerOwnsSEIs = false;
+  // read nested SEI messages
+  do {
+    xReadSEImessage(sei.m_nestedSEIs, nalUnitType, sps);
+  } while (m_pcBitstream->getNumBitsLeft() > 8);
+}
+#endif
 Void SEIReader::xParseByteAlign()
+{

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/SEIread.h

-                      r438
+                      r446
   Void xParseSEITemporalLevel0Index   (SEITemporalLevel0Index &sei, UInt payloadSize);
   Void xParseSEIGradualDecodingRefreshInfo (SEIGradualDecodingRefreshInfo &sei, UInt payloadSize);
+#if J0149_TONE_MAPPING_SEI
+  Void xParseSEIToneMappingInfo       (SEIToneMappingInfo& sei, UInt payloadSize);
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+  Void xParseSEISOPDescription        (SEISOPDescription &sei, UInt payloadSize);
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  Void xParseSEIScalableNesting       (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps);
+#endif
   Void xParseByteAlign();
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/SyntaxElementParser.h

r324	r446
43	43	#endif // _MSC_VER > 1000
44	44
45		#include "TLibCommon/TComRom.h"
	45	#include "../TLibCommon/TComRom.h"
46	46
47	47	#if ENC_DEC_TRACE

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

-                      r438
+                      r446
 TDecCavlc::TDecCavlc()
+{
+#if H_3D
+  m_aaiTempScale            = new Int* [ MAX_NUM_LAYERS ];
+  m_aaiTempOffset           = new Int* [ MAX_NUM_LAYERS ];
+  for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
+  {
+    m_aaiTempScale            [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
+    m_aaiTempOffset           [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
+  }
+#endif
+}
 TDecCavlc::~TDecCavlc()
+{
+#if H_3D
+  for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
+  {
+    delete [] m_aaiTempScale            [ uiVId ];
+    delete [] m_aaiTempOffset           [ uiVId ];
+  }
+  delete [] m_aaiTempScale;
+  delete [] m_aaiTempOffset;
+#endif
+}
 …
   rps->printDeltaPOC();
 #endif
+}
-/** copy SAO parameter
-* \param dst
-* \param src
-*/
-inline Void copySaoOneLcuParam(SaoLcuParam* dst,  SaoLcuParam* src)
+{
-  Int i;
-  dst->partIdx = src->partIdx;
-  dst->typeIdx = src->typeIdx;
-  if (dst->typeIdx != -1)
+  {
-    dst->subTypeIdx = src->subTypeIdx ;
-    dst->length  = src->length;
-    for (i=0;i<dst->length;i++)
+    {
-      dst->offset[i] = src->offset[i];
+    }
+  }
-  else
+  {
-    dst->length  = 0;
-    for (i=0;i<SAO_BO_LEN;i++)
+    {
-      dst->offset[i] = 0;
+    }
+  }
+}
 …
   READ_FLAG(     uiCode, "field_seq_flag");                           pcVUI->setFieldSeqFlag(uiCode);
-  assert(pcVUI->getFieldSeqFlag() == false);        // not supported yet
   READ_FLAG(uiCode, "frame_field_info_present_flag");                 pcVUI->setFrameFieldInfoPresentFlag(uiCode);
 …
+}
+#if H_3D
+Void TDecCavlc::parseSPS(TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
+#else
 Void TDecCavlc::parseSPS(TComSPS* pcSPS)
+#endif
+{
 #if ENC_DEC_TRACE
 …
   READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
+  g_bitDepthY = 8 + uiCode;
+  pcSPS->setBitDepthY(g_bitDepthY);
+  pcSPS->setBitDepthY( uiCode + 8 );
   pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
   READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
+  g_bitDepthC = 8 + uiCode;
+  pcSPS->setBitDepthC(g_bitDepthC);
+  pcSPS->setBitDepthC( uiCode + 8 );
   pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
 …
   for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
+  {
+#if L0323_DPB
+#if H_MV
+    READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
+#else
+    READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1");
+#endif
+    pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
+#else
     READ_UVLC ( uiCode, "sps_max_dec_pic_buffering");
     pcSPS->setMaxDecPicBuffering( uiCode, i);
+#endif
+#if H_MV
+    READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
+#else
     READ_UVLC ( uiCode, "sps_num_reorder_pics" );
+#endif
     pcSPS->setNumReorderPics(uiCode, i);
+#if H_MV
+    READ_UVLC ( uiCode, "sps_max_latency_increase[i]");
+#else
     READ_UVLC ( uiCode, "sps_max_latency_increase");
+#endif
     pcSPS->setMaxLatencyIncrease( uiCode, i );
 …
   READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
+  UInt log2MinCUSize = uiCode + 3;
+  Int log2MinCUSize = uiCode + 3;
+  pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
   READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
+  UInt uiMaxCUDepthCorrect = uiCode;
+  pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUWidth  = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
+  pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUHeight = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
+  pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
+  Int maxCUDepthDelta = uiCode;
+  pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + maxCUDepthDelta) );
+  pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
   READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" );   pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
 …
   READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" );    pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
   READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" );    pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
+  g_uiAddCUDepth = 0;
+  while( ( pcSPS->getMaxCUWidth() >> uiMaxCUDepthCorrect ) > ( 1 << ( pcSPS->getQuadtreeTULog2MinSize() + g_uiAddCUDepth )  ) )
+  {
+    g_uiAddCUDepth++;
+  }
+  pcSPS->setMaxCUDepth( uiMaxCUDepthCorrect+g_uiAddCUDepth  );
+  g_uiMaxCUDepth  = uiMaxCUDepthCorrect+g_uiAddCUDepth;
+  // BB: these parameters may be removed completly and replaced by the fixed values
+  pcSPS->setMinTrDepth( 0 );
+  pcSPS->setMaxTrDepth( 1 );
+  Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
+  pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth );
   READ_FLAG( uiCode, "scaling_list_enabled_flag" );                 pcSPS->setScalingListFlag ( uiCode );
   if(pcSPS->getScalingListFlag())
 …
   if (uiCode)
+  {
+#if !H_MV
     while ( xMoreRbspData() )
+    {
       READ_FLAG( uiCode, "sps_extension_data_flag");
+    }
+#else
+    READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );    pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
+    READ_FLAG( uiCode, "sps_extension2_flag");
+    if ( uiCode )
+    {
+#if !H_3D
+      while ( xMoreRbspData() )
+      {
+        READ_FLAG( uiCode, "sps_extension_data_flag");
+      }
+#else
+      UInt uiCamParPrecision = 0;
+      Bool bCamParSlice      = false;
+      if ( !depthFlag )
+      {
+        READ_UVLC( uiCamParPrecision, "cp_precision" );
+        READ_FLAG( uiCode, "cp_in_slice_header_flag" );    bCamParSlice = ( uiCode == 1 );
+        if( !bCamParSlice )
+        {
+          for( UInt uiBaseIndex = 0; uiBaseIndex < viewIndex; uiBaseIndex++ )
+          {
+            Int iCode;
+            READ_SVLC( iCode, "cp_scale" );                m_aaiTempScale  [ uiBaseIndex ][ viewIndex ]   = iCode;
+            READ_SVLC( iCode, "cp_off" );                  m_aaiTempOffset [ uiBaseIndex ][ viewIndex ]   = iCode;
+            READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale  [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
+            READ_SVLC( iCode, "cp_inv_off_plus_off" );     m_aaiTempOffset [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
+          }
+        }
+      }
+      pcSPS->initCamParaSPS( viewIndex, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
+      READ_FLAG( uiCode, "sps_extension3_flag");
+      if ( uiCode )
+      {
+        while ( xMoreRbspData() )
+        {
+          READ_FLAG( uiCode, "sps_extension_data_flag");
+        }
+      }
+#endif // !H_3D
+    }
+#endif // !H_MV
+  }
+}
 …
   for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
+  {
+#if L0323_DPB
+    READ_UVLC( uiCode,  "vps_max_dec_pic_buffering_minus1[i]" );     pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
+#else
     READ_UVLC( uiCode,  "vps_max_dec_pic_buffering[i]" );     pcVPS->setMaxDecPicBuffering( uiCode, i );
+#endif
     READ_UVLC( uiCode,  "vps_num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
     READ_UVLC( uiCode,  "vps_max_latency_increase[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
 …
     // parse layer_id_in_nuh[i] and derive LayerIdInVps
+    pcVPS->setLayerIdInNuh( 0, 0 ); pcVPS->setLayerIdInVps( 0, 0 );
+    for( Int layer = 1; layer <= pcVPS->getMaxLayers() - 1; layer++ )
+    // already updated to JCT3V-D0220
+    for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
+    {
       UInt layerIdInNuh;
       if ( pcVPS->getVpsNuhLayerIdPresentFlag() )
+      if ( pcVPS->getVpsNuhLayerIdPresentFlag() && ( layer != 0 ) )
+      {
         READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" );                layerIdInNuh = uiCode;
 …
 #endif
+  }
+#if H_3D
+  pcVPS->initViewIndex();
+#endif
   return;
+}
 …
   vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
   assert(vps!=0);
+  rpcSlice->setVPS(vps);
+  rpcSlice->setVPS(vps);
+  rpcSlice->setViewId   ( vps->getViewId   ( rpcSlice->getLayerIdInVps() )      );
+#if H_3D
+  rpcSlice->setViewIndex( vps->getViewIndex( rpcSlice->getLayerIdInVps() )      );
+  rpcSlice->setIsDepth  ( vps->getDepthId  ( rpcSlice->getLayerIdInVps() ) == 1 );
+#endif
 #endif
   rpcSlice->setSPS(sps);
 …
         iPOCmsb = iPrevPOCmsb;
+      }
       if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
         || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
+      if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
         || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
+      {
 …
       TComReferencePictureSet* rps;
+      rps = rpcSlice->getLocalRPS();
+      rpcSlice->setRPS(rps);
       READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
       if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
+      {
-        rps = rpcSlice->getLocalRPS();
         parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
-        rpcSlice->setRPS(rps);
+      }
       else // use reference to short-term reference picture set in PPS
 …
           uiCode = 0;
+        }
+        rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
+        rps = rpcSlice->getRPS();
+        memcpy(rps,sps->getRPSList()->getReferencePictureSet(uiCode),sizeof(TComReferencePictureSet));
+      }
       if(sps->getLongTermRefsPresent())
 …
         rps->setNumberOfLongtermPictures(numOfLtrp);
         Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC();
         Int prevLSB = 0, prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
+        Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
         for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
+        {
 …
             READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
             Bool deltaFlag = false;
             //            First LTRP                               || First LTRP from SH           || curr LSB    != prev LSB
             if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) || (pocLsbLt != prevLSB) )
+            //            First LTRP                               || First LTRP from SH
+            if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
+            {
               deltaFlag = true;
 …
             rps->setCheckLTMSBPresent(j,false);
+          }
-          prevLSB = pocLsbLt;
           prevDeltaMSB = deltaPocMSBCycleLT;
+        }
 …
         rps->setNumberOfPictures(offset);
+      }
       if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
         || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT
+      if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
         || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
+      {
 …
       if(refPicListModification->getRefPicListModificationFlagL0())
+      {
+      {
         uiCode = 0;
         Int i = 0;
 …
         if(!rpcSlice->getDeblockingFilterDisable())
+        {
+          READ_SVLC( iCode, "beta_offset_div2" );                       rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
+          READ_SVLC( iCode, "tc_offset_div2" );                         rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
+          READ_SVLC( iCode, "slice_beta_offset_div2" );                       rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
+          assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
+                 rpcSlice->getDeblockingFilterBetaOffsetDiv2() <=  6);
+          READ_SVLC( iCode, "slice_tc_offset_div2" );                         rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
+          assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
+                 rpcSlice->getDeblockingFilterTcOffsetDiv2() <=  6);
+        }
+      }
 …
+  }
-  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+  {
     UInt *entryPointOffset          = NULL;
     UInt numEntryPointOffsets, offsetLenMinus1;
+  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+  {
     READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
     if (numEntryPointOffsets>0)
 …
 #endif
+    }
+  }
+  else
+  {
+    rpcSlice->setNumEntryPointOffsets ( 0 );
+  }
+  if(pps->getSliceHeaderExtensionPresentFlag())
+  {
+    READ_UVLC(uiCode,"slice_header_extension_length");
+#if H_3D
+    if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
+    {
+      UInt uiViewIndex = rpcSlice->getViewIndex();
+      for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
+      {
+        READ_SVLC( iCode, "cp_scale" );                m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ] = iCode;
+        READ_SVLC( iCode, "cp_off" );                  m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ] = iCode;
+        READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale [ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ];
+        READ_SVLC( iCode, "cp_inv_off_plus_off" );     m_aaiTempOffset[ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ];
+      }
+      rpcSlice->setCamparaSlice( m_aaiTempScale, m_aaiTempOffset );
+    }
+    READ_FLAG(uiCode,"slice_segment_header_extension2_flag");
+    if ( uiCode )
+    {
+      READ_UVLC(uiCode,"slice_header_extension2_length");
+      for(Int i=0; i<uiCode; i++)
+      {
+        UInt ignore;
+        READ_CODE(8,ignore,"slice_header_extension2_data_byte");
+      }
+    }
+  }
+#else
+    for(Int i=0; i<uiCode; i++)
+    {
+      UInt ignore;
+      READ_CODE(8,ignore,"slice_header_extension_data_byte");
+    }
+  }
+#endif
+  m_pcBitstream->readByteAlignment();
+  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+  {
+    Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
+    Int  curEntryPointOffset     = 0;
+    Int  prevEntryPointOffset    = 0;
+    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
+    {
+      curEntryPointOffset += entryPointOffset[ idx ];
+      Int emulationPreventionByteCount = 0;
+      for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
+      {
+        if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) &&
+             m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) <  ( curEntryPointOffset  + endOfSliceHeaderLocation ) )
+        {
+          emulationPreventionByteCount++;
+        }
+      }
+      entryPointOffset[ idx ] -= emulationPreventionByteCount;
+      prevEntryPointOffset = curEntryPointOffset;
+    }
     if ( pps->getTilesEnabledFlag() )
 …
+    }
+  }
+  else
+  {
+    rpcSlice->setNumEntryPointOffsets ( 0 );
+  }
+  if(pps->getSliceHeaderExtensionPresentFlag())
+  {
+    READ_UVLC(uiCode,"slice_header_extension_length");
+    for(Int i=0; i<uiCode; i++)
+    {
+      UInt ignore;
+      READ_CODE(8,ignore,"slice_header_extension_data_byte");
+    }
+  }
+  m_pcBitstream->readByteAlignment();
   return;
+}
 …
 // ====================================================================================================================
-/** Parse PCM alignment zero bits.
-* \returns Void
-*/
-Void TDecCavlc::xReadPCMAlignZero( )
+{
-  UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
-  if(uiNumberOfBits)
+  {
-    UInt uiBits;
-    UInt uiSymbol;
-    for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
+    {
-      xReadFlag( uiSymbol );
-      assert( uiSymbol == 0 );
+    }
+  }
+}
-Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol )
+{
-  if (uiMaxSymbol == 0)
+  {
-    ruiSymbol = 0;
-    return;
+  }
-  xReadFlag( ruiSymbol );
-  if (ruiSymbol == 0 || uiMaxSymbol == 1)
+  {
-    return;
+  }
-  UInt uiSymbol = 0;
-  UInt uiCont;
-  do
+  {
-    xReadFlag( uiCont );
-    uiSymbol++;
+  }
-  while( uiCont && (uiSymbol < uiMaxSymbol-1) );
-  if( uiCont && (uiSymbol == uiMaxSymbol-1) )
+  {
-    uiSymbol++;
+  }
-  ruiSymbol = uiSymbol;
+}
-Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol )
+{
-  UInt uiSymbol ;
-  UInt uiCount = 0;
-  do
+  {
-    xReadFlag( uiSymbol );
-    uiCount++;
+  }
-  while( uiSymbol && (uiCount != 13));
-  ruiSymbol = uiCount-1;
-  if( uiSymbol )
+  {
-    xReadEpExGolomb( uiSymbol, 0 );
-    ruiSymbol += uiSymbol+1;
+  }
-  return;
+}
-Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
+{
-  UInt uiSymbol = 0;
-  UInt uiBit = 1;
-  while( uiBit )
+  {
-    xReadFlag( uiBit );
-    uiSymbol += uiBit << uiCount++;
+  }
-  uiCount--;
-  while( uiCount-- )
+  {
-    xReadFlag( uiBit );
-    uiSymbol += uiBit << uiCount;
+  }
-  ruiSymbol = uiSymbol;
-  return;
+}
-UInt TDecCavlc::xGetBit()
+{
-  UInt ruiCode;
-  m_pcBitstream->read( 1, ruiCode );
-  return ruiCode;
+}
 /** parse explicit wp tables
 * \param TComSlice* pcSlice
 …
   // decode delta_luma_log2_weight_denom :
   READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
+  assert( uiLog2WeightDenomLuma <= 7 );
   if( bChroma )
+  {
     READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );     // se(v): delta_chroma_log2_weight_denom
     assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
+    assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
     uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
+  }
 …
         Int iDeltaWeight;
         READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" );  // se(v): delta_luma_weight_l0[i]
+        assert( iDeltaWeight >= -128 );
+        assert( iDeltaWeight <=  127 );
         wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
         READ_SVLC( wp[0].iOffset, "luma_offset_lX" );       // se(v): luma_offset_l0[i]
+        assert( wp[0].iOffset >= -128 );
+        assert( wp[0].iOffset <=  127 );
+      }
       else
 …
             Int iDeltaWeight;
             READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );  // se(v): chroma_weight_l0[i][j]
+            assert( iDeltaWeight >= -128 );
+            assert( iDeltaWeight <=  127 );
             wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
             Int iDeltaChroma;
             READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );  // se(v): delta_chroma_offset_l0[i][j]
+            assert( iDeltaChroma >= -512 );
+            assert( iDeltaChroma <=  511 );
             Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
             wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) );

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecCAVLC.h

-                      r438
+                      r446
 protected:
+  Void  xReadEpExGolomb       ( UInt& ruiSymbol, UInt uiCount );
+  Void  xReadExGolombLevel    ( UInt& ruiSymbol );
+  Void  xReadUnaryMaxSymbol   ( UInt& ruiSymbol, UInt uiMaxSymbol );
+  void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
+  Void  xReadPCMAlignZero     ();
+  UInt  xGetBit             ();
+  void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
+private:
+#if H_3D
+  Int**    m_aaiTempScale;
+  Int**    m_aaiTempOffset;
+#endif
 public:
 …
   Void  parseQtRootCbf      ( UInt uiAbsPartIdx, UInt& uiQtRootCbf );
   Void  parseVPS            ( TComVPS* pcVPS );
+#if H_3D
+  Void  parseSPS            ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
+#else
   Void  parseSPS            ( TComSPS* pcSPS );
+#endif
   Void  parsePPS            ( TComPPS* pcPPS);
   Void  parseVUI            ( TComVUI* pcVUI, TComSPS* pcSPS );

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecEntropy.h

-                      r324
+                      r446
 #define __TDECENTROPY__
 #include "TLibCommon/CommonDef.h"
 #include "TLibCommon/TComBitStream.h"
 #include "TLibCommon/TComSlice.h"
 #include "TLibCommon/TComPic.h"
 #include "TLibCommon/TComPrediction.h"
 #include "TLibCommon/TComSampleAdaptiveOffset.h"
+#include "../TLibCommon/CommonDef.h"
+#include "../TLibCommon/TComBitStream.h"
+#include "../TLibCommon/TComSlice.h"
+#include "../TLibCommon/TComPic.h"
+#include "../TLibCommon/TComPrediction.h"
+#include "../TLibCommon/TComSampleAdaptiveOffset.h"
 class TDecSbac;
 …
   virtual Void  parseVPS                  ( TComVPS* pcVPS )                       = 0;
+#if H_3D
+  virtual Void  parseSPS                  ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag  )         = 0;
+#else
   virtual Void  parseSPS                  ( TComSPS* pcSPS )                                      = 0;
+#endif
   virtual Void  parsePPS                  ( TComPPS* pcPPS )                                      = 0;
 …
   Void    resetEntropy                ( TComSlice* p)           { m_pcEntropyDecoderIf->resetEntropy(p);                    }
   Void    decodeVPS                   ( TComVPS* pcVPS ) { m_pcEntropyDecoderIf->parseVPS(pcVPS); }
+#if H_3D
+  Void    decodeSPS                   ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )    { m_pcEntropyDecoderIf->parseSPS(pcSPS, viewIndex, depthFlag );                    }
+#else
   Void    decodeSPS                   ( TComSPS* pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
+#endif
   Void    decodePPS                   ( TComPPS* pcPPS )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
   Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager);         }

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecGop.cpp

-                      r438
+                      r446
   rpcPic->compressMotion();
 #endif
   Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
   if (!pcSlice->isReferenced()) c += 32;
   //-- For time output for each slice
 #if H_MV
   printf("\nLayer %2d   POC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getLayerId(),

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecSbac.h

-                      r324
+                      r446
   Void  setBitstream              ( TComInputBitstream* p  ) { m_pcBitstream = p; m_pcTDecBinIf->init( p ); }
   Void  parseVPS                  ( TComVPS* /*pcVPS*/ ) {}
+#if H_3D
+  Void  parseSPS                  ( TComSPS* /*pcSPS*/ , Int /*viewIndex*/, Bool /*depthFlag*/ ) {}
+#else
   Void  parseSPS                  ( TComSPS* /*pcSPS*/ ) {}
+#endif
   Void  parsePPS                  ( TComPPS* /*pcPPS*/ ) {}

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecSlice.h

r438	r446
84	84	Void initCtxMem( UInt i );
85	85	Void setCtxMem( TDecSbac* sb, Int b ) { CTXMem[b] = sb; }
	86	Int getCtxMemSize( ) { return (Int)CTXMem.size(); }
86	87	};
87	88

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecTop.cpp

-                      r438
+                      r446
 ParameterSetManagerDecoder TDecTop::m_parameterSetManagerDecoder;
 #endif
 //! \ingroup TLibDecoder
 //! \{
+#if H_3D
+CamParsCollector::CamParsCollector()
+: m_bInitialized( false )
+{
+  m_aaiCodedOffset         = new Int* [ MAX_NUM_LAYERS ];
+  m_aaiCodedScale          = new Int* [ MAX_NUM_LAYERS ];
+  m_aiViewId               = new Int  [ MAX_NUM_LAYERS ];
+  m_aiLayerIdx             = new Int  [ MAX_NUM_LAYERS ];
+  m_bViewReceived          = new Bool [ MAX_NUM_LAYERS ];
+  for( UInt uiId = 0; uiId < MAX_NUM_LAYERS; uiId++ )
+  {
+    m_aaiCodedOffset      [ uiId ] = new Int [ MAX_NUM_LAYERS ];
+    m_aaiCodedScale       [ uiId ] = new Int [ MAX_NUM_LAYERS ];
+  }
+  xCreateLUTs( (UInt)MAX_NUM_LAYERS, (UInt)MAX_NUM_LAYERS, m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+  m_iLog2Precision   = LOG2_DISP_PREC_LUT;
+  m_uiBitDepthForLUT = 8; // fixed
+}
+CamParsCollector::~CamParsCollector()
+{
+  for( UInt uiId = 0; uiId < MAX_NUM_LAYERS; uiId++ )
+  {
+    delete [] m_aaiCodedOffset      [ uiId ];
+    delete [] m_aaiCodedScale       [ uiId ];
+  }
+  delete [] m_aaiCodedOffset;
+  delete [] m_aaiCodedScale;
+  delete [] m_aiViewId;
+  delete [] m_bViewReceived;
+  xDeleteArray( m_adBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
+  xDeleteArray( m_aiBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
+}
+Void
+CamParsCollector::init( FILE* pCodedScaleOffsetFile )
+{
+  m_bInitialized            = true;
+  m_pCodedScaleOffsetFile   = pCodedScaleOffsetFile;
+  m_uiCamParsCodedPrecision = 0;
+  m_bCamParsVaryOverTime    = false;
+  m_iLastViewIndex             = -1;
+  m_iLastPOC                = -1;
+  m_uiMaxViewIndex             = 0;
+}
+Void
+CamParsCollector::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT)
+{
+  uiNumberSourceViews = std::max( (UInt) 1, uiNumberSourceViews );
+  uiNumberTargetViews = std::max( (UInt) 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;
+  }
+  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 ];
+}
+Void
+CamParsCollector::uninit()
+{
+  m_bInitialized = false;
+}
+Void
+CamParsCollector::setSlice( TComSlice* pcSlice )
+{
+  if( pcSlice == 0 )
+  {
+    AOF( xIsComplete() );
+    if( m_bCamParsVaryOverTime || m_iLastPOC == 0 )
+    {
+      xOutput( m_iLastPOC );
+    }
+    return;
+  }
+  if ( pcSlice->getIsDepth())
+  {
+    return;
+  }
+  Bool  bFirstAU          = ( pcSlice->getPOC()     == 0 );
+  Bool  bFirstSliceInAU   = ( pcSlice->getPOC()     != Int ( m_iLastPOC ) );
+  Bool  bFirstSliceInView = ( pcSlice->getViewIndex()  != UInt( m_iLastViewIndex ) || bFirstSliceInAU );
+  AOT(  bFirstSliceInAU  &&   pcSlice->getViewIndex()  != 0 );
+  AOT( !bFirstSliceInAU  &&   pcSlice->getViewIndex()   < UInt( m_iLastViewIndex ) );
+  AOT( !bFirstSliceInAU  &&   pcSlice->getViewIndex()   > UInt( m_iLastViewIndex + 1 ) );
+  AOT( !bFirstAU         &&   pcSlice->getViewIndex()   > m_uiMaxViewIndex );
+  if ( !bFirstSliceInView )
+  {
+    if( m_bCamParsVaryOverTime ) // check consistency of slice parameters here
+    {
+      UInt uiViewIndex = pcSlice->getViewIndex();
+      for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
+      {
+        AOF( m_aaiCodedScale [ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedScale    () [ uiBaseViewIndex ] );
+        AOF( m_aaiCodedOffset[ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedOffset   () [ uiBaseViewIndex ] );
+        AOF( m_aaiCodedScale [ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedScale () [ uiBaseViewIndex ] );
+        AOF( m_aaiCodedOffset[ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedOffset() [ uiBaseViewIndex ] );
+      }
+    }
+    return;
+  }
+  if( bFirstSliceInAU )
+  {
+    if( !bFirstAU )
+    {
+      AOF( xIsComplete() );
+      xOutput( m_iLastPOC );
+    }
+    ::memset( m_bViewReceived, false, MAX_NUM_LAYERS * sizeof( Bool ) );
+  }
+  UInt uiViewIndex                       = pcSlice->getViewIndex();
+  m_bViewReceived[ uiViewIndex ]         = true;
+  if( bFirstAU )
+  {
+    m_uiMaxViewIndex                     = std::max( m_uiMaxViewIndex, uiViewIndex );
+    m_aiViewId[ uiViewIndex ]            = pcSlice->getViewId();
+    if( uiViewIndex == 1 )
+    {
+      m_uiCamParsCodedPrecision       = pcSlice->getSPS()->getCamParPrecision     ();
+      m_bCamParsVaryOverTime          = pcSlice->getSPS()->hasCamParInSliceHeader ();
+    }
+    else if( uiViewIndex > 1 )
+    {
+      AOF( m_uiCamParsCodedPrecision == pcSlice->getSPS()->getCamParPrecision     () );
+      AOF( m_bCamParsVaryOverTime    == pcSlice->getSPS()->hasCamParInSliceHeader () );
+    }
+    for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
+    {
+      if( m_bCamParsVaryOverTime )
+      {
+        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedScale    () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedOffset   () [ uiBaseIndex ];
+        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedScale () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedOffset() [ uiBaseIndex ];
+        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+      }
+      else
+      {
+        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedScale    () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedOffset   () [ uiBaseIndex ];
+        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseIndex ];
+        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+      }
+    }
+  }
+  else
+  {
+    AOF( m_aiViewId[ uiViewIndex ] == pcSlice->getViewId() );
+    if( m_bCamParsVaryOverTime )
+    {
+      for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
+      {
+        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedScale    () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedOffset   () [ uiBaseIndex ];
+        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedScale () [ uiBaseIndex ];
+        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedOffset() [ uiBaseIndex ];
+        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+      }
+    }
+  }
+  m_iLastViewIndex = (Int)pcSlice->getViewIndex();
+  m_iLastPOC       = (Int)pcSlice->getPOC();
+}
+Bool
+CamParsCollector::xIsComplete()
+{
+  for( UInt uiView = 0; uiView <= m_uiMaxViewIndex; uiView++ )
+  {
+    if( m_bViewReceived[ uiView ] == 0 )
+    {
+      return false;
+    }
+  }
+  return true;
+}
+Void
+CamParsCollector::xOutput( Int iPOC )
+{
+  if( m_pCodedScaleOffsetFile )
+  {
+    if( iPOC == 0 )
+    {
+      fprintf( m_pCodedScaleOffsetFile, "#  ViewIndex       ViewId\n" );
+      fprintf( m_pCodedScaleOffsetFile, "#----------- ------------\n" );
+      for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
+      {
+        fprintf( m_pCodedScaleOffsetFile, "%12d %12d\n", uiViewIndex, m_aiViewId[ uiViewIndex ] );
+      }
+      fprintf( m_pCodedScaleOffsetFile, "\n\n");
+      fprintf( m_pCodedScaleOffsetFile, "# StartFrame     EndFrame   TargetView     BaseView   CodedScale  CodedOffset    Precision\n" );
+      fprintf( m_pCodedScaleOffsetFile, "#----------- ------------ ------------ ------------ ------------ ------------ ------------\n" );
+    }
+    if( iPOC == 0 || m_bCamParsVaryOverTime )
+    {
+      Int iS = iPOC;
+      Int iE = ( m_bCamParsVaryOverTime ? iPOC : ~( 1 << 31 ) );
+      for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
+      {
+        for( UInt uiBaseIndex = 0; uiBaseIndex <= m_uiMaxViewIndex; uiBaseIndex++ )
+        {
+          if( uiViewIndex != uiBaseIndex )
+          {
+            fprintf( m_pCodedScaleOffsetFile, "%12d %12d %12d %12d %12d %12d %12d\n",
+              iS, iE, uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_uiCamParsCodedPrecision );
+          }
+        }
+      }
+    }
+  }
+}
+#endif
 TDecTop::TDecTop()
+{
 …
   m_iMaxRefPicNum = 0;
 #if ENC_DEC_TRACE
+#if H_MV
+  if ( g_hTrace == NULL )
+  {
+#endif
   g_hTrace = fopen( "TraceDec.txt", "wb" );
   g_bJustDoIt = g_bEncDecTraceDisable;
   g_nSymbolCounter = 0;
+#if H_MV
+  }
+#endif
 #endif
   m_pocCRA = 0;
 …
   m_viewId = 0;
 #if H_3D
+  m_viewIndex = 0;
   m_isDepth = false;
+  m_pcCamParsCollector = 0;
 #endif
 #endif
 …
+}
 Void TDecTop::init()
+{
 …
   initROM();
 #endif
   m_cGopDecoder.init( &m_cEntropyDecoder, &m_cSbacDecoder, &m_cBinCABAC, &m_cCavlcDecoder, &m_cSliceDecoder, &m_cLoopFilter, &m_cSAO);
   m_cSliceDecoder.init( &m_cEntropyDecoder, &m_cCuDecoder );
 …
+  }
+#if L0323_DPB
+  m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer());     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
+#else
   m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()) + 1; // +1 to have space for the picture currently being decoded
+#endif
   if (m_cListPic.size() < (UInt)m_iMaxRefPicNum)
+  {
 …
   rpcListPic          = &m_cListPic;
   m_cCuDecoder.destroy();
 #if H_MV
   TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer );
   TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, targetDecLayerIdSet, m_parameterSetManagerDecoder.getActiveVPS(), m_layerId, poc );
 #endif
   m_bFirstSliceInPicture  = true;
 …
   assert (sps != 0);
   if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->getIdrPicFlag()))
+  if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
+  {
     printf ("Parameter set activation failed!");
 …
+  }
+  if( pps->getDependentSliceSegmentsEnabledFlag() )
+  {
+    Int NumCtx = pps->getEntropyCodingSyncEnabledFlag()?2:1;
+    if (m_cSliceDecoder.getCtxMemSize() != NumCtx)
+    {
+      m_cSliceDecoder.initCtxMem(NumCtx);
+      for ( UInt st = 0; st < NumCtx; st++ )
+      {
+        TDecSbac* ctx = NULL;
+        ctx = new TDecSbac;
+        ctx->init( &m_cBinCABAC );
+        m_cSliceDecoder.setCtxMem( ctx, st );
+      }
+    }
+  }
   m_apcSlicePilot->setPPS(pps);
   m_apcSlicePilot->setSPS(sps);
 #if H_MV
   m_apcSlicePilot->setVPS( m_parameterSetManagerDecoder.getActiveVPS() );
 #endif
   pps->setSPS(sps);
   pps->setNumSubstreams(pps->getEntropyCodingSyncEnabledFlag() ? ((sps->getPicHeightInLumaSamples() + sps->getMaxCUHeight() - 1) / sps->getMaxCUHeight()) * (pps->getNumColumnsMinus1() + 1) : 1);
   pps->setMinCuDQPSize( sps->getMaxCUWidth() >> ( pps->getMaxCuDQPDepth()) );
+  for (Int i = 0; i < sps->getMaxCUDepth() - g_uiAddCUDepth; i++)
+  g_bitDepthY     = sps->getBitDepthY();
+  g_bitDepthC     = sps->getBitDepthC();
+  g_uiMaxCUWidth  = sps->getMaxCUWidth();
+  g_uiMaxCUHeight = sps->getMaxCUHeight();
+  g_uiMaxCUDepth  = sps->getMaxCUDepth();
+  g_uiAddCUDepth  = max (0, sps->getLog2MinCodingBlockSize() - (Int)sps->getQuadtreeTULog2MinSize() );
+  for (Int i = 0; i < sps->getLog2DiffMaxMinCodingBlockSize(); i++)
+  {
     sps->setAMPAcc( i, sps->getUseAMP() );
+  }
   for (Int i = sps->getMaxCUDepth() - g_uiAddCUDepth; i < sps->getMaxCUDepth(); i++)
+  for (Int i = sps->getLog2DiffMaxMinCodingBlockSize(); i < sps->getMaxCUDepth(); i++)
+  {
     sps->setAMPAcc( i, 0 );
 …
   m_cSAO.destroy();
   m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight );
   m_cLoopFilter.        create( g_uiMaxCUDepth );
+  m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getMaxCUWidth(), sps->getMaxCUHeight() );
+  m_cLoopFilter.create( sps->getMaxCUDepth() );
+}
 …
   m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType);
+  if((m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N) ||
+     (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N) ||
+     (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N))
+  {
+    m_apcSlicePilot->setTemporalLayerNonReferenceFlag(true);
+  }
+  Bool nonReferenceFlag = (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N ||
+                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N   ||
+                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N  ||
+                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N  ||
+                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N);
+  m_apcSlicePilot->setTemporalLayerNonReferenceFlag(nonReferenceFlag);
   m_apcSlicePilot->setReferenced(true); // Putting this as true ensures that picture is referenced the first time it is in an RPS
   m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
 …
   m_apcSlicePilot->setLayerId( nalu.m_layerId );
 #endif
   m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder);
 #if H_MV
   TComVPS* vps     = m_apcSlicePilot->getVPS();
+  Int layerIdInVps = vps->getLayerIdInVps( nalu.m_layerId );
+  setViewId(  vps->getViewId( layerIdInVps  ) );
+  m_apcSlicePilot->setViewId( getViewId() );
+  Int layerIdInVps = vps->getLayerIdInVps( nalu.m_layerId );
+  setViewId   ( vps->getViewId   ( layerIdInVps )      );
 #if H_3D
+  setIsDepth( vps->getDepthId( layerIdInVps ) == 1 );
+  m_apcSlicePilot->setIsDepth( getIsDepth() );
+#endif
+#endif
+  if (m_apcSlicePilot->isNextSlice())
+  {
+  setViewIndex( vps->getViewIndex( layerIdInVps )      );
+  setIsDepth  ( vps->getDepthId  ( layerIdInVps ) == 1 );
+  m_ivPicLists->setVPS( vps );
+#endif
+#endif
     // Skip pictures due to random access
     if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
 …
       return false;
+    }
+  }
+  //we should only get a different poc for a new picture (with CTU address==0)
+  if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence && (!m_apcSlicePilot->getSliceCurStartCUAddr()==0))
+  {
+    printf ("Warning, the first slice of a picture might have been lost!\n");
+  }
   // exit when a new picture is found
   if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence)
+  if (m_apcSlicePilot->isNextSlice() && (m_apcSlicePilot->getSliceCurStartCUAddr() == 0 && !m_bFirstSliceInPicture) && !m_bFirstSliceInSequence )
+  {
     if (m_prevPOC >= m_pocRandomAccess)
 …
     m_prevPOC = m_apcSlicePilot->getPOC();
+  }
 #if H_MV
   if ( newLayerFlag )
 …
+  }
 #endif
   // actual decoding starts here
   xActivateParameterSets();
 …
     xCreateLostPicture(lostPoc-1);
+  }
   if (m_bFirstSliceInPicture)
+  {
 …
     m_cPrediction.initTempBuff();
     m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
 #if H_MV
     m_apcSlicePilot->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer );
 #endif
     //  Get a new picture buffer
     xGetNewPicBuffer (m_apcSlicePilot, pcPic);
 …
   pcPic->setViewId ( getViewId() );
 #if H_3D
   pcPic->setIsDepth( getIsDepth() );
+#endif
 #endif
+  pcPic->setViewIndex( getViewIndex() );
+  pcPic->setIsDepth  ( getIsDepth  () );
+#endif
+#endif
   if (bNextSlice)
+  {
     pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA );
+    pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA, m_cListPic );
     // Set reference list
 #if H_MV
+    pcSlice->setRefPicList( m_cListPic, m_refPicSetInterLayer );
+    pcSlice->setRefPicList( m_cListPic, m_refPicSetInterLayer, true );
+#else
+#if FIX1071
+    pcSlice->setRefPicList( m_cListPic, true );
 #else
     pcSlice->setRefPicList( m_cListPic );
 #endif
+#endif
     // For generalized B
     // note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
 …
     //---------------
     pcSlice->setRefPOCList();
+#if !L0034_COMBINED_LIST_CLEANUP
     pcSlice->setNoBackPredFlag( false );
     if ( pcSlice->getSliceType() == B_SLICE )
 …
+      }
+    }
+#endif
+  }
 …
   //  Decode a picture
   m_cGopDecoder.decompressSlice(nalu.m_Bitstream, pcPic);
+#if H_3D
+  if( m_pcCamParsCollector )
+  {
+    m_pcCamParsCollector->setSlice( pcSlice );
+  }
+#endif
   m_bFirstSliceInPicture = false;
   m_uiSliceIdx++;
 …
+{
   TComSPS* sps = new TComSPS();
+#if H_3D
+  // Preliminary fix. assuming that all sps refer to the same SPS.
+  // Parsing dependency should be resolved!
+  TComVPS* vps = m_parameterSetManagerDecoder.getPrefetchedVPS( 0 );
+  assert( vps != 0 );
+  Int layerIdInVPS = vps->getLayerIdInVps( m_layerId );
+  m_cEntropyDecoder.decodeSPS( sps, vps->getViewIndex( layerIdInVPS ), ( vps->getDepthId( layerIdInVPS ) == 1 ) );
+#else
   m_cEntropyDecoder.decodeSPS( sps );
+#endif
   m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
+}
 …
   m_cEntropyDecoder.decodePPS( pps );
   m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
-  if( pps->getDependentSliceSegmentsEnabledFlag() )
+  {
-    Int NumCtx = pps->getEntropyCodingSyncEnabledFlag()?2:1;
-    m_cSliceDecoder.initCtxMem(NumCtx);
-    for ( UInt st = 0; st < NumCtx; st++ )
+    {
-      TDecSbac* ctx = NULL;
-      ctx = new TDecSbac;
-      ctx->init( &m_cBinCABAC );
-      m_cSliceDecoder.setCtxMem( ctx, st );
+    }
+  }
+}
 Void TDecTop::xDecodeSEI( TComInputBitstream* bs, const NalUnitType nalUnitType )
+{
   if(nalUnitType == NAL_UNIT_SEI_SUFFIX)
+  if(nalUnitType == NAL_UNIT_SUFFIX_SEI)
+  {
     m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
 …
       return false;
     case NAL_UNIT_SEI:
     case NAL_UNIT_SEI_SUFFIX:
+    case NAL_UNIT_PREFIX_SEI:
+    case NAL_UNIT_SUFFIX_SEI:
       xDecodeSEI( nalu.m_Bitstream, nalu.m_nalUnitType );
       return false;
 …
     case NAL_UNIT_CODED_SLICE_TRAIL_R:
     case NAL_UNIT_CODED_SLICE_TRAIL_N:
     case NAL_UNIT_CODED_SLICE_TLA:
+    case NAL_UNIT_CODED_SLICE_TLA_R:
     case NAL_UNIT_CODED_SLICE_TSA_N:
     case NAL_UNIT_CODED_SLICE_STSA_R:
     case NAL_UNIT_CODED_SLICE_STSA_N:
     case NAL_UNIT_CODED_SLICE_BLA:
     case NAL_UNIT_CODED_SLICE_BLANT:
+    case NAL_UNIT_CODED_SLICE_BLA_W_LP:
+    case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
     case NAL_UNIT_CODED_SLICE_BLA_N_LP:
     case NAL_UNIT_CODED_SLICE_IDR:
+    case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
     case NAL_UNIT_CODED_SLICE_IDR_N_LP:
     case NAL_UNIT_CODED_SLICE_CRA:
     case NAL_UNIT_CODED_SLICE_RADL_N:
     case NAL_UNIT_CODED_SLICE_DLP:
+    case NAL_UNIT_CODED_SLICE_RADL_R:
     case NAL_UNIT_CODED_SLICE_RASL_N:
     case NAL_UNIT_CODED_SLICE_TFD:
+    case NAL_UNIT_CODED_SLICE_RASL_R:
 #if H_MV
       return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay, newLayerFlag);
 …
 Bool TDecTop::isSkipPictureForBLA(Int& iPOCLastDisplay)
+{
   if (m_prevRAPisBLA && m_apcSlicePilot->getPOC() < m_pocCRA && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TFD || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
+  if (m_prevRAPisBLA && m_apcSlicePilot->getPOC() < m_pocCRA && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
+  {
     iPOCLastDisplay++;
 …
+  {
     if (   m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA
         || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA
+        || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
         || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
         || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT )
+        || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL )
+    {
       // set the POC random access since we need to skip the reordered pictures in the case of CRA/CRANT/BLA/BLANT.
       m_pocRandomAccess = m_apcSlicePilot->getPOC();
+    }
     else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    {
       m_pocRandomAccess = -MAX_INT; // no need to skip the reordered pictures in IDR, they are decodable.
 …
+  }
   // skip the reordered pictures, if necessary
   else if (m_apcSlicePilot->getPOC() < m_pocRandomAccess && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TFD || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
+  else if (m_apcSlicePilot->getPOC() < m_pocRandomAccess && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
+  {
     iPOCLastDisplay++;
 …
 #endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibDecoder/TDecTop.h

-                      r438
+                      r446
 class TAppDecTop;
 #endif
+#if H_3D
+class CamParsCollector
+{
+public:
+  CamParsCollector  ();
+  ~CamParsCollector ();
+  Void  init        ( FILE* pCodedScaleOffsetFile );
+  Void  uninit      ();
+  Void  setSlice    ( TComSlice* pcSlice );
+  Bool  isInitialized() const     { return m_bInitialized; }
+  Int**** getBaseViewShiftLUTI()  { return m_aiBaseViewShiftLUT;   }
+private:
+  Bool  xIsComplete ();
+  Void  xOutput     ( Int iPOC );
+private:
+  Bool    m_bInitialized;
+  FILE*   m_pCodedScaleOffsetFile;
+  Int**   m_aaiCodedOffset;
+  Int**   m_aaiCodedScale;
+  Int*    m_aiViewId;
+  Int*    m_aiLayerIdx;
+  Bool*   m_bViewReceived;
+  UInt    m_uiCamParsCodedPrecision;
+  Bool    m_bCamParsVaryOverTime;
+  Int     m_iLastViewIndex;
+  Int     m_iLastPOC;
+  UInt    m_uiMaxViewIndex;
+  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 );
+};
+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 //H_3D
 /// decoder class
 class TDecTop
 …
   ParameterSetManagerDecoder m_parameterSetManagerDecoder;  // storage for parameter sets
 #endif
   TComSlice*              m_apcSlicePilot;
 …
   std::vector<TComPic*>   m_refPicSetInterLayer;
 #if H_3D
+  Int                     m_viewIndex;
   Bool                    m_isDepth;
+  CamParsCollector*       m_pcCamParsCollector;
 #endif
 #endif
 …
 #endif
 #if H_MV
   TComPic*                getPic                ( Int poc );
 …
   Int                     getViewId             ()               { return m_viewId;     }
 #if H_3D
+  Void                    setViewIndex          ( Int viewIndex  )  { m_viewIndex  = viewIndex;  }
+  Int                     getViewIndex          ()               { return m_viewIndex;     }
   Void                    setIsDepth            ( Bool isDepth ) { m_isDepth = isDepth; }
   Bool                    getIsDepth            ()               { return m_isDepth;    }
+#endif
 #endif
+  Void                    setCamParsCollector( CamParsCollector* pcCamParsCollector ) { m_pcCamParsCollector = pcCamParsCollector; }
+#endif
+#endif
 protected:
   Void  xGetNewPicBuffer  (TComSlice* pcSlice, TComPic*& rpcPic);

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/SEIwrite.cpp

-                      r438
+                      r446
     fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
     break;
+#if J0149_TONE_MAPPING_SEI
+  case SEI::TONE_MAPPING_INFO:
+    fprintf( g_hTrace, "=========== Tone Mapping Info SEI message ===========\n");
+    break;
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+  case SEI::SOP_DESCRIPTION:
+    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
+    break;
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  case SEI::SCALABLE_NESTING:
+    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
+    break;
+#endif
   default:
     fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
 …
 #endif
+#if K0180_SCALABLE_NESTING_SEI
+void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
+#else
 void SEIWriter::xWriteSEIpayloadData(const SEI& sei, TComSPS *sps)
+#endif
+{
   switch (sei.payloadType())
 …
     xWriteSEIGradualDecodingRefreshInfo(*static_cast<const SEIGradualDecodingRefreshInfo*>(&sei));
     break;
+#if J0149_TONE_MAPPING_SEI
+  case SEI::TONE_MAPPING_INFO:
+    xWriteSEIToneMappingInfo(*static_cast<const SEIToneMappingInfo*>(&sei));
+    break;
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+  case SEI::SOP_DESCRIPTION:
+    xWriteSEISOPDescription(*static_cast<const SEISOPDescription*>(&sei));
+    break;
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  case SEI::SCALABLE_NESTING:
+    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
+    break;
+#endif
   default:
     assert(!"Unhandled SEI message");
 …
   setBitstream(&bs_count);
+#if K0180_SCALABLE_NESTING_SEI
+#if ENC_DEC_TRACE
+  Bool traceEnable = g_HLSTraceEnable;
+  g_HLSTraceEnable = false;
+#endif
+  xWriteSEIpayloadData(bs_count, sei, sps);
+#if ENC_DEC_TRACE
+  g_HLSTraceEnable = traceEnable;
+#endif
+#else
 #if ENC_DEC_TRACE
   g_HLSTraceEnable = false;
 …
   g_HLSTraceEnable = true;
 #endif
+#endif
   UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
   assert(0 == payload_data_num_bits % 8);
 …
 #if ENC_DEC_TRACE
+#if K0180_SCALABLE_NESTING_SEI
+  if (g_HLSTraceEnable)
+#endif
   xTraceSEIHeader();
 #endif
 …
   /* payloadData */
 #if ENC_DEC_TRACE
+#if K0180_SCALABLE_NESTING_SEI
+  if (g_HLSTraceEnable)
+#endif
   xTraceSEIMessageType(sei.payloadType());
 #endif
+#if K0180_SCALABLE_NESTING_SEI
+  xWriteSEIpayloadData(bs, sei, sps);
+#else
   xWriteSEIpayloadData(sei, sps);
+#endif
+}
 …
   xWriteByteAlign();
+}
+#if J0149_TONE_MAPPING_SEI
+Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei)
+{
+  Int i;
+  WRITE_UVLC( sei.m_toneMapId,                    "tone_map_id" );
+  WRITE_FLAG( sei.m_toneMapCancelFlag,            "tone_map_cancel_flag" );
+  if( !sei.m_toneMapCancelFlag )
+  {
+    WRITE_FLAG( sei.m_toneMapPersistenceFlag,     "tone_map_persistence_flag" );
+    WRITE_CODE( sei.m_codedDataBitDepth,    8,    "coded_data_bit_depth" );
+    WRITE_CODE( sei.m_targetBitDepth,       8,    "target_bit_depth" );
+    WRITE_UVLC( sei.m_modelId,                    "model_id" );
+    switch(sei.m_modelId)
+    {
+    case 0:
+      {
+        WRITE_CODE( sei.m_minValue,  32,        "min_value" );
+        WRITE_CODE( sei.m_maxValue, 32,         "max_value" );
+        break;
+      }
+    case 1:
+      {
+        WRITE_CODE( sei.m_sigmoidMidpoint, 32,  "sigmoid_midpoint" );
+        WRITE_CODE( sei.m_sigmoidWidth,    32,  "sigmoid_width"    );
+        break;
+      }
+    case 2:
+      {
+        UInt num = 1u << sei.m_targetBitDepth;
+        for(i = 0; i < num; i++)
+        {
+          WRITE_CODE( sei.m_startOfCodedInterval[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,  "start_of_coded_interval" );
+        }
+        break;
+      }
+    case 3:
+      {
+        WRITE_CODE( sei.m_numPivots, 16,          "num_pivots" );
+        for(i = 0; i < sei.m_numPivots; i++ )
+        {
+          WRITE_CODE( sei.m_codedPivotValue[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,       "coded_pivot_value" );
+          WRITE_CODE( sei.m_targetPivotValue[i], (( sei.m_targetBitDepth + 7 ) >> 3 ) << 3,         "target_pivot_value");
+        }
+        break;
+      }
+    case 4:
+      {
+        WRITE_CODE( sei.m_cameraIsoSpeedIdc,    8,    "camera_iso_speed_idc" );
+        if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO
+        {
+          WRITE_CODE( sei.m_cameraIsoSpeedValue,    32,    "camera_iso_speed_value" );
+        }
+        WRITE_FLAG( sei.m_exposureCompensationValueSignFlag,           "exposure_compensation_value_sign_flag" );
+        WRITE_CODE( sei.m_exposureCompensationValueNumerator,     16,  "exposure_compensation_value_numerator" );
+        WRITE_CODE( sei.m_exposureCompensationValueDenomIdc,      16,  "exposure_compensation_value_denom_idc" );
+        WRITE_CODE( sei.m_refScreenLuminanceWhite,                32,  "ref_screen_luminance_white" );
+        WRITE_CODE( sei.m_extendedRangeWhiteLevel,                32,  "extended_range_white_level" );
+        WRITE_CODE( sei.m_nominalBlackLevelLumaCodeValue,         16,  "nominal_black_level_luma_code_value" );
+        WRITE_CODE( sei.m_nominalWhiteLevelLumaCodeValue,         16,  "nominal_white_level_luma_code_value" );
+        WRITE_CODE( sei.m_extendedWhiteLevelLumaCodeValue,        16,  "extended_white_level_luma_code_value" );
+        break;
+      }
+    default:
+      {
+        assert(!"Undefined SEIToneMapModelId");
+        break;
+      }
+    }//switch m_modelId
+  }//if(!sei.m_toneMapCancelFlag)
+  xWriteByteAlign();
+}
+#endif
 Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei)
+{
 …
+}
+#if L0208_SOP_DESCRIPTION_SEI
+Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei)
+{
+  WRITE_UVLC( sei.m_sopSeqParameterSetId,           "sop_seq_parameter_set_id"               );
+  WRITE_UVLC( sei.m_numPicsInSopMinus1,             "num_pics_in_sop_minus1"               );
+  for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
+  {
+    WRITE_CODE( sei.m_sopDescVclNaluType[i], 6, "sop_desc_vcl_nalu_type" );
+    WRITE_CODE( sei.m_sopDescTemporalId[i],  3, "sop_desc_temporal_id" );
+    if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
+    {
+      WRITE_UVLC( sei.m_sopDescStRpsIdx[i],           "sop_desc_st_rps_idx"               );
+    }
+    if (i > 0)
+    {
+      WRITE_SVLC( sei.m_sopDescPocDelta[i],           "sop_desc_poc_delta"               );
+    }
+  }
+  xWriteByteAlign();
+}
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps)
+{
+  WRITE_FLAG( sei.m_bitStreamSubsetFlag,             "bitstream_subset_flag"         );
+  WRITE_FLAG( sei.m_nestingOpFlag,                   "nesting_op_flag      "         );
+  if (sei.m_nestingOpFlag)
+  {
+    WRITE_FLAG( sei.m_defaultOpFlag,                 "default_op_flag"               );
+    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops"               );
+    for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++)
+    {
+      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
+      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id"       );
+      WRITE_UVLC( sei.m_nestingOpIdx[i],                  "nesting_op_idx"                );
+    }
+  }
+  else
+  {
+    WRITE_FLAG( sei.m_allLayersFlag,                      "all_layers_flag"               );
+    if (!sei.m_allLayersFlag)
+    {
+      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
+      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"            );
+      for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
+      {
+        WRITE_CODE( sei.m_nestingLayerId[i], 6,           "nesting_layer_id"              );
+      }
+    }
+  }
+  // byte alignment
+  while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
+  {
+    WRITE_FLAG( 0, "nesting_zero_bit" );
+  }
+  // write nested SEI messages
+  for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
+  {
+    writeSEImessage(bs, *(*it), sps);
+  }
+}
+#endif
 Void SEIWriter::xWriteByteAlign()
+{

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/SEIwrite.h

-                      r438
+                      r446
 protected:
+#if K0180_SCALABLE_NESTING_SEI
+  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps);
+#else
   Void xWriteSEIpayloadData(const SEI& sei, TComSPS *sps);
+#endif
   Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
   Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
 …
   Void xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei);
   Void xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei);
+#if J0149_TONE_MAPPING_SEI
+  Void xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei);
+#endif
+#if L0208_SOP_DESCRIPTION_SEI
+  Void xWriteSEISOPDescription(const SEISOPDescription& sei);
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps);
+#endif
   Void xWriteByteAlign();
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncBinCoderCABAC.cpp

r438	r446
185	185	{
186	186	{
	187	#if !H_MV
187	188	DTRACE_CABAC_VL( g_nSymbolCounter++ )
188	189	DTRACE_CABAC_T( "\tstate=" )
…	…
191	192	DTRACE_CABAC_V( binValue )
192	193	DTRACE_CABAC_T( "\n" )
	194	#endif
193	195	}
194	196	m_uiBinsCoded += m_binCountIncrement;
…	…
231	233	{
232	234	{
	235	#if !H_MV
233	236	DTRACE_CABAC_VL( g_nSymbolCounter++ )
234	237	DTRACE_CABAC_T( "\tEPsymbol=" )
235	238	DTRACE_CABAC_V( binValue )
236	239	DTRACE_CABAC_T( "\n" )
	240	#endif
237	241	}
238	242	m_uiBinsCoded += m_binCountIncrement;
…	…
259	263	for ( Int i = 0; i < numBins; i++ )
260	264	{
	265	#if !H_MV
261	266	DTRACE_CABAC_VL( g_nSymbolCounter++ )
262	267	DTRACE_CABAC_T( "\tEPsymbol=" )
263	268	DTRACE_CABAC_V( ( binValues >> ( numBins - 1 - i ) ) & 1 )
264	269	DTRACE_CABAC_T( "\n" )
	270	#endif
265	271	}
266	272

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

-                      r438
+                      r446
   WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(),           "neutral_chroma_indication_flag");
   WRITE_FLAG(pcVUI->getFieldSeqFlag(),                          "field_seq_flag");
-  assert(pcVUI->getFieldSeqFlag() == 0);                        // not currently supported
   WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(),             "frame_field_info_present_flag");
 …
+}
+#if H_3D
+Void TEncCavlc::codeSPS( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
+#else
 Void TEncCavlc::codeSPS( TComSPS* pcSPS )
+#endif
+{
 #if ENC_DEC_TRACE
 …
   for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
+  {
+#if L0323_DPB
+    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1,       "sps_max_dec_pic_buffering_minus1[i]" );
+#else
     WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i),           "sps_max_dec_pic_buffering[i]" );
+#endif
     WRITE_UVLC( pcSPS->getNumReorderPics(i),               "sps_num_reorder_pics[i]" );
     WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase[i]" );
 …
   assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
+  UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth );
+  UInt log2MinCUSize = 0;
+  while(MinCUSize > 1)
+  {
+    MinCUSize >>= 1;
+    log2MinCUSize++;
+  }
+  WRITE_UVLC( log2MinCUSize - 3,                                                     "log2_min_coding_block_size_minus3" );
+  WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth,                                 "log2_diff_max_min_coding_block_size" );
+  WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3,                                "log2_min_coding_block_size_minus3" );
+  WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(),                             "log2_diff_max_min_coding_block_size" );
   WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2,                                 "log2_min_transform_block_size_minus2" );
   WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
 …
+  }
+#if H_MV
+  WRITE_FLAG( 1, "sps_extension_flag" );
+  WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
+#if !H_3D
+  WRITE_FLAG( 0, "sps_extension2_flag" );
+#else
+  WRITE_FLAG( 1, "sps_extension2_flag"  );
+  if (!depthFlag )
+  {
+    WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
+    WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
+    if( !pcSPS->hasCamParInSliceHeader() )
+    {
+      for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
+      {
+        WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
+        WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
+        WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
+        WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
+      }
+    }
+  }
+  WRITE_FLAG( 0, "sps_extension3_flag" );
+#endif
+#else
   WRITE_FLAG( 0, "sps_extension_flag" );
+#endif
+}
 …
   WRITE_FLAG( pcVPS->getTemporalNestingFlag(),                "vps_temporal_id_nesting_flag" );
   assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
+#if H_MV
   WRITE_CODE( 0xffff,                              16,        "vps_extension_offset" );
+#else
+  WRITE_CODE( 0xffff,                              16,        "vps_reserved_ffff_16bits" );
+#endif
   codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
 #if SIGNAL_BITRATE_PICRATE_IN_VPS
 …
   for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
+  {
+#if L0323_DPB
+    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1,       "vps_max_dec_pic_buffering_minus1[i]" );
+#else
     WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i),           "vps_max_dec_pic_buffering[i]" );
+#endif
     WRITE_UVLC( pcVPS->getNumReorderPics(i),               "vps_num_reorder_pics[i]" );
     WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase[i]" );
 …
+  }
 #endif
 #if H_MV
   WRITE_FLAG( 1,                                             "vps_extension_flag" );
 …
   WRITE_FLAG( pcVPS->getVpsNuhLayerIdPresentFlag() ? 1 : 0,  "vps_nuh_layer_id_present_flag");
+  for( Int layer = 1; layer <= pcVPS->getMaxLayers() - 1; layer++ )
+  {
+    if (pcVPS->getVpsNuhLayerIdPresentFlag() )
+  // already updated to JCT3V-D0220
+  for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
+  {
+    if ( ( layer != 0 ) && pcVPS->getVpsNuhLayerIdPresentFlag() )
       WRITE_CODE( pcVPS->getLayerIdInNuh( layer ), 6,          "layer_id_in_nuh[i]");
     for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes() ; sIdx++ )
 …
     //   colour_plane_id                                      u(2)
+#if H_MV
+    // Temporary fix for FIX1071 should be removed later
+    TComReferencePictureSet* rps = pcSlice->getRPS();
+#endif
     if( !pcSlice->getIdrPicFlag() )
+    {
       Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC());
       WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
+#if !H_MV
+      // Temporary fix for FIX1071 should be removed later
       TComReferencePictureSet* rps = pcSlice->getRPS();
+#endif
+#if FIX1071
+      // Deal with bitstream restriction stating that:
+      // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+      // Ideally this process should not be repeated for each slice in a picture
+      TComReferencePictureSet altRps;
+      Bool useAltRps = false;
+      if (pcSlice->getRapPicFlag())
+      {
+        for (Int picIdx = 0; !useAltRps && picIdx < rps->getNumberOfPictures(); picIdx++)
+        {
+          useAltRps = rps->getUsed(picIdx);
+        }
+        if (useAltRps)
+        {
+          memcpy(&altRps, rps, sizeof(TComReferencePictureSet));
+          rps = &altRps;
+          for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
+          {
+            rps->setUsed(picIdx, false);
+          }
+        }
+      }
+      if(pcSlice->getRPSidx() < 0 || useAltRps)
+#else
       if(pcSlice->getRPSidx() < 0)
+#endif
+      {
         WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
 …
       pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
+    }
+#if H_MV
+    // Temporary fix for FIX1071 should be removed later
+    if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList( rps ) > 1)
+#else
     if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
+#endif
+    {
       TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
 …
   if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
+  {
+#if !H_3D
     WRITE_UVLC(0,"slice_header_extension_length");
+#else
+    WRITE_UVLC(0,"slice_header_extension_length"); //<- this element needs to be set to the correct value!!
+    if( pcSlice->getSPS()->hasCamParInSliceHeader() )
+    {
+      for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
+      {
+        WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ],                                     "cp_scale" );
+        WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ],                                     "cp_off" );
+        WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "cp_inv_scale_plus_scale" );
+        WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "cp_inv_off_plus_off" );
+      }
+    }
+    Bool sliceSegmentHeaderExtension2Flag = false;
+    WRITE_FLAG( sliceSegmentHeaderExtension2Flag ? 1 : 0 , "slice_segment_header_extension2_flag" );
+    if ( sliceSegmentHeaderExtension2Flag )
+    {
+      WRITE_UVLC(0,"slice_header_extension2_length");
+    }
+#endif
+  }
+}
 …
 // ====================================================================================================================
-/** Write PCM alignment bits.
- * \returns Void
- */
-Void  TEncCavlc::xWritePCMAlignZero    ()
+{
-  m_pcBitIf->writeAlignZero();
+}
-Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol )
+{
-  if (uiMaxSymbol == 0)
+  {
-    return;
+  }
-  xWriteFlag( uiSymbol ? 1 : 0 );
-  if ( uiSymbol == 0 )
+  {
-    return;
+  }
-  Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
-  while( --uiSymbol )
+  {
-    xWriteFlag( 1 );
+  }
-  if( bCodeLast )
+  {
-    xWriteFlag( 0 );
+  }
-  return;
+}
-Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol )
+{
-  if( uiSymbol )
+  {
-    xWriteFlag( 1 );
-    UInt uiCount = 0;
-    Bool bNoExGo = (uiSymbol < 13);
-    while( --uiSymbol && ++uiCount < 13 )
+    {
-      xWriteFlag( 1 );
+    }
-    if( bNoExGo )
+    {
-      xWriteFlag( 0 );
+    }
-    else
+    {
-      xWriteEpExGolomb( uiSymbol, 0 );
+    }
+  }
-  else
+  {
-    xWriteFlag( 0 );
+  }
-  return;
+}
-Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
+{
-  while( uiSymbol >= (UInt)(1<<uiCount) )
+  {
-    xWriteFlag( 1 );
-    uiSymbol -= 1<<uiCount;
-    uiCount  ++;
+  }
-  xWriteFlag( 0 );
-  while( uiCount-- )
+  {
-    xWriteFlag( (uiSymbol>>uiCount) & 1 );
+  }
-  return;
+}
 /** code explicit wp tables
  * \param TComSlice* pcSlice

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncCavlc.h

-                      r438
+                      r446
   UInt          m_uiCoeffCost;
-  Void  xWritePCMAlignZero    ();
-  Void  xWriteEpExGolomb      ( UInt uiSymbol, UInt uiCount );
-  Void  xWriteExGolombLevel    ( UInt uiSymbol );
-  Void  xWriteUnaryMaxSymbol  ( UInt uiSymbol, UInt uiMaxSymbol );
   Void codeShortTermRefPicSet              ( TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx );
   Bool findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag );
 …
   Void  codeVPS                 ( TComVPS* pcVPS );
   Void  codeVUI                 ( TComVUI *pcVUI, TComSPS* pcSPS );
+#if H_3D
+  Void  codeSPS                 ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
+#else
   Void  codeSPS                 ( TComSPS* pcSPS );
+#endif
   Void  codePPS                 ( TComPPS* pcPPS );
   Void  codeSliceHeader         ( TComSlice* pcSlice );

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncCfg.h

-                      r438
+                      r446
 #include "TLibCommon/TComSlice.h"
 #include <assert.h>
+#if H_3D
+#include "TAppCommon/TAppComCamPara.h"
+#include "TLibRenderer/TRenModSetupStrParser.h"
+#endif
 struct GOPEntry
 …
   Int m_interViewRefPosL[2][MAX_NUM_REF_PICS];
 #endif
   GOPEntry()
   : m_POC(-1)
 …
   Int       m_loopFilterTcOffsetDiv2;
   Bool      m_DeblockingFilterControlPresent;
+#if L0386_DB_METRIC
+  Bool      m_DeblockingFilterMetric;
+#endif
   Bool      m_bUseSAO;
   Int       m_maxNumOffsetsPerPic;
 …
   Bool      m_bUseASR;
   Bool      m_bUseHADME;
+#if !L0034_COMBINED_LIST_CLEANUP
   Bool      m_bUseLComb;
+#endif
   Bool      m_useRDOQ;
   Bool      m_useRDOQTS;
 …
   Int       m_pictureTimingSEIEnabled;
   Int       m_recoveryPointSEIEnabled;
+#if J0149_TONE_MAPPING_SEI
+  Bool      m_toneMappingInfoSEIEnabled;
+  Int       m_toneMapId;
+  Bool      m_toneMapCancelFlag;
+  Bool      m_toneMapPersistenceFlag;
+  Int       m_codedDataBitDepth;
+  Int       m_targetBitDepth;
+  Int       m_modelId;
+  Int       m_minValue;
+  Int       m_maxValue;
+  Int       m_sigmoidMidpoint;
+  Int       m_sigmoidWidth;
+  Int       m_numPivots;
+  Int       m_cameraIsoSpeedIdc;
+  Int       m_cameraIsoSpeedValue;
+  Int       m_exposureCompensationValueSignFlag;
+  Int       m_exposureCompensationValueNumerator;
+  Int       m_exposureCompensationValueDenomIdc;
+  Int       m_refScreenLuminanceWhite;
+  Int       m_extendedRangeWhiteLevel;
+  Int       m_nominalBlackLevelLumaCodeValue;
+  Int       m_nominalWhiteLevelLumaCodeValue;
+  Int       m_extendedWhiteLevelLumaCodeValue;
+  Int*      m_startOfCodedInterval;
+  Int*      m_codedPivotValue;
+  Int*      m_targetPivotValue;
+#endif
   Int       m_framePackingSEIEnabled;
   Int       m_framePackingSEIType;
 …
   Int       m_gradualDecodingRefreshInfoEnabled;
   Int       m_decodingUnitInfoSEIEnabled;
+#if L0208_SOP_DESCRIPTION_SEI
+  Int       m_SOPDescriptionSEIEnabled;
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  Int       m_scalableNestingSEIEnabled;
+#endif
   //====== Weighted Prediction ========
   Bool      m_useWeightedPred;       //< Use of Weighting Prediction (P_SLICE)
 …
   Int       m_layerIdInVps;
   Int       m_viewId;
+#endif
 #if H_3D
+  Int       m_viewIndex;
   Bool      m_isDepth;
+#endif
+  //====== Camera Parameters ======
+  UInt      m_uiCamParPrecision;
+  Bool      m_bCamParInSliceHeader;
+  Int**     m_aaiCodedScale;
+  Int**     m_aaiCodedOffset;
+  TAppComCamPara* m_cameraParameters;
+#if H_3D_VSO
+  //====== View Synthesis Optimization ======
+  TRenModSetupStrParser* m_renderModelParameters;
+  Bool      m_bUseVSO;
+  Bool      m_bForceLambdaScale;
+  Bool      m_bAllowNegDist;
+  Double    m_dLambdaScaleVSO;
+  UInt      m_uiVSOMode;
+  // LGE_WVSO_A0119
+  Bool      m_bUseWVSO;
+  Int       m_iVSOWeight;
+  Int       m_iVSDWeight;
+  Int       m_iDWeight;
+#endif
+  // SAIT_VSO_EST_A0033
+  Bool      m_bUseEstimatedVSD;
+  Double    m_dDispCoeff;
 #endif
 …
   , m_viewId(-1)
 #if H_3D
+  , m_viewIndex(-1)
   , m_isDepth(false)
 #endif
 …
   Int       getViewId                        ()                   { return m_viewId;    }
 #if H_3D
+  Void      setViewIndex                     ( Int viewIndex  )   { m_viewIndex  = viewIndex;  }
+  Int       getViewIndex                     ()                   { return m_viewIndex;    }
   Void      setIsDepth                       ( Bool isDepth )   { m_isDepth = isDepth; }
   Bool      getIsDepth                       ()                 { return m_isDepth; }
 #endif
 #endif
   //====== Coding Structure ========
   Void      setIntraPeriod                  ( Int   i )      { m_uiIntraPeriod = (UInt)i; }
 …
   Void      setLoopFilterTcOffset           ( Int   i )      { m_loopFilterTcOffsetDiv2    = i; }
   Void      setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; }
+#if L0386_DB_METRIC
+  Void      setDeblockingFilterMetric       ( Bool  b )      { m_DeblockingFilterMetric = b; }
+#endif
   //====== Motion search ========
 …
   Int       getLoopFilterTcOffset           ()      { return m_loopFilterTcOffsetDiv2; }
   Bool      getDeblockingFilterControlPresent()  { return  m_DeblockingFilterControlPresent; }
+#if L0386_DB_METRIC
+  Bool      getDeblockingFilterMetric       ()      { return m_DeblockingFilterMetric; }
+#endif
   //==== Motion search ========
 …
   Void      setUseASR                       ( Bool  b )     { m_bUseASR     = b; }
   Void      setUseHADME                     ( Bool  b )     { m_bUseHADME   = b; }
+#if !L0034_COMBINED_LIST_CLEANUP
   Void      setUseLComb                     ( Bool  b )     { m_bUseLComb   = b; }
+#endif
   Void      setUseRDOQ                      ( Bool  b )     { m_useRDOQ    = b; }
   Void      setUseRDOQTS                    ( Bool  b )     { m_useRDOQTS  = b; }
 …
   Bool      getUseASR                       ()      { return m_bUseASR;     }
   Bool      getUseHADME                     ()      { return m_bUseHADME;   }
+#if !L0034_COMBINED_LIST_CLEANUP
   Bool      getUseLComb                     ()      { return m_bUseLComb;   }
+#endif
   Bool      getUseRDOQ                      ()      { return m_useRDOQ;    }
   Bool      getUseRDOQTS                    ()      { return m_useRDOQTS;  }
 …
   Void  setRecoveryPointSEIEnabled(Int b)                { m_recoveryPointSEIEnabled = b; }
   Int   getRecoveryPointSEIEnabled()                     { return m_recoveryPointSEIEnabled; }
+#if J0149_TONE_MAPPING_SEI
+  Void  setToneMappingInfoSEIEnabled(Bool b)                 {  m_toneMappingInfoSEIEnabled = b;  }
+  Bool  getToneMappingInfoSEIEnabled()                       {  return m_toneMappingInfoSEIEnabled;  }
+  Void  setTMISEIToneMapId(Int b)                            {  m_toneMapId = b;  }
+  Int   getTMISEIToneMapId()                                 {  return m_toneMapId;  }
+  Void  setTMISEIToneMapCancelFlag(Bool b)                   {  m_toneMapCancelFlag=b;  }
+  Bool  getTMISEIToneMapCancelFlag()                         {  return m_toneMapCancelFlag;  }
+  Void  setTMISEIToneMapPersistenceFlag(Bool b)              {  m_toneMapPersistenceFlag = b;  }
+  Bool   getTMISEIToneMapPersistenceFlag()                   {  return m_toneMapPersistenceFlag;  }
+  Void  setTMISEICodedDataBitDepth(Int b)                    {  m_codedDataBitDepth = b;  }
+  Int   getTMISEICodedDataBitDepth()                         {  return m_codedDataBitDepth;  }
+  Void  setTMISEITargetBitDepth(Int b)                       {  m_targetBitDepth = b;  }
+  Int   getTMISEITargetBitDepth()                            {  return m_targetBitDepth;  }
+  Void  setTMISEIModelID(Int b)                              {  m_modelId = b;  }
+  Int   getTMISEIModelID()                                   {  return m_modelId;  }
+  Void  setTMISEIMinValue(Int b)                             {  m_minValue = b;  }
+  Int   getTMISEIMinValue()                                  {  return m_minValue;  }
+  Void  setTMISEIMaxValue(Int b)                             {  m_maxValue = b;  }
+  Int   getTMISEIMaxValue()                                  {  return m_maxValue;  }
+  Void  setTMISEISigmoidMidpoint(Int b)                      {  m_sigmoidMidpoint = b;  }
+  Int   getTMISEISigmoidMidpoint()                           {  return m_sigmoidMidpoint;  }
+  Void  setTMISEISigmoidWidth(Int b)                         {  m_sigmoidWidth = b;  }
+  Int   getTMISEISigmoidWidth()                              {  return m_sigmoidWidth;  }
+  Void  setTMISEIStartOfCodedInterva( Int*  p )              {  m_startOfCodedInterval = p;  }
+  Int*  getTMISEIStartOfCodedInterva()                       {  return m_startOfCodedInterval;  }
+  Void  setTMISEINumPivots(Int b)                            {  m_numPivots = b;  }
+  Int   getTMISEINumPivots()                                 {  return m_numPivots;  }
+  Void  setTMISEICodedPivotValue( Int*  p )                  {  m_codedPivotValue = p;  }
+  Int*  getTMISEICodedPivotValue()                           {  return m_codedPivotValue;  }
+  Void  setTMISEITargetPivotValue( Int*  p )                 {  m_targetPivotValue = p;  }
+  Int*  getTMISEITargetPivotValue()                          {  return m_targetPivotValue;  }
+  Void  setTMISEICameraIsoSpeedIdc(Int b)                    {  m_cameraIsoSpeedIdc = b;  }
+  Int   getTMISEICameraIsoSpeedIdc()                         {  return m_cameraIsoSpeedIdc;  }
+  Void  setTMISEICameraIsoSpeedValue(Int b)                  {  m_cameraIsoSpeedValue = b;  }
+  Int   getTMISEICameraIsoSpeedValue()                       {  return m_cameraIsoSpeedValue;  }
+  Void  setTMISEIExposureCompensationValueSignFlag(Int b)    {  m_exposureCompensationValueSignFlag = b;  }
+  Int   getTMISEIExposureCompensationValueSignFlag()         {  return m_exposureCompensationValueSignFlag;  }
+  Void  setTMISEIExposureCompensationValueNumerator(Int b)   {  m_exposureCompensationValueNumerator = b;  }
+  Int   getTMISEIExposureCompensationValueNumerator()        {  return m_exposureCompensationValueNumerator;  }
+  Void  setTMISEIExposureCompensationValueDenomIdc(Int b)    {  m_exposureCompensationValueDenomIdc =b;  }
+  Int   getTMISEIExposureCompensationValueDenomIdc()         {  return m_exposureCompensationValueDenomIdc;  }
+  Void  setTMISEIRefScreenLuminanceWhite(Int b)              {  m_refScreenLuminanceWhite = b;  }
+  Int   getTMISEIRefScreenLuminanceWhite()                   {  return m_refScreenLuminanceWhite;  }
+  Void  setTMISEIExtendedRangeWhiteLevel(Int b)              {  m_extendedRangeWhiteLevel = b;  }
+  Int   getTMISEIExtendedRangeWhiteLevel()                   {  return m_extendedRangeWhiteLevel;  }
+  Void  setTMISEINominalBlackLevelLumaCodeValue(Int b)       {  m_nominalBlackLevelLumaCodeValue = b;  }
+  Int   getTMISEINominalBlackLevelLumaCodeValue()            {  return m_nominalBlackLevelLumaCodeValue;  }
+  Void  setTMISEINominalWhiteLevelLumaCodeValue(Int b)       {  m_nominalWhiteLevelLumaCodeValue = b;  }
+  Int   getTMISEINominalWhiteLevelLumaCodeValue()            {  return m_nominalWhiteLevelLumaCodeValue;  }
+  Void  setTMISEIExtendedWhiteLevelLumaCodeValue(Int b)      {  m_extendedWhiteLevelLumaCodeValue =b;  }
+  Int   getTMISEIExtendedWhiteLevelLumaCodeValue()           {  return m_extendedWhiteLevelLumaCodeValue;  }
+#endif
   Void  setFramePackingArrangementSEIEnabled(Int b)      { m_framePackingSEIEnabled = b; }
   Int   getFramePackingArrangementSEIEnabled()           { return m_framePackingSEIEnabled; }
 …
   Void  setDecodingUnitInfoSEIEnabled(Int b)                { m_decodingUnitInfoSEIEnabled = b;    }
   Int   getDecodingUnitInfoSEIEnabled()                     { return m_decodingUnitInfoSEIEnabled; }
+#if L0208_SOP_DESCRIPTION_SEI
+  Void  setSOPDescriptionSEIEnabled(Int b)                { m_SOPDescriptionSEIEnabled = b; }
+  Int   getSOPDescriptionSEIEnabled()                     { return m_SOPDescriptionSEIEnabled; }
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  Void  setScalableNestingSEIEnabled(Int b)                { m_scalableNestingSEIEnabled = b; }
+  Int   getScalableNestingSEIEnabled()                     { return m_scalableNestingSEIEnabled; }
+#endif
   Void      setUseWP               ( Bool b )    { m_useWeightedPred   = b;    }
   Void      setWPBiPred            ( Bool b )    { m_useWeightedBiPred = b;    }
 …
   Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
 #endif
+#if H_3D
+  /// 3D Tools
+ //==== CAMERA PARAMETERS  ==========
+  Void      setCamParPrecision              ( UInt  u )      { m_uiCamParPrecision      = u; }
+  Void      setCamParInSliceHeader          ( Bool  b )      { m_bCamParInSliceHeader   = b; }
+  Void      setCodedScale                   ( Int** p )      { m_aaiCodedScale          = p; }
+  Void      setCodedOffset                  ( Int** p )      { m_aaiCodedOffset         = p; }
+  Void      setCameraParameters             ( TAppComCamPara* c) { m_cameraParameters   = c; }
+#if H_3D_VSO
+ //==== VSO  ==========
+  Void      setRenderModelParameters ( TRenModSetupStrParser* c ) { m_renderModelParameters = c; }
+  Bool      getUseVSO                       ()              { return m_bUseVSO;     }
+  Void      setUseVSO                       ( Bool  b  )    { m_bUseVSO     = b; }
+  UInt      getVSOMode                      ()              { return m_uiVSOMode; }
+  Void      setVSOMode                      ( UInt  ui )    { m_uiVSOMode   = ui; }
+  Bool      getForceLambdaScaleVSO          ()              { return m_bForceLambdaScale; }
+  Void      setForceLambdaScaleVSO          ( Bool   b )    { m_bForceLambdaScale = b; };
+  Double    getLambdaScaleVSO               ()              { return m_dLambdaScaleVSO;   }
+  Void      setLambdaScaleVSO               ( Double d )    { m_dLambdaScaleVSO   = d; };
+  Bool      getAllowNegDist                 ()              { return m_bAllowNegDist;     }
+  Void      setAllowNegDist                 ( Bool   b )    { m_bAllowNegDist     = b; };
+  // LGE_WVSO_A0119
+  Bool      getUseWVSO                      ()              { return m_bUseWVSO;     }
+  Void      setUseWVSO                      ( Bool  b )     { m_bUseWVSO   = b; }
+  Int       getVSOWeight                    ()              { return m_iVSOWeight;    }
+  Void      setVSOWeight                    ( Int   i )     { m_iVSOWeight = i; }
+  Int       getVSDWeight                    ()              { return m_iVSDWeight;    }
+  Void      setVSDWeight                    ( Int   i )     { m_iVSDWeight = i; }
+  Int       getDWeight                      ()              { return m_iDWeight;    }
+  Void      setDWeight                      ( Int   i )     { m_iDWeight   = i; }
+  // SAIT_VSO_EST_A0033
+  Bool      getUseEstimatedVSD              ()              { return m_bUseEstimatedVSD; }
+  Void      setUseEstimatedVSD              ( Bool  b )     { m_bUseEstimatedVSD = b; }
+  Double    getDispCoeff                    ()              { return m_dDispCoeff;    }
+  Void      setDispCoeff                    ( Double  d )   { m_dDispCoeff  = d; }
+#endif // H_3D_VSO
+#endif // H_3D
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncCu.cpp

-                      r324
+                      r446
           UInt uiRawBits = (2 * g_bitDepthY + g_bitDepthC) * rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) / 2;
           UInt uiBestBits = rpcBestCU->getTotalBits();
+#if H_3D_VSO // M7
+          Double dRDCostTemp = m_pcRdCost->getUseVSO() ? m_pcRdCost->calcRdCostVSO(uiRawBits, 0) : m_pcRdCost->calcRdCost(uiRawBits, 0);
+          if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > dRDCostTemp ))
+#else
           if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
+#endif
+          {
             xCheckIntraPCM (rpcBestCU, rpcTempCU);
 …
       rpcBestCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+    }
+#if H_3D_VSO // M8
+    if ( m_pcRdCost->getUseVSO() )
+      rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
+    else
+#endif
     rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
 …
     if( bSubBranch && bTrySplitDQP && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
+    {
+#if H_3D_VSO // M9
+      // reset Model
+      if( m_pcRdCost->getUseRenModel() )
+      {
+        UInt  uiWidth     = m_ppcOrigYuv[uiDepth]->getWidth ( );
+        UInt  uiHeight    = m_ppcOrigYuv[uiDepth]->getHeight( );
+        Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr( 0 );
+        UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride();
+        m_pcRdCost->setRenModelData( m_ppcBestCU[uiDepth], 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+      }
+#endif
       UChar       uhNextDepth         = uiDepth+1;
       TComDataCU* pcSubBestPartCU     = m_ppcBestCU[uhNextDepth];
 …
+        }
+      }
+#if H_3D_VSO // M10
+      if ( m_pcRdCost->getUseVSO() )
+        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
+      else
+#endif
       rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
 …
             rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+          }
+#if H_3D_VSO // M11
+          if ( m_pcRdCost->getUseLambdaScaleVSO())
+            rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
+          else
+#endif
           rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
 #endif
 …
+    }
+  }
+#if H_3D_VSO // M12
+  if( m_pcRdCost->getUseRenModel() )
+  {
+    UInt  uiWidth     = m_ppcRecoYuvBest[uiDepth]->getWidth   ( );
+    UInt  uiHeight    = m_ppcRecoYuvBest[uiDepth]->getHeight  ( );
+    Pel*  piSrc       = m_ppcRecoYuvBest[uiDepth]->getLumaAddr( 0 );
+    UInt  uiSrcStride = m_ppcRecoYuvBest[uiDepth]->getStride  ( );
+    m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+  }
+#endif
   rpcBestCU->copyToPic(uiDepth);                                                     // Copy Best data to Picture for next partition prediction.
 …
+  }
   UChar uhDepth = rpcTempCU->getDepth( 0 );
+#if H_3D_VSO // M1  //nececcary here?
+  if( m_pcRdCost->getUseRenModel() )
+  {
+    UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
+    UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
+    Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
+    UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
+    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+  }
+#endif
   rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
   rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
 …
        m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
        // estimate residual and encode everything
+#if H_3D_VSO //M2
+       if( m_pcRdCost->getUseRenModel() )
+       { //Reset
+         UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth    ();
+         UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight   ();
+         Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
+         UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride   ();
+         m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+       }
+#endif
        m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
          m_ppcOrigYuv    [uhDepth],
 …
+{
   UChar uhDepth = rpcTempCU->getDepth( 0 );
+#if H_3D_VSO // M3
+  if( m_pcRdCost->getUseRenModel() )
+  {
+    UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
+    UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
+    Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
+    UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
+    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+  }
+#endif
   rpcTempCU->setDepthSubParts( uhDepth, 0 );
 …
   m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
+#if H_3D_VSO // M4
+  if( m_pcRdCost->getUseLambdaScaleVSO() )
+    rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
+  else
+#endif
   rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
 …
   UInt uiDepth = rpcTempCU->getDepth( 0 );
+#if H_3D_VSO // M5
+  if( m_pcRdCost->getUseRenModel() )
+  {
+    UInt  uiWidth     = m_ppcOrigYuv[uiDepth]->getWidth   ();
+    UInt  uiHeight    = m_ppcOrigYuv[uiDepth]->getHeight  ();
+    Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr();
+    UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride  ();
+    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+  }
+#endif
   rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
 …
     rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+  }
+#if H_3D_VSO // M6
+  if( m_pcRdCost->getUseLambdaScaleVSO())
+    rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
+  else
+#endif
   rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
 …
     rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+  }
+#if H_3D_VSO // M44
+  if ( m_pcRdCost->getUseVSO() )
+    rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
+  else
+#endif
   rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
 …
         pcCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+      }
+#if H_3D_VSO // M45
+      if ( m_pcRdCost->getUseVSO() )
+        pcCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
+      else
+#endif
       pcCU->getTotalCost() = m_pcRdCost->calcRdCost( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
 #endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncEntropy.cpp

-                      r438
+                      r446
+}
+#if H_3D
+Void TEncEntropy::encodeSPS( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
+{
+  m_pcEntropyCoderIf->codeSPS( pcSPS, viewIndex, depthFlag );
+  return;
+}
+#else
 Void TEncEntropy::encodeSPS( TComSPS* pcSPS )
+{
 …
   return;
+}
+#endif
 Void TEncEntropy::encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
 …
   if( pcCU->isIntra(uiAbsPartIdx) )
+  {
+#if !H_MV
     DTRACE_CABAC_VL( g_nSymbolCounter++ )
     DTRACE_CABAC_T( "\tdecodeTransformIdx()\tCUDepth=" )
     DTRACE_CABAC_V( uiDepth )
     DTRACE_CABAC_T( "\n" )
+#endif
+  }
   else

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncEntropy.h

-                      r324
+                      r446
   virtual Void  codeVPS                 ( TComVPS* pcVPS )                                      = 0;
+#if !H_3D
   virtual Void  codeSPS                 ( TComSPS* pcSPS )                                      = 0;
+#else
+  virtual Void  codeSPS                 ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )       = 0;
+#endif
   virtual Void  codePPS                 ( TComPPS* pcPPS )                                      = 0;
   virtual Void  codeSliceHeader         ( TComSlice* pcSlice )                                  = 0;
 …
   Void encodeVPS               ( TComVPS* pcVPS);
   // SPS
+#if H_3D
+  Void encodeSPS               ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
+#else
   Void encodeSPS               ( TComSPS* pcSPS );
+#endif
   Void encodePPS               ( TComPPS* pcPPS );
   Void encodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncGOP.cpp

-                      r438
+                      r446
 #if L0045_NON_NESTED_SEI_RESTRICTIONS
   xResetNonNestedSEIPresentFlags();
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  xResetNestedSEIPresentFlags();
+#endif
+#endif
 #if H_MV
   m_layerId      = 0;
 …
   m_pocLastCoded = -1;
 #if H_3D
+  m_viewIndex  =   0;
   m_isDepth = false;
 #endif
 #endif
   return;
+}
 …
   m_viewId               = pcTEncTop->getViewId();
 #if H_3D
+  m_viewIndex            = pcTEncTop->getViewIndex();
   m_isDepth              = pcTEncTop->getIsDepth();
 #endif
 …
+}
+#if J0149_TONE_MAPPING_SEI
+SEIToneMappingInfo*  TEncGOP::xCreateSEIToneMappingInfo()
+{
+  SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
+  seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
+  seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
+  seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
+  seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
+  assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
+  seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
+  assert( (seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17) || (seiToneMappingInfo->m_targetBitDepth  == 255) );
+  seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
+  assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
+  switch( seiToneMappingInfo->m_modelId)
+  {
+  case 0:
+    {
+      seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
+      seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
+      break;
+    }
+  case 1:
+    {
+      seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
+      seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
+      break;
+    }
+  case 2:
+    {
+      UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
+      seiToneMappingInfo->m_startOfCodedInterval.resize(num);
+      Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
+      if(ptmp)
+      {
+        for(int i=0; i<num;i++)
+        {
+          seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
+        }
+      }
+      break;
+    }
+  case 3:
+    {
+      seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
+      seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
+      seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
+      Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
+      Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
+      if(ptmpcoded&&ptmptarget)
+      {
+        for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
+        {
+          seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
+          seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
+         }
+       }
+       break;
+     }
+  case 4:
+     {
+       seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
+       seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
+       assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
+       seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
+       seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
+       seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
+       seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
+       seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
+       assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
+       seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
+       seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
+       assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
+       seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
+       assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
+       break;
+    }
+  default:
+    {
+      assert(!"Undefined SEIToneMapModelId");
+      break;
+    }
+  }
+  return seiToneMappingInfo;
+}
+#endif
 Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps)
+{
   OutputNALUnit nalu(NAL_UNIT_SEI);
+  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
   if(m_pcCfg->getActiveParameterSetsSEIEnabled())
 …
     SEIFramePacking *sei = xCreateSEIFramePacking ();
     nalu = NALUnit(NAL_UNIT_SEI);
+    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
     m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
     m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
 …
     SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
     nalu = NALUnit(NAL_UNIT_SEI);
+    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
     m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
     m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
 …
     delete sei;
+  }
+#if J0149_TONE_MAPPING_SEI
+  if(m_pcCfg->getToneMappingInfoSEIEnabled())
+  {
+    SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
+    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
+    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
+    writeRBSPTrailingBits(nalu.m_Bitstream);
+    accessUnit.push_back(new NALUnitEBSP(nalu));
+    delete sei;
+  }
+#endif
+}
 …
 // Public member functions
 // ====================================================================================================================
 #if H_MV
 Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
 …
+}
 #endif
 #if H_MV
 Void TEncGOP::compressPicInGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Int iGOPid)
 …
   TComPicYuv*     pcPicYuvRecOut;
   TComSlice*      pcSlice;
+  TComOutputBitstream* pcBitstreamRedirect = new TComOutputBitstream;
+  TComOutputBitstream  *pcBitstreamRedirect;
+  pcBitstreamRedirect = new TComOutputBitstream;
   AccessUnit::iterator  itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
   UInt                  uiOneBitstreamPerSliceLength = 0;
 …
   m_iNumPicCoded = 0;
 #endif
   SEIPictureTiming pictureTimingSEI;
+#if L0208_SOP_DESCRIPTION_SEI
+  Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  // Initialize Scalable Nesting SEI with single layer values
+  SEIScalableNesting scalableNestingSEI;
+  scalableNestingSEI.m_bitStreamSubsetFlag           = 1;      // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
+  scalableNestingSEI.m_nestingOpFlag                 = 0;
+  scalableNestingSEI.m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
+  scalableNestingSEI.m_allLayersFlag                 = 0;
+  scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
+  scalableNestingSEI.m_nestingNumLayersMinus1        = 1 - 1;  //nesting_num_layers_minus1
+  scalableNestingSEI.m_nestingLayerId[0]             = 0;
+  scalableNestingSEI.m_callerOwnsSEIs                = true;
+#endif
 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
   Int picSptDpbOutputDuDelay = 0;
 …
   UInt *accumNalsDU = NULL;
   SEIDecodingUnitInfo decodingUnitInfoSEI;
 #if !H_MV
   for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
 #endif
+  {
     UInt uiColDir = 1;
 …
     if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
+    {
 #if H_MV
       delete pcBitstreamRedirect;
 …
       continue;
 #endif
+    }
+    if( getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    }
+    if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    {
       m_iLastIDR = pocCurr;
 …
     pcSlice->setLastIDR(m_iLastIDR);
     pcSlice->setSliceIdx(0);
 #if H_MV
     pcPic  ->setLayerId     ( getLayerId() );
     pcPic  ->setViewId      ( getViewId()  );
+    pcPic  ->setLayerId     ( getLayerId()   );
+    pcPic  ->setViewId      ( getViewId()    );
     pcSlice->setLayerId     ( getLayerId() );
     pcSlice->setViewId      ( getViewId()  );
+    pcSlice->setViewId      ( getViewId()  );
     pcSlice->setVPS         ( m_pcEncTop->getVPS() );
 #if H_3D
+    pcPic  ->setViewIndex   ( getViewIndex() );
     pcPic  ->setIsDepth( getIsDepth() );
+    pcSlice->setIsDepth( getIsDepth() );
+#endif
+#endif
+    pcSlice->setViewIndex   ( getViewIndex()  );
+    pcSlice->setIsDepth( getIsDepth() );
+    pcSlice->setCamparaSlice( pcPic->getCodedScale(), pcPic->getCodedOffset() );
+#endif
+#endif
     //set default slice level flag to the same as SPS level flag
     pcSlice->setLFCrossSliceBoundaryFlag(  pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()  );
 …
 #if H_MV
     // Set the nal unit type
     pcSlice->setNalUnitType(getNalUnitType(pocCurr));
+    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
     if( pcSlice->getSliceType() == B_SLICE )
+    {
 …
+    }
     // Set the nal unit type
     pcSlice->setNalUnitType(getNalUnitType(pocCurr));
 #endif
     if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R)
+    {
       if(pcSlice->getTemporalLayerNonReferenceFlag())
+    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
+#endif
+    if(pcSlice->getTemporalLayerNonReferenceFlag())
+    {
+      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R)
+      {
         pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
+      }
+      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
+      {
+        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
+      }
+      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
+      {
+        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
+      }
+    }
 …
         else
+        {
           pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA);
+          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R);
+        }
+      }
 …
+    }
 #endif
+#if !L0034_COMBINED_LIST_CLEANUP
     if (pcSlice->getSliceType() != B_SLICE || !pcSlice->getSPS()->getUseLComb())
+    {
 …
       pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
+    }
+#endif
     if (pcSlice->getSliceType() == B_SLICE)
 …
       pcSlice->setCheckLDC(bLowDelay);
+    }
+    else
+    {
+      pcSlice->setCheckLDC(true);
+    }
     uiColDir = 1-uiColDir;
 …
     pcSlice->setRefPOCList();
+#if L0034_COMBINED_LIST_CLEANUP
+    pcSlice->setList1IdxToList0Idx();
+#else
     pcSlice->setNoBackPredFlag( false );
     if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
 …
+    }
     pcSlice->generateCombinedList();
+#endif
     if (m_pcEncTop->getTMVPModeId() == 2)
 …
       pcSlice->setEnableTMVPFlag(0);
+    }
+#if H_3D_VSO
+  // Should be moved to TEncTop !!!
+  Bool bUseVSO = m_pcEncTop->getUseVSO();
+  TComRdCost* pcRdCost = m_pcEncTop->getRdCost();
+  pcRdCost->setUseVSO( bUseVSO );
+  // SAIT_VSO_EST_A0033
+  pcRdCost->setUseEstimatedVSD( m_pcEncTop->getUseEstimatedVSD() );
+  if ( bUseVSO )
+  {
+    Int iVSOMode = m_pcEncTop->getVSOMode();
+    pcRdCost->setVSOMode( iVSOMode  );
+    pcRdCost->setAllowNegDist( m_pcEncTop->getAllowNegDist() );
+    // SAIT_VSO_EST_A0033
+    pcRdCost->setVideoRecPicYuv( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false , pcSlice->getPOC(), true ) );
+    pcRdCost->setDepthPicYuv   ( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), true  , pcSlice->getPOC(), false ) );
+    // LGE_WVSO_A0119
+    Bool bUseWVSO  = m_pcEncTop->getUseWVSO();
+    pcRdCost->setUseWVSO( bUseWVSO );
+  }
+#endif
     /////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
     //  Slice compression
 …
     Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
     m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
+#if L0386_DB_METRIC
+    if ( m_pcCfg->getDeblockingFilterMetric() )
+    {
+      dblMetric(pcPic, uiNumSlices);
+    }
+#endif
     m_pcLoopFilter->loopFilterPic( pcPic );
 …
         pcSlice->getSPS()->getVuiParameters()->setHrdParametersPresentFlag( true );
+      }
+#if !H_3D
       m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
+#else
+      m_pcEntropyCoder->encodeSPS(pcSlice->getSPS(), pcSlice->getViewIndex(), pcSlice->getIsDepth() );
+#endif
       writeRBSPTrailingBits(nalu.m_Bitstream);
       accessUnit.push_back(new NALUnitEBSP(nalu));
 …
+    }
+#if L0208_SOP_DESCRIPTION_SEI
+    if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
+    {
+      Int SOPcurrPOC = pocCurr;
+      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
+      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
+      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+      SEISOPDescription SOPDescriptionSEI;
+      SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
+      UInt i = 0;
+      UInt prevEntryId = iGOPid;
+      for (j = iGOPid; j < m_iGopSize; j++)
+      {
+        Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
+        if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
+        {
+          SOPcurrPOC += deltaPOC;
+          SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR);
+          SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
+          SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
+          SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
+          prevEntryId = j;
+          i++;
+        }
+      }
+      SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
+      m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
+      writeRBSPTrailingBits(nalu.m_Bitstream);
+      accessUnit.push_back(new NALUnitEBSP(nalu));
+      writeSOP = false;
+    }
+#endif
     if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
         ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
 …
        || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
+    {
       OutputNALUnit nalu(NAL_UNIT_SEI);
+      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
       m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
       m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
 …
       writeRBSPTrailingBits(nalu.m_Bitstream);
 #if L0045_NON_NESTED_SEI_RESTRICTIONS
+      {
       UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
       UInt offsetPosition = m_activeParameterSetSEIPresentInAU;   // Insert BP SEI after APS SEI
 …
       accessUnit.insert(it, new NALUnitEBSP(nalu));
       m_bufferingPeriodSEIPresentInAU = true;
+      }
 #else
       accessUnit.push_back(new NALUnitEBSP(nalu));
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+      if (m_pcCfg->getScalableNestingSEIEnabled())
+      {
+        OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
+        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
+        m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
+        scalableNestingSEI.m_nestedSEIs.clear();
+        scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
+        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
+        writeRBSPTrailingBits(naluTmp.m_Bitstream);
+#if L0045_NON_NESTED_SEI_RESTRICTIONS
+        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
+        UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU;   // Insert BP SEI after non-nested APS, BP and PT SEIs
+        AccessUnit::iterator it;
+        for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
+        {
+          it++;
+        }
+        accessUnit.insert(it, new NALUnitEBSP(naluTmp));
+        m_nestedBufferingPeriodSEIPresentInAU = true;
+#else
+        accessUnit.push_back(new NALUnitEBSP(naluTmp));
+#endif
+      }
 #endif
 …
+      {
         // Gradual decoding refresh SEI
         OutputNALUnit nalu(NAL_UNIT_SEI);
+        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
         m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
         m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
 …
+      }
     // Recovery point SEI
       OutputNALUnit nalu(NAL_UNIT_SEI);
+      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
       m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
       m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
 …
           pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
-          if (!sliceSegment)
+          {
             pcSlice->setTileLocationCount ( 0 );
+            m_pcSliceEncoder->encodeSlice(pcPic, pcBitstreamRedirect, pcSubstreamsOut); // redirect is only used for CAVLC tile position info.
+          }
+          else
+          {
+            m_pcSliceEncoder->encodeSlice(pcPic, &nalu.m_Bitstream, pcSubstreamsOut); // nalu.m_Bitstream is only used for CAVLC tile position info.
+          }
+          m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
+          {
 …
               if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
+              {
                 puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits();
+                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
+              }
+            }
 …
           // If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
           Bool bNALUAlignedWrittenToList    = false; // used to ensure current NALU is not written more than once to the NALU list.
           xWriteTileLocationToSliceHeader(nalu, pcBitstreamRedirect, pcSlice);
+          xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
           accessUnit.push_back(new NALUnitEBSP(nalu));
 #if RATE_CONTROL_LAMBDA_DOMAIN
 …
+            {
               UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
               if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
+              if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
+              {
                 numRBSPBytes += numRBSPBytes_nal;
 …
       pcPic->compressMotion();
 #endif
 #if H_MV
       m_pocLastCoded = pcPic->getPOC();
 …
           digestStr = digestToString(sei_recon_picture_digest.digest, 4);
+        }
         OutputNALUnit nalu(NAL_UNIT_SEI_SUFFIX, pcSlice->getTLayer());
+        OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
         /* write the SEI messages */
 …
         sei_temporal_level0_index.rapIdx = m_rapIdx;
         OutputNALUnit nalu(NAL_UNIT_SEI);
+        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
         /* write the SEI messages */
 …
         if( m_pcCfg->getPictureTimingSEIEnabled() )
+        {
+          OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer());
+          {
+            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
           m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
           m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
 …
 #endif
+        }
+#if K0180_SCALABLE_NESTING_SEI
+          if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
+          {
+            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
+            m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
+            scalableNestingSEI.m_nestedSEIs.clear();
+            scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
+            m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
+            writeRBSPTrailingBits(nalu.m_Bitstream);
+#if L0045_NON_NESTED_SEI_RESTRICTIONS
+            UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
+            UInt offsetPosition = m_activeParameterSetSEIPresentInAU
+              + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
+            AccessUnit::iterator it;
+            for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
+            {
+              it++;
+            }
+            accessUnit.insert(it, new NALUnitEBSP(nalu));
+            m_nestedPictureTimingSEIPresentInAU = true;
+#else
+            AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
+            accessUnit.insert(it, new NALUnitEBSP(nalu));
+#endif
+          }
+#endif
+        }
         if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
+        {
 …
           for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
+          {
             OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer());
+            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
             SEIDecodingUnitInfo tempSEI;
 …
                   break;
+                }
                 if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
+                if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
+                {
                   ctr++;
 …
 #if L0045_NON_NESTED_SEI_RESTRICTIONS
       xResetNonNestedSEIPresentFlags();
+#if K0180_SCALABLE_NESTING_SEI
+      xResetNestedSEIPresentFlags();
+#endif
 #endif
       pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
 …
   assert ( m_iNumPicCoded == iNumPicRcvd );
 #endif
+}
 …
+}
 #endif
+#if H_3D_VSO
+Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, Dist64& ruiDist, UInt64& ruiBits )
+#else
 Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
+#endif
+{
   TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
 …
+}
+#if H_3D_VSO
+Dist64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
+#else
 UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
+#endif
+{
   Int     x, y;
 …
   Int   iHeight = pcPic0->getHeight();
+#if H_3D_VSO
+  Dist64  uiTotalDiff = 0;
+#else
   UInt64  uiTotalDiff = 0;
+#endif
   for( y = 0; y < iHeight; y++ )
 …
     case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
     case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
     case NAL_UNIT_CODED_SLICE_TLA: return "TLA";
+    case NAL_UNIT_CODED_SLICE_TLA_R:      return "TLA_R";
     case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
     case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
     case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N";
     case NAL_UNIT_CODED_SLICE_BLA: return "BLA";
     case NAL_UNIT_CODED_SLICE_BLANT: return "BLANT";
+    case NAL_UNIT_CODED_SLICE_BLA_W_LP:   return "BLA_W_LP";
+    case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
     case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP";
     case NAL_UNIT_CODED_SLICE_IDR: return "IDR";
+    case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
     case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP";
     case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
     case NAL_UNIT_CODED_SLICE_DLP: return "DLP";
     case NAL_UNIT_CODED_SLICE_TFD: return "TFD";
+    case NAL_UNIT_CODED_SLICE_RADL_R:     return "RADL_R";
+    case NAL_UNIT_CODED_SLICE_RASL_R:     return "RASL_R";
     case NAL_UNIT_VPS: return "VPS";
     case NAL_UNIT_SPS: return "SPS";
 …
     case NAL_UNIT_EOB: return "EOB";
     case NAL_UNIT_FILLER_DATA: return "FILLER";
+    case NAL_UNIT_SEI: return "SEI";
+    case NAL_UNIT_PREFIX_SEI:             return "SEI";
+    case NAL_UNIT_SUFFIX_SEI:             return "SEI";
     default: return "UNK";
+  }
 …
+  }
+  iHeight >>= 1;
+#if H_3D_VSO
+#if H_3D_VSO_SYNTH_DIST_OUT
+  if ( m_pcRdCost->getUseRenModel() )
+  {
+    unsigned int maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
+    Double fRefValueY = (double) maxval * maxval * iSize;
+    Double fRefValueC = fRefValueY / 4.0;
+    TRenModel*  pcRenModel = m_pcEncTop->getEncTop()->getRenModel();
+    Int64 iDistVSOY, iDistVSOU, iDistVSOV;
+    pcRenModel->getTotalSSE( iDistVSOY, iDistVSOU, iDistVSOV );
+    dYPSNR = ( iDistVSOY ? 10.0 * log10( fRefValueY / (Double) iDistVSOY ) : 99.99 );
+    dUPSNR = ( iDistVSOU ? 10.0 * log10( fRefValueC / (Double) iDistVSOU ) : 99.99 );
+    dVPSNR = ( iDistVSOV ? 10.0 * log10( fRefValueC / (Double) iDistVSOV ) : 99.99 );
+  }
+  else
+  {
+#endif
+#endif
+    iHeight >>= 1;
   iWidth  >>= 1;
   iStride >>= 1;
 …
   dUPSNR            = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
   dVPSNR            = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
+#if H_3D_VSO
+#if H_3D_VSO_SYNTH_DIST_OUT
+}
+#endif
+#endif
   /* calculate the size of the access unit, excluding:
    *  - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
 …
     printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
 #endif
     if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
+    if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
+    {
       numRBSPBytes += numRBSPBytes_nal;
 …
   //===== add PSNR =====
 #if H_MV
   m_pcEncTop->getAnalyzeAll()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 …
   m_gcAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 #endif
   TComSlice*  pcSlice = pcPic->getSlice(0);
   if (pcSlice->isIntra())
+  {
 #if H_MV
     m_pcEncTop->getAnalyzeI()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 …
     m_gcAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 #endif
+  }
   if (pcSlice->isInterP())
+  {
 #if H_MV
     m_pcEncTop->getAnalyzeP()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 …
     m_gcAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 #endif
+  }
   if (pcSlice->isInterB())
+  {
 #if H_MV
     m_pcEncTop->getAnalyzeB()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 …
     m_gcAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
 #endif
+  }
 …
 #if ADAPTIVE_QP_SELECTION
 #if H_MV
   printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
 …
          uibits );
 #endif
+#else
+#else
 #if H_MV
   printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
 …
          uibits );
 #endif
 #endif
 …
  * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
  */
 NalUnitType TEncGOP::getNalUnitType(Int pocCurr)
+NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR)
+{
   if (pocCurr == 0)
+  {
     return NAL_UNIT_CODED_SLICE_IDR;
+    return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
+  }
   if (pocCurr % m_pcCfg->getIntraPeriod() == 0)
 …
     else if (m_pcCfg->getDecodingRefreshType() == 2)
+    {
       return NAL_UNIT_CODED_SLICE_IDR;
+      return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
+    }
+  }
 …
       // controlling the reference pictures used for encoding that leading picture. Such a leading
       // picture need not be marked as a TFD picture.
+      return NAL_UNIT_CODED_SLICE_TFD;
+      return NAL_UNIT_CODED_SLICE_RASL_R;
+    }
+  }
+  if (lastIDR>0)
+  {
+    if (pocCurr < lastIDR)
+    {
+      return NAL_UNIT_CODED_SLICE_RADL_R;
+    }
+  }
 …
+}
+/** Determine the difference between consecutive tile sizes (in bytes) and writes it to  bistream rNalu [slice header]
+ * \param rpcBitstreamRedirect contains the bitstream to be concatenated to rNalu. rpcBitstreamRedirect contains slice payload. rpcSlice contains tile location information.
+ * \returns Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
+/** Attaches the input bitstream to the stream in the output NAL unit
+    Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
+ *  \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
+ *  \param rNalu          target NAL unit
  */
 Void TEncGOP::xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice)
+Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData)
+{
   // Byte-align
 …
   // Perform bitstream concatenation
+  if (rpcBitstreamRedirect->getNumberOfWrittenBits() > 0)
+  {
+    UInt uiBitCount  = rpcBitstreamRedirect->getNumberOfWrittenBits();
+    if (rpcBitstreamRedirect->getByteStreamLength()>0)
+    {
+      UChar *pucStart  =  reinterpret_cast<UChar*>(rpcBitstreamRedirect->getByteStream());
+      UInt uiWriteByteCount = 0;
+      while (uiWriteByteCount < (uiBitCount >> 3) )
+      {
+        UInt uiBits = (*pucStart);
+        rNalu.m_Bitstream.write(uiBits, 8);
+        pucStart++;
+        uiWriteByteCount++;
+      }
+    }
+    UInt uiBitsHeld = (uiBitCount & 0x07);
+    for (UInt uiIdx=0; uiIdx < uiBitsHeld; uiIdx++)
+    {
+      rNalu.m_Bitstream.write((rpcBitstreamRedirect->getHeldBits() & (1 << (7-uiIdx))) >> (7-uiIdx), 1);
+    }
+  if (codedSliceData->getNumberOfWrittenBits() > 0)
+    {
+    rNalu.m_Bitstream.addSubstream(codedSliceData);
+  }
   m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
+  delete rpcBitstreamRedirect;
+  rpcBitstreamRedirect = new TComOutputBitstream;
+  codedSliceData->clear();
+}
 …
+     }
+  }
+  assert(it != accessUnit.end());
+//  assert(it != accessUnit.end());  // Triggers with some legit configurations
   return seiStartPos;
+}
 #endif
+#if L0386_DB_METRIC
+Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
+{
+  TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
+  Pel* Rec    = pcPicYuvRec->getLumaAddr( 0 );
+  Pel* tempRec = Rec;
+  Int  stride = pcPicYuvRec->getStride();
+  UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
+  UInt maxTBsize = (1<<log2maxTB);
+  const UInt minBlockArtSize = 8;
+  const UInt picWidth = pcPicYuvRec->getWidth();
+  const UInt picHeight = pcPicYuvRec->getHeight();
+  const UInt noCol = (picWidth>>log2maxTB);
+  const UInt noRows = (picHeight>>log2maxTB);
+  UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64));
+  UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64));
+  UInt colIdx = 0;
+  UInt rowIdx = 0;
+  Pel p0, p1, p2, q0, q1, q2;
+  Int qp = pcPic->getSlice(0)->getSliceQp();
+  Int bitdepthScale = 1 << (g_bitDepthY-8);
+  Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
+  const Int thr2 = (beta>>2);
+  const Int thr1 = 2*bitdepthScale;
+  UInt a = 0;
+  memset(colSAD, 0, noCol*sizeof(UInt64));
+  memset(rowSAD, 0, noRows*sizeof(UInt64));
+  if (maxTBsize > minBlockArtSize)
+  {
+    // Analyze vertical artifact edges
+    for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
+    {
+      for(Int r = 0; r < picHeight; r++)
+      {
+        p2 = Rec[c-3];
+        p1 = Rec[c-2];
+        p0 = Rec[c-1];
+        q0 = Rec[c];
+        q1 = Rec[c+1];
+        q2 = Rec[c+2];
+        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
+        if ( thr1 < a && a < thr2)
+        {
+          colSAD[colIdx] += abs(p0 - q0);
+        }
+        Rec += stride;
+      }
+      colIdx++;
+      Rec = tempRec;
+    }
+    // Analyze horizontal artifact edges
+    for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
+    {
+      for(Int c = 0; c < picWidth; c++)
+      {
+        p2 = Rec[c + (r-3)*stride];
+        p1 = Rec[c + (r-2)*stride];
+        p0 = Rec[c + (r-1)*stride];
+        q0 = Rec[c + r*stride];
+        q1 = Rec[c + (r+1)*stride];
+        q2 = Rec[c + (r+2)*stride];
+        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
+        if (thr1 < a && a < thr2)
+        {
+          rowSAD[rowIdx] += abs(p0 - q0);
+        }
+      }
+      rowIdx++;
+    }
+  }
+  UInt64 colSADsum = 0;
+  UInt64 rowSADsum = 0;
+  for(Int c = 0; c < noCol-1; c++)
+  {
+    colSADsum += colSAD[c];
+  }
+  for(Int r = 0; r < noRows-1; r++)
+  {
+    rowSADsum += rowSAD[r];
+  }
+  colSADsum <<= 10;
+  rowSADsum <<= 10;
+  colSADsum /= (noCol-1);
+  colSADsum /= picHeight;
+  rowSADsum /= (noRows-1);
+  rowSADsum /= picWidth;
+  UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
+  avgSAD >>= (g_bitDepthY-8);
+  if ( avgSAD > 2048 )
+  {
+    avgSAD >>= 9;
+    Int offset = Clip3(2,6,(Int)avgSAD);
+    for (Int i=0; i<uiNumSlices; i++)
+    {
+      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
+      pcPic->getSlice(i)->setDeblockingFilterDisable(false);
+      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
+      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
+    }
+  }
+  else
+  {
+    for (Int i=0; i<uiNumSlices; i++)
+    {
+      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
+      pcPic->getSlice(i)->setDeblockingFilterDisable(        pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
+      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
+      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2(   pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2()   );
+    }
+  }
+  free(colSAD);
+  free(rowSAD);
+}
+#endif
 #if H_MV
 Void TEncGOP::xSetRefPicListModificationsMvc( TComSlice* pcSlice, UInt uiPOCCurr, UInt iGOPid )
 …
     // set inter-view modifications
+    if( (maxRefListSize > 1) && (numModifications > 0) )
+    {
+      refPicListModification->setRefPicListModificationFlagL( li, true );
+    Bool isModified = false;
       Int tempList[16];
       for( Int k = 0; k < 16; k++ ) { tempList[k] = -1; }
+      Bool isModified = false;
+    if( (maxRefListSize > 1) && (numModifications > 0) )
+    {
       for( Int k = 0; k < ge.m_numInterViewRefPics; k++ )
+      {
 …
+        }
+      }
+    }
+    refPicListModification->setRefPicListModificationFlagL( li, isModified );
       if( isModified )
+      {
 …
+        }
+      }
-      else
+      {
-        refPicListModification->setRefPicListModificationFlagL( li, false );
+      }
+    }
+  }
+}
 #endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncGOP.h

-                      r438
+                      r446
   Int                     m_viewId;
 #if H_3D
+  Int                     m_viewIndex;
   Bool                    m_isDepth;
 #endif
 #endif
   //--Adaptive Loop filter
   TEncSampleAdaptiveOffset*  m_pcSAO;
 …
   Bool                    m_bufferingPeriodSEIPresentInAU;
   Bool                    m_pictureTimingSEIPresentInAU;
+#if K0180_SCALABLE_NESTING_SEI
+  Bool                    m_nestedBufferingPeriodSEIPresentInAU;
+  Bool                    m_nestedPictureTimingSEIPresentInAU;
+#endif
 #endif
 public:
 …
   Void  init        ( TEncTop* pcTEncTop );
 #if H_MV
   Void  initGOP     ( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP);
 …
   Void  compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRec, std::list<AccessUnit>& accessUnitsInGOP );
 #endif
+  Void xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice);
+  Void  xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect);
 #if H_MV
 …
   Int       getViewId        ()                 { return m_viewId;    }
 #if H_3D
+  Int       getViewIndex     ()                 { return m_viewIndex;    }
   Bool      getIsDepth       ()                 { return m_isDepth; }
 #endif
 …
   Void  printOutSummary      ( UInt uiNumAllPicCoded );
 #endif
+#if H_3D_VSO
+  Void  preLoopFilterPicAll  ( TComPic* pcPic, Dist64& ruiDist, UInt64& ruiBits );
+#else
   Void  preLoopFilterPicAll  ( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits );
+#endif
   TEncSlice*  getSliceEncoder()   { return m_pcSliceEncoder; }
   NalUnitType getNalUnitType( Int pocCurr );
+  NalUnitType getNalUnitType( Int pocCurr, Int lastIdr );
   Void arrangeLongtermPicturesInRPS(TComSlice *, TComList<TComPic*>& );
 protected:
 …
   Void  xCalculateAddPSNR ( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit&, Double dEncTime );
+#if H_3D_VSO
+  Dist64 xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1);
+#else
   UInt64 xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1);
+#endif
   Double xCalculateRVM();
 …
   SEIFramePacking*        xCreateSEIFramePacking();
   SEIDisplayOrientation*  xCreateSEIDisplayOrientation();
+#if J0149_TONE_MAPPING_SEI
+  SEIToneMappingInfo*     xCreateSEIToneMappingInfo();
+#endif
   Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps);
 …
     m_pictureTimingSEIPresentInAU      = false;
+  }
+#endif
+#if K0180_SCALABLE_NESTING_SEI
+  Void xResetNestedSEIPresentFlags()
+  {
+    m_nestedBufferingPeriodSEIPresentInAU    = false;
+    m_nestedPictureTimingSEIPresentInAU      = false;
+  }
+#endif
+#endif
 #if H_MV
    Void  xSetRefPicListModificationsMvc( TComSlice* pcSlice, UInt uiPOCCurr, UInt iGOPid );
 #endif
+#if L0386_DB_METRIC
+  Void dblMetric( TComPic* pcPic, UInt uiNumSlices );
+#endif
 };// END CLASS DEFINITION TEncGOP

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

-                      r438
+                      r446
 #endif
+{
-#if SAO_CHROMA_LAMBDA
-  m_dLambdaLuma    = dLambdaLuma;
-  m_dLambdaChroma  = dLambdaChroma;
-#else
-  m_dLambdaLuma    = dLambda;
-  m_dLambdaChroma  = dLambda;
-#endif
   if(m_bUseNIF)
+  {

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h

-                      r438
+                      r446
+{
 private:
-  Double            m_dLambdaLuma;
-  Double            m_dLambdaChroma;
   TEncEntropy*      m_pcEntropyCoder;
   TEncSbac***       m_pppcRDSbacCoder;              ///< for CABAC

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSbac.cpp

r324	r446
246	246	}
247	247
	248	#if H_3D
	249	Void TEncSbac::codeSPS( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
	250	#else
248	251	Void TEncSbac::codeSPS( TComSPS* pcSPS )
	252	#endif
249	253	{
250	254	assert (0);

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSbac.h

-                      r438
+                      r446
   Void  codeVPS                 ( TComVPS* pcVPS );
+#if !H_3D
   Void  codeSPS                 ( TComSPS* pcSPS     );
+#else
+  Void  codeSPS                 ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
+#endif
   Void  codePPS                 ( TComPPS* pcPPS     );
   Void  codeSliceHeader         ( TComSlice* pcSlice );
 …
   Void  xWriteEpExGolomb     ( UInt uiSymbol, UInt uiCount );
   Void  xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam );
-  Void  xWriteTerminatingBit ( UInt uiBit );
   Void  xCopyFrom            ( TEncSbac* pSrc );

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSearch.cpp

-                      r438
+                      r446
                                 TComYuv*    pcPredYuv,
                                 TComYuv*    pcResiYuv,
+#if H_3D_VSO
+                                Dist&       ruiDist,
+#else
                                 UInt&       ruiDist,
+#endif
                                 Int        default0Save1Load2 )
+{
 …
   //===== update distortion =====
+#if H_3D_VSO // M39
+  if ( m_pcRdCost->getUseVSO() )
+      ruiDist += m_pcRdCost->getDistPartVSO  ( pcCU, uiAbsPartIdx, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, false );
+  else
+#endif
   ruiDist += m_pcRdCost->getDistPart(g_bitDepthY, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight );
+}
 …
                                 TComYuv*     pcPredYuv,
                                 TComYuv*     pcResiYuv,
+#if H_3D_VSO
+                                Dist&        ruiDistY,
+#else
                                 UInt&        ruiDistY,
+#endif
                                 UInt&        ruiDistC,
 #if HHI_RQT_INTRA_SPEEDUP
 …
 #endif
   Double  dSingleCost   = MAX_DOUBLE;
+#if H_3D_VSO
+  Dist    uiSingleDistY = 0;
+#else
   UInt    uiSingleDistY = 0;
+#endif
   UInt    uiSingleDistC = 0;
   UInt    uiSingleCbfY  = 0;
 …
         m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
+      }
+#if H_3D_VSO
+      Dist   singleDistYTmp     = 0;
+#else
       UInt   singleDistYTmp     = 0;
+#endif
       UInt   singleDistCTmp     = 0;
       UInt   singleCbfYTmp      = 0;
 …
+        {
           UInt uiSingleBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
+#if H_3D_VSO // M NEW
+          if ( m_pcRdCost->getUseRenModel() )
+            singleCostTmp     = m_pcRdCost->calcRdCostVSO( uiSingleBits, singleDistYTmp + singleDistCTmp );
+          else
+#endif
           singleCostTmp     = m_pcRdCost->calcRdCost( uiSingleBits, singleDistYTmp + singleDistCTmp );
+        }
 …
+      }
 #endif
+#if H_3D_VSO // M40
+      if ( m_pcRdCost->getUseLambdaScaleVSO())
+        dSingleCost = m_pcRdCost->calcRdCostVSO( uiSingleBits, uiSingleDistY + uiSingleDistC );
+      else
+#endif
       dSingleCost       = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDistY + uiSingleDistC );
+    }
 …
     //----- code splitted block -----
     Double  dSplitCost      = 0.0;
+#if H_3D_VSO
+    Dist    uiSplitDistY    = 0;
+#else
     UInt    uiSplitDistY    = 0;
+#endif
     UInt    uiSplitDistC    = 0;
     UInt    uiQPartsDiv     = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
 …
     //----- determine rate and r-d cost -----
     UInt uiSplitBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
+#if H_3D_VSO // M41
+    if( m_pcRdCost->getUseLambdaScaleVSO() )
+      dSplitCost = m_pcRdCost->calcRdCostVSO( uiSplitBits, uiSplitDistY + uiSplitDistC );
+    else
+#endif
     dSplitCost       = m_pcRdCost->calcRdCost( uiSplitBits, uiSplitDistY + uiSplitDistC );
 …
+    }
+  }
+#if H_3D_VSO // M42
+  if ( m_pcRdCost->getUseRenModel() && bCheckFull )
+  {
+    UInt  uiWidth     = pcCU->getWidth ( 0 ) >> uiTrDepth;
+    UInt  uiHeight    = pcCU->getHeight( 0 ) >> uiTrDepth;
+    UInt  uiQTLayer   = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
+    Pel*  piSrc       = m_pcQTTempTComYuv[ uiQTLayer ].getLumaAddr( uiAbsPartIdx );
+    UInt  uiSrcStride = m_pcQTTempTComYuv[ uiQTLayer ].getStride  ();
+    m_pcRdCost->setRenModelData( pcCU, uiAbsPartIdx, piSrc, (Int) uiSrcStride, (Int) uiWidth, (Int) uiHeight );
+  }
+#endif
   ruiDistY += uiSingleDistY;
   ruiDistC += uiSingleDistC;
 …
   UInt    uiQNumParts    = pcCU->getTotalNumPart() >> 2;
   UInt    uiWidthBit     = pcCU->getIntraSizeIdx(0);
+#if H_3D_VSO
+  Dist    uiOverallDistY = 0;
+#else
   UInt    uiOverallDistY = 0;
+#endif
   UInt    uiOverallDistC = 0;
   UInt    CandNum;
 …
         predIntraLumaAng( pcCU->getPattern(), uiMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
+#if H_3D_VSO // M34
+        Dist uiSad;
+        if ( m_pcRdCost->getUseVSO() )
+        {
+          if ( m_pcRdCost->getUseEstimatedVSD() )
+          {
+            uiSad = (Dist) ( m_pcRdCost->getDistPartVSD( pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true ) );
+          }
+          else
+          {
+            uiSad = m_pcRdCost->getDistPartVSO(pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true );
+          }
+        }
+        else
+        {
+          uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
+        }
+#else
         // use hadamard transform here
         UInt uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
+#endif
         UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
+#if H_3D_VSO // M35
+        Double dLambda;
+        if ( m_pcRdCost->getUseLambdaScaleVSO() )
+          dLambda = m_pcRdCost->getUseRenModel() ? m_pcRdCost->getLambdaVSO() : m_pcRdCost->getSqrtLambdaVSO();
+        else
+          dLambda = m_pcRdCost->getSqrtLambda();
         Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
+#else
+        Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
+#endif
         CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
 …
     UInt    uiBestPUMode  = 0;
+#if H_3D_VSO
+    Dist    uiBestPUDistY = 0;
+#else
     UInt    uiBestPUDistY = 0;
+#endif
     UInt    uiBestPUDistC = 0;
     Double  dBestPUCost   = MAX_DOUBLE;
 …
       // determine residual for partition
+#if H_3D_VSO
+      Dist   uiPUDistY = 0;
+#else
       UInt   uiPUDistY = 0;
+#endif
       UInt   uiPUDistC = 0;
       Double dPUCost   = 0.0;
+#if H_3D_VSO // M36
+      if( m_pcRdCost->getUseRenModel() )
+      {
+        m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
+      }
+#endif
 #if HHI_RQT_INTRA_SPEEDUP
       xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
 …
       // determine residual for partition
+#if H_3D_VSO
+      Dist   uiPUDistY = 0;
+#else
       UInt   uiPUDistY = 0;
+#endif
       UInt   uiPUDistC = 0;
       Double dPUCost   = 0.0;
+#if H_3D_VSO // M37
+      // reset Model
+      if( m_pcRdCost->getUseRenModel() )
+      {
+        m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
+      }
+#endif
       xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
 …
+        }
+      }
+#if H_3D_VSO // M38
+      // set model
+      if( m_pcRdCost->getUseRenModel() )
+      {
+        piSrc = pcRecoYuv->getLumaAddr( uiPartOffset );
+        m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piSrc, uiSrcStride, uiCompWidth, uiCompHeight);
+      }
+#endif
       if( !bLumaOnly && !bSkipChroma )
+      {
 …
   uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
+#if H_3D_VSO // M43
+  if( m_pcRdCost->getUseLambdaScaleVSO() )
+    dCost =  m_pcRdCost->calcRdCostVSO( uiBits, uiDistortion );
+  else
+#endif
   dCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
 …
     UInt          uiBitsTempL0[MAX_NUM_REF];
+#if L0034_COMBINED_LIST_CLEANUP
+    TComMv        mvValidList1;
+    Int           refIdxValidList1 = 0;
+    UInt          bitsValidList1 = MAX_UINT;
+    UInt          costValidList1 = MAX_UINT;
+#endif
     xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
 …
         uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
 #if ZERO_MVD_EST
+#if L0034_COMBINED_LIST_CLEANUP
+        if ( iRefList == 0 || pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
+#else
         if ((iRefList != 1 || !pcCU->getSlice()->getNoBackPredFlag()) &&
             (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 || pcCU->getSlice()->getRefIdxOfLC(eRefPicList, iRefIdxTemp)>=0))
+#endif
+        {
           uiZeroMvdBitsTemp = uiBitsTemp;
 …
 #if GPB_SIMPLE_UNI
+#if L0034_COMBINED_LIST_CLEANUP
+        if ( iRefList == 1 )    // list 1
+        {
+          if ( pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) >= 0 )
+          {
+            cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
+            uiCostTemp = uiCostTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
+            /*first subtract the bit-rate part of the cost of the other list*/
+            uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )] );
+            /*correct the bit-rate part of the current ref*/
+            m_pcRdCost->setPredictor  ( cMvPred[iRefList][iRefIdxTemp] );
+            uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
+            /*calculate the correct cost*/
+            uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
+          }
+          else
+          {
+            xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
+          }
+        }
+        else
+        {
+          xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
+        }
+#else
         if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
+        {
 …
+          }
+        }
+#endif
 #else
         xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
 …
         xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
+#if L0034_COMBINED_LIST_CLEANUP
+        if ( iRefList == 0 )
+        {
+          uiCostTempL0[iRefIdxTemp] = uiCostTemp;
+          uiBitsTempL0[iRefIdxTemp] = uiBitsTemp;
+        }
+        if ( uiCostTemp < uiCost[iRefList] )
+        {
+          uiCost[iRefList] = uiCostTemp;
+          uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction
+          // set motion
+          cMv[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
+          iRefIdx[iRefList] = iRefIdxTemp;
+        }
+        if ( iRefList == 1 && uiCostTemp < costValidList1 && pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
+        {
+          costValidList1 = uiCostTemp;
+          bitsValidList1 = uiBitsTemp;
+          // set motion
+          mvValidList1     = cMvTemp[iRefList][iRefIdxTemp];
+          refIdxValidList1 = iRefIdxTemp;
+        }
+#else
         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag())
+        {
 …
+            }
+          }
+#endif
+      }
+    }
 …
         Int         iRefList    = iIter % 2;
+#if L0034_COMBINED_LIST_CLEANUP
+        if ( m_pcEncCfg->getUseFastEnc() )
+        {
+          if( uiCost[0] <= uiCost[1] )
+          {
+            iRefList = 1;
+          }
+          else
+          {
+            iRefList = 0;
+          }
+        }
+        else if ( iIter == 0 )
+        {
+          iRefList = 0;
+        }
+        if ( iIter == 0 && !pcCU->getSlice()->getMvdL1ZeroFlag())
+        {
+          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllMv( cMv[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
+          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllRefIdx( iRefIdx[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
+          TComYuv*  pcYuvPred = &m_acYuvPred[1-iRefList];
+          motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx );
+        }
+#else
         if ( m_pcEncCfg->getUseFastEnc() && (pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 )) )
+        {
           iRefList = 1;
+        }
+#endif
         RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
 …
     UInt uiMEBits = 0;
     // Set Motion Field_
+#if L0034_COMBINED_LIST_CLEANUP
+    cMv[1] = mvValidList1;
+    iRefIdx[1] = refIdxValidList1;
+    uiBits[1] = bitsValidList1;
+    uiCost[1] = costValidList1;
+#else
     if ( pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 ) )
+    {
       uiCost[1] = MAX_UINT;
+    }
+#endif
 #if AMP_MRG
     if (bTestNormalMC)
 …
   Bool      bHighPass    = pcCU->getSlice()->getDepth() ? true : false;
   UInt      uiBits       = 0, uiBitsBest = 0;
+#if H_3D_VSO
+  Dist      uiDistortion = 0, uiDistortionBest = 0;
+#else
   UInt      uiDistortion = 0, uiDistortionBest = 0;
+#endif
   UInt      uiWidth      = pcCU->getWidth ( 0 );
 …
     pcYuvPred->copyToPartYuv( rpcYuvRec, 0 );
+#if H_3D_VSO // M13
+    if ( m_pcRdCost->getUseVSO() )
+    {
+      uiDistortion = m_pcRdCost->getDistPartVSO( pcCU, 0, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight     , false );
+    }
+    else
+    {
+#endif
 #if WEIGHTED_CHROMA_DISTORTION
     uiDistortion = m_pcRdCost->getDistPart(g_bitDepthY, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight      )
 …
 #endif
+#if H_3D_VSO // MIgnore
+    }
+#endif
     if( m_bUseSBACRD )
       m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST]);
 …
     pcCU->getTotalBits()       = uiBits;
     pcCU->getTotalDistortion() = uiDistortion;
+    pcCU->getTotalCost()       = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
+#if H_3D_VSO //M 14
+    if ( m_pcRdCost->getUseLambdaScaleVSO() )
+      pcCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( uiBits, uiDistortion );
+    else
+#endif
+    pcCU->getTotalCost() = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
     if( m_bUseSBACRD )
       m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_TEMP_BEST]);
 …
     pcCU->setCbfSubParts( 0, 0, 0, 0, pcCU->getDepth( 0 ) );
     pcCU->setTrIdxSubParts( 0, 0, pcCU->getDepth(0) );
+#if H_3D_VSO // necessary? // M15
+    // set Model
+    if( !m_pcRdCost->getUseEstimatedVSD()&& m_pcRdCost->getUseRenModel() )
+    {
+      Pel*  piSrc       = rpcYuvRec->getLumaAddr();
+      UInt  uiSrcStride = rpcYuvRec->getStride();
+      m_pcRdCost->setRenModelData( pcCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+    }
+#endif
     return;
+  }
 …
     while( pcCU->getWidth(0) > (pcCU->getSlice()->getSPS()->getMaxTrSize()<<uiTrLevel) ) uiTrLevel++;
+  }
   UInt uiMaxTrMode = pcCU->getSlice()->getSPS()->getMaxTrDepth() + uiTrLevel;
+  UInt uiMaxTrMode = 1 + uiTrLevel;
   while((uiWidth>>uiMaxTrMode) < (g_uiMaxCUWidth>>g_uiMaxCUDepth)) uiMaxTrMode--;
 …
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_CURR_BEST ] );
+    }
+    }
+#if H_3D_VSO // M16 // M18
+    Dist uiZeroDistortion = 0;
+    if ( m_pcRdCost->getUseVSO() )  // This creating and destroying need to be fixed.
+    {
+      m_cYuvRecTemp.create( pcYuvPred->getWidth(), pcYuvPred->getHeight()  );
+    }
+    xEstimateResidualQT( pcCU, 0, 0, 0, pcYuvOrg, pcYuvPred, rpcYuvResi,  pcCU->getDepth(0), dCost, uiBits, uiDistortion, &uiZeroDistortion );
+    if ( m_pcRdCost->getUseVSO() )
+    {
+      m_cYuvRecTemp.destroy();
+    }
+#else
     UInt uiZeroDistortion = 0;
     xEstimateResidualQT( pcCU, 0, 0, 0, rpcYuvResi,  pcCU->getDepth(0), dCost, uiBits, uiDistortion, &uiZeroDistortion );
+#endif
     m_pcEntropyCoder->resetBits();
     m_pcEntropyCoder->encodeQtRootCbfZero( pcCU );
     UInt zeroResiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
+#if H_3D_VSO  // M19
+    Double dZeroCost;
+    if( m_pcRdCost->getUseLambdaScaleVSO() )
+      dZeroCost = m_pcRdCost->calcRdCostVSO( 0, uiZeroDistortion );
+    else
+      dZeroCost = m_pcRdCost->calcRdCost( zeroResiBits, uiZeroDistortion );
+#else
     Double dZeroCost = m_pcRdCost->calcRdCost( zeroResiBits, uiZeroDistortion );
+#endif
     if(pcCU->isLosslessCoded( 0 ))
+    {
 …
+    }
+#if H_3D_VSO // M20
+    Double dExactCost;
+    if( m_pcRdCost->getUseLambdaScaleVSO() )
+      dExactCost = m_pcRdCost->calcRdCostVSO( uiBits, uiDistortion );
+    else
+      dExactCost = m_pcRdCost->calcRdCost   ( uiBits, uiDistortion );
+#else
     Double dExactCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
+#endif
     dCost = dExactCost;
 …
+      }
+    }
+#if H_3D_VSO // M21
+    if( m_pcRdCost->getUseRenModel() && !m_pcRdCost->getUseEstimatedVSD() )
+    {
+      Pel*  piSrc       = pcYuvOrg->getLumaAddr();
+      UInt  uiSrcStride = pcYuvOrg->getStride();
+      m_pcRdCost->setRenModelData( pcCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+    }
+#endif
+  }
 …
+  }
   rpcYuvRec->addClip ( pcYuvPred, rpcYuvResiBest, 0, uiWidth );
+#if H_3D_VSO  // M22 // GT: might be removed since VSO already provided clipped distortion
+  if ( m_pcRdCost->getUseVSO() )
+  {
+    uiDistortionBest = m_pcRdCost->getDistPartVSO  ( pcCU, 0, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight, false );
+  }
+  else
+  {
+#endif
   // update with clipped distortion and cost (qp estimation loop uses unclipped values)
 #if WEIGHTED_CHROMA_DISTORTION
 …
   + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCrAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCrAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1 );
 #endif
+#if H_3D_VSO // M23
+  }
+  if ( m_pcRdCost->getUseLambdaScaleVSO() )
+    dCostBest = m_pcRdCost->calcRdCostVSO( uiBitsBest, uiDistortionBest );
+  else
+#endif
   dCostBest = m_pcRdCost->calcRdCost( uiBitsBest, uiDistortionBest );
 …
   pcCU->setQPSubParts( qpBest, 0, pcCU->getDepth(0) );
+#if H_3D_VSO // M24 // necessary??
+  if( m_pcRdCost->getUseRenModel() && !m_pcRdCost->getUseEstimatedVSD() )
+  {
+    Pel*  piSrc       = rpcYuvRec->getLumaAddr();
+    UInt  uiSrcStride = rpcYuvRec->getStride();
+    m_pcRdCost->setRenModelData( pcCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
+  }
+#endif
+}
+#if H_3D_VSO // M25
+Void TEncSearch::xEstimateResidualQT( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx, TComYuv* pcOrg, TComYuv* pcPred, TComYuv* pcResi, const UInt uiDepth, Double &rdCost, UInt &ruiBits, Dist &ruiDist, Dist *puiZeroDist )
+#else
 Void TEncSearch::xEstimateResidualQT( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx, TComYuv* pcResi, const UInt uiDepth, Double &rdCost, UInt &ruiBits, UInt &ruiDist, UInt *puiZeroDist )
+#endif
+{
   const UInt uiTrMode = uiDepth - pcCU->getDepth( 0 );
 …
   Double dSingleCost = MAX_DOUBLE;
   UInt uiSingleBits = 0;
+#if H_3D_VSO
+  Dist uiSingleDist = 0;
+#else
   UInt uiSingleDist = 0;
+#endif
   UInt uiAbsSumY = 0, uiAbsSumU = 0, uiAbsSumV = 0;
   UInt uiBestTransformMode[3] = {0};
 …
     ::memset( m_pTempPel, 0, sizeof( Pel ) * uiNumSamplesLuma ); // not necessary needed for inside of recursion (only at the beginning)
+#if H_3D_VSO // M27
+    Dist uiDistY;
+    if ( m_pcRdCost->getUseVSO() )
+    {
+      if( m_pcRdCost->getUseEstimatedVSD() )
+      {
+        uiDistY = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPartIdx, m_pTempPel, 1<< uiLog2TrSize, pcResi->getLumaAddr( uiAbsPartIdx ), pcResi->getStride(), 1<< uiLog2TrSize, 1<< uiLog2TrSize, false );
+      }
+      else
+      {
+        uiDistY = m_pcRdCost->getDistPartVSO  ( pcCU, uiAbsPartIdx, pcPred->getLumaAddr( uiAbsPartIdx ), pcPred->getStride(), pcOrg->getLumaAddr( uiAbsPartIdx), pcOrg->getStride(), 1<< uiLog2TrSize, 1<< uiLog2TrSize, false ); // initialized with zero residual distortion
+      }
+    }
+    else
+    {
+      uiDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pTempPel, trWidth, pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth, trHeight ); // initialized with zero residual destortion
+    }
+#else
     UInt uiDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pTempPel, trWidth, pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth, trHeight ); // initialized with zero residual destortion
+#endif
     if ( puiZeroDist )
 …
       assert(scalingListType < 6);
       m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType );//this is for inter mode only
+      const UInt uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
+      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
+#if H_3D_VSO // M28
+      Dist uiNonzeroDistY;
+      if ( m_pcRdCost->getUseVSO() )
+      {
+        if ( m_pcRdCost->getUseEstimatedVSD() )
+        {
+          uiNonzeroDistY = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPartIdx, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( uiAbsPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(), pcResi->getLumaAddr( uiAbsPartIdx ), pcResi->getStride(),  1<< uiLog2TrSize,    1<< uiLog2TrSize, false );
+        }
+        else
+        {
+          m_cYuvRecTemp.addClipPartLuma( &m_pcQTTempTComYuv[uiQTTempAccessLayer], pcPred, uiAbsPartIdx, 1<< uiLog2TrSize  );
+          uiNonzeroDistY = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPartIdx, m_cYuvRecTemp.getLumaAddr(uiAbsPartIdx), m_cYuvRecTemp.getStride(),
+            pcOrg->getLumaAddr( uiAbsPartIdx ), pcOrg->getStride(), 1<< uiLog2TrSize,   1<< uiLog2TrSize, false );
+        }
+      }
+      else
+      {
+        uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
+      }
+#else
+      const UInt uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
+#endif
       if (pcCU->isLosslessCoded(0))
+      {
 …
       else
+      {
+#if H_3D_VSO // M29
+        Double singleCostY;
+        if ( m_pcRdCost->getUseLambdaScaleVSO())
+          singleCostY = m_pcRdCost->calcRdCostVSO( uiSingleBitsY, uiNonzeroDistY );
+        else
+          singleCostY = m_pcRdCost->calcRdCost( uiSingleBitsY, uiNonzeroDistY );
+#else
         const Double singleCostY = m_pcRdCost->calcRdCost( uiSingleBitsY, uiNonzeroDistY );
+#endif
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA,     uiTrMode );
         const UInt uiNullBitsY   = m_pcEntropyCoder->getNumberOfWrittenBits();
+#if H_3D_VSO // M29
+        Double nullCostY;
+        if ( m_pcRdCost->getUseLambdaScaleVSO())
+          nullCostY   = m_pcRdCost->calcRdCostVSO( uiNullBitsY, uiDistY );
+        else
+          nullCostY   = m_pcRdCost->calcRdCost   ( uiNullBitsY, uiDistY );
+#else
         const Double nullCostY   = m_pcRdCost->calcRdCost( uiNullBitsY, uiDistY );
+#endif
         if( nullCostY < singleCostY )
+        {
 …
       m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA, uiTrMode );
       const UInt uiNullBitsY = m_pcEntropyCoder->getNumberOfWrittenBits();
+#if H_3D_VSO // M NEW01
+      if ( m_pcRdCost->getUseRenModel() )
+        minCostY = m_pcRdCost->calcRdCostVSO( uiNullBitsY, uiDistY );
+      else
+#endif
       minCostY = m_pcRdCost->calcRdCost( uiNullBitsY, uiDistY );
+    }
 …
     if( checkTransformSkipY )
+    {
+#if H_3D_VSO
+      Dist uiNonzeroDistY;
+      UInt uiAbsSumTransformSkipY;
+#else
       UInt uiNonzeroDistY, uiAbsSumTransformSkipY;
+#endif
       Double dSingleCostY;
 …
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType, true );
+        uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
+#if H_3D_VSO // M NEW
+        if ( m_pcRdCost->getUseVSO() )
+        {
+          if ( m_pcRdCost->getUseEstimatedVSD() )
+          {
+            uiNonzeroDistY = m_pcRdCost->getDistPartVSD( pcCU,  uiAbsPartIdx, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( uiAbsPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(), pcResi->getLumaAddr( uiAbsPartIdx ), pcResi->getStride(),  1<< uiLog2TrSize,    1<< uiLog2TrSize, false );
+          }
+          else
+          {
+            m_cYuvRecTemp.addClipPartLuma( &m_pcQTTempTComYuv[uiQTTempAccessLayer], pcPred, uiAbsPartIdx, 1<< uiLog2TrSize  );
+            uiNonzeroDistY = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPartIdx, m_cYuvRecTemp.getLumaAddr(uiAbsPartIdx), m_cYuvRecTemp.getStride(),
+              pcOrg->getLumaAddr( uiAbsPartIdx ), pcOrg->getStride(), 1<< uiLog2TrSize,   1<< uiLog2TrSize, false );
+          }
+        }
+        else
+#endif
+          uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
           pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth, trHeight );
+#if H_3D_VSO
+        if ( m_pcRdCost->getUseRenModel() )
+          dSingleCostY = m_pcRdCost->calcRdCostVSO( uiTsSingleBitsY, uiNonzeroDistY );
+        else
+#endif
         dSingleCostY = m_pcRdCost->calcRdCost( uiTsSingleBitsY, uiNonzeroDistY );
+      }
 …
     uiSingleDist = uiDistY + uiDistU + uiDistV;
+#if H_3D_VSO // M30
+    if ( m_pcRdCost->getUseLambdaScaleVSO())
+      dSingleCost = m_pcRdCost->calcRdCostVSO( uiSingleBits, uiSingleDist );
+    else
+#endif
     dSingleCost = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDist );
+  }
 …
       m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+    }
+#if H_3D_VSO
+    Dist uiSubdivDist = 0;
+#else
     UInt uiSubdivDist = 0;
+#endif
     UInt uiSubdivBits = 0;
     Double dSubdivCost = 0.0;
 …
+    {
       UInt nsAddr = uiAbsPartIdx + ui * uiQPartNumSubdiv;
+#if H_3D_VSO // M31
+      xEstimateResidualQT( pcCU, ui, uiAbsPartIdx + ui * uiQPartNumSubdiv, nsAddr, pcOrg, pcPred, pcResi, uiDepth + 1, dSubdivCost, uiSubdivBits, uiSubdivDist, bCheckFull ? NULL : puiZeroDist );
+#else
       xEstimateResidualQT( pcCU, ui, uiAbsPartIdx + ui * uiQPartNumSubdiv, nsAddr, pcResi, uiDepth + 1, dSubdivCost, uiSubdivBits, uiSubdivDist, bCheckFull ? NULL : puiZeroDist );
+#endif
+    }
 …
     uiSubdivBits = m_pcEntropyCoder->getNumberOfWrittenBits();
+#if H_3D_VSO // M32
+    if ( m_pcRdCost->getUseLambdaScaleVSO())
+      dSubdivCost  = m_pcRdCost->calcRdCostVSO( uiSubdivBits, uiSubdivDist );
+    else
+#endif
     dSubdivCost  = m_pcRdCost->calcRdCost( uiSubdivBits, uiSubdivDist );
 …
+    }
+  }
+#if H_3D_VSO // M33
+  if( m_pcRdCost->getUseRenModel() && !m_pcRdCost->getUseEstimatedVSD() )
+  {
+    UInt  uiWidth     = 1<< uiLog2TrSize;
+    UInt  uiHeight    = 1<< uiLog2TrSize;
+    Pel*  piSrc;
+    UInt  uiSrcStride;
+    if ( uiAbsSumY )
+    {
+      UInt  uiQTLayer   = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
+      m_cYuvRecTemp.addClipPartLuma( &m_pcQTTempTComYuv[uiQTLayer], pcPred, uiAbsPartIdx, 1<< uiLog2TrSize  );
+      piSrc       = m_cYuvRecTemp.getLumaAddr( uiAbsPartIdx );
+      uiSrcStride = m_cYuvRecTemp.getStride  ();
+    }
+    else
+    {
+      piSrc       = pcPred->getLumaAddr( uiAbsPartIdx );
+      uiSrcStride = pcPred->getStride  ();
+    }
+    m_pcRdCost->setRenModelData( pcCU, uiAbsPartIdx, piSrc, (Int) uiSrcStride, (Int) uiWidth, (Int) uiHeight );
+  }
+#endif
   rdCost += dSingleCost;
   ruiBits += uiSingleBits;

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSearch.h

-                      r324
+                      r446
   const UInt*     m_puiDFilter;
   Int             m_iMaxDeltaQP;
+#if H_3D_VSO // M17
+  TComYuv         m_cYuvRecTemp;
+#endif
   // AMVP cost computation
   // UInt            m_auiMVPIdxCost[AMVP_MAX_NUM_CANDS+1][AMVP_MAX_NUM_CANDS];
 …
                                     TComYuv*     pcPredYuv,
                                     TComYuv*     pcResiYuv,
+#if H_3D_VSO
+                                    Dist&        ruiDist,
+#else
                                     UInt&        ruiDist,
+#endif
                                     Int         default0Save1Load2 = 0);
   Void  xIntraCodingChromaBlk     ( TComDataCU*  pcCU,
 …
                                     TComYuv*     pcPredYuv,
                                     TComYuv*     pcResiYuv,
+#if H_3D_VSO
+                                    Dist&        ruiDistY,
+#else
                                     UInt&        ruiDistY,
+#endif
                                     UInt&        ruiDistC,
 #if HHI_RQT_INTRA_SPEEDUP
 …
   Void xEncodeResidualQT( TComDataCU* pcCU, UInt uiAbsPartIdx, const UInt uiDepth, Bool bSubdivAndCbf, TextType eType );
+#if H_3D_VSO // M26
+  Void xEstimateResidualQT( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx,TComYuv* pcOrg, TComYuv* pcPred, TComYuv* pcResi, const UInt uiDepth, Double &rdCost, UInt &ruiBits, Dist &ruiDist, Dist *puiZeroDist );
+#else
   Void xEstimateResidualQT( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx,TComYuv* pcResi, const UInt uiDepth, Double &rdCost, UInt &ruiBits, UInt &ruiDist, UInt *puiZeroDist );
+#endif
   Void xSetResidualQTData( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx,UInt absTUPartIdx, TComYuv* pcResi, UInt uiDepth, Bool bSpatial );

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSlice.cpp

-                      r438
+                      r446
   // store lambda
   m_pcRdCost ->setLambda( dLambda );
+#if H_3D_VSO
+  m_pcRdCost->setUseLambdaScaleVSO  ( (m_pcCfg->getUseVSO() ||  m_pcCfg->getForceLambdaScaleVSO()) && m_pcCfg->getIsDepth() );
+  m_pcRdCost->setLambdaVSO          ( dLambda * m_pcCfg->getLambdaScaleVSO() );
+  // Should be moved to TEncTop
+  // SAIT_VSO_EST_A0033
+  m_pcRdCost->setDisparityCoeff( m_pcCfg->getDispCoeff() );
+  // LGE_WVSO_A0119
+  if( m_pcCfg->getUseWVSO() && m_pcCfg->getIsDepth() )
+  {
+    m_pcRdCost->setDWeight  ( m_pcCfg->getDWeight()   );
+    m_pcRdCost->setVSOWeight( m_pcCfg->getVSOWeight() );
+    m_pcRdCost->setVSDWeight( m_pcCfg->getVSDWeight() );
+  }
+#endif
 #if WEIGHTED_CHROMA_DISTORTION
 // for RDO
 …
   eSliceType = (pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
 #endif
   rpcSlice->setSliceType        ( eSliceType );
 #endif
 …
 #endif
+#if L0386_DB_METRIC
+  if ( m_pcCfg->getDeblockingFilterMetric() )
+  {
+    rpcSlice->setDeblockingFilterOverrideFlag(true);
+    rpcSlice->setDeblockingFilterDisable(false);
+    rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
+    rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
+  } else
+#endif
   if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
+  {
 …
     Double dPicRdCost;
+#if H_3D_VSO
+    Dist64 uiPicDist        = m_uiPicDist;
+#else
     UInt64 uiPicDist        = m_uiPicDist;
+#endif
     UInt64 uiALFBits        = 0;
 …
     // compute RD cost and choose the best
     dPicRdCost = m_pcRdCost->calcRdCost64( m_uiPicTotalBits + uiALFBits, uiPicDist, true, DF_SSE_FRAME);
+#if H_3D
+    // Above calculation need to be fixed for VSO, including frameLambda value.
+#endif
     if ( dPicRdCost < dPicRdCostBest )
 …
+  }
   // for every CU in slice
+#if H_3D
+  Int iLastPosY = -1;
+#endif
   UInt uiEncCUOrder;
   for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();
 …
     TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
     pcCU->initCU( rpcPic, uiCUAddr );
+#if H_3D_VSO
+    if ( m_pcRdCost->getUseRenModel() )
+    {
+      // updated renderer model if necessary
+      Int iCurPosX;
+      Int iCurPosY;
+      pcCU->getPosInPic(0, iCurPosX, iCurPosY );
+      if ( iCurPosY != iLastPosY )
+      {
+        iLastPosY = iCurPosY;
+        pcEncTop->setupRenModel( pcSlice->getPOC() , pcSlice->getViewIndex(), pcSlice->getIsDepth() ? 1 : 0, iCurPosY );
+      }
+    }
+#endif
 #if !RATE_CONTROL_LAMBDA_DOMAIN
     if(m_pcCfg->getUseRateCtrl())
 …
  \retval rpcBitstream  bitstream class
  */
 Void TEncSlice::encodeSlice   ( TComPic*& rpcPic, TComOutputBitstream* pcBitstream, TComOutputBitstream* pcSubstreams )
+Void TEncSlice::encodeSlice   ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams )
+{
   UInt       uiCUAddr;
 …
+      }
+      {
+          UInt uiCounter = 0;
+          vector<uint8_t>& rbsp   = pcSubstreams[uiSubStrm].getFIFO();
+          for (vector<uint8_t>::iterator it = rbsp.begin(); it != rbsp.end();)
+          {
+            /* 1) find the next emulated 00 00 {00,01,02,03}
+             * 2a) if not found, write all remaining bytes out, stop.
+             * 2b) otherwise, write all non-emulated bytes out
+             * 3) insert emulation_prevention_three_byte
+             */
+            vector<uint8_t>::iterator found = it;
+            do
+            {
+              /* NB, end()-1, prevents finding a trailing two byte sequence */
+              found = search_n(found, rbsp.end()-1, 2, 0);
+              found++;
+              /* if not found, found == end, otherwise found = second zero byte */
+              if (found == rbsp.end())
+              {
+                break;
+              }
+              if (*(++found) <= 3)
+              {
+                break;
+              }
+            } while (true);
+            it = found;
+            if (found != rbsp.end())
+            {
+              it++;
+              uiCounter++;
+            }
+          }
+        UInt numStartCodeEmulations = pcSubstreams[uiSubStrm].countStartCodeEmulations();
         UInt uiAccumulatedSubstreamLength = 0;
         for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
 …
         // add bits coded in previous dependent slices + bits coded so far
         // add number of emulation prevention byte count in the tile
         pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + uiCounter );
+        pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + numStartCodeEmulations );
+      }
+    }

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncSlice.h

-                      r438
+                      r446
   TEncSbac*               m_pcRDGoOnSbacCoder;                  ///< go-on SBAC encoder
   UInt64                  m_uiPicTotalBits;                     ///< total bits for the picture
+#if H_3D_VSO
+  Dist64                  m_uiPicDist;                          ///< total distortion for the picture
+#else
   UInt64                  m_uiPicDist;                          ///< total distortion for the picture
+#endif
   Double                  m_dPicRdCost;                         ///< picture-level RD cost
   Double*                 m_pdRdPicLambda;                      ///< array of lambda candidates
 …
   Void    precompressSlice    ( TComPic*& rpcPic                                );      ///< precompress slice for multi-loop opt.
   Void    compressSlice       ( TComPic*& rpcPic                                );      ///< analysis stage of slice
   Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* rpcBitstream, TComOutputBitstream* pcSubstreams  );
+  Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams  );
   // misc. functions

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncTop.cpp

-                      r438
+                      r446
   m_pcBitCounters          = NULL;
   m_pcRdCosts              = NULL;
 #if H_MV
   m_ivPicLists = NULL;
 …
 Void TEncTop::create ()
+{
 #if !H_MV
   // initialize global variables
 …
 Void TEncTop::init()
+{
   // initialize SPS
   xInitSPS();
 …
     m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
+  }
+}
+#endif
+#if H_MV
+  pcPicCurr->setLayerId( getLayerId());
+#endif
+#if H_3D
+  pcPicCurr->setScaleOffset( m_aaiCodedScale, m_aaiCodedOffset );
+#endif
+}
+#endif
 Void TEncTop::deletePicBuffer()
+{
 …
  \retval  iNumEncoded         number of encoded pictures
  */
-Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded
 #if H_MV
+                     , Int gopId
+#endif
+                     )
+{
+Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded , Int gopId )
+{
+#else
+Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
+{
+#endif
 #if H_3D
   TComPic* picLastCoded = getPic( getGOPEncoder()->getPocLastCoded() );
 …
+  }
 #endif
 #if H_MV
   if( gopId == 0)
 …
   m_iNumPicRcvd       = 0;
   m_uiNumAllPicCoded += iNumEncoded;
 #if H_MV
+}
 #endif
+}
 …
   m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
   m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
+  m_cSPS.setMinTrDepth    ( 0                   );
+  m_cSPS.setMaxTrDepth    ( 1                   );
+  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
+  Int log2MinCUSize = 0;
+  while(minCUSize > 1)
+  {
+    minCUSize >>= 1;
+    log2MinCUSize++;
+  }
+  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
+  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
   m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
 …
   m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
+#if !L0034_COMBINED_LIST_CLEANUP
   m_cSPS.setUseLComb    ( m_bUseLComb           );
+#endif
   Int i;
 …
     pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
+  }
+#if H_3D
+  if ( !m_isDepth )
+  {
+    m_cSPS.initCamParaSPS           ( m_viewIndex, m_uiCamParPrecision, m_bCamParInSliceHeader, m_aaiCodedScale, m_aaiCodedOffset );
+  }
+#endif
+}
 …
   m_cPPS.setOutputFlagPresentFlag( false );
   m_cPPS.setSignHideFlag(getSignHideFlag());
+#if L0386_DB_METRIC
+  if ( getDeblockingFilterMetric() )
+  {
+    m_cPPS.setDeblockingFilterControlPresentFlag (true);
+    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
+    m_cPPS.setPicDisableDeblockingFilterFlag(false);
+    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
+    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
+  }
+  else
+  {
   m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
+  }
+#else
+  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
+#endif
   m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
   m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
 …
+    }
+  }
+#if H_3D
+  if( m_cSPS.hasCamParInSliceHeader() )
+  {
+    m_cPPS.setSliceHeaderExtensionPresentFlag( true );
+  }
+#endif
+}
 …
+  }
 #endif
+}
+}
+#if L0208_SOP_DESCRIPTION_SEI
+Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
+{
+  int rpsIdx = GOPid;
+  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
+  {
+    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
+    {
+      Int POCIndex = POCCurr%m_uiIntraPeriod;
+      if(POCIndex == 0)
+      {
+        POCIndex = m_uiIntraPeriod;
+      }
+      if(POCIndex == m_GOPList[extraNum].m_POC)
+      {
+        rpsIdx = extraNum;
+      }
+    }
+    else
+    {
+      if(POCCurr==m_GOPList[extraNum].m_POC)
+      {
+        rpsIdx = extraNum;
+      }
+    }
+  }
+  return rpsIdx;
+}
+#endif
 Void  TEncTop::xInitPPSforTiles()
 …
+  }
+}
 #if H_MV
 Void TEncTop::printSummary( Int numAllPicCoded )
 …
 #endif
+#if H_3D_VSO
+Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
+{
+  TRenModel* rendererModel = m_cRdCost.getRenModel();
+  rendererModel->setupPart( iHorOffset, std::min( (Int) g_uiMaxCUHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ;
+  Int iEncViewSIdx = m_cameraParameters->getBaseId2SortedId()[ iEncViewIdx ];
+  // setup base views
+  Int iNumOfBV = m_renderModelParameters->getNumOfBaseViewsForView( iEncViewSIdx, iEncContent );
+  for (Int iCurView = 0; iCurView < iNumOfBV; iCurView++ )
+  {
+    Int iBaseViewSIdx;
+    Int iVideoDistMode;
+    Int iDepthDistMode;
+    m_renderModelParameters->getBaseViewData( iEncViewSIdx, iEncContent, iCurView, iBaseViewSIdx, iVideoDistMode, iDepthDistMode );
+    AOT( iVideoDistMode < 0 || iVideoDistMode > 2 );
+    Int iBaseViewIdx = m_cameraParameters->getBaseSortedId2Id()[ iBaseViewSIdx ];
+    TComPicYuv* pcPicYuvVideoRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, true  );
+    TComPicYuv* pcPicYuvDepthRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, true  );
+    TComPicYuv* pcPicYuvVideoOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, false );
+    TComPicYuv* pcPicYuvDepthOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, false );
+    TComPicYuv* pcPicYuvVideoRef  = ( iVideoDistMode == 2 ) ? pcPicYuvVideoOrg  : NULL;
+    TComPicYuv* pcPicYuvDepthRef  = ( iDepthDistMode == 2 ) ? pcPicYuvDepthOrg  : NULL;
+    TComPicYuv* pcPicYuvVideoTest = ( iVideoDistMode == 0 ) ? pcPicYuvVideoOrg  : pcPicYuvVideoRec;
+    TComPicYuv* pcPicYuvDepthTest = ( iDepthDistMode == 0 ) ? pcPicYuvDepthOrg  : pcPicYuvDepthRec;
+    AOT( (iVideoDistMode == 2) != (pcPicYuvVideoRef != NULL) );
+    AOT( (iDepthDistMode == 2) != (pcPicYuvDepthRef != NULL) );
+    AOT( pcPicYuvDepthTest == NULL );
+    AOT( pcPicYuvVideoTest == NULL );
+    rendererModel->setBaseView( iBaseViewSIdx, pcPicYuvVideoTest, pcPicYuvDepthTest, pcPicYuvVideoRef, pcPicYuvDepthRef );
+  }
+  rendererModel->setErrorMode( iEncViewSIdx, iEncContent, 0 );
+  // setup virtual views
+  Int iNumOfSV  = m_renderModelParameters->getNumOfModelsForView( iEncViewSIdx, iEncContent );
+  for (Int iCurView = 0; iCurView < iNumOfSV; iCurView++ )
+  {
+    Int iOrgRefBaseViewSIdx;
+    Int iLeftBaseViewSIdx;
+    Int iRightBaseViewSIdx;
+    Int iSynthViewRelNum;
+    Int iModelNum;
+    Int iBlendMode;
+    m_renderModelParameters->getSingleModelData(iEncViewSIdx, iEncContent, iCurView, iModelNum, iBlendMode,iLeftBaseViewSIdx, iRightBaseViewSIdx, iOrgRefBaseViewSIdx, iSynthViewRelNum );
+    Int iLeftBaseViewIdx    = -1;
+    Int iRightBaseViewIdx   = -1;
+    TComPicYuv* pcPicYuvOrgRef  = NULL;
+    Int**      ppiShiftLUTLeft  = NULL;
+    Int**      ppiShiftLUTRight = NULL;
+    Int**      ppiBaseShiftLUTLeft  = NULL;
+    Int**      ppiBaseShiftLUTRight = NULL;
+    Int        iDistToLeft      = -1;
+    Int iSynthViewIdx = m_cameraParameters->synthRelNum2Idx( iSynthViewRelNum );
+    if ( iLeftBaseViewSIdx != -1 )
+    {
+      iLeftBaseViewIdx   = m_cameraParameters->getBaseSortedId2Id()   [ iLeftBaseViewSIdx ];
+      ppiShiftLUTLeft    = m_cameraParameters->getSynthViewShiftLUTI()[ iLeftBaseViewIdx  ][ iSynthViewIdx  ];
+    }
+    if ( iRightBaseViewSIdx != -1 )
+    {
+      iRightBaseViewIdx  = m_cameraParameters->getBaseSortedId2Id()   [iRightBaseViewSIdx ];
+      ppiShiftLUTRight   = m_cameraParameters->getSynthViewShiftLUTI()[ iRightBaseViewIdx ][ iSynthViewIdx ];
+    }
+    if ( iRightBaseViewSIdx != -1 && iLeftBaseViewSIdx != -1 )
+    {
+      iDistToLeft          = m_cameraParameters->getRelDistLeft(  iSynthViewIdx , iLeftBaseViewIdx, iRightBaseViewIdx);
+      ppiBaseShiftLUTLeft  = m_cameraParameters->getBaseViewShiftLUTI() [ iLeftBaseViewIdx  ][ iRightBaseViewIdx ];
+      ppiBaseShiftLUTRight = m_cameraParameters->getBaseViewShiftLUTI() [ iRightBaseViewIdx ][ iLeftBaseViewIdx  ];
+    }
+    if ( iOrgRefBaseViewSIdx != -1 )
+    {
+      pcPicYuvOrgRef = m_ivPicLists->getPicYuv(  m_cameraParameters->getBaseSortedId2Id()[ iOrgRefBaseViewSIdx ] , false, iPoc, false );
+      AOF ( pcPicYuvOrgRef );
+    }
+    rendererModel->setSingleModel( iModelNum, ppiShiftLUTLeft, ppiBaseShiftLUTLeft, ppiShiftLUTRight, ppiBaseShiftLUTRight, iDistToLeft, pcPicYuvOrgRef );
+  }
+}
+#endif
 //! \}

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/TEncTop.h

-                      r438
+                      r446
 // Class definition
 // ====================================================================================================================
 /// encoder class
 …
   TEncAnalyze             m_cAnalyzeB;
 #endif
 protected:
   Void  xGetNewPicBuffer  ( TComPic*& rpcPic );           ///< get picture buffer which will be processed
 …
   Void      create          ();
   Void      destroy         ();
   Void      init            ();
 #if H_MV
   TComPicLists* getIvPicLists() { return m_ivPicLists; }
 #endif
   Void      deletePicBuffer ();
 …
   Void      initNewPic(TComPicYuv* pcPicYuvOrg);
 #endif
   // -------------------------------------------------------------------------------------------------------------------
   // member access functions
 …
   TComPPS*                getPPS                () { return  &m_cPPS;                 }
   Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid );
+#if L0208_SOP_DESCRIPTION_SEI
+  Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid );
+#endif
   TComScalingList*        getScalingList        () { return  &m_scalingList;         }
 #if H_MV
   TEncAnalyze*            getAnalyzeAll         () { return &m_cAnalyzeAll; }
 …
   Void                    setIvPicLists         ( TComPicLists* picLists) { m_ivPicLists = picLists; }
 #endif
   // -------------------------------------------------------------------------------------------------------------------
   // encoder function
 …
   /// encode several number of pictures until end-of-sequence
+#if H_MV
+  Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded  , Int gopId  );
+#else
   Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut,
+              std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded
+#if H_MV
+              , Int gopId
+#endif
+              );
+#if H_MV
+  void printSummary      ( Int numAllPicCoded );
+              std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded );
+#endif
+#if H_MV
+  Void printSummary      ( Int numAllPicCoded );
 #else
+  void printSummary() { m_cGOPEncoder.printOutSummary (m_uiNumAllPicCoded); }
+#endif
+  void printSummary() { m_cGOPEncoder.printOutSummary (m_uiNumAllPicCoded); }
+#endif
+#if H_3D
+   Void setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset );
+#endif
 };

branches/HTM-DEV-0.2-dev/source/Lib/TLibEncoder/WeightPredAnalysis.cpp

-                      r438
+                      r446
         Int offset = (Int)( ((currDC<<log2Denom) - ((Int64)weight * refDC) + (Int64)realOffset) >> realLog2Denom );
         // Chroma offset range limination
+        // Chroma offset range limitation
         if(comp)
+        {
+          Int shift = 1 << (g_bitDepthC - 1);
+          Int pred = ( shift - ( ( shift*weight)>>(log2Denom) ) );
+          Int pred = ( 128 - ( ( 128*weight)>>(log2Denom) ) );
           Int deltaOffset = Clip3( -512, 511, (offset - pred) );    // signed 10bit
           offset = Clip3( -128, 127, (deltaOffset + pred) );        // signed 8bit
+        }
+        // Luma offset range limitation
+        else
+        {
+          offset = Clip3( -128, 127, offset);
+        }

branches/HTM-DEV-0.2-dev/source/Lib/TLibExtractor/TExtrTop.cpp

-                      r438
+                      r446
 #include "TExtrTop.h"
+#if H_MV
 TExtrTop::TExtrTop()
+{
 …
 Bool TExtrTop::extract( InputNALUnit& nalu, std::set<UInt>& rsuiExtractLayerIds )
+{
-#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   //extraction now has to be done using layer_id
+  UInt uiLayerId = nalu.m_layerId;
+#else
+  UInt uiLayerId = xGetLayerId( nalu.m_viewId, nalu.m_isDepth );
+#endif
+  UInt uiLayerId      = nalu.m_layerId;
   // Initialize entropy decoder
   m_cEntropyDecoder.setEntropyDecoder( &m_cCavlcDecoder );
   m_cEntropyDecoder.setBitstream     ( nalu.m_Bitstream );
-#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   if ( nalu.m_nalUnitType == NAL_UNIT_VPS )
+  {
     // a hack for now assuming there's only one VPS in the bitstream
+    m_cEntropyDecoder.decodeVPS( &m_cVPS );
+    m_cEntropyDecoder.decodeVPS( &m_cVPS );
+  }
-#endif
   if ( nalu.m_nalUnitType == NAL_UNIT_SPS )
+  {
+     TComSPS cSPS;
+     TComRPSList cRPS;
+     cSPS.setRPSList( &cRPS );
+#if HHI_MPI || H3D_QTL
+#if VIDYO_VPS_INTEGRATION
+     m_cEntropyDecoder.decodeSPS( &cSPS, m_cVPS.getDepthFlag(uiLayerId) );
+     TComSPS     cSPS;
+#if H_3D
+     Int layerIdInVPS = m_cVPS.getLayerIdInVps( uiLayerId );
+     m_cEntropyDecoder   .decodeSPS( &cSPS, m_cVPS.getViewIndex( layerIdInVPS ), ( m_cVPS.getDepthId( layerIdInVPS ) == 1 ) );
 #else
      m_cEntropyDecoder.decodeSPS( &cSPS, nalu.m_isDepth );
+     m_cEntropyDecoder   .decodeSPS( &cSPS );
 #endif
+#else
+     m_cEntropyDecoder.decodeSPS( &cSPS );
+#endif
+     m_acSPSBuffer.push_back( cSPS );
+     m_acSPSBuffer       .push_back( cSPS );
+  }
 …
 Void TExtrTop::dumpSpsInfo( std::ostream& rcSpsInfoHandle )
+{
+{
   rcSpsInfoHandle << "NumSPS = " << m_acSPSBuffer.size() << std::endl;
+  std::list<Int>::iterator iterSPSLayerId = m_aiSPSLayerIdBuffer.begin();
+  for( std::list<TComSPS>::iterator iterSPS = m_acSPSBuffer.begin(); iterSPS != m_acSPSBuffer.end(); iterSPS++ )
+  {
+     rcSpsInfoHandle << std::endl;
+     rcSpsInfoHandle << "layer_id = "              << xGetLayerId( iterSPS->getViewId(), iterSPS->isDepth() ) << std::endl;
+  for( std::list<TComSPS>::iterator iterSPS = m_acSPSBuffer.begin(); iterSPS != m_acSPSBuffer.end(); iterSPS++, iterSPSLayerId++ )
+  {
+     rcSpsInfoHandle << "layer_id = "              << *iterSPSLayerId << std::endl;
      rcSpsInfoHandle << "seq_parameter_set_id = "  << iterSPS->getSPSId() << std::endl;
-     rcSpsInfoHandle << "view_id = "               << iterSPS->getViewId() << std::endl;
-     rcSpsInfoHandle << "view_order_idx = "        << iterSPS->getViewOrderIdx() << std::endl;
-     rcSpsInfoHandle << "is_depth = "              << iterSPS->isDepth() << std::endl;
+  }
+}
+Void TExtrTop::dumpVpsInfo( std::ostream& rcVpsInfoHandle )
+{
+  rcVpsInfoHandle << "MaxLayers = "     << m_cVPS.getMaxLayers()     << std::endl;
+  rcVpsInfoHandle << "MaxNuhLayerId = " << m_cVPS.getMaxNuhLayerId() << std::endl;
+  for ( Int layerIdxInVps = 0; layerIdxInVps < m_cVPS.getMaxLayers(); layerIdxInVps++ )
+  {
+    rcVpsInfoHandle << "LayerIdxInVps =  " << layerIdxInVps                           << std::endl;
+    rcVpsInfoHandle << "LayerIdInNuh = "   << m_cVPS.getLayerIdInNuh( layerIdxInVps ) << std::endl;
+    rcVpsInfoHandle << "ViewId = "         << m_cVPS.getViewId      ( layerIdxInVps ) << std::endl;
+#if H_3D
+    rcVpsInfoHandle << "DepthFlag = "      << m_cVPS.getViewIndex   ( layerIdxInVps ) << std::endl;
+    rcVpsInfoHandle << "DepthFlag = "      << m_cVPS.getDepthId     ( layerIdxInVps ) << std::endl;
+#endif
+  }
+}
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibExtractor/TExtrTop.h

-                      r438
+                      r446
 #include <set>
+#if H_MV
 // ====================================================================================================================
 // Class definition
 …
+{
 private:
+#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
   TComVPS                 m_cVPS;
+#endif
    std::list<TComSPS>      m_acSPSBuffer;
+  std::list<TComSPS>      m_acSPSBuffer;
+  std::list<Int    >      m_aiSPSLayerIdBuffer;
   // functional classes
 …
   Bool     extract( InputNALUnit& nalu, std::set<UInt>& rsuiExtractLayerIds );
   Void     dumpSpsInfo( std::ostream& rcSpsInfoHandle );
+  Void     dumpVpsInfo( std::ostream& rcVpsInfoHandle );
   TComSPS *getFirstSPS() { return m_acSPSBuffer.empty() ? 0 : &(m_acSPSBuffer.front()); }
 protected:
+   UInt     xGetLayerId( UInt uiViewId, Bool bIsDepth ) { return ( ( uiViewId << 1 ) + ( bIsDepth ? 1 : 0 ) ); }
 };// END CLASS DEFINITION TExtrTop
 #endif // __TEXTRTOP__
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenFilter.cpp

-                      r438
+                      r446
 #include "TRenFilter.h"
 #include "TRenInterpFilter.h"
+#if H_3D
 ///// COMMON /////
 …
+  }
   // Set Threshold
   riBlendZThres  = ( Max( abs(piInvZLUTLeft[0]- piInvZLUTLeft[255]), abs(piInvZLUTRight[0]- piInvZLUTRight[255]) ) * iBlendZThresPerc + 50)  / 100;
+  riBlendZThres  = ( std::max( abs(piInvZLUTLeft[0]- piInvZLUTLeft[255]), abs(piInvZLUTRight[0]- piInvZLUTRight[255]) ) * iBlendZThresPerc + 50)  / 100;
+}
 …
 /////////// Comparison ///////////
 Int64 TRenFilter::SSE   (PelImagePlane* pcInputPlane1, PelImagePlane* pcInputPlane2   )
+Int64 TRenFilter::SSE   (PelImagePlane* pcInputPlane1, PelImagePlane* pcInputPlane2, Bool bLuma )
+{
   UInt uiWidth     = pcInputPlane1->getWidth();
 …
   Pel* pucImData2  = pcInputPlane2->getPlaneData();
   return SSE( pucImData1, (Int) uiStride1, (Int) uiWidth, (Int) uiHeight, pucImData2, (Int) uiStride2 );
+}
 Int64 TRenFilter::SSE( Pel* piSrc1, Int iSrcStride1, Int iWidth, Int iHeight,  Pel* piSrc2, Int iSrcStride2 )
+  return SSE( pucImData1, (Int) uiStride1, (Int) uiWidth, (Int) uiHeight, pucImData2, (Int) uiStride2, bLuma );
+}
+Int64 TRenFilter::SSE( Pel* piSrc1, Int iSrcStride1, Int iWidth, Int iHeight,  Pel* piSrc2, Int iSrcStride2, Bool bLuma )
+{
   Int64 iSSE = 0;
+  Int iShift = g_uiBitIncrement << 1;
+  Int iShift = DISTORTION_PRECISION_ADJUSTMENT( ( bLuma ? g_bitDepthY : g_bitDepthC ) - 8 ) << 1 ;
   for(Int iPosY = 0; iPosY < iHeight; iPosY++)
+  {
 …
 inline Void TRenFilter::sampleUp2Tap13(PelImage* pcInputImage, PelImage* pcOutputImage)
+{// UpSampling from JSVM Software (DownConvertStatic) ???
+{ // UpSampling from JSVM Software (DownConvertStatic) ???
+  AOF( g_bitDepthC == g_bitDepthY );
   UInt uiNumPlanes = pcInputImage->getNumberOfPlanes();
 …
+      {
         // Scale and copy to image buffer.
         pcOutputPlaneData[iOffset+i] = max(min((Pel) ((piDst[i] + iAddH) / iDivH), g_uiBASE_MAX ),0);
+        pcOutputPlaneData[iOffset+i] = ClipY((Pel) ((piDst[i] + iAddH) / iDivH));
+      }
+    }
 …
 Void TRenFilter::sampleDown2Tap13( Pel* pcInputPlaneData, Int iInputStride, Int iWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride  )
 { // DownSampling from JSVM Software (DownConvertStatic) ??
+  AOF( g_bitDepthC == g_bitDepthY );
   Int iOffset, iPosX, iPosY, k;
   Int* piDataHorDown = new Int[(Int)(iWidth * iHeight / 2)];
 …
+    {
       // Scale and copy back to image buffer.
       pcOutputPlaneData[iOutputStride*iPosY+iPosX] = max(min( ( Pel) ( (piDst[iPosY] + iAddV) / iDivV), g_uiBASE_MAX ),0);
+      pcOutputPlaneData[iOutputStride*iPosY+iPosX] = ClipY( ( Pel) ( (piDst[iPosY] + iAddV) / iDivV));
+    }
+  }
 …
 Void TRenFilter::sampleVerDown2Tap13( PelImagePlane* pcInputPlane, PelImagePlane* pcOutputPlane, Int uiPad)
+{ // DownSampling from JSVM Software (DownConvertStatic) ??
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
+  // DownSampling from JSVM Software (DownConvertStatic) ??
   Int iWidth       = pcInputPlane->getWidth();
   Int iHeight      = pcInputPlane->getHeight();
 …
       Int iSum = iTmp4 + iTmp3 - iTmp2 + ((iTmp0 + iTmp4 + iTmp5 - iTmp2) << 1) + ( ( iTmp3 - iTmp1)  << 2) + (  iTmp5 << 3 ) + (( iTmp4 + iTmp5 ) << 4);
       pcOutputPlaneData[ iXPos ] = (Pel) Clip((iSum + 32) >> 6);
+      pcOutputPlaneData[ iXPos ] = (Pel) ClipY((iSum + 32) >> 6);
       pcTmpIn++;
+    }
 …
 Void TRenFilter::sampleHorDown2Tap13( PelImagePlane* pcInputPlane, PelImagePlane* pcOutputPlane, Int uiPad )
+{ // DownSampling from JSVM Software (DownConvertStatic) ??
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
+  // DownSampling from JSVM Software (DownConvertStatic) ??
   Int iWidth       = pcInputPlane->getWidth();
   Int iHeight      = pcInputPlane->getHeight();
 …
       Int iSum = iTmp4 + iTmp3 - iTmp2 + ((iTmp0 + iTmp4 + iTmp5 - iTmp2) << 1) + ( ( iTmp3 - iTmp1)  << 2) + (  iTmp5 << 3 ) + (( iTmp4 + iTmp5 ) << 4);
       pcOutputPlaneData[ iXPos ] = (Pel) Clip((iSum + 32) >> 6);
+      pcOutputPlaneData[ iXPos ] = (Pel) ClipY((iSum + 32) >> 6);
       pcTmpIn += 2;
+    }
 …
   UInt uiPlane;
   for (uiPlane = 0; uiPlane < pcInputImage->getNumberOfFullPlanes(); uiPlane ++)
+  for (uiPlane = 0; uiPlane < pcInputImage->getNumberOfPlanes(); uiPlane ++)
+  {
     binominal( pcInputImage->getPlane(uiPlane), pcOutputImage->getPlane(uiPlane), uiSize );
 …
 Pel TRenFilter::xFiltBinom3( Pel* pcInputData, Int iStride )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int iSum = pcInputData[-1 * iStride ] + pcInputData[ 0 ] +  (pcInputData[iStride ] << 1 );
   return Clip( (iSum +  2) >>  2 );
+  return ClipY( (iSum +  2) >>  2 );
+}
 Pel TRenFilter::xFiltBinom5( Pel* pcInputData, Int iStride )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   // { 1,4,6,4,1 }
   Int iStride0  = 0;
 …
   Int iSum = iTmp0 +  (iTmp2 << 1) + ((iTmp1 + iTmp2) << 2);
   return Clip( (iSum +  8) >>  4 );
+  return ClipY( (iSum +  8) >>  4 );
+}
 Pel TRenFilter::xFiltBinom7( Pel* pcInputData, Int iStride )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   // { 1,6,15,20,15,6,1 }
   Int iStride0  = 0;
 …
   Int iSum = iTmp0 - iTmp2 + ( iTmp1  << 1) + ( (iTmp1 + iTmp3) << 2) + ((iTmp2 + iTmp3) << 4);
   return Clip( (iSum +  32) >>  6 );
+  return ClipY( (iSum +  32) >>  6 );
+}
 Pel TRenFilter::xFiltBinom9( Pel* pcInputData, Int iStride )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   // {  1     8    28    56    70    56    28     8     1 }
   Int iStride0  = 0;
 …
   Int iSum = iTmp0 + ((iTmp4 ) << 1) + ( ( iTmp4 - iTmp2 ) << 2) +  ( (iTmp1 - iTmp3) << 3 ) +  ((iTmp2 ) << 5) + ((iTmp3+ iTmp4 ) << 6);
   return Clip( (iSum +  128) >>  8 );
+  return ClipY( (iSum +  128) >>  8 );
+}
 …
 Void TRenFilter::diffHorSym(PelImagePlane* pcInputPlane, IntImagePlane* pcOutputPlane)
+{
   UInt uiInputStride  = pcInputPlane ->getStride();
+  UInt uiInputStride = pcInputPlane ->getStride();
   UInt uiOutputStride = pcOutputPlane->getStride();
   UInt uiWidth        = pcInputPlane ->getWidth();
   UInt uiHeight       = pcInputPlane ->getHeight();
   Pel*   pcInputData  = pcInputPlane ->getPlaneData();
   Int*   piOutputData = pcOutputPlane->getPlaneData();
+  Pel*   pcInputData   = pcInputPlane ->getPlaneData();
+  Int*   piOutputData  = pcOutputPlane->getPlaneData();
   for (UInt uiPosY = 0; uiPosY < uiHeight; uiPosY++)
 …
     };
     piOutputData[0]         = piOutputData[1];
+    piOutputData[0] = piOutputData[1];
     piOutputData[uiWidth-1] = piOutputData[uiWidth-2];
+    pcInputData            += uiInputStride;
+    piOutputData           += uiOutputStride;
+    pcInputData += uiInputStride;
+    piOutputData  += uiOutputStride;
   };
+}
 …
 Void TRenFilter::xInterpHorChroma( Pel* piSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* piDst, Int iDstStride, Int iDstStepX, Int iDstStepY, FpChromaIntFilt fpFilter )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
+    {
       iSum      = (cFilter.*fpFilter)( piSrcTmp,  iSrcStepX );
       piDst[x * iDstStepX ] =  Clip ((iSum +  32) >>  6 );
+      piDst[x * iDstStepX ] =  ClipC ((iSum +  32) >>  6 );
       piSrcTmp+= iSrcStepX;
+    }
 …
 Void TRenFilter::xInterpVerChroma( Pel* piSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* piDst, Int iDstStride, Int iDstStepX, Int iDstStepY, FpChromaIntFilt fpFilter )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
+    {
       iSum      = (cFilter.*fpFilter)( piSrcTmp,  iSrcStepY * iSrcStride );
       piDst[x * iDstStepX ]  =  Clip ((iSum +  32) >>  6 );
+      piDst[x * iDstStepX ]  =  ClipC ((iSum +  32) >>  6 );
       piSrcTmp += iSrcStepX;
+    }
 …
 Void TRenFilter::xSampleDownHor2( Pel* piSrc, Int iSrcStride, Int iSrcWidth, Int iHeight, Pel* piDst, Int iDstStride  )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
       // { 1,2,1 }
       iSum = piSrcTmp[0] + piSrcTmp[2] +  (piSrcTmp[1] << 1);
       piDst[x] = Clip( (iSum +  2) >>  2 );
+      piDst[x] = ClipY( (iSum +  2) >>  2 );
       piSrcTmp += 2;
+    }
 …
 Void TRenFilter::xSampleDownVer2( Pel* piSrc, Int iSrcStride, Int iSrcWidth, Int iSrcHeight, Pel* piDst, Int iDstStride  )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
       // { 1,2,1 }
       iSum = piSrcTmp[0] + piSrcTmp[ iSrcStride << 1] +  (piSrcTmp[ iSrcStride ] << 1);
       piDst[x] = Clip( (iSum +  2) >>  2 );
+      piDst[x] = ClipY( (iSum +  2) >>  2 );
       piSrcTmp += 1;
+    }
 …
 Void TRenFilter::xSampleDownHor4( Pel* piSrc, Int iSrcStride, Int iSrcWidth, Int iHeight, Pel* piDst, Int iDstStride  )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
       iSum = iTmp0 +  (iTmp2 << 1) + ((iTmp1 + iTmp2) << 2);
       piDst[x] = Clip( (iSum +  8) >>  4 );
+      piDst[x] = ClipY( (iSum +  8) >>  4 );
       piSrcTmp += 4;
+    }
 …
 Void TRenFilter::xSampleDownHor8( Pel* piSrc, Int iSrcStride, Int iSrcWidth, Int iHeight, Pel* piDst, Int iDstStride  )
+{
+  assert( g_bitDepthY == g_bitDepthC); // ToDo: Update renderer to work with different luma/chroma bit depth
   Int   iSum;
   Pel*  piSrcTmp;
 …
       iSum = iTmp0 - iTmp2 + ( iTmp1  << 1) + ( (iTmp1 + iTmp3) << 2) + ((iTmp2 + iTmp3) << 4);
       piDst[x] = Clip( (iSum +  32) >>  6 );
+      piDst[x] = ClipY( (iSum +  32) >>  6 );
       piSrcTmp += 8;
+    }
 …
 template Void TRenFilter::mirrorHor(        TRenImage<Int>           *pcImage );
 template Void TRenFilter::mirrorHor(        TRenImagePlane<Pel>      *pcImagePlane );
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenFilter.h

-                      r438
+                      r446
 #ifndef __TRENFILTER__
 #define __TRENFILTER__
 …
 #include "TRenImage.h"
 #include "TRenInterpFilter.h"
+#if H_3D
 typedef Int (TRenInterpFilter::*FpChromaIntFilt) ( Pel*, Int );
 …
   /////////// Comparison ///////////
   static Int64                          SSE  ( PelImagePlane*     pcInputPlane1, PelImagePlane*      pcInputPlane2 );
   static Int64                          SSE  ( Pel* piSrc1,       Int iSrcStride1, Int iWidth, Int iHeight,  Pel* piSrc2, Int iSrcStride2 );
+  static Int64                          SSE  ( PelImagePlane*     pcInputPlane1, PelImagePlane*      pcInputPlane2, Bool bLuma );
+  static Int64                          SSE  ( Pel* piSrc1,       Int iSrcStride1, Int iWidth, Int iHeight,  Pel* piSrc2, Int iSrcStride2, Bool bLuma );
   template <typename T> static Bool compare  (TRenImage<T> *pcInputImage1     , TRenImage<T> *pcInputImage2);
 …
 };
+#endif
 #endif //__TRENFILTER__

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenImage.cpp

-                      r438
+                      r446
 #include "TRenFilter.h"
 #include "assert.h"
+#if H_3D
 template<typename T>
 …
     m_uiNumberOfQuaterPlanes = 0;
     m_apcPlanes    = new TRenImagePlane<Pel>*[ m_uiNumberOfPlanes ];
     m_apcPlanes[0] = new TRenImagePlane<Pel>( pcPicYuv->getBufY(), pcPicYuv->getWidth() + (REN_LUMA_MARGIN << 1),   pcPicYuv->getHeight()+ (REN_LUMA_MARGIN << 1), pcPicYuv->getStride (), REN_LUMA_MARGIN, g_uiPCMBitDepthLuma );
+    m_apcPlanes[0] = new TRenImagePlane<Pel>( pcPicYuv->getBufY(), pcPicYuv->getWidth() + (REN_LUMA_MARGIN << 1),   pcPicYuv->getHeight()+ (REN_LUMA_MARGIN << 1), pcPicYuv->getStride (), REN_LUMA_MARGIN );
+  }
   else //420
 …
     m_apcPlanes    = new TRenImagePlane<Pel>*[ m_uiNumberOfPlanes ];
     m_apcPlanes[0] = new TRenImagePlane<Pel>( pcPicYuv->getBufY(),   pcPicYuv->getWidth()     + (REN_LUMA_MARGIN << 1),  pcPicYuv->getHeight()      + (REN_LUMA_MARGIN << 1), pcPicYuv->getStride (), REN_LUMA_MARGIN     , g_uiPCMBitDepthLuma   );
     m_apcPlanes[1] = new TRenImagePlane<Pel>( pcPicYuv->getBufU(),   (pcPicYuv->getWidth()>>1)+  REN_LUMA_MARGIN      ,  (pcPicYuv->getHeight()>>1) +  REN_LUMA_MARGIN      , pcPicYuv->getCStride(), REN_LUMA_MARGIN >> 1, g_uiPCMBitDepthChroma );
     m_apcPlanes[2] = new TRenImagePlane<Pel>( pcPicYuv->getBufV(),   (pcPicYuv->getWidth()>>1)+  REN_LUMA_MARGIN      ,  (pcPicYuv->getHeight()>>1) +  REN_LUMA_MARGIN      , pcPicYuv->getCStride(), REN_LUMA_MARGIN >> 1, g_uiPCMBitDepthChroma );
+    m_apcPlanes[0] = new TRenImagePlane<Pel>( pcPicYuv->getBufY(),   pcPicYuv->getWidth()     + (REN_LUMA_MARGIN << 1),  pcPicYuv->getHeight()      + (REN_LUMA_MARGIN << 1), pcPicYuv->getStride (), REN_LUMA_MARGIN );
+    m_apcPlanes[1] = new TRenImagePlane<Pel>( pcPicYuv->getBufU(),   (pcPicYuv->getWidth()>>1)+  REN_LUMA_MARGIN      ,  (pcPicYuv->getHeight()>>1) +  REN_LUMA_MARGIN      , pcPicYuv->getCStride(), REN_LUMA_MARGIN >> 1 );
+    m_apcPlanes[2] = new TRenImagePlane<Pel>( pcPicYuv->getBufV(),   (pcPicYuv->getWidth()>>1)+  REN_LUMA_MARGIN      ,  (pcPicYuv->getHeight()>>1) +  REN_LUMA_MARGIN      , pcPicYuv->getCStride(), REN_LUMA_MARGIN >> 1 );
+  }
+}
 …
   assert( uiNumberOfFullPlanes + uiNumberOfQuaterPlanes);
   UInt uiHalfWidth  = uiWidth  >> 1;
   UInt uiHalfHeight = uiHeight >> 1;
+  UInt uiHalfWidth  = uiWidth  / 2;
+  UInt uiHalfHeight = uiHeight / 2;
   uiHalfWidth  = (uiHalfWidth  == 0) ? 1 : uiHalfWidth ;
 …
   for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfFullPlanes; uiCurPlane++)
+  {
     this->m_apcPlanes[uiCurPlane] = new TRenImagePlane<T>(uiWidth, uiHeight, REN_LUMA_MARGIN, g_uiPCMBitDepthLuma );
+    this->m_apcPlanes[uiCurPlane] = new TRenImagePlane<T>(uiWidth, uiHeight, REN_LUMA_MARGIN);
   };
   for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfQuaterPlanes; uiCurPlane++)
+  {
     this->m_apcPlanes[uiCurPlane+uiNumberOfFullPlanes] = new TRenImagePlane<T>(uiHalfWidth, uiHalfHeight, REN_LUMA_MARGIN >> 1, g_uiPCMBitDepthChroma);
+    this->m_apcPlanes[uiCurPlane+uiNumberOfFullPlanes] = new TRenImagePlane<T>(uiHalfWidth, uiHalfHeight, REN_LUMA_MARGIN >> 1);
   };
+}
 …
   for (UInt uiCurPlane = 1; uiCurPlane < m_uiNumberOfPlanes; uiCurPlane++)
+  {
     m_apcPlanes[uiCurPlane]->assign( (Pel) ((g_uiIBDI_MAX+1) >> 1) );
+    m_apcPlanes[uiCurPlane]->assign( (Pel) ( 1 << ( g_bitDepthC - 1 ) ) );
+  }
+}
 …
 template Void TRenImage<Pel>::assign<Pel>    (TRenImage<Pel>*   );
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenImage.h

-                      r438
+                      r446
 #include "../TLibCommon/TComPicYuv.h"
 #include "TRenImagePlane.h"
+#if H_3D
 …
 };
+#endif // H_3D
 #endif // __TRENIMAGE__

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenImagePlane.cpp

-                      r438
+                      r446
 #include "TRenFilter.h"
 #include <string.h>
+#if H_3D
 /////// TRenImagePlane ///////
 …
 template<class T>
+TRenImagePlane<T>::TRenImagePlane(UInt uiWidth, UInt uiHeight, UInt uiPad, UInt uiBitDepth )
+: m_uiWidth    (uiWidth),
+  m_uiHeight   (uiHeight),
+  m_uiStride   (uiWidth+2*uiPad),
+  m_uiWidthOrg (uiWidth+2*uiPad),
+  m_uiHeightOrg(uiHeight+2*uiPad),
+  m_uiPad      (uiPad),
+  m_uiBitDepth (uiBitDepth)
+TRenImagePlane<T>::TRenImagePlane(UInt uiWidth, UInt uiHeight, UInt uiPad)
+: m_uiWidth(uiWidth), m_uiHeight(uiHeight), m_uiStride(uiWidth+2*uiPad), m_uiWidthOrg(uiWidth+2*uiPad), m_uiHeightOrg(uiHeight+2*uiPad), m_uiPad(uiPad)
+{
   m_pcDataOrg = new T[ m_uiWidthOrg * m_uiHeightOrg ];
 …
 template<class T>
 TRenImagePlane<T>::TRenImagePlane(TRenImagePlane* pcPlane)
 : m_uiWidth    (pcPlane->getWidth   ())
 , m_uiHeight   (pcPlane->getHeight  ())
 , m_uiStride   (pcPlane->getStride  ())
 , m_uiWidthOrg (pcPlane->getWidthOrg())
+: m_uiWidth   (pcPlane->getWidth   ())
+, m_uiHeight  (pcPlane->getHeight  ())
+, m_uiStride  (pcPlane->getStride  ())
+, m_uiWidthOrg(pcPlane->getWidthOrg())
 , m_uiHeightOrg(pcPlane->getHeightOrg())
+, m_uiPad      (pcPlane->getPad     ())
+, m_uiBitDepth (pcPlane->getBitDepth())
+, m_uiPad     (pcPlane->getPad     ())
+{
   m_pcData = new T[m_uiWidthOrg*m_uiHeightOrg];
 …
 template<typename T>
 TRenImagePlane<T>::TRenImagePlane( T* pcDataOrg, UInt uiWidthOrg, UInt uiHeightOrg, UInt uiStride, UInt uiPad, UInt uiBitDepth )
+TRenImagePlane<T>::TRenImagePlane( T* pcDataOrg, UInt uiWidthOrg, UInt uiHeightOrg, UInt uiStride, UInt uiPad )
 : m_pcData     (pcDataOrg + uiStride * uiPad + uiPad )
 , m_uiWidth    (uiWidthOrg  - 2* uiPad )
 …
 , m_uiPad      (uiPad      )
 , m_bClean     (false      )
-, m_uiBitDepth (uiBitDepth )
+{
 …
 template<typename T>
 TRenImagePlanePart<T>::TRenImagePlanePart( TRenImagePlane<T>* pPlane, UInt uHorOff, UInt uVerOff, UInt uWidth, UInt uHeight )
 : TRenImagePlane<T>( pPlane->getPlaneData() + uHorOff + uVerOff * pPlane->getStride(), uWidth, uHeight, pPlane->getStride(),0, pPlane->getBitDepth())
+: TRenImagePlane<T>( pPlane->getPlaneData() + uHorOff + uVerOff * pPlane->getStride(), uWidth, uHeight, pPlane->getStride(),0)
+{
 …
 template class TRenImagePlanePart<Bool>;
 template class TRenImagePlanePart<Int>;
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenImagePlane.h

-                      r438
+                      r446
 #include "../TLibCommon/TComPicYuv.h"
+#if H_3D
 #define PelImagePlane     TRenImagePlane<Pel>
 #define DoubleImagePlane  TRenImagePlane<Double>
 …
   // Construction
   TRenImagePlane();
   TRenImagePlane( UInt uiWidth, UInt uiHeight, UInt uiPad, UInt uiBitDepth );
+  TRenImagePlane( UInt uiWidth, UInt uiHeight, UInt uiPad);
   TRenImagePlane( TRenImagePlane* pcInputPlane );
   TRenImagePlane( T* pcDataOrg, UInt uiWidthOrg, UInt uiHeightOrg, UInt uiStride, UInt uiPad, UInt uiBitDepth  );
+  TRenImagePlane( T* pcDataOrg, UInt uiWidthOrg, UInt uiHeightOrg, UInt uiStride, UInt uiPad );
   ~TRenImagePlane();
 …
   UInt getHeightOrg() { return m_uiHeightOrg; };
   UInt getPad      () { return m_uiPad;       };
-  UInt getBitDepth () { return m_uiBitDepth; };
   UInt getStride   () { return m_uiStride; };
 …
   UInt   m_uiHeightOrg;
   UInt   m_uiPad;
-  UInt   m_uiBitDepth;
+  Double m_dRatio;
   Bool   m_bClean;
 …
 };
+#endif // H_3D
 #endif // __TRENIMAGEPLANE__

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenInterpFilter.cpp

-                      r438
+                      r446
 #include "TRenInterpFilter.h"
+#if H_3D
 // ====================================================================================================================
 …
+}
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenInterpFilter.h

-                      r438
+                      r446
 #include "TLibCommon/CommonDef.h"
 #include "assert.h"
+#if H_3D
 // ====================================================================================================================
 // Constants
 …
    __inline Int xCTI_Filter_VI04_C_OCT3( Int* pSrc, Int iStride );
-#if HIGH_ACCURACY_BI
-  __inline Void xCTI_FilterHalfHor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst); //
-  __inline Void xCTI_FilterHalfHor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst);//
-  __inline Void xCTI_FilterQuarter0Hor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst); //
-  __inline Void xCTI_FilterQuarter0Hor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst); //
-  __inline Void xCTI_FilterQuarter1Hor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst); //
-  __inline Void xCTI_FilterQuarter1Hor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst); //
-  __inline Void xCTI_FilterHalfVer_ha (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst ); //
-  __inline Void xCTI_FilterQuarter0Ver_ha (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst );
-  __inline Void xCTI_FilterQuarter1Ver_ha (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst );
-  __inline Void xCTI_Filter1DHorC_ha (Pel* piSrc, Int iSrcStride,  Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV);
-  __inline Void xCTI_Filter1DVerC_ha (Pel* piSrc, Int iSrcStride,  Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV);
-  __inline Void xCTI_Filter2DHorC_ha (Int* piSrc, Int iSrcStride,  Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV);
-#endif
 };
+#if HIGH_ACCURACY_BI
+__inline Void TRenInterpFilter::xCTI_FilterHalfHor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+// ------------------------------------------------------------------------------------------------
+// DCTIF filters
+// ------------------------------------------------------------------------------------------------
+__inline Void TRenInterpFilter::xCTI_FilterHalfHor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
   Pel*  piSrcTmp;
   Int iSrcStep2 = iSrcStep*2;
   Int iSrcStep3 = iSrcStep*3;
 …
   Int iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
+  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
   for ( Int y = iHeight; y != 0; y-- )
+  {
 …
             + (   iTmpA          << 1 )
             -    iTmp0 -  iTmp2;
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      piDst   [x * iDstStep] = ClipY( (iSum +  32) >>  6 );
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfHor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfHor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
   Int*  piSrcTmp;
   Int iSrcStep2 = iSrcStep*2;
   Int iSrcStep3 = iSrcStep*3;
 …
   Int iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
+  Int shiftNum = 6 + g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
   for ( Int y = iHeight; y != 0; y-- )
+  {
 …
             -    iTmp0 -  iTmp2;
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      piDst   [x * iDstStep] = ClipY( (iSum +  2048) >>  12 );
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
   Pel*  piSrcTmp;
   Int iSrcStep2 = iSrcStep*2;
   Int iSrcStep3 = iSrcStep*3;
 …
   Int  iTmp1, iTmp2;
+  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
   for ( Int y = iHeight; y != 0; y-- )
+  {
 …
       iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
+            - ( ( piSrcTmp[iSrcStep2] - iTmp2 ) << 1 )
+            + (  piSrcTmp[iSrcStep]             << 2 )
+            - ( ( piSrcTmp[iSrcStep2] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStep4]           << 4 )
+            + ( piSrcTmp[iSrcStep3]             << 6);
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum + shiftOffset) >> shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0,16383, (iSum + shiftOffset) >> shiftNum );
+#endif
+             - ( ( piSrcTmp[iSrcStep2] - iTmp2 ) << 1 )
+             + (  piSrcTmp[iSrcStep]             << 2 )
+             - ( ( piSrcTmp[iSrcStep2] + iTmp1 ) << 3 )
+             + (   piSrcTmp[iSrcStep4]           << 4 );
+      piDst   [x * iDstStep] = ClipY(( (iSum +  32) >>  6 )+ piSrcTmp[iSrcStep3]);
       piSrcTmp += iSrcStep;
+    }
 …
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
   Int*  piSrcTmp;
   Int iSrcStep2 = iSrcStep*2;
   Int iSrcStep3 = iSrcStep*3;
 …
   Int iSrcStep6 = iSrcStep*6;
   Int iSrcStep7 = iSrcStep*7;
+  Int shiftNum = 6 + g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
   Int  iTmp1, iTmp2;
 …
             + (   piSrcTmp[iSrcStep3]           << 6 );
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      piDst   [x * iDstStep] = ClipY( (iSum +  2048) >>  12 );
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor_ha(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
   Pel*  piSrcTmp;
   Int iSrcStep2 = iSrcStep*2;
   Int iSrcStep3 = iSrcStep*3;
 …
   Int iSrcStep6 = iSrcStep*6;
   Int iSrcStep7 = iSrcStep*7;
+  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
+  Int  iTmp1, iTmp2;
+  for ( Int y = iHeight; y != 0; y-- )
+  {
+    piSrcTmp = &piSrc[ -3*iSrcStep ];
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+      // {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
+      iTmp1 = piSrcTmp[iSrcStep4] + piSrcTmp[iSrcStep2];
+      iTmp2 = piSrcTmp[iSrcStep ] + piSrcTmp[iSrcStep3];
+      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
+            - ( ( piSrcTmp[iSrcStep5] - iTmp2 ) << 1 )
+            + (   piSrcTmp[iSrcStep6]           << 2 )
+            - ( ( piSrcTmp[iSrcStep5] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStep3]           << 4 );
+      piDst   [x * iDstStep] = ClipY( ((iSum +  32) >>  6) + piSrcTmp[iSrcStep4] );
+      piSrcTmp += iSrcStep;
+    }
+    piSrc += iSrcStride;
+    piDst += iDstStride;
+  }
+  return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
+  Pel*  piDst    = rpiDst;
+  Int   iSum;
+  Int*  piSrcTmp;
+  Int iSrcStep2 = iSrcStep*2;
+  Int iSrcStep3 = iSrcStep*3;
+  Int iSrcStep4 = iSrcStep*4;
+  Int iSrcStep5 = iSrcStep*5;
+  Int iSrcStep6 = iSrcStep*6;
+  Int iSrcStep7 = iSrcStep*7;
   Int  iTmp1, iTmp2;
 …
             + (   piSrcTmp[iSrcStep3]           << 4 )
             + (   piSrcTmp[iSrcStep4]           << 6 );
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      piDst   [x * iDstStep] = ClipY( (iSum +  2048) >>  12 );
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor_ha(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  Pel*  piDst    = rpiDst;
+  Int   iSum;
+  Int*  piSrcTmp;
+  Int iSrcStep2 = iSrcStep*2;
+  Int iSrcStep3 = iSrcStep*3;
+  Int iSrcStep4 = iSrcStep*4;
+  Int iSrcStep5 = iSrcStep*5;
+  Int iSrcStep6 = iSrcStep*6;
+  Int iSrcStep7 = iSrcStep*7;
+  Int shiftNum = 6+g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
+  Int  iTmp1, iTmp2;
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst, Int iDstStridePel, Pel*& rpiDstPel )
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
+  Int*  piDst = rpiDst;
+  Pel*  piDstPel = rpiDstPel;
+  Int   iSum;
+  Pel*  piSrcTmp;
+  Int iSrcStride2 = iSrcStride*2;
+  Int iSrcStride3 = iSrcStride*3;
+  Int iSrcStride4 = iSrcStride*4;
+  Int iSrcStride5 = iSrcStride*5;
+  Int iSrcStride6 = iSrcStride*6;
+  Int iSrcStride7 = iSrcStride*7;
+  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
   for ( Int y = iHeight; y != 0; y-- )
+  {
     piSrcTmp = &piSrc[ -3*iSrcStep ];
+    piSrcTmp = &piSrc[ -3*iSrcStride ];
     for ( Int x = 0; x < iWidth; x++ )
+    {
+      // {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
+      iTmp1 = piSrcTmp[iSrcStep4] + piSrcTmp[iSrcStep2];
+      iTmp2 = piSrcTmp[iSrcStep ] + piSrcTmp[iSrcStep3];
+      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
+            - ( ( piSrcTmp[iSrcStep5] - iTmp2 ) << 1 )
+            + (   piSrcTmp[iSrcStep6]           << 2 )
+            - ( ( piSrcTmp[iSrcStep5] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStep3]           << 4 )
+            + (   piSrcTmp[iSrcStep4]           << 6 );
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      // { -1,4,-11,40,40,-11,4,-1   }
+      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
+      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
+      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
+      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
+      iTmpA = (iTmp3 << 2) - iTmp2;
+      iSum  = (   iTmp1          << 2 )
+            + (   iTmpA          << 3 )
+            + (   iTmpA          << 1 )
+            -    iTmp0 -  iTmp2;
+      piDst[x * iDstStep]    = iSum;
+      piDstPel[x * iDstStep] = ClipY( (iSum +  32) >>  6 );
       piSrcTmp += iSrcStep;
+    }
     piSrc += iSrcStride;
     piDst += iDstStride;
+  }
+  return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Ver_ha (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+    piDstPel += iDstStridePel;
+  }
+ return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst)
+{
+  Int*  piDst = rpiDst;
+  Int   iSum;
+  Pel*  piSrcTmp;
+  Int iSrcStride2 = iSrcStride*2;
+  Int iSrcStride3 = iSrcStride*3;
+  Int iSrcStride4 = iSrcStride*4;
+  Int iSrcStride5 = iSrcStride*5;
+  Int iSrcStride6 = iSrcStride*6;
+  Int iSrcStride7 = iSrcStride*7;
+  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
+  for ( Int y = iHeight; y != 0; y-- )
+  {
+    piSrcTmp = &piSrc[ -3*iSrcStride ];
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+      // { -1,4,-11,40,40,-11,4,-1   }
+      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
+      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
+      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
+      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
+      iTmpA = (iTmp3 << 2) - iTmp2;
+      iSum  = (   iTmp1          << 2 )
+            + (   iTmpA          << 3 )
+            + (   iTmpA          << 1 )
+            -    iTmp0 -  iTmp2;
+      piDst[x * iDstStep] = iSum;
+      piSrcTmp += iSrcStep;
+    }
+    piSrc += iSrcStride;
+    piDst += iDstStride;
+  }
+  return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst = rpiDst;
   Int   iSum;
 …
   Int iSrcStride6 = iSrcStride*6;
   Int iSrcStride7 = iSrcStride*7;
+  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
+  Int  iTmp1, iTmp2;
+  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
   for ( Int y = iHeight; y != 0; y-- )
+  {
 …
     for ( Int x = 0; x < iWidth; x++ )
+    {
+      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
+      iTmp1 = piSrcTmp[iSrcStride3] + piSrcTmp[iSrcStride5];
+      iTmp2 = piSrcTmp[iSrcStride6] + piSrcTmp[iSrcStride4];
+      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStride7]
+            - ( ( piSrcTmp[iSrcStride2] - iTmp2 ) << 1 )
+            + (  piSrcTmp[iSrcStride]             << 2 )
+            - ( ( piSrcTmp[iSrcStride2] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStride4]           << 4 )
+            + (   piSrcTmp[iSrcStride3]           << 6);
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+      // { -1,4,-11,40,40,-11,4,-1   }
+      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
+      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
+      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
+      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
+      iTmpA = (iTmp3 << 2) - iTmp2;
+      iSum  = (   iTmp1          << 2 )
+            + (   iTmpA          << 3 )
+            + (   iTmpA          << 1 )
+            -    iTmp0 -  iTmp2;
+      piDst[x * iDstStep] = ClipY( (iSum +  32) >>  6 );
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Ver_ha (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  Pel*  piDst = rpiDst;
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Ver (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst)
+{
+  Int*  piDst = rpiDst;
   Int   iSum;
   Pel*  piSrcTmp;
   Int iSrcStride2 = iSrcStride*2;
   Int iSrcStride3 = iSrcStride*3;
 …
   Int iSrcStride6 = iSrcStride*6;
   Int iSrcStride7 = iSrcStride*7;
+  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
+  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
   Int  iTmp1, iTmp2;
   for ( Int y = iHeight; y != 0; y-- )
+  {
 …
     for ( Int x = 0; x < iWidth; x++ )
+    {
+      /// {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
+      iTmp1 = piSrcTmp[iSrcStride4] + piSrcTmp[iSrcStride2];
+      iTmp2 = piSrcTmp[iSrcStride ] + piSrcTmp[iSrcStride3];
+      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
+      iTmp1 = piSrcTmp[iSrcStride3] + piSrcTmp[iSrcStride5];
+      iTmp2 = piSrcTmp[iSrcStride6] + piSrcTmp[iSrcStride4];
       iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStride7]
+            - ( ( piSrcTmp[iSrcStride5] - iTmp2 ) << 1 )
+            + (   piSrcTmp[iSrcStride6]           << 2 )
+            - ( ( piSrcTmp[iSrcStride5] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStride3]           << 4 )
+            + (   piSrcTmp[iSrcStride4]           << 6 );
+#if REMOVE_INTERMEDIATE_CLIPPING
+      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
+#else
+      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
+#endif
+            - ( ( piSrcTmp[iSrcStride2] - iTmp2 ) << 1 )
+            + (  piSrcTmp[iSrcStride]             << 2 )
+            - ( ( piSrcTmp[iSrcStride2] + iTmp1 ) << 3 )
+            + (   piSrcTmp[iSrcStride4]           << 4 )
+            + (   piSrcTmp[iSrcStride3]           << 6 );
+      piDst[x * iDstStep] = iSum;
       piSrcTmp += iSrcStep;
+    }
 …
+  }
   return;
+}
+__inline Void TRenInterpFilter::xCTI_FilterHalfVer_ha  (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+}
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Ver (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY );  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst = rpiDst;
   Int   iSum;
 …
   Int iSrcStride6 = iSrcStride*6;
   Int iSrcStride7 = iSrcStride*7;
-  Int shiftNum = g_uiBitIncrement + g_uiBitDepth - 8;
-  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
-  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStride ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
-      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
-      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
-      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-#if REMOVE_INTERMEDIATE_CLIPPING
-      piDst   [x * iDstStep] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-      piDst   [x * iDstStep] = Clip3(0, 16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-#endif
-// ------------------------------------------------------------------------------------------------
-// DCTIF filters
-// ------------------------------------------------------------------------------------------------
-__inline Void TRenInterpFilter::xCTI_FilterHalfHor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[        0]+piSrcTmp[iSrcStep7];
-      iTmp1 = piSrcTmp[iSrcStep]+piSrcTmp[iSrcStep6];
-      iTmp2 = piSrcTmp[iSrcStep2]+piSrcTmp[iSrcStep5];
-      iTmp3 = piSrcTmp[iSrcStep3]+piSrcTmp[iSrcStep4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-      piDst   [x * iDstStep] = ClipY( (iSum +  32) >>  6 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterHalfHor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Int*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[        0]+piSrcTmp[iSrcStep7];
-      iTmp1 = piSrcTmp[iSrcStep ]+piSrcTmp[iSrcStep6];
-      iTmp2 = piSrcTmp[iSrcStep2]+piSrcTmp[iSrcStep5];
-      iTmp3 = piSrcTmp[iSrcStep3]+piSrcTmp[iSrcStep4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-      piDst   [x * iDstStep] = ClipY( (iSum +  2048) >>  12 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int  iTmp1, iTmp2;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
-      iTmp1 = piSrcTmp[iSrcStep3] + piSrcTmp[iSrcStep5];
-      iTmp2 = piSrcTmp[iSrcStep6] + piSrcTmp[iSrcStep4];
-      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
-             - ( ( piSrcTmp[iSrcStep2] - iTmp2 ) << 1 )
-             + (  piSrcTmp[iSrcStep]             << 2 )
-             - ( ( piSrcTmp[iSrcStep2] + iTmp1 ) << 3 )
-             + (   piSrcTmp[iSrcStep4]           << 4 );
-      piDst   [x * iDstStep] = ClipY(( (iSum +  32) >>  6 )+ piSrcTmp[iSrcStep3]);
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Int*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int  iTmp1, iTmp2;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
-      iTmp1 = piSrcTmp[iSrcStep3] + piSrcTmp[iSrcStep5];
-      iTmp2 = piSrcTmp[iSrcStep6] + piSrcTmp[iSrcStep4];
-      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
-            - ( ( piSrcTmp[iSrcStep2] - iTmp2 ) << 1 )
-            + (  piSrcTmp[iSrcStep]             << 2 )
-            - ( ( piSrcTmp[iSrcStep2] + iTmp1 ) << 3 )
-            + (   piSrcTmp[iSrcStep4]           << 4 )
-            + (   piSrcTmp[iSrcStep3]           << 6 );
-      piDst   [x * iDstStep] = ClipY( (iSum +  2048) >>  12 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int  iTmp1, iTmp2;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
-      iTmp1 = piSrcTmp[iSrcStep4] + piSrcTmp[iSrcStep2];
-      iTmp2 = piSrcTmp[iSrcStep ] + piSrcTmp[iSrcStep3];
-      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
-            - ( ( piSrcTmp[iSrcStep5] - iTmp2 ) << 1 )
-            + (   piSrcTmp[iSrcStep6]           << 2 )
-            - ( ( piSrcTmp[iSrcStep5] + iTmp1 ) << 3 )
-            + (   piSrcTmp[iSrcStep3]           << 4 );
-      piDst   [x * iDstStep] = Clip( ((iSum +  32) >>  6) + piSrcTmp[iSrcStep4] );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Int*  piSrcTmp;
-  Int iSrcStep2 = iSrcStep*2;
-  Int iSrcStep3 = iSrcStep*3;
-  Int iSrcStep4 = iSrcStep*4;
-  Int iSrcStep5 = iSrcStep*5;
-  Int iSrcStep6 = iSrcStep*6;
-  Int iSrcStep7 = iSrcStep*7;
-  Int  iTmp1, iTmp2;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStep ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
-      iTmp1 = piSrcTmp[iSrcStep4] + piSrcTmp[iSrcStep2];
-      iTmp2 = piSrcTmp[iSrcStep ] + piSrcTmp[iSrcStep3];
-      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStep7]
-            - ( ( piSrcTmp[iSrcStep5] - iTmp2 ) << 1 )
-            + (   piSrcTmp[iSrcStep6]           << 2 )
-            - ( ( piSrcTmp[iSrcStep5] + iTmp1 ) << 3 )
-            + (   piSrcTmp[iSrcStep3]           << 4 )
-            + (   piSrcTmp[iSrcStep4]           << 6 );
-      piDst   [x * iDstStep] = Clip( (iSum +  2048) >>  12 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst, Int iDstStridePel, Pel*& rpiDstPel )
+{
-  Int*  piDst = rpiDst;
-  Pel*  piDstPel = rpiDstPel;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStride2 = iSrcStride*2;
-  Int iSrcStride3 = iSrcStride*3;
-  Int iSrcStride4 = iSrcStride*4;
-  Int iSrcStride5 = iSrcStride*5;
-  Int iSrcStride6 = iSrcStride*6;
-  Int iSrcStride7 = iSrcStride*7;
-  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStride ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
-      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
-      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
-      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-      piDst[x * iDstStep]    = iSum;
-      piDstPel[x * iDstStep] = Clip( (iSum +  32) >>  6 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
-    piDstPel += iDstStridePel;
+  }
- return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst)
+{
-  Int*  piDst = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStride2 = iSrcStride*2;
-  Int iSrcStride3 = iSrcStride*3;
-  Int iSrcStride4 = iSrcStride*4;
-  Int iSrcStride5 = iSrcStride*5;
-  Int iSrcStride6 = iSrcStride*6;
-  Int iSrcStride7 = iSrcStride*7;
-  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStride ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
-      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
-      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
-      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-      piDst[x * iDstStep] = iSum;
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStride2 = iSrcStride*2;
-  Int iSrcStride3 = iSrcStride*3;
-  Int iSrcStride4 = iSrcStride*4;
-  Int iSrcStride5 = iSrcStride*5;
-  Int iSrcStride6 = iSrcStride*6;
-  Int iSrcStride7 = iSrcStride*7;
-  Int  iTmp0, iTmp1, iTmp2, iTmp3, iTmpA;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStride ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // { -1,4,-11,40,40,-11,4,-1   }
-      iTmp0 = piSrcTmp[          0]+piSrcTmp[iSrcStride7];
-      iTmp1 = piSrcTmp[iSrcStride ]+piSrcTmp[iSrcStride6];
-      iTmp2 = piSrcTmp[iSrcStride2]+piSrcTmp[iSrcStride5];
-      iTmp3 = piSrcTmp[iSrcStride3]+piSrcTmp[iSrcStride4];
-      iTmpA = (iTmp3 << 2) - iTmp2;
-      iSum  = (   iTmp1          << 2 )
-            + (   iTmpA          << 3 )
-            + (   iTmpA          << 1 )
-            -    iTmp0 -  iTmp2;
-      piDst[x * iDstStep] = Clip( (iSum +  32) >>  6 );
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter0Ver (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst)
+{
-  Int*  piDst = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStride2 = iSrcStride*2;
-  Int iSrcStride3 = iSrcStride*3;
-  Int iSrcStride4 = iSrcStride*4;
-  Int iSrcStride5 = iSrcStride*5;
-  Int iSrcStride6 = iSrcStride*6;
-  Int iSrcStride7 = iSrcStride*7;
-  Int  iTmp1, iTmp2;
-  for ( Int y = iHeight; y != 0; y-- )
+  {
-    piSrcTmp = &piSrc[ -3*iSrcStride ];
-    for ( Int x = 0; x < iWidth; x++ )
+    {
-      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
-      iTmp1 = piSrcTmp[iSrcStride3] + piSrcTmp[iSrcStride5];
-      iTmp2 = piSrcTmp[iSrcStride6] + piSrcTmp[iSrcStride4];
-      iSum  =  iTmp1 + iTmp2 - piSrcTmp[0] - piSrcTmp[iSrcStride7]
-            - ( ( piSrcTmp[iSrcStride2] - iTmp2 ) << 1 )
-            + (  piSrcTmp[iSrcStride]             << 2 )
-            - ( ( piSrcTmp[iSrcStride2] + iTmp1 ) << 3 )
-            + (   piSrcTmp[iSrcStride4]           << 4 )
-            + (   piSrcTmp[iSrcStride3]           << 6 );
-      piDst[x * iDstStep] = iSum;
-      piSrcTmp += iSrcStep;
+    }
-    piSrc += iSrcStride;
-    piDst += iDstStride;
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_FilterQuarter0Ver (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
-  Pel*  piDst = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int iSrcStride2 = iSrcStride*2;
-  Int iSrcStride3 = iSrcStride*3;
-  Int iSrcStride4 = iSrcStride*4;
-  Int iSrcStride5 = iSrcStride*5;
-  Int iSrcStride6 = iSrcStride*6;
-  Int iSrcStride7 = iSrcStride*7;
   Int  iTmp1, iTmp2;
 …
             + (   piSrcTmp[iSrcStride4]           << 4 );
       piDst[x * iDstStep] = Clip( ((iSum +  32) >>  6) + piSrcTmp[iSrcStride3] );
+      piDst[x * iDstStep] = ClipY( ((iSum +  32) >>  6) + piSrcTmp[iSrcStride3] );
       piSrcTmp += iSrcStep;
+    }
 …
 __inline Void TRenInterpFilter::xCTI_FilterQuarter1Ver (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst = rpiDst;
   Int   iSum;
 …
             + (   piSrcTmp[iSrcStride3]           << 4 );
       piDst[x * iDstStep] = Clip( ((iSum +  32) >>  6) +  piSrcTmp[iSrcStride4] );
+      piDst[x * iDstStep] = ClipY( ((iSum +  32) >>  6) +  piSrcTmp[iSrcStride4] );
       piSrcTmp += iSrcStep;
+    }
 …
 __inline Void TRenInterpFilter::xCTI_Filter2DHorC(Int* piSrc, Int iSrcStride,  Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst    = rpiDst;
   Int   iSum;
 …
+        {
           iSum         = xCTI_Filter_VI04_C_OCT0( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VI04_C_QUA0( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VI04_C_QUA1( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VI04_C_OCT1( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VI04_C_OCT2( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VI04_C_OCT3( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VIS04_C_HAL( piSrcTmp, 1 );
           piDst   [x ] = Clip ((iSum +  2048) >>  12 );
+          piDst   [x ] = ClipC ((iSum +  2048) >>  12 );
           piSrcTmp++;
+        }
 …
 __inline Void TRenInterpFilter::xCTI_Filter1DVerC (Pel* piSrc, Int iSrcStride, Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV)
+{
+  assert( g_bitDepthC == g_bitDepthY);  // ToDo: Update renderer to work with different luma/chroma bit depth
   Pel*  piDst = rpiDst;
   Int   iSum;
 …
+        {
           iSum      = xCTI_Filter_VP04_C_OCT0( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VP04_C_QUA0( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VP04_C_QUA1( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VP04_C_OCT1( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VP04_C_OCT2( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VP04_C_OCT3( piSrcTmp,  iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum      = xCTI_Filter_VPS04_C_HAL( piSrcTmp, iSrcStride );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_OCT0( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_QUA0( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_QUA1( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_OCT1( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_OCT2( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VP04_C_OCT3( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
+        {
           iSum         = xCTI_Filter_VPS04_C_HAL( piSrcTmp,  1 );
           piDst[x ] = Clip ((iSum +  32) >>  6 );
+          piDst[x ] = ClipC ((iSum +  32) >>  6 );
           piSrcTmp++;
+        }
 …
   return;
+}
-#if HIGH_ACCURACY_BI
-__inline Void TRenInterpFilter::xCTI_Filter2DHorC_ha(Int* piSrc, Int iSrcStride,  Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Int*  piSrcTmp;
-  Int shiftNum  = 6 + g_uiBitIncrement + g_uiBitDepth - 8;
-  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
-  switch (iMV)
+  {
-  case 1:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_OCT0( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 2:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_QUA0( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 6:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_QUA1( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 3:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_OCT1( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 5:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_OCT2( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 7:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VI04_C_OCT3( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 4:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VIS04_C_HAL( piSrcTmp, 1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  default:
-    assert( 0 );
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_Filter1DVerC_ha (Pel* piSrc, Int iSrcStride, Int iWidth, Int iHeight, Int iDstStride,  Pel*& rpiDst, Int iMV)
+{
-  Pel*  piDst = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int shiftNum  = g_uiBitIncrement + g_uiBitDepth - 8;
-  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
-  switch (iMV)
+  {
-  case 1:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT0( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 2:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_QUA0( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 6:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_QUA1( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 3:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT1( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 5:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT2( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 7:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT3( piSrcTmp,  iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 4:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[-iSrcStride ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VPS04_C_HAL( piSrcTmp, iSrcStride );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  default:
-    assert( 0 );
+  }
-  return;
+}
-__inline Void TRenInterpFilter::xCTI_Filter1DHorC_ha(Pel* piSrc, Int iSrcStride, Int iWidth, Int iHeight, Int iDstStride, Pel*& rpiDst, Int iMV)
+{
-  Pel*  piDst    = rpiDst;
-  Int   iSum;
-  Pel*  piSrcTmp;
-  Int shiftNum  = g_uiBitIncrement + g_uiBitDepth - 8;
-  Int shiftOffset = (shiftNum > 0) ? ( 1 << (shiftNum - 1)) : 0 ;
-  switch (iMV)
+  {
-  case 1:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT0( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 2:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_QUA0( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 6:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VP04_C_QUA1( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 3:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum      = xCTI_Filter_VP04_C_OCT1( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 5:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VP04_C_OCT2( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 7:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum         = xCTI_Filter_VP04_C_OCT3( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  case 4:
+  {
-      for ( Int y = iHeight; y != 0; y-- )
+      {
-        piSrcTmp = &piSrc[ -1 ];
-        for ( Int x = 0; x < iWidth; x++ )
+        {
-          iSum    = xCTI_Filter_VPS04_C_HAL( piSrcTmp,  1 );
-#if REMOVE_INTERMEDIATE_CLIPPING
-          piDst[x ] = (iSum +  shiftOffset) >>  shiftNum;
-#else
-          piDst[x ] = Clip3(0,16383, (iSum +  shiftOffset) >>  shiftNum );
-#endif
-          piSrcTmp++;
+        }
-        piSrc += iSrcStride;
-        piDst += iDstStride;
+      }
+  }
-  break;
-  default:
-    assert( 0 );
+ }
-  return;
+}
-#endif
 __inline Int TRenInterpFilter::xCTI_Filter_VP04_C_OCT0( Pel* pSrc,  Int iStride )
 …
   return iSum;
+}
+#endif // H_3D
 #endif // __TRENINTERP__

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenModSetupStrParser.cpp

-                      r438
+                      r446
 #include "TRenFilter.h"
 #include "TRenModSetupStrParser.h"
+#if !QC_MVHEVC_B0046
+#if H_3D
 Int
 TRenModSetupStrParser::getNumOfModels()
 …
   rcNextChar = m_pchSetStr[iPos];
+}
 #endif
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenModSetupStrParser.h

-                      r438
+                      r446
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
+#if !QC_MVHEVC_B0046
 #ifndef __TRENMODSETUPSTRPARSER__
 #define __TRENMODSETUPSTRPARSER__
 …
 #include "../TLibCommon/TypeDef.h"
 #include "../TAppCommon/TAppComCamPara.h"
+#if H_3D
 …
 };
+#endif // H_3D
 #endif //__TRENMODEL__
-#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenModel.cpp

-                      r438
+                      r446
 #include "TRenFilter.h"
 #include "TRenModel.h"
+#if !QC_MVHEVC_B0046
+#if H_3D_VSO
 ///////////  TRENMODEL //////////////////////
 TRenModel::TRenModel()
 …
   m_iHoleMargin        =  1;
   m_uiHorOff           = -1;
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   m_bEarlySkip         = false;
 #endif
 …
 Void
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 TRenModel::create( Int iNumOfBaseViews, Int iNumOfModels, Int iWidth, Int iHeight, Int iShiftPrec, Int iHoleMargin, Bool bEarlySkip )
 #else
 …
   m_iShiftPrec          = iShiftPrec;
   m_iHoleMargin         = iHoleMargin;
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   m_bEarlySkip          = bEarlySkip;
 #endif
 …
   AOT( iContent      < -1 || iContent > 1 );
   AOT( iBlendMode < -1 || iBlendMode > 2 );
+  Bool bBitInc = (g_uiBitIncrement != 0);
+  AOT( g_bitDepthY  != g_bitDepthC );
+  Bool bBitInc = ( DISTORTION_PRECISION_ADJUSTMENT( g_bitDepthY - 8 ) != 0);
   AOT( m_apcRenModels[iModelNum] );
 …
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   m_apcRenModels[iModelNum]->create( iMode ,m_iWidth, m_iHeight, m_iShiftPrec, m_aaaiSubPelShiftLut, m_iHoleMargin,  bUseOrgRef, iBlendMode, m_bEarlySkip );
 #else
 …
+}
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 RMDist
 TRenModel::getDist( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel * piOrgData, Int iOrgStride)
 …
     if (m_iCurrentContent == 1)
+    {
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
       iDist +=  m_apcCurRenModels[iModelNum]->getDistDepth  ( m_aiCurPosInModels[iModelNum], iStartPosX, iStartPosY,  iWidth,  iHeight,  iStride,  piNewData , piOrgData, iOrgStride);
 #else
 …
     if (m_iCurrentContent == 1)
+    {
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
       Int iTargetStride = m_aiCurDepthStrides[ m_iCurrentView ];
       m_apcCurRenModels[iModelNum]->setDepth  ( m_aiCurPosInModels[iModelNum], iStartPosX, iStartPosY, iWidth, iHeight, iStride, piNewData,m_apiCurDepthPel[ m_iCurrentView ] + iStartPosY * iTargetStride + iStartPosX ,iTargetStride );
 …
+  }
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   if (m_iCurrentContent == 1)
+  {
 …
     m_apcCurRenModels[iCurModel]->getRefVideo  ( m_aiCurPosInModels[iCurModel], &cPicYuvTempRef   );
     iSSEY += TRenFilter::SSE( cPicYuvSynth.getLumaAddr(), cPicYuvSynth.getStride(),  m_iWidth,      m_iUsedHeight     , cPicYuvTempRef.getLumaAddr(), cPicYuvTempRef.getStride() );
     iSSEU += TRenFilter::SSE( cPicYuvSynth.getCbAddr()  , cPicYuvSynth.getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, cPicYuvTempRef.getCbAddr()  , cPicYuvTempRef.getCStride());
     iSSEV += TRenFilter::SSE( cPicYuvSynth.getCrAddr()  , cPicYuvSynth.getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, cPicYuvTempRef.getCrAddr()  , cPicYuvTempRef.getCStride());
+    iSSEY += TRenFilter::SSE( cPicYuvSynth.getLumaAddr(), cPicYuvSynth.getStride(),  m_iWidth,      m_iUsedHeight     , cPicYuvTempRef.getLumaAddr(), cPicYuvTempRef.getStride() , true  );
+    iSSEU += TRenFilter::SSE( cPicYuvSynth.getCbAddr()  , cPicYuvSynth.getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, cPicYuvTempRef.getCbAddr()  , cPicYuvTempRef.getCStride(), false );
+    iSSEV += TRenFilter::SSE( cPicYuvSynth.getCrAddr()  , cPicYuvSynth.getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, cPicYuvTempRef.getCrAddr()  , cPicYuvTempRef.getCStride(), false );
+  }
 …
+  }
+}
+#endif
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenModel.h

-                      r438
+                      r446
  */
+#if !QC_MVHEVC_B0046
 #ifndef __TRENMODEL__
 #define __TRENMODEL__
 …
 #include "../TLibCommon/TypeDef.h"
+#if H_3D_VSO
 class TRenModel
+{
 …
   // Creation
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Void  create           ( Int iNumOfBaseViews, Int iNumOfModels, Int iWidth, Int iHeight, Int iShiftPrec, Int iHoleMargin, Bool bEarlySkip );
 #else
 …
   // Get Distortion, set Data
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Int64 getDist          ( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel * piOrgData, Int iOrgStride);
 #else
 …
   Int**  m_aaaiSubPelShiftLut[2];
   Int    m_iHoleMargin;
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Bool   m_bEarlySkip;
 #endif
 …
 };
+#endif // H_3D
 #endif //__TRENMODEL__
-#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenSingleModel.cpp

-                      r438
+                      r446
 #include "TRenSingleModel.h"
+#if !QC_MVHEVC_B0046
+#if H_3D_VSO
 ////////////// TRENSINGLE MODEL ///////////////
 template <BlenMod iBM, Bool bBitInc>
 TRenSingleModelC<iBM,bBitInc>::TRenSingleModelC()
 :  m_iDistShift ( g_uiBitIncrement << 1 )
+:  m_iDistShift ( ( g_bitDepthY - 8) << 1 )
+{
   m_iWidth  = -1;
 …
+  }
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   m_pbHorSkip = NULL;
 #endif
 …
 TRenSingleModelC<iBM,bBitInc>::~TRenSingleModelC()
+{
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   if ( m_pbHorSkip )
+  {
 …
 template <BlenMod iBM, Bool bBitInc> Void
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 TRenSingleModelC<iBM,bBitInc>::create( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bEarlySkip )
 #else
 …
+{
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   m_pbHorSkip     = new Bool [MAX_CU_SIZE];
   m_bEarlySkip    = bEarlySkip;
 …
   Pel* piDRow = piCurDepthPel;
   Pel* piYRow = apiCurVideoPel[0];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel* piURow = apiCurVideoPel[1];
   Pel* piVRow = apiCurVideoPel[2];
 …
       Int iSubPosX = (1 << m_iShiftPrec);
       pcCurInputSampleRow[0].aiY[iSubPosX] = piYRow[0];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       pcCurInputSampleRow[0].aiU[iSubPosX] = piURow[0];
       pcCurInputSampleRow[0].aiV[iSubPosX] = piVRow[0];
 …
         Int iShift = (iPosX << m_iShiftPrec) + iSubPosX;
         pcCurInputSampleRow[iPosX+iOffsetX].aiY[iSubPosX] = piYRow[iShift];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         pcCurInputSampleRow[iPosX+iOffsetX].aiU[iSubPosX] = piURow[iShift];
         pcCurInputSampleRow[iPosX+iOffsetX].aiV[iSubPosX] = piVRow[iShift];
 …
     piDRow += iCurDepthStride;
     piYRow += aiCurVideoStride[0];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     piURow += aiCurVideoStride[1];
     piVRow += aiCurVideoStride[2];
 …
+  {
   case 0:
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false );
 #else
 …
     break;
   case 1:
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
 #else
 …
   case 2:
     TRenFilter::setupZLUT( true, 30, iDistToLeft, ppiBaseShiftLutLeft, ppiBaseShiftLutRight, m_iBlendZThres, m_iBlendDistWeight, m_piInvZLUTLeft, m_piInvZLUTRight );
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false);
     xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
 …
 template <BlenMod iBM, Bool bBitInc> Void
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
 TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY, Pel RenModelOutPels::*& rpiSrcU, Pel RenModelOutPels::*& rpiSrcV )
 #else
 …
   case 0:
     rpiSrcY = &RenModelOutPels::iYLeft;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     rpiSrcU = &RenModelOutPels::iULeft;
     rpiSrcV = &RenModelOutPels::iVLeft;
 …
   case 1:
     rpiSrcY = &RenModelOutPels::iYRight;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     rpiSrcU = &RenModelOutPels::iURight;
     rpiSrcV = &RenModelOutPels::iVRight;
 …
   case 2:
     rpiSrcY = &RenModelOutPels::iYBlended;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     rpiSrcU = &RenModelOutPels::iUBlended;
     rpiSrcV = &RenModelOutPels::iVBlended;
 …
   Pel* piYRow = m_aapiRefVideoPel[0];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel* piURow = m_aapiRefVideoPel[1];
   Pel* piVRow = m_aapiRefVideoPel[2];
 …
+    {
       pcCurOutSampleRow[iPosX].iYRef = piYRow[iPosX];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       pcCurOutSampleRow[iPosX].iURef = piURow[iPosX];
       pcCurOutSampleRow[iPosX].iVRef = piVRow[iPosX];
 …
     piYRow += m_aiRefVideoStrides[0];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     piURow += m_aiRefVideoStrides[1];
     piVRow += m_aiRefVideoStrides[2];
 …
   Pel RenModelOutPels::* piSrcY = NULL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel RenModelOutPels::* piSrcU = NULL;
   Pel RenModelOutPels::* piSrcV = NULL;
 …
+    {
       pcCurOutSampleRow[iPosX].iYRef = pcCurOutSampleRow[iPosX].*piSrcY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       pcCurOutSampleRow[iPosX].iURef = pcCurOutSampleRow[iPosX].*piSrcU;
       pcCurOutSampleRow[iPosX].iVRef = pcCurOutSampleRow[iPosX].*piSrcV;
 …
       pcOutSampleRow[iPosX].iYRight       = 0;
       pcOutSampleRow[iPosX].iYBlended     = 0;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       // U Planes
       pcOutSampleRow[iPosX].iULeft        = 128 << g_uiBitIncrement;
       pcOutSampleRow[iPosX].iURight       = 128 << g_uiBitIncrement;
       pcOutSampleRow[iPosX].iUBlended     = 128 << g_uiBitIncrement;
+      pcOutSampleRow[iPosX].iULeft        = 1 << (g_bitDepthC - 1);
+      pcOutSampleRow[iPosX].iURight       = 1 << (g_bitDepthC - 1);
+      pcOutSampleRow[iPosX].iUBlended     = 1 << (g_bitDepthC - 1);
       // V Planes
       pcOutSampleRow[iPosX].iVLeft        = 128 << g_uiBitIncrement;
       pcOutSampleRow[iPosX].iVRight       = 128 << g_uiBitIncrement;
       pcOutSampleRow[iPosX].iVBlended     = 128 << g_uiBitIncrement;
+      pcOutSampleRow[iPosX].iVLeft        = 1 << (g_bitDepthC - 1);
+      pcOutSampleRow[iPosX].iVRight       = 1 << (g_bitDepthC - 1);
+      pcOutSampleRow[iPosX].iVBlended     = 1 << (g_bitDepthC - 1);
 #endif
       //// Input Samples
 …
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 template <BlenMod iBM, Bool bBitInc> RMDist
 TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Pel * piOrgData, Int iOrgStride )
 …
+{
   RMDist iSSE = 0;
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Bool   bEarlySkip;
 #endif
 …
+  {
   case 0:
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     bEarlySkip = m_bEarlySkip ? xDetectEarlySkipL(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
     if( !bEarlySkip )
 …
     break;
   case 1:
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     bEarlySkip = m_bEarlySkip ? xDetectEarlySkipR(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
     if( !bEarlySkip )
 …
   return iSSE;
+}
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 template <BlenMod iBM, Bool bBitInc> Void
 TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel* piOrgData, Int iOrgStride )
 …
 #endif
+{
 #ifdef  LGE_VSO_EARLY_SKIP_A0093
+#ifdef  H_3D_VSO_EARLY_SKIP
   Bool bEarlySkip;
 #endif
 …
+  {
   case 0:
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     bEarlySkip = m_bEarlySkip ? xDetectEarlySkipL(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
     if( !bEarlySkip )
 …
     break;
   case 1:
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     bEarlySkip = m_bEarlySkip ? xDetectEarlySkipR(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
     if( !bEarlySkip )
 …
   AOT( pcPicYuv->getHeight() < m_iUsedHeight + m_iHorOffset );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel RenModelOutPels::* piText[3] = { NULL, NULL, NULL };
   xGetSampleStrTextPtrs(iViewPos, piText[0], piText[1], piText[2]);
 …
   xGetSampleStrTextPtrs(iViewPos, piY);
   xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piY, pcPicYuv->getLumaAddr() + m_iHorOffset * pcPicYuv->getStride(), pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
   pcPicYuv->setChromaTo( 128 << g_uiBitIncrement );
+  pcPicYuv->setChromaTo( 1 << (g_bitDepthC - 1) );
 #endif
+}
 …
   xGetSampleStrDepthPtrs(iViewPos, piD);
   xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piD, pcPicYuv->getLumaAddr() + pcPicYuv->getStride() * m_iHorOffset, pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
   pcPicYuv->setChromaTo( 128 << g_uiBitIncrement );
+  pcPicYuv->setChromaTo( 1 << (g_bitDepthC - 1) );
+}
 …
   AOT( pcPicYuv->getHeight() <  m_iUsedHeight + m_iHorOffset);
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel RenModelOutPels::* piText[3];
   piText[0] = &RenModelOutPels::iYRef;
 …
 #else
   xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, &RenModelOutPels::iYRef, pcPicYuv->getLumaAddr() *  pcPicYuv->getStride() + m_iHorOffset, pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
   pcPicYuv->setChromaTo( 128 << g_uiBitIncrement );
+  pcPicYuv->setChromaTo( 1 << ( g_bitDepthC - 1 ) );
 #endif
+}
 …
   m_pcOutputSamplesRow   += m_iOutputSamplesStride;
+}
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
 TRenSingleModelC<iBM,bBitInc>::xRenderL( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Bool bFast)
 …
   for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
+  {
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     if( m_bEarlySkip && bFast )
+    {
 …
       xExtrapolateMarginL<bSet>  ( iCurSPos, iEndChangePos, iError );
       iMinChangedSPos       = Min( iMinChangedSPos, (iEndChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( Max(m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
+      iMinChangedSPos       = std::min( iMinChangedSPos, (iEndChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
       iLastSPos             = iCurSPos;
       m_iLastDepth          = m_iCurDepth;
 …
       // Get minimal changed sample position
       iMinChangedSPos = Min( iMinChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( Max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
+      iMinChangedSPos = std::min( iMinChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
       Int iCurSPos    = xShiftNewData(iCurPosX,iPosXinNewData);
       m_iCurDepth     = m_piNewDepthData[iPosXinNewData];
 …
+}
 #ifdef  LGE_VSO_EARLY_SKIP_A0093
+#ifdef  H_3D_VSO_EARLY_SKIP
 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
 TRenSingleModelC<iBM,bBitInc>::xRenderR( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Bool bFast)
 …
   for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
+  {
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
     if( m_bEarlySkip && bFast )
+    {
 …
       xExtrapolateMarginR<bSet>     ( iCurSPos, iStartChangePos, iError );
       iMaxChangedSPos       = Max( iMaxChangedSPos, (iStartChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( Max(m_pcInputSamplesRow[iCurViewPos][iStartChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
+      iMaxChangedSPos       = std::max( iMaxChangedSPos, (iStartChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iStartChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
       iLastSPos             = iCurSPos;
       m_iLastDepth          = m_iCurDepth;
 …
       // Get minimal changed sample position
       iMaxChangedSPos = Max( iMaxChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( Max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
+      iMaxChangedSPos = std::max( iMaxChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
       Int iCurSPos    = xShiftNewData(iCurPosX,iPosXinNewData);
       m_iCurDepth     = m_piNewDepthData[iPosXinNewData];
 …
     m_iThisDepth = m_iCurDepth;
     for (Int iFillSPos = Max(0, xRangeLeftL(iCurSPos) ); iFillSPos <= min(xRangeRightL( iLastSPos ) ,m_iLastOccludedSPosFP-1); iFillSPos++ )
+    for (Int iFillSPos = std::max(0, xRangeLeftL(iCurSPos) ); iFillSPos <= min(xRangeRightL( iLastSPos ) ,m_iLastOccludedSPosFP-1); iFillSPos++ )
+    {
       Int iDeltaCurSPos  = (iFillSPos << m_iShiftPrec) - iCurSPos;
 …
   m_iThisDepth = m_iLastDepth;
   for (Int iFillSPos = Max(iStartFillSPosFP+1,0); iFillSPos <= min(xRangeRightL( iLastSPos ), m_iLastOccludedSPosFP-1 ); iFillSPos++ )
+  for (Int iFillSPos = std::max(iStartFillSPosFP+1,0); iFillSPos <= min(xRangeRightL( iLastSPos ), m_iLastOccludedSPosFP-1 ); iFillSPos++ )
+  {
     xSetShiftedPelL<bSet>( iLastPos, 0,  iFillSPos, REN_IS_HOLE, riError );
 …
 //    return;
   Int iSPosFullPel = Max(0,xRangeLeftL(iCurSPos));
+  Int iSPosFullPel = std::max(0,xRangeLeftL(iCurSPos));
   m_iThisDepth = m_iCurDepth;
 …
   //    return;
   Int iSPosFullPel = Min(m_iWidth-1,xRangeRightR(iCurSPos));
+  Int iSPosFullPel = std::min(m_iWidth-1,xRangeRightR(iCurSPos));
   m_iThisDepth = m_iCurDepth;
 …
     // Yuv
     pcOutSample->iYLeft  = pcInSample->aiY[iSubSourcePos];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcOutSample->iULeft  = pcInSample->aiU[iSubSourcePos];
     pcOutSample->iVLeft  = pcInSample->aiV[iSubSourcePos];
 …
   else
+  {
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef,
                          pcInSample->aiU[iSubSourcePos] - pcOutSample->iURef,
 …
+{
   Pel piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel piBlendedValueU;
   Pel piBlendedValueV;
 …
     pcInSample ->aiY[iSubSourcePos],
     pcOutSample->iYRight,
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcInSample ->aiU[iSubSourcePos],
     pcOutSample->iURight,
 …
     pcOutSample->iFilledRight  ,
     piBlendedValueY
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     , piBlendedValueU,
     piBlendedValueV
 …
     pcOutSample->iYLeft      = pcInSample ->aiY[iSubSourcePos];
     pcOutSample->iYBlended   = piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcOutSample->iULeft      = pcInSample ->aiU[iSubSourcePos];
     pcOutSample->iUBlended   = piBlendedValueU;
 …
     // Get Error
     Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Int iDiffU = pcOutSample->iURef - piBlendedValueU;
     Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
 …
+  {
     Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Int iDiffU = pcOutSample->iURef - piBlendedValueU;
     Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
 …
     // Yuv
     pcOutSample->iYRight  = pcInSample->aiY[iSubSourcePos];
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcOutSample->iURight  = pcInSample->aiU[iSubSourcePos];
     pcOutSample->iVRight  = pcInSample->aiV[iSubSourcePos];
 …
   else
+  {
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef,
       pcInSample->aiU[iSubSourcePos] - pcOutSample->iURef,
 …
+{
   Pel piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Pel piBlendedValueU;
   Pel piBlendedValueV;
 …
     pcOutSample->iYLeft,
     pcInSample ->aiY[iSubSourcePos],
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcOutSample->iULeft,
     pcInSample ->aiU[iSubSourcePos],
 …
     iFilled,
     piBlendedValueY
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     , piBlendedValueU,
     piBlendedValueV
 …
     pcOutSample->iYRight     = pcInSample ->aiY[iSubSourcePos];
     pcOutSample->iYBlended   = piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     pcOutSample->iURight     = pcInSample ->aiU[iSubSourcePos];
     pcOutSample->iUBlended   = piBlendedValueU;
 …
     // Get Error
     Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Int iDiffU = pcOutSample->iURef - piBlendedValueU;
     Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
 …
+  {
     Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Int iDiffU = pcOutSample->iURef - piBlendedValueU;
     Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
 …
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
 template <BlenMod iBM, Bool bBitInc>  __inline Void
 TRenSingleModelC<iBM,bBitInc>::xGetBlendedValue( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
 …
     if (iBM == BLEND_LEFT )
+    {
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       xGetBlendedValueBM1(  iYL,  iYR,  iUL,  iUR,  iVL,  iVR,  iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY,  riU, riV );
 #else
 …
     else
+    {
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       xGetBlendedValueBM2(  iYL,  iYR,  iUL,  iUR,  iVL,  iVR,  iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY,  riU, riV );
 #else
 …
+      {
         riY = xBlend( iYL, iYR, iFilledR >> 1 );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU = xBlend( iUL, iUR, iFilledR >> 1 );
         riV = xBlend( iVL, iVR, iFilledR >> 1 );
 …
+      {
         riY = xBlend( iYR, iYL, (iFilledL >> 1) );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU = xBlend( iUR, iUL, (iFilledL >> 1) );
         riV = xBlend( iVR, iVL, (iFilledL >> 1) );
 …
+      {
         riY = xBlend( iYL, iYR, m_iBlendDistWeight );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU = xBlend( iUL, iUR, m_iBlendDistWeight );
         riV = xBlend( iVL, iVR, m_iBlendDistWeight );
 …
+    {
       riY = iYL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       riU = iUL;
       riV = iVL;
 …
+    {
       riY = iYR;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       riU = iUR;
       riV = iVR;
 …
+    {
         riY =  iYR;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU =  iUR;
         riV =  iVR;
 …
+    {
         riY =  iYL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU =  iUL;
         riV =  iVL;
 …
+    {
         riY = iYL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
         riU = iUL;
         riV = iVL;
 …
+    {
       riY = iYR;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
       riU = iUR;
       riV = iVR;
 …
 template <BlenMod iBM, Bool bBitInc> __inline Void
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
 TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM1( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
 #else
 …
+  {
     riY = iYL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = iUL;
     riV = iVL;
 …
+  {
     riY = iYR;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = iUR;
     riV = iVR;
 …
+  {
     riY = xBlend( iYR, iYL, iFilledL );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = xBlend( iUR, iUL, iFilledL );
     riV = xBlend( iVR, iUL, iFilledL );
 …
 template <BlenMod iBM, Bool bBitInc> __inline Void
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
 TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM2( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
 #else
 …
+  {
     riY = iYR;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = iUR;
     riV = iVR;
 …
+  {
     riY = iYL;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = iUL;
     riV = iVL;
 …
+  {
     riY = xBlend( iYL, iYR, iFilledR );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     riU = xBlend( iUL, iUR, iFilledR );
     riV = xBlend( iVL, iUR, iFilledR );
 …
 template class TRenSingleModelC<BLEND_RIGHT,false>;
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
 template <BlenMod iBM, Bool bBitInc>
 __inline Bool
 …
+}
 #endif
 #endif
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenSingleModel.h

-                      r438
+                      r446
  */
+#if !QC_MVHEVC_B0046
 #ifndef __TRENSINGLEMODEL__
 #define __TRENSINGLEMODEL__
 …
 #include <cstring>
+#if H_3D_VSO
 using namespace std;
+#if HHI_VSO_RM_ASSERTIONS
+#if H_3D_VSO_RM_ASSERTIONS
 #define RM_AOT( exp ) AOT ( exp )
 #define RM_AOF( exp ) AOF ( exp )
 …
   virtual ~TRenSingleModel() { }
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   virtual Void   create    ( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bEarlySkip ) = 0;
 #else
 …
   // Set Data
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   virtual Void   setDepth  ( Int iViewPos,                 Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel* piOrgData, Int iOrgStride )  = 0;
 #else
 …
   // Get Distortion
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   virtual RMDist getDistDepth  ( Int iViewPos,             Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel * piOrgData , Int iOrgStride)=0;
 #else
 …
     // video
     Pel aiY[5]    ; // y-value
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Pel aiU[5]    ; // u-value
     Pel aiV[5]    ; // v-value
 …
     Pel iYRight   ;
     Pel iYBlended ;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Pel iULeft    ;
     Pel iURight   ;
 …
     // reference
     Pel iYRef    ;
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
     Pel iURef    ;
     Pel iVRef    ;
 …
   // Create Model
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Void   create    ( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bEarlySkip  );
 #else
 …
   Void   setup     ( TComPicYuv* pcOrgVideo, Int** ppiShiftLutLeft, Int** ppiBaseShiftLutLeft, Int** ppiShiftLutRight,  Int** ppiBaseShiftLutRight,  Int iDistToLeft, Bool bKeepReference );
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Void   setDepth  ( Int iViewPos,                 Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel* piOrgData, Int iOrgStride );
 #else
 …
   // Get Distortion
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   RMDist getDistDepth  ( Int iViewPos,             Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel * piOrgData , Int iOrgStride);
 #else
 …
   /////  Rendering /////
   // Left to Right
 #if LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
                       __inline Bool   xDetectEarlySkipL   ( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData,Pel* piOrgData, Int iOrgStride );
                       __inline Bool   xDetectEarlySkipR   ( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData,Pel* piOrgData, Int iOrgStride );
 …
   template<Bool bSet> __inline Void   xSetShiftedPelBlend ( Int iSourcePos, Int iTargetSPos, Pel iFilled, RMDist& riError );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   __inline Void   xGetBlendedValue    ( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV );
   __inline Void   xGetBlendedValueBM1 ( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV );
 …
   __inline Void   xSetInts   ( Int*  piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Int iVal );
 #if HHI_VSO_COLOR_PLANES
+#if H_3D_VSO_COLOR_PLANES
   Void            xGetSampleStrTextPtrs ( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY, Pel RenModelOutPels::*& rpiSrcU, Pel RenModelOutPels::*& rpiSrcV );
 #else
 …
   Int   m_iShiftPrec;
   Int   m_iHoleMargin;
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Bool  m_bEarlySkip;
 #endif
 …
   //// Early Skip
 #ifdef LGE_VSO_EARLY_SKIP_A0093
+#if H_3D_VSO_EARLY_SKIP
   Bool* m_pbHorSkip;
 #endif
 };
+#endif // H_3D
 #endif //__TRENSINGLEMODEL__
+#endif

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenTop.cpp

-                      r438
+                      r446
  */
 #include "TRenImage.h"
 #include "TRenTop.h"
 …
 #include <math.h>
 #include "../TLibCommon/CommonDef.h"
+#if H_3D
 Void TRenTop::xGetDataPointers( PelImage*& rpcInputImage, PelImage*& rpcOutputImage, PelImage*& rpcInputDepth, PelImage*& rpcOutputDepth, PelImage*& rpcFilled, Bool bRenderDepth )
 …
 Void TRenTop::xEnhSimilarityPlane       ( PelImagePlane** apcLeftPlane, PelImagePlane** apcRightPlane, PelImagePlane* pcFilledLeftPlane, PelImagePlane* pcFilledRightPlane, UInt uiNumberOfPlanes )
+{
+  AOF( g_bitDepthC == g_bitDepthY );
   AOT( m_iSimEnhBaseView != 1 && m_iSimEnhBaseView != 2 );
   Int iWidth  = (*apcRightPlane)->getWidth ();
   Int iHeight = (*apcRightPlane)->getHeight();
   Int* aiHistLeft  = new Int[ g_uiIBDI_MAX + 1 ];
   Int* aiHistRight = new Int[ g_uiIBDI_MAX + 1 ];
   Pel* aiConvLUT   = new Pel[ g_uiIBDI_MAX + 1 ];
+  Int* aiHistLeft  = new Int[ ((Int64)1 ) << g_bitDepthY ];
+  Int* aiHistRight = new Int[ ((Int64)1 ) << g_bitDepthY ];
+  Pel* aiConvLUT   = new Pel[ ((Int64)1 ) << g_bitDepthY ];
   for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++ )
+  {
     for (Int iCurVal = 0 ; iCurVal <= g_uiIBDI_MAX; iCurVal++)
+    for (Int iCurVal = 0 ; iCurVal < ( 1 << g_bitDepthY ); iCurVal++)
+    {
       aiHistLeft [iCurVal] = 0;
 …
     Int iCheckSumRight = 0;
     for (Int iCurVal = 0 ; iCurVal <= g_uiIBDI_MAX; iCurVal++)
+    for (Int iCurVal = 0 ; iCurVal < ( 1 << g_bitDepthY ); iCurVal++)
+    {
       iCheckSumLeft  += aiHistLeft [iCurVal];
 …
     while( iCurChangeVal <= g_uiIBDI_MAX )
+    while( iCurChangeVal < ( 1 << g_bitDepthY ) )
+    {
       if ( iCumSumBase == iCumSumChange )
+      {
         aiConvLUT[iCurChangeVal] = Min(iCurBaseVal, g_uiIBDI_MAX);
+        aiConvLUT[iCurChangeVal] = std::min( iCurBaseVal,  ( 1 << g_bitDepthY ) - 1 );
         iCurBaseVal  ++;
         iCurChangeVal++;
         iCumSumChange += aiHistChange[iCurChangeVal];
         if (iCurBaseVal <= g_uiIBDI_MAX )
+        if (iCurBaseVal <  ( 1 << g_bitDepthY ) )
+        {
           iCumSumBase   += aiHistBase  [iCurBaseVal]  ;
 …
+      {
         iCurBaseVal++;
         if (iCurBaseVal <= g_uiIBDI_MAX )
+        if (iCurBaseVal < ( 1 << g_bitDepthY ) )
+        {
           iCumSumBase   += aiHistBase  [iCurBaseVal]  ;
 …
       else if ( iCumSumBase > iCumSumChange)
+      {
         aiConvLUT[iCurChangeVal] = Min(iCurBaseVal, g_uiIBDI_MAX);
+        aiConvLUT[iCurChangeVal] = std::min(iCurBaseVal, ( 1 << g_bitDepthY )-1);
         iCurChangeVal++;
         iCumSumChange += aiHistChange  [iCurChangeVal]  ;
 …
 Void TRenTop::temporalFilterVSRS( TComPicYuv* pcPicYuvVideoCur, TComPicYuv* pcPicYuvDepthCur, TComPicYuv* pcPicYuvVideoLast, TComPicYuv* pcPicYuvDepthLast, Bool bFirstFrame )
+{
+  AOF( g_bitDepthY == g_bitDepthC );
   Int iSADThres  = 100 ;  //threshold of sad in 4*4 block motion detection
 …
             { //Weight: 0.75
               Int iFilt = (( (pcDepthLastDataBlk[iCurPosX] << 1 ) + pcDepthLastDataBlk[iCurPosX] + pcDepthCurDataBlk[iCurPosX] + 2 ) >> 2 );
               assert( (iFilt >= 0) && (iFilt <=  g_uiIBDI_MAX) );
+              assert( (iFilt >= 0) && (iFilt <  ( 1 << g_bitDepthY ) ) );
               pcDepthCurDataBlk[iCurPosX] = pcDepthLastDataBlk[iCurPosX];
               pcDepthCurDataBlk[iCurPosX] = iFilt;
 …
   if(m_aiBlkMoving         != NULL ) delete[] m_aiBlkMoving;
+}
+#endif // H_3D

branches/HTM-DEV-0.2-dev/source/Lib/TLibRenderer/TRenTop.h

-                      r438
+                      r446
 #include "../TLibCommon/CommonDef.h"
 #include "../TLibCommon/TComPicYuv.h"
+#if H_3D
 #include <list>
 #include <vector>
 …
 };
+#endif // H_3D
 #endif //__TRENTOP__

Context navigation

Changeset 446 in 3DVCSoftware for branches/HTM-DEV-0.2-dev/source/Lib

Legend:

Download in other formats: