Changeset 166 in 3DVCSoftware for branches/HTM-4.0.1-VSP-dev0/source

Timestamp:

1 Nov 2012, 19:22:41 (12 years ago)

Author:

mitsubishi-htm

Message:

Initial integration of VSP into HTM 4.0.1. The version used for JCT3V-B0102 at Shanghai meeting.

• VC9 project/solution files updated. Other Visual C++ project/solution files are not updated.
• Linux make file updated.

TODO

• A second release is expected to include some bug fix and improvements on the interface, e.g. to move switches from macro definition to the configuration file.
• A third release is expected after being integrated within HTM 5.x, which is to be used for CE1.h anchor.

Location:

branches/HTM-4.0.1-VSP-dev0/source

Files:

• App/TAppDecoder/TAppDecTop.cpp (modified) (5 diffs)
• App/TAppDecoder/TAppDecTop.h (modified) (4 diffs)
• App/TAppEncoder/TAppEncCfg.cpp (modified) (2 diffs)
• App/TAppEncoder/TAppEncTop.cpp (modified) (6 diffs)
• App/TAppEncoder/TAppEncTop.h (modified) (2 diffs)
• Lib/TAppCommon/TAppComCamPara.cpp (modified) (6 diffs)
• Lib/TAppCommon/TAppComCamPara.h (modified) (4 diffs)
• Lib/TLibCommon/CommonDef.h (modified) (1 diff)
• Lib/TLibCommon/DebugLog.cpp (added)
• Lib/TLibCommon/DebugLog.h (added)
• Lib/TLibCommon/TComDataCU.cpp (modified) (44 diffs)
• Lib/TLibCommon/TComDataCU.h (modified) (2 diffs)
• Lib/TLibCommon/TComDepthMapGenerator.cpp (modified) (6 diffs)
• Lib/TLibCommon/TComDepthMapGenerator.h (modified) (1 diff)
• Lib/TLibCommon/TComLoopFilter.cpp (modified) (3 diffs)
• Lib/TLibCommon/TComPic.cpp (modified) (5 diffs)
• Lib/TLibCommon/TComPic.h (modified) (4 diffs)
• Lib/TLibCommon/TComPicSym.cpp (modified) (1 diff)
• Lib/TLibCommon/TComPicYuv.h (modified) (1 diff)
• Lib/TLibCommon/TComPrediction.h (modified) (3 diffs)
• Lib/TLibCommon/TComResidualGenerator.cpp (modified) (1 diff)
• Lib/TLibCommon/TComSlice.cpp (modified) (10 diffs)
• Lib/TLibCommon/TComSlice.h (modified) (4 diffs)
• Lib/TLibCommon/TComYuv.h (modified) (1 diff)
• Lib/TLibCommon/TypeDef.h (modified) (3 diffs)
• Lib/TLibDecoder/TDecCAVLC.cpp (modified) (2 diffs)
• Lib/TLibDecoder/TDecCAVLC.h (modified) (1 diff)
• Lib/TLibDecoder/TDecCu.cpp (modified) (14 diffs)
• Lib/TLibDecoder/TDecCu.h (modified) (4 diffs)
• Lib/TLibDecoder/TDecEntropy.cpp (modified) (2 diffs)
• Lib/TLibDecoder/TDecEntropy.h (modified) (2 diffs)
• Lib/TLibDecoder/TDecSbac.cpp (modified) (2 diffs)
• Lib/TLibDecoder/TDecSbac.h (modified) (1 diff)
• Lib/TLibDecoder/TDecSlice.cpp (modified) (2 diffs)
• Lib/TLibDecoder/TDecTop.cpp (modified) (15 diffs)
• Lib/TLibDecoder/TDecTop.h (modified) (4 diffs)
• Lib/TLibEncoder/TEncCavlc.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncCavlc.h (modified) (1 diff)
• Lib/TLibEncoder/TEncCu.cpp (modified) (12 diffs)
• Lib/TLibEncoder/TEncCu.h (modified) (3 diffs)
• Lib/TLibEncoder/TEncEntropy.cpp (modified) (4 diffs)
• Lib/TLibEncoder/TEncEntropy.h (modified) (2 diffs)
• Lib/TLibEncoder/TEncGOP.cpp (modified) (4 diffs)
• Lib/TLibEncoder/TEncGOP.h (modified) (1 diff)
• Lib/TLibEncoder/TEncSbac.cpp (modified) (3 diffs)
• Lib/TLibEncoder/TEncSbac.h (modified) (1 diff)
• Lib/TLibEncoder/TEncSearch.cpp (modified) (37 diffs)
• Lib/TLibEncoder/TEncSearch.h (modified) (4 diffs)
• Lib/TLibEncoder/TEncTop.cpp (modified) (4 diffs)
• Lib/TLibEncoder/TEncTop.h (modified) (2 diffs)
• Lib/TLibRenderer/TRenFilter.cpp (modified) (2 diffs)
• Lib/TLibRenderer/TRenFilter.h (modified) (2 diffs)
• Lib/TLibRenderer/TRenInterpFilter.h (modified) (2 diffs)
• Lib/TLibRenderer/TRenModel.cpp (modified) (1 diff)
• Lib/TLibRenderer/TRenSingleModel.cpp (modified) (1 diff)
• Lib/TLibRenderer/TRenTop.cpp (modified) (13 diffs)
• Lib/TLibRenderer/TRenTop.h (modified) (5 diffs)

branches/HTM-4.0.1-VSP-dev0/source/App/TAppDecoder/TAppDecTop.cpp

@@ -262 +262 @@
     }
   }
+#if DEBUGIMGOUT
+  for(Int viewDepthIdx=0; viewDepthIdx<m_tVideoIOYuvReconDbgFile.size() ; viewDepthIdx++)
+  {
+    if( m_tVideoIOYuvReconDbgFile[viewDepthIdx] )
+    {
+      m_tVideoIOYuvReconDbgFile[viewDepthIdx]->close();
+      delete m_tVideoIOYuvReconDbgFile[viewDepthIdx]; 
+      m_tVideoIOYuvReconDbgFile[viewDepthIdx] = NULL ;
+    }
+  }
+#endif
 
   for(Int viewDepthIdx=0; viewDepthIdx<m_tDecTop.size() ; viewDepthIdx++)
@@ -330 +341 @@
 #endif
       }
+#if DEBUGIMGOUT
+#if PIC_CROPPING
+      m_tVideoIOYuvReconDbgFile[viewDepthId]->write( pcPic->getPicYuvRecDbg(), sps->getPicCropLeftOffset(), sps->getPicCropRightOffset(), sps->getPicCropTopOffset(), sps->getPicCropBottomOffset() );
+#else
+      m_tVideoIOYuvReconDbgFile[viewDepthId]->write( pcPic->getPicYuvRecDbg(), pcPic->getSlice(0)->getSPS()->getPad() );
+#endif
+#endif   
       
       // update POC of display order
@@ -388 +406 @@
 #endif
       }
+#if DEBUGIMGOUT
+#if PIC_CROPPING
+      m_tVideoIOYuvReconDbgFile[viewDepthId]->write( pcPic->getPicYuvRecDbg(), sps->getPicCropLeftOffset(), sps->getPicCropRightOffset(), sps->getPicCropTopOffset(), sps->getPicCropBottomOffset() );
+#else
+      m_tVideoIOYuvReconDbgFile[viewDepthId]->write( pcPic->getPicYuvRecDbg(), pcPic->getSlice(0)->getSPS()->getPad() );
+#endif
+#endif
       
       // update POC of display order
@@ -476 +501 @@
   }
 #endif
-
+#if DEBUGIMGOUT
+  while( m_tVideoIOYuvReconDbgFile.size() < newNumberOfViewDepth)
+  {
+    m_tVideoIOYuvReconDbgFile.push_back(new TVideoIOYuv);
+    Char buffer[4];
+    sprintf(buffer,"_%i", (Int)(m_tVideoIOYuvReconDbgFile.size()-1) / 2 );
+    Char* nextFilename = NULL;
+    if( (m_tVideoIOYuvReconDbgFile.size() % 2) == 0 )
+    {
+      Char* pchTempFilename = NULL;
+      xAppendToFileNameEnd( "DebugImg.yuv", "_depth", pchTempFilename);
+      xAppendToFileNameEnd( pchTempFilename, buffer, nextFilename);
+      free ( pchTempFilename );
+    }
+    else
+    {
+      xAppendToFileNameEnd( "DebugImg.yuv", buffer, nextFilename);
+    }
+    if( isDepth || ( !isDepth && (m_tVideoIOYuvReconDbgFile.size() % 2) == 1 ) )
+    {
+      m_tVideoIOYuvReconDbgFile.back()->open( nextFilename, true, m_outputBitDepth, g_uiBitDepth + g_uiBitIncrement );
+    }
+    free ( nextFilename );
+  }
+#endif
   while( m_pocLastDisplay.size() < newNumberOfViewDepth )
   {
@@ -533 +582 @@
   return pcPic;
 }
+
+#if VSP_N
+Void TAppDecTop::storeVSPInBuffer(TComPic* pcPicVSP, TComPic* pcPicAvail, Int iCodedViewIdx, Int iCoddedViewOrderIdx, Int iCurPoc, Bool bDepth)
+{
+  //first view does not have VSP 
+#if VSP_TEXT_ONLY
+  if((iCodedViewIdx == 0)||(bDepth))
+#else
+  if((iCodedViewIdx == 0))
+#endif
+    return;
+  pcPicVSP->getSlice(0)->setPOC( iCurPoc );
+  Int iNeighborViewId = 0;
+  Bool bRenderFromLeft;
+  //check if the neighboring view is situated to the left of the current view
+  bRenderFromLeft = ((iCoddedViewOrderIdx)>0);
+  //pointers to buffers   
+  TComPicYuv* pcPicYuvVideo = getPicFromView(iNeighborViewId, iCurPoc, bDepth)->getPicYuvRec();
+  TComPicYuv* pcPicYuvDepth = getPicFromView(iNeighborViewId, iCurPoc, true)->getPicYuvRec();
+  TComPicYuv* pcPicYuvVSP   = pcPicVSP->getPicYuvRec();
+  TComPicYuv* pcPicYuvAvail = pcPicAvail->getPicYuvRec();
+  //verifying buffers
+  AOF(pcPicYuvVideo);
+  AOF(pcPicYuvDepth);
+  AOF(pcPicYuvVSP);
+  AOF(pcPicYuvAvail);
+
+  TComPic* pcPic = getPicFromView( iCodedViewIdx, iCurPoc, bDepth );
+  pcPic->setPicYuvSynth( pcPicYuvVSP );
+  pcPic->setPicYuvAvail( pcPicYuvAvail );
+
+  //setting look-up table
+#if 0
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      -1
+      );
+#else
+#if NTT_SUBPEL
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewIPelLUT  ()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewIPelLUT  ()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      -1
+      );
+  m_cVSPRendererTop.setFposLUTs( 
+      m_cCamParsCollector.getBaseViewFPosLUT()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewFPosLUT()[iNeighborViewId][iCodedViewIdx]
+      );
+#else
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      m_cCamParsCollector.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCamParsCollector.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      -1
+      );
+#endif
+#endif
+
+#if NTT_SUBPEL
+  m_cVSPRendererTop.setInterpolationMode( (bDepth ? 0 : 5) );
+#endif
+
+  //extrapolate from view iNeighborViewId to the current view, storing in the VSP buffer
+  //m_cVSPRendererTop.extrapolateView(pcPicYuvVideo,pcPicYuvDepth, pcPicYuvVSP, bRenderFromLeft);
+  m_cVSPRendererTop.extrapolateAvailabilityView(pcPicYuvVideo,pcPicYuvDepth, pcPicYuvVSP, pcPicYuvAvail, bRenderFromLeft);
+
+  // mark it should be extended
+  pcPicVSP->getPicYuvRec()->setBorderExtension(false); 
+  pcPicVSP->getPicYuvRec()->extendPicBorder(); //will extend the border for prediction using pixels outside the frame
+  pcPicAvail->getPicYuvRec()->setBorderExtension(false); 
+  pcPicAvail->getPicYuvRec()->extendPicBorder();
+#if VSP_N_DUMP
+  {
+    Char acFilenameBase[1024];
+    ::sprintf(acFilenameBase,"VSP_dec_%sv%d_%dx%d_%04d.yuv",(bDepth?"D":"T"),iCodedViewIdx,pcPicYuvVSP->getWidth(), pcPicYuvVSP->getHeight(), iCurPoc);
+    pcPicYuvVSP->dump(acFilenameBase,0);
+    //pcPicYuvAvail->dump(acFilenameBase,iCurPoc!=0);
+  }
+#endif
+}
+#endif
+
 //! \}

branches/HTM-4.0.1-VSP-dev0/source/App/TAppDecoder/TAppDecTop.h

@@ -49 +49 @@
 #include "TLibDecoder/TDecTop.h"
 #include "TAppDecCfg.h"
+#if VSP_N
+#include "../../Lib/TLibRenderer/TRenTop.h"
+#endif
 
 //! \ingroup TAppDecoder
@@ -65 +68 @@
 
   std::vector<TVideoIOYuv*>       m_tVideoIOYuvReconFile;         ///< reconstruction YUV class
+#if DEBUGIMGOUT
+  std::vector<TVideoIOYuv*>       m_tVideoIOYuvReconDbgFile;      ///< debug YUV class
+#endif
 
   // for output control
@@ -79 +85 @@
   TComSPSAccess                   m_cSPSAccess;
   TComAUPicAccess                 m_cAUPicAccess;
+#endif
+
+#if VSP_N
+  TRenTop                         m_cVSPRendererTop;
 #endif
 
@@ -107 +117 @@
 #endif
 
+#if VSP_N
+  Bool              getUseDepth   () { return m_useDepth; }
+  TRenTop*          getVSPRendererTop(){ return &m_cVSPRendererTop; }
+  Void              storeVSPInBuffer(TComPic* pcPicVSP, TComPic* pcPicAvail, Int iCodedViewIdx, Int iCoddedViewOrderIdx, Int iCurPoc, Bool bDepth);
+#endif
+
 protected:
 //  Void  xCreateDecLib     (); ///< create internal classes

branches/HTM-4.0.1-VSP-dev0/source/App/TAppEncoder/TAppEncCfg.cpp

@@ -194 +194 @@
   
   /* File, I/O and source parameters */
-  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM , "original Yuv input file name %d")
-  ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM , "original Yuv depth input file name %d")
-  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv output file name %d")
-  ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv depth output file name %d")
-  ("BitstreamFile,b", cfg_BitstreamFile, string(""), "bitstream output file name")
-  ("CodeDepthMaps",         m_bUsingDepthMaps, false, "Encode depth maps" )
-  ("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
-  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( double )1.0, "Lambda modifier for temporal layer 0")
-  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( double )1.0, "Lambda modifier for temporal layer 1")
-  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( double )1.0, "Lambda modifier for temporal layer 2")
-  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( double )1.0, "Lambda modifier for temporal layer 3")
-  ("SourceWidth,-wdt",      m_iSourceWidth,  0, "Source picture width")
-  ("SourceHeight,-hgt",     m_iSourceHeight, 0, "Source picture height")
+  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM ,   "original Yuv input file name %d")
+  ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM ,   "original Yuv depth input file name %d")
+  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv output file name %d")
+  ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv depth output file name %d")
+  ("BitstreamFile,b",         cfg_BitstreamFile,        string(""),                   "bitstream output file name")
+  ("CodeDepthMaps",           m_bUsingDepthMaps,        false,                        "Encode depth maps" )
+  ("CodedCamParsPrecision",   m_iCodedCamParPrecision,  STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
+  ("LambdaModifier0,-LM0",    m_adLambdaModifier[ 0 ],  ( double )1.0,                "Lambda modifier for temporal layer 0")
+  ("LambdaModifier1,-LM1",    m_adLambdaModifier[ 1 ],  ( double )1.0,                "Lambda modifier for temporal layer 1")
+  ("LambdaModifier2,-LM2",    m_adLambdaModifier[ 2 ],  ( double )1.0,                "Lambda modifier for temporal layer 2")
+  ("LambdaModifier3,-LM3",    m_adLambdaModifier[ 3 ],  ( double )1.0,                "Lambda modifier for temporal layer 3")
+  ("SourceWidth,-wdt",        m_iSourceWidth,           0,                            "Source picture width")
+  ("SourceHeight,-hgt",       m_iSourceHeight,          0,                            "Source picture height")
 #if PIC_CROPPING
-  ("CroppingMode",          m_croppingMode,  0, "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
-  ("CropLeft",              m_cropLeft,      0, "Left cropping/padding for cropping mode 3")
-  ("CropRight",             m_cropRight,     0, "Right cropping/padding for cropping mode 3")
-  ("CropTop",               m_cropTop,       0, "Top cropping/padding for cropping mode 3")
-  ("CropBottom",            m_cropBottom,    0, "Bottom cropping/padding for cropping mode 3")
-  ("HorizontalPadding,-pdx",m_aiPad[0],      0, "horizontal source padding for cropping mode 2")
-  ("VerticalPadding,-pdy",  m_aiPad[1],      0, "vertical source padding for cropping mode 2")
+  ("CroppingMode",            m_croppingMode,           0,                            "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
+  ("CropLeft",                m_cropLeft,               0,                            "Left cropping/padding for cropping mode 3")
+  ("CropRight",               m_cropRight,              0,                            "Right cropping/padding for cropping mode 3")
+  ("CropTop",                 m_cropTop,                0,                            "Top cropping/padding for cropping mode 3")
+  ("CropBottom",              m_cropBottom,             0,                            "Bottom cropping/padding for cropping mode 3")
+  ("HorizontalPadding,-pdx",  m_aiPad[0],               0,                            "horizontal source padding for cropping mode 2")
+  ("VerticalPadding,-pdy",    m_aiPad[1],               0,                            "vertical source padding for cropping mode 2")
 #endif
   ("InputBitDepth",         m_uiInputBitDepth, 8u, "bit-depth of input file")
@@ -498 +498 @@
   m_pchRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
   m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
-  
+
   if ( m_bUsingDepthMaps )
   {

branches/HTM-4.0.1-VSP-dev0/source/App/TAppEncoder/TAppEncTop.cpp

@@ -697 +697 @@
 #endif
 
+#if VSP_N
+#if NTT_SUBPEL
+  m_cVSPRendererTop.init(m_iSourceWidth, m_iSourceHeight, true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 5, 1, 0, 6 );
+#else
+  m_cVSPRendererTop.init(m_iSourceWidth, m_iSourceHeight, true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 4, 1, 0, 6 );
+#endif
+#endif
 }
 
@@ -822 +829 @@
   TComPicYuv*       pcPicYuvRec = NULL;
   TComPicYuv*       pcDepthPicYuvRec = NULL;
-  
+
   // initialize internal class & member variables
   xInitLibCfg();
@@ -918 +925 @@
       if ( iNextPoc < m_iFrameToBeEncoded )
       {
-      m_cCameraData.update( iNextPoc );
+        m_cCameraData.update( iNextPoc );
       }
       for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
@@ -930 +937 @@
 #endif
         iNumEncoded = 0;
+
+#if VSP_SLICE_HEADER
+        m_acTEncTopList     [iViewIdx]->setUseVSP( (gopId%VSP_FRAME_INTERVAL==0) );
+        m_acTEncDepthTopList[iViewIdx]->setUseVSP( (gopId%VSP_FRAME_INTERVAL==0) );
+#endif
+
+#if VSP_N
+#if VSP_SLICE_HEADER
+        if( m_acTEncTopList[iViewIdx]->getUseVSP() )
+#endif
+        if( m_bUsingDepthMaps )
+        {
+          // Forward Warping
+          xStoreVSPInBuffer(m_acTEncTopList[iViewIdx]->getVSPBuf(), m_acTEncTopList[iViewIdx]->getVSPAvailBuf(), iViewIdx, false, gopId);
+        }
+#endif
         // call encoding function for one frame
         m_acTEncTopList[iViewIdx]->encode( eos[iViewIdx], pcPicYuvOrg, *m_picYuvRec[iViewIdx], outputAccessUnits, iNumEncoded, gopId );
@@ -937 +960 @@
         {
           Int  iNumDepthEncoded = 0;
+#if VSP_N
+#if VSP_SLICE_HEADER
+          if( m_acTEncDepthTopList[iViewIdx]->getUseVSP() )
+#endif
+            xStoreVSPInBuffer(m_acTEncDepthTopList[iViewIdx]->getVSPBuf(), m_acTEncDepthTopList[iViewIdx]->getVSPAvailBuf(), iViewIdx, true, gopId);
+#endif
           // call encoding function for one depth frame
           m_acTEncDepthTopList[iViewIdx]->encode( depthEos[iViewIdx], pcDepthPicYuvOrg, *m_picYuvDepthRec[iViewIdx], outputAccessUnits, iNumDepthEncoded, gopId );
@@ -1377 +1406 @@
 };
 
+#if VSP_N
+Void TAppEncTop::xStoreVSPInBuffer(TComPic* pcPicVSP, TComPic* pcPicAvail, Int iCodedViewIdx, Bool bDepth, Int gopId)
+{
+  //first view does not have VSP 
+#if VSP_TEXT_ONLY
+  if((iCodedViewIdx == 0)||(bDepth))
+#else
+  if((iCodedViewIdx == 0))
+#endif
+    return;
+
+  AOT( iCodedViewIdx <= 0);
+  AOT( iCodedViewIdx >= m_iNumberOfViews );
+  
+  Int iCurPoc;
+  //getting currrent POC and checking if the frame will be coded
+  if(bDepth)
+  {
+    iCurPoc = m_acTEncDepthTopList[iCodedViewIdx]->getFrameId(gopId);
+    if(iCurPoc>=m_acTEncDepthTopList[iCodedViewIdx]->getFrameToBeEncoded())
+      return;
+    //if(!(m_acTEncDepthTopList[iCodedViewIdx]->currentPocWillBeCoded())) 
+    //  return;
+  }
+  else
+  {
+    iCurPoc = m_acTEncTopList[iCodedViewIdx]->getFrameId(gopId);
+    if(iCurPoc>=m_acTEncTopList[iCodedViewIdx]->getFrameToBeEncoded())
+      return;
+    //if(!(m_acTEncTopList[iCodedViewIdx]->currentPocWillBeCoded())) 
+    //  return;
+  }
+  pcPicVSP->getSlice(0)->setPOC( iCurPoc );
+
+  Int iNeighborViewId = 0;
+  Bool bRenderFromLeft;
+  //check if the neighboring view is situated to the left of the current view
+  bRenderFromLeft = ((m_cCameraData.getBaseSortedId2Id()[iCodedViewIdx]-m_cCameraData.getBaseSortedId2Id()[iNeighborViewId])>0);
+  //pointers to buffers   
+  TComPicYuv* pcPicYuvVideo = xGetPicYuvFromView(iNeighborViewId, iCurPoc, bDepth, true );
+  TComPicYuv* pcPicYuvDepth = xGetPicYuvFromView(iNeighborViewId, iCurPoc, true, true );
+  TComPicYuv* pcPicYuvVSP   = pcPicVSP->getPicYuvRec();
+  TComPicYuv* pcPicYuvAvail = pcPicAvail->getPicYuvRec();
+  //verifying buffers
+  AOF(pcPicYuvVideo);
+  AOF(pcPicYuvDepth);
+  AOF(pcPicYuvVSP);
+  AOF(pcPicYuvAvail);
+  
+  TComPic* pcPic = getPicFromView( iCodedViewIdx, iCurPoc, bDepth );
+  pcPic->setPicYuvSynth( pcPicYuvVSP );
+  pcPic->setPicYuvAvail( pcPicYuvAvail );
+
+  //setting look-up table
+#if 0
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      -1
+      );
+#else
+#if NTT_SUBPEL
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewIPelLUT  ()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewIPelLUT  ()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      -1
+      );
+  m_cVSPRendererTop.setFposLUTs( 
+      m_cCameraData.getBaseViewFPosLUT()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewFPosLUT()[iNeighborViewId][iCodedViewIdx]
+      );
+#else
+  m_cVSPRendererTop.setShiftLUTs(
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      m_cCameraData.getBaseViewShiftLUTD()[iNeighborViewId][iCodedViewIdx],
+      m_cCameraData.getBaseViewShiftLUTI()[iNeighborViewId][iCodedViewIdx],
+      NULL,
+      -1
+      );
+#endif
+#endif
+
+#if NTT_SUBPEL
+  m_cVSPRendererTop.setInterpolationMode( (bDepth ? 0 : 5) );
+#endif
+
+  //extrapolate from view iNeighborViewId to the current view, storing in the VSP buffer
+  //m_cVSPRendererTop.extrapolateView(pcPicYuvVideo,pcPicYuvDepth, pcPicYuvVSP, bRenderFromLeft);
+  m_cVSPRendererTop.extrapolateAvailabilityView(pcPicYuvVideo,pcPicYuvDepth, pcPicYuvVSP, pcPicYuvAvail, bRenderFromLeft);
+
+
+  // mark it should be extended
+  pcPicVSP->getPicYuvRec()->setBorderExtension(false); 
+  pcPicVSP->getPicYuvRec()->extendPicBorder();//will extend the border for prediction using pixels outside the frame (done at the slice level as well
+  pcPicAvail->getPicYuvRec()->setBorderExtension(false); 
+  pcPicAvail->getPicYuvRec()->extendPicBorder();
+
+#if VSP_N_DUMP
+  {
+    Char acFilenameBase[1024];
+    ::sprintf(acFilenameBase,"VSP_enc_%sv%d_%dx%d.yuv",(bDepth?"D":"T"),iCodedViewIdx,m_iSourceWidth, m_iSourceHeight);
+    pcPicYuvVSP->dump(acFilenameBase,iCurPoc!=0);
+    //pcPicYuvAvail->dump(acFilenameBase,iCurPoc!=0);
+  }
+#endif
+
+}
+#endif
+
 //! \}

branches/HTM-4.0.1-VSP-dev0/source/App/TAppEncoder/TAppEncTop.h

@@ -99 +99 @@
   TRenTop  m_cUsedPelsRenderer;                               ///< renderer for used pels map
 #endif
+
+#if VSP_N
+  TRenTop                     m_cVSPRendererTop;
+#endif
+
 protected:
   // initialization
@@ -162 +167 @@
 #endif
 
+#if VSP_N
+  Void xStoreVSPInBuffer(TComPic* pcPicVSP, TComPic* pcPicAvail, Int iCodedViewIdx, Bool bDepth, Int gopId);
+#endif
 };// END CLASS DEFINITION TAppEncTop
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TAppCommon/TAppComCamPara.cpp

@@ -89 +89 @@
 }
 
+#if NTT_SUBPEL
+Void
+TAppComCamPara::xCreateLUTs_Subpel( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Int****& raiLUT0, Int****& raiLUT1 )
+{
+  AOF( m_uiBitDepthForLUT == 8 );
+  AOF( raiLUT0 == NULL && raiLUT1 == NULL );
+
+  uiNumberSourceViews = Max( 1, uiNumberSourceViews );
+  uiNumberTargetViews = Max( 1, uiNumberTargetViews );
+
+  raiLUT0         = new Int   ***[ uiNumberSourceViews ];
+  raiLUT1         = new Int   ***[ uiNumberSourceViews ];
+
+  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
+  {
+    raiLUT0        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+    raiLUT1        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+
+    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
+    {
+      raiLUT0        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT0        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT0        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+    }
+  }
+}
+#endif
 
 Void
@@ -928 +958 @@
 }
 
+#if NTT_SUBPEL
+Void
+TAppComCamPara::xSetShiftParametersAndLUT( UInt uiNumberSourceViews, UInt uiNumberTargetViews, UInt uiFrame, Int****& raiLUT_Disp, Int****& raiLUT_Fracpos )
+{
+  if( uiNumberSourceViews <= 1 || uiNumberTargetViews == 0 )
+  {
+    return;
+  }
+  AOF( raiLUT_Disp != NULL && raiLUT_Fracpos != NULL );
+  AOF( m_uiBitDepthForLUT == 8 );
+
+  Int     iLog2Div = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2Div > 0 );
+  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
+  {
+    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
+    {
+      // integer-valued scale and offset
+      Int64 iScale, iOffset;
+      xGetShiftParameterInt ( uiSourceView, uiTargetView, uiFrame, false, true, iScale, iOffset );
+
+      // offsets including rounding offsets
+      iOffset += ( 1 << iLog2Div ) >> 1;
+
+      for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
+      {
+        Int64   iTempScale      = (Int64)uiDepthValue * iScale;
+        Int     iShiftSubpel    = (Int) (( iTempScale + iOffset ) >> iLog2Div);
+        Int     iShiftPelLuma   = iShiftSubpel >> m_iLog2Precision; // better to have rounding ?
+        Int     iShiftPelChroma = iShiftPelLuma >> 1;
+
+        raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = iShiftPelLuma;
+        raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = iShiftPelChroma;
+        raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = iShiftSubpel - ( iShiftPelLuma << m_iLog2Precision );
+        raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = iShiftSubpel - ( iShiftPelChroma << (m_iLog2Precision+1) );
+
+#if 0 // NTT bugfix
+        if ( raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] < 0 )
+          raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = -4 - raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ];
+        if ( raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] < 0 )
+          raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = -4 - raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ];
+#endif
+
+#if _DEBUG
+        AOF( (raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ]>> m_iLog2Precision   ) == 0 );
+        AOF( (raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ]>>(m_iLog2Precision+1)) == 0 );
+#endif
+      }
+
+      raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+      raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT_Disp   [ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+      raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+      raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT_Fracpos[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+    }
+  }
+}
+#endif
 
 Void
@@ -936 +1022 @@
   xSetShiftParametersAndLUT( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  uiFrame, false, m_adBaseViewShiftLUT,  m_aiBaseViewShiftLUT,  m_adBaseViewShiftParameter,  m_aiBaseViewShiftParameter  );
   xSetShiftParametersAndLUT( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfSynthViews, uiFrame, true,  m_adSynthViewShiftLUT, m_aiSynthViewShiftLUT, m_adSynthViewShiftParameter, m_aiSynthViewShiftParameter );
+#if NTT_SUBPEL
+  xSetShiftParametersAndLUT( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  uiFrame, m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+#endif
 };
 
@@ -1066 +1155 @@
   m_aiSynthViewShiftLUT       = 0;
 
+#if NTT_SUBPEL
+  m_aiBaseViewShiftLUT_ipel   = 0;
+  m_aiBaseViewShiftLUT_fpos   = 0;
+#endif
+
   m_bSetupFromCoded           = false;
   m_bCamParsCodedPrecSet      = false;
@@ -1091 +1185 @@
   xDeleteArray( m_aaiPdmScaleNomDelta,       m_iNumberOfBaseViews );
   xDeleteArray( m_aaiPdmOffset,              m_iNumberOfBaseViews );
+
+#if NTT_SUBPEL
+  xDeleteArray( m_aiBaseViewShiftLUT_ipel,   m_iNumberOfBaseViews, m_iNumberOfBaseViews,  2 );
+  xDeleteArray( m_aiBaseViewShiftLUT_fpos,   m_iNumberOfBaseViews, m_iNumberOfBaseViews,  2 );
+#endif
 }
 
@@ -1337 +1436 @@
   xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiPdmOffset            );
 
+#if NTT_SUBPEL
+  xCreateLUTs_Subpel( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aiBaseViewShiftLUT_ipel,  m_aiBaseViewShiftLUT_fpos);
+#endif
+
   //===== init disparity to virtual depth conversion parameters =====
   xSetPdmConversionParams();

branches/HTM-4.0.1-VSP-dev0/source/Lib/TAppCommon/TAppComCamPara.h

@@ -107 +107 @@
   Int****             m_aiSynthViewShiftLUT;                   ///< Disparity LUT
 
+#if NTT_SUBPEL
+  Int****             m_aiBaseViewShiftLUT_ipel;              ///< Disparity LUT
+  Int****             m_aiBaseViewShiftLUT_fpos;              ///< Disparity LUT
+#endif
 
 protected:
@@ -117 +121 @@
   template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize );
 
+#if NTT_SUBPEL
+  Void                    xCreateLUTs_Subpel  ( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Int****& raiLUT0, Int****& raiLUT1 );
+#endif
+
   // functions for reading, initialization, sorting, getting data, etc.
   Void  xReadCameraParameterFile  ( Char* pchCfgFileName );
@@ -143 +151 @@
   Void  xSetShiftParametersAndLUT ( UInt uiNumViewDim1, UInt uiNumViewDim2, UInt uiFrame, Bool bExternalReference, Double****& radLUT, Int****& raiLUT, Double***& radShiftParams, Int64***& raiShiftParams );
   Void  xSetShiftParametersAndLUT ( UInt uiFrame );
-
+#if NTT_SUBPEL
+  Void  xSetShiftParametersAndLUT ( UInt uiNumViewDim1, UInt uiNumViewDim2, UInt uiFrame, Int****& raiLUT_Disp, Int****& raiLUT_Fracpos );
+#endif
 
   // getting conversion parameters for disparity to virtual depth conversion
@@ -211 +221 @@
   Int****             getSynthViewShiftLUTI     ()  { return m_aiSynthViewShiftLUT;  }
   Int****             getBaseViewShiftLUTI      ()  { return m_aiBaseViewShiftLUT;   }
+
+#if NTT_SUBPEL
+  Int****             getBaseViewIPelLUT        ()  { return m_aiBaseViewShiftLUT_ipel;   }
+  Int****             getBaseViewFPosLUT        ()  { return m_aiBaseViewShiftLUT_fpos;   }
+#endif
 
   Bool                getVaryingCameraParameters()  { return m_bCamParsVaryOverTime;    }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/CommonDef.h

@@ -110 +110 @@
 #define MAX_GOP                     64          ///< max. value of hierarchical GOP size
 
+#if VSP_N
+#define MAX_NUM_REF                 5           ///< max. value of multiple reference frames
+#define MAX_NUM_REF_LC              10          ///< max. value of combined reference frames
+#else
 #define MAX_NUM_REF                 4           ///< max. value of multiple reference frames
 #define MAX_NUM_REF_LC              8           ///< max. value of combined reference frames
+#endif
 
 #define MAX_UINT                    0xFFFFFFFFU ///< max. value of unsigned 32-bit integer

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComDataCU.cpp

@@ -49 +49 @@
 Int * TComDataCU::m_pcGlbArlCoeffCb = NULL;
 Int * TComDataCU::m_pcGlbArlCoeffCr = NULL;
+#endif
+
+#if FORCE_REF_VSP==1
+#define CHECK_ADD_YET(pcCURef,uiIdx) 
+#define SET_AOUND_MVINFO(pcCURef,uiIdx)  \
+{\
+  if((pcCURef)->isVspMode((uiIdx))){\
+    pcMvFieldNeighbours[iCount<<1].setRefIdx(getSlice()->getRefIdxVsp(REF_PIC_LIST_0));\
+    if(getSlice()->isInterB()){\
+      pcMvFieldNeighbours[(iCount<<1)+1].setRefIdx(getSlice()->getRefIdxVsp(REF_PIC_LIST_1));\
+    }\
+  }\
+}
+
+#elif FORCE_REF_VSP==2
+#define CHECK_ADD_YET(pcCURef,uiIdx)  &&!((pcCURef)->isVspMode((uiIdx),TComMv(0,0))&&bVspMvZeroDone)
+#define SET_AOUND_MVINFO(pcCURef,uiIdx)   if((pcCURef)->isVspMode((uiIdx),TComMv(0,0))){bVspMvZeroDone=true;}
+
+inline bool TComDataCU::xAddVspSkip(UChar ucVspMergePos, Bool bVspMvZeroDone, UInt uiDepth, Bool* abCandIsInter, Int& iCount,
+                                    UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, Int mrgCandIdx)
+{
+#if VSP_SLICE_HEADER
+  if( !getSlice()->getVspFlag() ) return true;
+#endif
+
+  if( ucVspMergePos == VSP_MERGE_POS )
+  {
+#if VSP_TEXT_ONLY
+    if( !getSlice()->getSPS()->isDepth() )
+#endif
+    if( getSlice()->getSPS()->getViewId()!=0 && !bVspMvZeroDone )
+    {
+      Bool bSubCUCanBeSynthesized[4];
+      Bool * pbSubCUCanBeSynthesized = bSubCUCanBeSynthesized;
+      getPic()->checkSynthesisAvailability( getAddr(), getZorderIdxInCU(), uiDepth, pbSubCUCanBeSynthesized );
+      if( bSubCUCanBeSynthesized[0] && bSubCUCanBeSynthesized[1] && bSubCUCanBeSynthesized[2] && bSubCUCanBeSynthesized[3] )
+      {
+        abCandIsInter[iCount] = true;
+        // get Inter Dir
+        Int iInterDir = ((getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 && getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 0) ? 3 :
+          (getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 ? 1 : 2));
+        puhInterDirNeighbours[iCount] = iInterDir; //pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
+        // get Mv from Left
+        pcMvFieldNeighbours[iCount<<1].setMvField( TComMv(0, 0), getSlice()->getRefIdxVsp(REF_PIC_LIST_0) ); //pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
+        if ( getSlice()->isInterB() )
+        {
+          pcMvFieldNeighbours[(iCount<<1)+1].setMvField( TComMv(0, 0), getSlice()->getRefIdxVsp(REF_PIC_LIST_1) ); //pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
+        }
+#if SIMP_MRG_PRUN
+        if ( mrgCandIdx == iCount )
+        {
+          return false;
+        }
+#endif
+        iCount ++;
+      }
+    }
+  }
+  return true;
+}
 #endif
 
@@ -3450 +3510 @@
 #endif
 
+#if FORCE_REF_VSP==2
+  bool bVspMvZeroDone = false;
+#endif
+
   Int iCount = 0;
 
@@ -3513 +3577 @@
 #endif
 
-  //left
+#if FORCE_REF_VSP==2
+  //===== vsp 0 ===== 
+  if ( !xAddVspSkip(0, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+    return;
+#endif
+
+  //===== left ===== 
   UInt uiLeftPartIdx = 0;
   TComDataCU* pcCULeft = 0;
@@ -3533 +3603 @@
   if (!(uiPUIdx == 1 && (partSize == SIZE_Nx2N || partSize == SIZE_nLx2N || partSize == SIZE_nRx2N)))
   {
-  if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx ) )
+  if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx )
+#if FORCE_REF_VSP
+    CHECK_ADD_YET(pcCULeft, uiLeftPartIdx)
+#endif
+  )
   {
     abCandIsInter[iCount] = true;
@@ -3548 +3622 @@
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if FORCE_REF_VSP
+    SET_AOUND_MVINFO(pcCULeft, uiLeftPartIdx)
+#endif
 #if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
@@ -3581 +3658 @@
 #endif
 
-  // above
+#if FORCE_REF_VSP==2
+  //===== vsp 1 ===== 
+  if ( !xAddVspSkip(1, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+    return;
+#endif
+
+  //===== above ===== 
 #if !SIMP_MRG_PRUN
   partSize = getPartitionSize( uiAbsPartIdx );
@@ -3605 +3688 @@
 #if SIMP_MRG_PRUN
   if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx ) 
+#if FORCE_REF_VSP
+    CHECK_ADD_YET(pcCUAbove, uiAbovePartIdx)
+#endif
     && !(uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD))
     && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
@@ -3624 +3710 @@
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if FORCE_REF_VSP
+    SET_AOUND_MVINFO(pcCUAbove, uiAbovePartIdx)
+#endif
 #if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
@@ -3659 +3748 @@
 #endif
 
-  // above right
+#if FORCE_REF_VSP==2
+  //===== vsp 2 =====
+  if ( !xAddVspSkip(2, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+    return;
+#endif
+
+  //===== above right =====
   UInt uiAboveRightPartIdx = 0;
   TComDataCU* pcCUAboveRight = 0;
@@ -3677 +3772 @@
 #endif
 #if SIMP_MRG_PRUN
-  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
+  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) 
+#if FORCE_REF_VSP
+    CHECK_ADD_YET(pcCUAboveRight, uiAboveRightPartIdx)
+#endif
+    && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
 #else
   if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) )
@@ -3695 +3794 @@
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if FORCE_REF_VSP
+    SET_AOUND_MVINFO(pcCUAboveRight, uiAboveRightPartIdx)
+#endif
 #if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
@@ -3727 +3829 @@
 #endif
 
-  //left bottom
+#if FORCE_REF_VSP==2
+  //===== vsp 3 =====
+  if ( !xAddVspSkip(3, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+    return;
+#endif
+
+  //===== left bottom =====
+#if VSP_MERGE_POS < 4
+#if HHI_INTER_VIEW_MOTION_PRED
+  if( iCount < 4 + extraMergeCand )
+#else
+  if( iCount < 4 )
+#endif
+  {
+#endif
   UInt uiLeftBottomPartIdx = 0;
   TComDataCU* pcCULeftBottom = 0;
@@ -3745 +3861 @@
 #endif
 #if SIMP_MRG_PRUN
-  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
+  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) 
+#if FORCE_REF_VSP
+    CHECK_ADD_YET(pcCULeftBottom, uiLeftBottomPartIdx)
+#endif
+    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
 #else
   if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) )
@@ -3763 +3883 @@
     pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if FORCE_REF_VSP
+    SET_AOUND_MVINFO(pcCULeftBottom, uiLeftBottomPartIdx)
+#endif
 #if SIMP_MRG_PRUN
     if ( mrgCandIdx == iCount )
@@ -3771 +3894 @@
     iCount ++;
   }
+#if VSP_MERGE_POS < 4
+  }
+#endif
 
 #if HHI_INTER_VIEW_MOTION_PRED
@@ -3795 +3921 @@
 #endif
 
-  // above left 
+#if FORCE_REF_VSP==2
+  //===== vsp 4 =====
+  if( iCount < 4 + extraMergeCand )
+  {
+    if ( !xAddVspSkip(4, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+      return;
+  }
+#endif
+
+  //===== above left =====
 #if HHI_INTER_VIEW_MOTION_PRED
   if( iCount < 4 + extraMergeCand )
@@ -3820 +3955 @@
 #if SIMP_MRG_PRUN
     if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx )
+#if FORCE_REF_VSP
+     CHECK_ADD_YET(pcCUAboveLeft, uiAboveLeftPartIdx)
+#endif
      && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
      && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
@@ -3840 +3978 @@
       pcMvFieldNeighbours[(iCount<<1)+1].getMv().m_bDvMcp = false;
 #endif
+#if FORCE_REF_VSP
+      SET_AOUND_MVINFO(pcCUAboveLeft, uiAboveLeftPartIdx)
+#endif
 #if SIMP_MRG_PRUN
       if ( mrgCandIdx == iCount )
@@ -3849 +3990 @@
     }
   }
+
+#if FORCE_REF_VSP==2
+  //===== vsp 5 =====
+#if HHI_INTER_VIEW_MOTION_PRED
+  if( iCount < 4 + extraMergeCand )
+#else
+  if( iCount < 4 )
+#endif
+  {
+    if ( !xAddVspSkip(5, bVspMvZeroDone, uiDepth, abCandIsInter, iCount, puhInterDirNeighbours, pcMvFieldNeighbours, mrgCandIdx) )
+      return;
+  }
+#endif
 
   if ( getSlice()->getPPS()->getEnableTMVPFlag() )
@@ -4268 +4422 @@
   if( uiIter == 0 )
   {
-    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) 
+#if FORCE_REF_VSP==1
+     && !pcCorner->isVspMode( uiCornerPUIdx )
+#endif
+    )
     {
       rbValidCand = true;
@@ -4303 +4461 @@
   else
   {
-    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
+    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) 
+#if FORCE_REF_VSP==1
+     && !pcCorner->isVspMode( uiCornerPUIdx )
+#endif
+    )
     {
       rbValidCand = true;
@@ -4452 +4614 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
@@ -4478 +4643 @@
 
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
@@ -4504 +4672 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
@@ -4529 +4700 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
@@ -4557 +4731 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
@@ -4768 +4945 @@
   UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
 
-  Int   aiDvMcpDvCand[2][7] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal, DV-MCP ÁÖº¯ ºí·°¿¡¼­ »ç¿ëµÈ DV¸¦ ÀúÀå
+  Int   aiDvMcpDvCand[2][7] = {{0,},    {0,}}; // dummy, 5 spatial + 1 temporal, DV-MCP ÁÖº¯ ºúÓ°¿¡¼­ »ç¿EÈ DV¸¦ ÀúÀE
   Bool  abDvMcpFlag  [2][7] = {{false,},{false,}}; 
   //Int   aiRefPOC     [2][7] = {{-1,},{-1}}; // debug
@@ -4788 +4965 @@
   UInt uiLeftPartIdx = uiIdx;
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
@@ -4826 +5006 @@
 
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
@@ -4863 +5046 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
@@ -4900 +5086 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
@@ -4939 +5128 @@
 #endif
   if(pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ))
+#if VSP_N
+  if(pcTmpCU->getSlice()->getViewId() != NUM_VIEW_VSP)
+#endif
   {
     bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
@@ -5551 +5743 @@
 }
 
+#if FORCE_REF_VSP==2
+Int TComDataCU::isVspMode ( UInt uiPartIdx )
+{
+  if( m_pePredMode[ uiPartIdx ] == MODE_SKIP  ) return 0;
+  if( m_pePredMode[ uiPartIdx ] == MODE_INTRA ) return 0;
+
+  Int aiRefIdx[2] = {NOT_VALID, NOT_VALID}, iRet = 0;
+  for( Int iList = 0; iList < 2; iList++ )
+  {
+    aiRefIdx[iList] = getCUMvField( RefPicList(iList) )->getRefIdx( uiPartIdx );
+    if( aiRefIdx[iList] >= 0 && getSlice()->getRefViewId( RefPicList(iList), aiRefIdx[iList] ) == NUM_VIEW_VSP )
+    {
+      iRet |= (iList ? 0x02 : 0x01); // L0=1, L1=2, BI=3
+      continue;
+    }
+  }
+
+  return iRet; 
+}
+
+Int TComDataCU::isVspMode ( UInt uiPartIdx, TComMv cCompMv )
+{
+  TComMv cMv;
+  Int iRet = 0, iList = 0;
+
+  if( (iList = isVspMode( uiPartIdx )) )
+  {
+    switch( iList )
+    {
+    case 1:
+      cMv = getCUMvField( RefPicList(0) )->getMv( uiPartIdx );
+      if( cMv == cCompMv )
+      {
+        iRet = 1; // L0=1
+      }
+      break;
+    case 2:
+      cMv = getCUMvField( RefPicList(1) )->getMv( uiPartIdx );
+      if( cMv == cCompMv )
+      {
+        iRet = 2; // L1=2
+      }
+      break;
+    case 3:
+      cMv = getCUMvField( RefPicList(0) )->getMv( uiPartIdx );
+      if( cMv == cCompMv )
+      {
+        cMv = getCUMvField( RefPicList(1) )->getMv( uiPartIdx );
+        if( cMv == cCompMv )
+        {
+          iRet = 3; // BI=3
+        }
+      }
+      break;
+    }
+  }
+
+  return iRet; 
+}
+#endif
+
 // ====================================================================================================================
 // Protected member functions
@@ -5612 +5865 @@
   }
  
+#if AMVP_VSP_UNAVAILABLE
+  if( pcTmpCU != NULL && pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0 && pcTmpCU->getSlice()->getRefViewId( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ) == NUM_VIEW_VSP )
+  {
+    return false;
+  }
+#endif
+
   if ( pcTmpCU != NULL && m_pcSlice->isEqualRef(eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx), iRefIdx) )
   {
@@ -5713 +5973 @@
   TComDataCU* pcTmpCU = NULL;
   UInt uiIdx;
+#if VSP_N
+  Bool bRefVsp = false;
+#endif
   switch( eDir )
   {
@@ -5770 +6033 @@
     return false;
   }
+
+#if AMVP_VSP_UNAVAILABLE
+  if( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0 && pcTmpCU->getSlice()->getRefViewId( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ) == NUM_VIEW_VSP )
+  {
+    return false;
+  }
+#endif
   
   RefPicList eRefPicList2nd = REF_PIC_LIST_0;
@@ -5815 +6085 @@
     }
 
+#if VSP_N
+    if( pcTmpCU->getSlice()->getRefViewId( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ) == NUM_VIEW_VSP )
+    {
+      bRefVsp = true;
+    }
+    Int iScale = bRefVsp ? 4096 : xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#else
     Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#endif
     if ( iScale == 4096 )
     {
@@ -5842 +6120 @@
     }
 
+#if VSP_N
+    if( pcTmpCU->getSlice()->getRefViewId( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) ) == NUM_VIEW_VSP )
+    {
+      bRefVsp = true;
+    }
+    Int iScale = bRefVsp ? 4096 : xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#else
     Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
+#endif
     if ( iScale == 4096 )
     {
@@ -5875 +6161 @@
   Int iColViewIdx, iColRefViewIdx;
   TComPic *pColPic = getSlice()->getRefPic( eRefPicList, refidx);
+#if VSP_MV_ZERO // shimizu
   TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
   iColViewIdx = pColCU->getSlice()->getViewId();
-
+#if VSP_N
+  if( iColViewIdx == NUM_VIEW_VSP )
+  {
+    return false;
+  }
+#endif
+#else  
+#if VSP_N
+  if( pColPic->getSlice(0)->getViewId() == NUM_VIEW_VSP )
+  {
+    return false;
+  }
+#endif
+  TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
+  iColViewIdx = pColCU->getSlice()->getViewId();
+#endif
 
   if (pColCU->getPic()==0||pColCU->getPartitionSize(uiPartUnitIdx)==SIZE_NONE||pColCU->isIntra(uiAbsPartAddr))
@@ -5904 +6206 @@
 
     iColRefViewIdx = pColCU->getSlice()->getRefPic(eColRefPicList, iColRefIdx)->getViewId();
+#if VSP_N
+    if( iColRefViewIdx == NUM_VIEW_VSP )
+    {
+      continue;
+    }
+#endif
 
     if ( iColViewIdx    == iColRefViewIdx ) // temporal vector
@@ -6040 +6348 @@
   iScale = 0;
   iCurrRefViewOrderIdx = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx();
+#if VSP_N
+//  UInt uiColRefViewId = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewId();
+  UInt uiCurRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId();
+  if( uiCurRefViewId == NUM_VIEW_VSP )
+    iScale = 4096;
+  else
+#endif
   if((iColPOC != iColRefPOC)&&(iCurrPOC != iCurrRefPOC))
     iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
@@ -6052 +6367 @@
   if ( iScale == 4096 )
   {
+#if VSP_MV_ZERO
+    if( uiCurRefViewId == NUM_VIEW_VSP )
+      rcMv.setZero();
+    else
+#endif
     rcMv = cColMv;
   }
@@ -6151 +6471 @@
     return false;
   }
+
+#if VSP_N //??
+  if (pColCU->isSkipped(uiPartIdxCenter))
+    return false;
+#endif
   
   if( m_pcSlice->getRefPic( eRefPicList, iRefIdx )->getViewId() != m_pcSlice->getViewId() )
@@ -7705 +8030 @@
 
 //! \}
+

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComDataCU.h

@@ -265 +265 @@
   Bool          xAddMVPCand           ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
   Bool          xAddMVPCandOrder      ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
+#if FORCE_REF_VSP==2
+  inline bool   xAddVspSkip(UChar ucVspMergePos, Bool bVspMvZeroDone, UInt uiDepth, Bool* abCandIsInter, Int& iCount,
+                            UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, Int mrgCandIdx);
+#endif
 
   Void          deriveRightBottomIdx        ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxRB );
@@ -656 +660 @@
   Bool          isIntra   ( UInt uiPartIdx )  { return m_pePredMode[ uiPartIdx ] == MODE_INTRA; }
   Bool          isSkipped ( UInt uiPartIdx );                                                     ///< SKIP (no residual)
+#if FORCE_REF_VSP==1
+  Int           isVspMode ( UInt uiPartIdx )  { return m_pePredMode[ uiPartIdx ] == MODE_SYNTH; }
+#elif FORCE_REF_VSP==2 
+  Int           isVspMode ( UInt uiPartIdx );
+  Int           isVspMode ( UInt uiPartIdx, TComMv cCompMv );
+#endif
   
   // -------------------------------------------------------------------------------------------------------------------

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComDepthMapGenerator.cpp

@@ -562 +562 @@
   m_cTmpPic.dump( acFilename, ( pcPic->getPOC() != 0 )  );
 }
+
+#if VSP_N
+Void
+TComDepthMapGenerator::clearDepthMap( TComPic* pcPic, Int iVal/*=PDM_UNDEFINED_DEPTH*/ )
+{
+  xClearDepthMap( pcPic, iVal );
+}
+#endif
 #endif
 
@@ -733 +741 @@
       Int         iNumRefPics       = pcSlice->getNumRefIdx( eRefPicList );
       for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
-{
+      {
+#if VSP_N
+        if( pcSlice->getRefViewId( eRefPicList, iPdmRefIdx ) != NUM_VIEW_VSP )
+#endif
         if( pcSlice->getRefPOC( eRefPicList, iPdmRefIdx ) == pcSlice->getPOC())
         {
@@ -834 +845 @@
   Int           iRefPoc     = pcRefPic->getPOC();
   Bool          bInterview  = ( uiRefViewId < m_uiCurrViewId );
+#if VSP_N
+  Bool          bVsp        = ( pcRefPic->getViewId() == NUM_VIEW_VSP );
+  AOT(  bInterview &&  bVsp && iRefPoc != pcSlice->getPOC() );
+  AOT( !bInterview && !bVsp && iRefPoc == pcSlice->getPOC() );
+#else
   AOT(  bInterview && iRefPoc != pcSlice->getPOC() );
   AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
+#endif
+
+#if FORCE_REF_VSP
+  if( bVsp ) return false;
+#endif
+
   Bool          bPdmIView   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
   Bool          bPdmInter   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
@@ -924 +946 @@
   Int           iRefPoc     = pcRefPic->getPOC();
   Bool          bInterview  = ( uiRefViewId < m_uiCurrViewId );
+#if VSP_N
+  Bool          bVsp        = ( pcRefPic->getViewId() == NUM_VIEW_VSP );
+  AOT(  bInterview &&  bVsp && iRefPoc != pcSlice->getPOC() );
+  AOT( !bInterview && !bVsp && iRefPoc == pcSlice->getPOC() );
+#else
   AOT(  bInterview && iRefPoc != pcSlice->getPOC() );
   AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
+#endif
+
+#if FORCE_REF_VSP
+  if( bVsp ) return false;
+#endif
 
   Bool          bPdmIView   = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
@@ -1351 +1383 @@
     xInterPredictCUDepthMap( pcSubCU, pcSubDM );
     break;
+#if FORCE_REF_VSP==1
+  case MODE_SYNTH:
+    xIntraPredictCUDepthMap( pcSubCU, pcSubDM ); //What to do? Need Fix!
+    break;
+#endif
   default:
     AOT( true );
@@ -1464 +1501 @@
                                           aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != m_uiCurrViewId };
     Bool            bUsesInterViewPrd = ( abCurrIntView[0] || abCurrIntView[1] );
+#if VSP_N
+    if(( aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getViewId() == NUM_VIEW_VSP ) ||
+       ( aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getViewId() == NUM_VIEW_VSP )) {
+      //if refpic is VSP, copy to Original cuurent PDM
+      TComPicYuv* pcPdm = pcCU->getPic()->getPredDepthMap();
+      UInt  uiZOrderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
+      assert( pcPdm );
+      pcCUDepthMap->copyFromPicYuv( pcPdm, pcCU->getAddr(), uiZOrderIdx );
+    }
+#endif
     if( bUsesInterViewPrd )
     {

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComDepthMapGenerator.h

@@ -140 +140 @@
   Void  updateDepthMap        ( TComPic*      pcPic );
   Void  dumpDepthMap          ( TComPic*      pcPic, char* pFilenameBase );
+#if VSP_N
+  Void  clearDepthMap         ( TComPic*      pcPic, Int   iVal  = PDM_UNDEFINED_DEPTH);
+#endif
 #endif
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComLoopFilter.cpp

@@ -439 +439 @@
   
   //-- Set BS for Intra MB : BS = 4 or 3
-  if ( pcCUP->isIntra(uiPartP) || pcCUQ->isIntra(uiPartQ) )
+  if ( pcCUP->isIntra(uiPartP) || pcCUQ->isIntra(uiPartQ) 
+#if FORCE_REF_VSP==1
+    || pcCUP->isVspMode(uiPartP) || pcCUQ->isVspMode(uiPartQ) 
+#endif
+  )
   {
     uiBs = 2;
@@ -445 +449 @@
   
   //-- Set BS for not Intra MB : BS = 2 or 1 or 0
-  if ( !pcCUP->isIntra(uiPartP) && !pcCUQ->isIntra(uiPartQ) )
+  if ( !pcCUP->isIntra(uiPartP) && !pcCUQ->isIntra(uiPartQ) 
+#if FORCE_REF_VSP==1
+    && !pcCUP->isVspMode(uiPartP) && !pcCUQ->isVspMode(uiPartQ) 
+#endif
+  )
   {
 #if NSQT_LFFIX
@@ -542 +550 @@
   }   // enf of "if( not Intra )"
   
+#if FORCE_REF_VSP==1
+  if ( pcCUP->isVspMode(uiPartP) || pcCUQ->isVspMode(uiPartQ))
+  {
+    uiBs = 0;
+  }
+#endif
+
   m_aapucBS[iDir][uiAbsPartIdx] = uiBs;
 }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComPic.cpp

@@ -53 +53 @@
   m_apcPicYuv[0]      = NULL;
   m_apcPicYuv[1]      = NULL;
+#if VSP_N
+  m_apcPicYuvAvail     = NULL;
+  m_apcPicYuvSynth     = NULL;
+#endif
 #if DEPTH_MAP_GENERATION
   m_pcPredDepthMap    = NULL;
@@ -64 +68 @@
 #if HHI_INTER_VIEW_RESIDUAL_PRED
   m_pcResidual        = NULL;
+#endif
+#if DEBUGIMGOUT
+  m_acPicYuvDebug     = NULL;
 #endif
   m_pcPicYuvPred      = NULL;
@@ -95 +102 @@
   }
   m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
-  
+#if DEBUGIMGOUT
+  m_acPicYuvDebug    = new TComPicYuv;  m_acPicYuvDebug->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
+#endif
+
   /* there are no SEI messages associated with this picture initially */
   m_SEIs = NULL;
@@ -162 +172 @@
     delete m_pcResidual;
     m_pcResidual = NULL;
+  }
+#endif
+#if DEBUGIMGOUT
+  if (m_acPicYuvDebug)
+  {
+    m_acPicYuvDebug->destroy();
+    delete m_acPicYuvDebug;
+    m_acPicYuvDebug = NULL;
   }
 #endif
@@ -623 +641 @@
 }
 
+#if VSP_N
+Void TComPic::checkSynthesisAvailability( /*TComDataCU*& rpcCU, */UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth, Bool *&rpbCUSynthesied )
+{ 
+  rpbCUSynthesied[0] = true;
+  rpbCUSynthesied[1] = true;
+  rpbCUSynthesied[2] = true;
+  rpbCUSynthesied[3] = true;
+
+  if (!getPicYuvAvail())
+  {
+    rpbCUSynthesied[0] = false;
+    rpbCUSynthesied[1] = false;
+    rpbCUSynthesied[2] = false;
+    rpbCUSynthesied[3] = false;
+    return;    
+  }
+  
+  Int x, y;
+  Pel* pAvail  = getPicYuvAvail()->getLumaAddr ( iCuAddr, uiAbsZorderIdx );
+  Int CUHeight = g_uiMaxCUHeight >> uiPartDepth; //rpcCU->getHeight(uiAbsZorderIdx);
+  Int CUWidth  = g_uiMaxCUWidth  >> uiPartDepth; //rpcCU->getWidth(uiAbsZorderIdx);
+  
+  Int  iStride  = getPicYuvAvail()->getStride();
+  for ( y = ((CUHeight - 1) >> 1); y >= 0; y-- )
+  {
+    for ( x = ((CUWidth - 1) >> 1); x >= 0; x-- )
+    {
+      rpbCUSynthesied[0] &= (pAvail[x] != 0);
+    }
+    for ( x = CUWidth - 1; x >= ((CUWidth) >> 1); x-- )
+    {
+      rpbCUSynthesied[1] &= (pAvail[x] != 0);
+    }
+    pAvail += iStride;
+  }
+  //for ( y = CUHeight - 1; y >= ((CUHeight) >> 1); y-- )
+  for ( y = ((CUHeight - 1) >> 1); y >= 0; y-- ) //Owieczka
+  {
+    for ( x = ((CUWidth - 1) >> 1); x >= 0; x-- )
+    {
+      rpbCUSynthesied[2] &= (pAvail[x] != 0);
+    }
+    for ( x = CUWidth - 1; x >= ((CUWidth) >> 1); x-- )
+    {
+      rpbCUSynthesied[3] &= (pAvail[x] != 0);
+    }
+    pAvail += iStride;
+  }
+
+  //rpbCUSynthesied[0] = !rpbCUSynthesied[0];
+  //rpbCUSynthesied[1] = !rpbCUSynthesied[1];
+  //rpbCUSynthesied[2] = !rpbCUSynthesied[2];
+  //rpbCUSynthesied[3] = !rpbCUSynthesied[3];
+}
+#endif
 
 //! \}

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComPic.h

@@ -65 +65 @@
   TComPicYuv*           m_apcPicYuv[2];           //  Texture,  0:org / 1:rec
   
+#if VSP_N
+  TComPicYuv*           m_apcPicYuvAvail;         //  Availability Map - Does the given pixel can be synthesised in receiver
+  TComPicYuv*           m_apcPicYuvSynth;         //  Sythesied image
+#endif
+
 #if DEPTH_MAP_GENERATION
   TComPicYuv*           m_pcPredDepthMap;         //  estimated depth map
@@ -85 +90 @@
 #if HHI_INTER_VIEW_RESIDUAL_PRED
   TComPicYuv*           m_pcResidual;             //  residual buffer (coded or inter-view predicted residual)
+#endif
+#if DEBUGIMGOUT
+  TComPicYuv*           m_acPicYuvDebug;          //  debug image
 #endif
 
@@ -145 +153 @@
   TComPicYuv*   getPicYuvOrg()        { return  m_apcPicYuv[0]; }
   TComPicYuv*   getPicYuvRec()        { return  m_apcPicYuv[1]; }
+#if VSP_N
+  Void          setPicYuvAvail( TComPicYuv* pc ){ m_apcPicYuvAvail = pc; }
+  Void          setPicYuvSynth( TComPicYuv* pc ){ m_apcPicYuvSynth = pc; }
+  TComPicYuv*   getPicYuvAvail()      { return  m_apcPicYuvAvail; }
+  TComPicYuv*   getPicYuvSynth()      { return  m_apcPicYuvSynth; }
+  Void          checkSynthesisAvailability(  /*TComDataCU*& rpcBestCU, */UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth, Bool *&rpbCUSynthesied);
+#endif
 #if HHI_INTERVIEW_SKIP
   TComPicYuv*   getUsedPelsMap()      { return  m_pcUsedPelsMap; }
@@ -168 +183 @@
 #if HHI_INTER_VIEW_RESIDUAL_PRED
   TComPicYuv*   getResidual()         { return  m_pcResidual; }
+#endif
+
+#if DEBUGIMGOUT
+  TComPicYuv*   getPicYuvRecDbg()     { return  m_acPicYuvDebug; }
 #endif
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComPicSym.cpp

@@ -97 +97 @@
     m_puiInverseCUOrderMap[i] = i;
   }
+
+#if VSP_N
+  m_apcTComTile = NULL;
+#endif
 }
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComPicYuv.h

@@ -184 +184 @@
   Void  setChromaTo  ( Pel pVal );  
 
+#if DEBUGIMGOUT
+  // Degub tools
+public:
+  Void colsetToPicYuv   ( const UChar ucColor[3],                 Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void colsetToPicLuma  ( const UChar ucLumaOffCol,               Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void colsetToPicChroma( const UChar ucUCol, const UChar ucVCol, Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void drawLineToPicYuv ( bool bHor, bool bVer, UInt uiSize,      TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+#endif
+
 };// END CLASS DEFINITION TComPicYuv
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComPrediction.h

@@ -95 +95 @@
   Void xPredInterPrdDepthMap    ( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight,                         TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset );
 #endif
-
 #if DEPTH_MAP_GENERATION
   Void xWeightedAveragePdm      ( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst, UInt uiSubSampExpX, UInt uiSubSampExpY );
@@ -103 +102 @@
   Void xPredInterChromaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi );
   Void xWeightedAverage         ( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst );
-  
+
   Void xGetLLSPrediction ( TComPattern* pcPattern, Int* pSrc0, Int iSrcStride, Pel* pDst0, Int iDstStride, UInt uiWidth, UInt uiHeight, UInt uiExt0 );
 
@@ -142 +141 @@
   Void motionCompensation         ( TComDataCU*  pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList = REF_PIC_LIST_X, Int iPartIdx = -1 );
 #endif
-  
+
   // motion vector prediction
   Void getMvPredAMVP              ( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComResidualGenerator.cpp

@@ -390 +390 @@
     xSetRecResidualInterCU( pcSubCU, pcSubRes );
     break;
+#if FORCE_REF_VSP==1
+  case MODE_SYNTH:
+    xSetRecResidualIntraCU( pcSubCU, pcSubRes ); //MayBe it should be seperate function
+    break;
+#endif
   default:
     AOT( true );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComSlice.cpp

@@ -114 +114 @@
 {
   m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = m_aiNumRefIdx[2] = 0;
+
+#if FORCE_REF_VSP
+  m_iRefIdxVsp[0] = m_iRefIdxVsp[1] = NOT_VALID;
+#endif
   
   initEqualRef();
@@ -139 +143 @@
   resetWpScalingLC(m_weightPredTableLC);
   initWpAcDcParam();
+
+#if VSP_SLICE_HEADER
+  m_bVspFlag = false;
+#endif
 }
 
@@ -185 +193 @@
   m_numEntryPointOffsets = 0;
 #endif
+#if VSP_SLICE_HEADER
+  m_bVspFlag = false;
+#endif
+
 }
 
@@ -407 +419 @@
 }
 
+#if VSP_N
+Void TComSlice::setRefPicListMvc( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics, TComPic* pcVspPic )
+#else
 Void TComSlice::setRefPicListMvc( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics )
+#endif
 {
   if( m_eSliceType == I_SLICE )
@@ -422 +438 @@
   TComPic*  RefPicSetLtCurr [16];
   TComPic*  RefPicSetIvCurr [16];
+#if VSP_N
+  TComPic*  RefPicSetVspCurr [16] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}; //for Linux comp
+#endif
 
   UInt NumPocStCurr0 = 0;
@@ -427 +446 @@
   UInt NumPocLtCurr  = 0;
   UInt NumPocIvCurr  = 0;
+#if VSP_N
+  UInt NumPocVspCurr  = 0;
+#endif
 
   Int i;
@@ -474 +496 @@
     NumPocIvCurr++;
   }
+#if VSP_N
+  if( pcVspPic )
+  {
+    pcRefPic = pcVspPic;
+    pcRefPic->setIsLongTerm( 0 );
+    pcRefPic->getPicYuvRec()->extendPicBorder();
+    RefPicSetVspCurr[NumPocVspCurr] = pcRefPic;
+    NumPocVspCurr++;
+  }
+#endif
 
   // ref_pic_list_init
@@ -481 +513 @@
 
   assert( (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) == getNumPocTotalCurrMvc() );
+#if VSP_N
+  Int numRpsCurrTempList0 = max( (num_ref_idx_l0_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr + NumPocVspCurr) );
+  Int numRpsCurrTempList1 = max( (num_ref_idx_l1_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr + NumPocVspCurr) );
+#else
   Int numRpsCurrTempList0 = max( (num_ref_idx_l0_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) );
   Int numRpsCurrTempList1 = max( (num_ref_idx_l1_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) );
+#endif
 
   assert( numRpsCurrTempList0 <= 16 );
@@ -509 +546 @@
   for( cIdx = 0; cIdx <= num_ref_idx_l0_active_minus1; cIdx ++ )
   {
+#if VSP_N
+    if( pcVspPic && cIdx == num_ref_idx_l0_active_minus1 )
+    {
+      m_apcRefPicList[0][cIdx] = RefPicSetVspCurr[0];
+#if FORCE_REF_VSP
+      m_iRefIdxVsp[0] = cIdx;
+#endif
+    }
+    else
+      m_apcRefPicList[0][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? refPicListTemp0[ m_RefPicListModification.getRefPicSetIdxL0(cIdx) ] : refPicListTemp0[cIdx];
+#else
     m_apcRefPicList[0][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? refPicListTemp0[ m_RefPicListModification.getRefPicSetIdxL0(cIdx) ] : refPicListTemp0[cIdx];
+#endif
   }
   if( m_eSliceType == P_SLICE )
@@ -520 +569 @@
     for( cIdx = 0; cIdx <= num_ref_idx_l1_active_minus1; cIdx ++ )
     {
+#if VSP_N
+      if( pcVspPic && cIdx == num_ref_idx_l1_active_minus1 )
+      {
+        m_apcRefPicList[1][cIdx] = RefPicSetVspCurr[0];
+#if FORCE_REF_VSP
+        m_iRefIdxVsp[1] = cIdx;
+#endif
+      }
+      else
+        m_apcRefPicList[1][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(cIdx) ] : refPicListTemp1[cIdx];
+#else
       m_apcRefPicList[1][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(cIdx) ] : refPicListTemp1[cIdx];
+#endif
     }
   }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComSlice.h

@@ -45 +45 @@
 #include "TComRom.h"
 #include "TComList.h"
-
 //! \ingroup TLibCommon
 //! \{
@@ -1269 +1268 @@
 
 #if SONY_COLPIC_AVAILABILITY
-  Int         m_iViewOrderIdx;
+  Int        m_iViewOrderIdx;
+#endif
+
+#if FORCE_REF_VSP
+  Int        m_iRefIdxVsp[2]; // L0/L1
+#endif
+
+#if VSP_SLICE_HEADER
+  Bool      m_bVspFlag;
 #endif
 
@@ -1411 +1418 @@
   Int       getNumPocTotalCurr();
   Int       getNumPocTotalCurrMvc();
+#if VSP_N
+  Void      setRefPicListMvc    ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics, TComPic* pcVspPic );
+#else
   Void      setRefPicListMvc    ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics );
+#endif
   Void      setRefPOCnViewListsMvc();
 
@@ -1565 +1576 @@
   Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
 
+#if FORCE_REF_VSP
+  Void      setRefIdxVsp ( Int idx, Int refList ) { m_iRefIdxVsp[refList] = idx; }
+  Int       getRefIdxVsp ( Int refList )          { return m_iRefIdxVsp[refList]; }
+#endif
+
+#if VSP_SLICE_HEADER
+  Void      setVspFlag          ( Bool val )    { m_bVspFlag = val; }
+  Bool      getVspFlag          ()              { return m_bVspFlag; }
+#endif
+
 protected:
   TComPic*  xGetRefPic        (TComList<TComPic*>& rcListPic, UInt uiPOC);

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComYuv.h

@@ -213 +213 @@
 
   __inline Pel  xClip  (Pel x )      { return ( (x < 0) ? 0 : (x > (Pel)g_uiIBDI_MAX) ? (Pel)g_uiIBDI_MAX : x ); }
+
+#if DEBUGIMGOUT
+public:
+  Void colsetToPicYuv   ( const UChar ucColor[3],                 Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void colsetToPicLuma  ( const UChar ucLumaOffCol,               Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void colsetToPicChroma( const UChar ucUCol, const UChar ucVCol, Int iOffset[2][2], TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+  Void drawLineToPicYuv ( bool bHor, bool bVer, UInt uiSize,      TComPicYuv* pcPicYuvDst, UInt iCuAddr, UInt uiAbsZorderIdx, UInt uiPartDepth = 0, UInt uiPartIdx = 0 );
+#endif
+
 };// END CLASS DEFINITION TComYuv
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TypeDef.h

@@ -42 +42 @@
 //! \{
 
+#define VSP_N                             1
+#if VSP_N
+#define VSP_TEXT_ONLY                     1
+#define NUM_VIEW_VSP                      99
+#define VSP_N_DUMP                        0
+#define FORCE_REF_VSP                     2   // 0=NotUseVSPSKIP 1:VSPSKIPforFlag 2:VSPSKIPforMergeIdx
+#define VSP_MV_ZERO                       0   // use zero vector for VSP
+#if VSP_MV_ZERO
+#define AMVP_VSP_UNAVAILABLE              1
+#endif
+#define VSP_MERGE_POS                     5   // position of vsp in merge list (0..5)
+#define NTT_SUBPEL                        1
+#endif
+#define DEBUGIMGOUT                       0   //Debug YUVImage Out
+#define DEBUGLOGOUT                       0   //Debug Log Out
+
+#define VSP_SLICE_HEADER                  1
+#define VSP_FRAME_INTERVAL                2
+
 #define FIXES                             1
 #define POZNAN_CABAC_INIT_FLAG_FIX        1
@@ -115 +134 @@
 #define HHI_FULL_PEL_DEPTH_MAP_MV_ACC     1   // full-pel mv accuracy for depth maps
                                        
-#if HHI_INTER_VIEW_MOTION_PRED         
+#if HHI_INTER_VIEW_MOTION_PRED
 #define SAIT_IMPROV_MOTION_PRED_M24829    1   // improved inter-view motion vector prediction
 #else                                  
@@ -727 +746 @@
   MODE_INTER,           ///< inter-prediction mode
   MODE_INTRA,           ///< intra-prediction mode
+#if FORCE_REF_VSP==1
+  MODE_SYNTH,           ///< synth-mode
+#endif
   MODE_NONE = 15
 };

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp

@@ -2348 +2348 @@
 #endif
 
+#if VSP_SLICE_HEADER
+  if( rpcSlice->getSPS()->getViewId()!=0 
+#if VSP_TEXT_ONLY
+      && !(rpcSlice->getSPS()->isDepth()) 
+#endif
+    )
+  {
+    READ_FLAG( uiCode, "vsp_flag" );
+    rpcSlice->setVspFlag( uiCode ? true : false );
+  }
+#endif
+
   if (!bEntropySlice)
   {
@@ -2601 +2613 @@
 }
 
+#if FORCE_REF_VSP==1
+Void TDecCavlc::parseVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  assert(0);
+}
+#endif
+
 #if HHI_INTER_VIEW_MOTION_PRED
 Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCAVLC.h

@@ -142 +142 @@
   
   Void  parseSkipFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#if FORCE_REF_VSP==1
+  Void  parseVspFlag        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#endif
   Void parseMergeFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
   Void parseMergeIndex      ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCu.cpp

@@ -52 +52 @@
   m_ppcYuvResPred = NULL;
 #endif
+#if FORCE_REF_VSP
+  m_ppcYuvAvail   = NULL;
+  m_ppcYuvSynth   = NULL;
+#endif
   m_ppcCU      = NULL;
 }
@@ -79 +83 @@
 #if HHI_INTER_VIEW_RESIDUAL_PRED
   m_ppcYuvResPred = new TComYuv*   [m_uiMaxDepth-1];
+#endif
+#if FORCE_REF_VSP
+  m_ppcYuvAvail   = new TComYuv*    [m_uiMaxDepth-1];
+  m_ppcYuvSynth   = new TComYuv*    [m_uiMaxDepth-1];
 #endif
   m_ppcCU      = new TComDataCU*[m_uiMaxDepth-1];
@@ -94 +102 @@
     m_ppcYuvResPred[ui] = new TComYuv;    m_ppcYuvResPred[ui]->create( uiWidth, uiHeight );
 #endif
+#if FORCE_REF_VSP
+    m_ppcYuvAvail  [ui] = new TComYuv;    m_ppcYuvAvail  [ui]->create( uiWidth, uiHeight );
+    m_ppcYuvSynth  [ui] = new TComYuv;    m_ppcYuvSynth  [ui]->create( uiWidth, uiHeight );
+#endif
     m_ppcCU     [ui] = new TComDataCU; m_ppcCU     [ui]->create( uiNumPartitions, uiWidth, uiHeight, true, uiMaxWidth >> (m_uiMaxDepth - 1) );
   }
@@ -118 +130 @@
     m_ppcYuvResPred[ui]->destroy(); delete m_ppcYuvResPred[ui]; m_ppcYuvResPred[ui] = NULL;
 #endif
+#if FORCE_REF_VSP
+    m_ppcYuvAvail  [ui]->destroy(); delete m_ppcYuvAvail  [ui]; m_ppcYuvAvail  [ui] = NULL;
+    m_ppcYuvSynth  [ui]->destroy(); delete m_ppcYuvSynth  [ui]; m_ppcYuvSynth  [ui] = NULL;
+#endif
     m_ppcCU     [ui]->destroy(); delete m_ppcCU     [ui]; m_ppcCU     [ui] = NULL;
   }
@@ -125 +141 @@
 #if HHI_INTER_VIEW_RESIDUAL_PRED
   delete [] m_ppcYuvResPred; m_ppcYuvResPred = NULL;
+#endif
+#if FORCE_REF_VSP
+  delete [] m_ppcYuvAvail;   m_ppcYuvAvail   = NULL;
+  delete [] m_ppcYuvSynth;   m_ppcYuvSynth   = NULL;
 #endif
   delete [] m_ppcCU     ; m_ppcCU      = NULL;
@@ -328 +348 @@
   {
     m_pcEntropyDecoder->decodeSkipFlag( pcCU, uiAbsPartIdx, uiDepth );
+
+#if FORCE_REF_VSP==1
+    if( pcCU->isSkipped(uiAbsPartIdx) && pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+    if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+    {
+      m_pcEntropyDecoder->decodeVspFlag( pcCU, uiAbsPartIdx, uiDepth );
+    }
+#endif
   }
  
   if( pcCU->isSkipped(uiAbsPartIdx) )
+#if FORCE_REF_VSP==1
+  if( !pcCU->isVspMode(uiAbsPartIdx) )
+#endif
   {
     m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_0 );
@@ -352 +385 @@
     if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == uiDepth )
     {
+#if DEBUGLOGOUT
+      PredMode   eOrgPred = pcCU->getPredictionMode( uiAbsPartIdx );
+#endif
       TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
       pcCU->copyTextureMotionDataFrom( pcTextureCU, uiDepth, pcCU->getZorderIdxInCU() + uiAbsPartIdx, uiAbsPartIdx );
+#if DEBUGLOGOUT
+      if( eOrgPred == MODE_SKIP )
+        pcCU->setPredModeSubParts( MODE_SKIP, uiAbsPartIdx, uiDepth );
+      m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
 
       UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
@@ -396 +437 @@
 #endif
     xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
+#if DEBUGLOGOUT
+#if HHI_MPI
+    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) != uiDepth )
+#endif
+      m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
     return;
   }
+
+#if FORCE_REF_VSP==1
+  if( pcCU->isVspMode( uiAbsPartIdx ) )
+  {
+    TComMv cMvZero;
+
+    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
+    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
+
+    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,       SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( cMvZero,       SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
+
+    //pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_0), SIZE_2Nx2N, 0, pcCU->getDepth(0), 0 );
+    //pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_1), SIZE_2Nx2N, 0, pcCU->getDepth(0), 0 );
+
+    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiAbsPartIdx, 0, uiDepth );
+    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiAbsPartIdx, 0, uiDepth );
+    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiAbsPartIdx, 0, uiDepth );
+    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiAbsPartIdx, 0, uiDepth );
+
+    pcCU->setCbfSubParts( 0, 0, 0, uiAbsPartIdx, uiDepth );
+    pcCU->setTrIdxSubParts( 0 , uiAbsPartIdx, uiDepth );
+    pcCU->setNSQTIdxSubParts( uiAbsPartIdx, uiDepth );
+
+    xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
+#if DEBUGLOGOUT
+    m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
+    return;
+  }
+#endif
 
 #if HHI_MPI
@@ -428 +508 @@
     {
       xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
+#if DEBUGLOGOUT
+      m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
       return;
     }
@@ -527 +610 @@
   setdQPFlag( bCodeDQP );
   xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
+#if DEBUGLOGOUT
+  m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
 }
 
@@ -553 +639 @@
 {
   TComPic* pcPic = pcCU->getPic();
+#if FORCE_REF_VSP
+  if(pcPic->getPicYuvSynth())  m_ppcYuvSynth[uiDepth]->copyFromPicYuv( pcPic->getPicYuvSynth(), pcCU->getAddr(), uiAbsPartIdx );
+  if(pcPic->getPicYuvAvail())  m_ppcYuvAvail[uiDepth]->copyFromPicYuv( pcPic->getPicYuvAvail(), pcCU->getAddr(), uiAbsPartIdx );
+#endif
   
   Bool bBoundary = false;
@@ -603 +693 @@
       xReconIntraQT( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
       break;
+#if FORCE_REF_VSP==1
+    case MODE_SYNTH:
+      m_ppcYuvReco[uiDepth]->copyFromPicYuv(pcPic->getPicYuvSynth(), pcCU->getAddr(), uiAbsPartIdx);
+      break;
+#endif
     default:
       assert(0);
@@ -615 +710 @@
   
   xCopyToPic( m_ppcCU[uiDepth], pcPic, uiAbsPartIdx, uiDepth );
+#if DEBUGIMGOUT
+  xColsetToPicMerge( m_ppcCU[uiDepth], pcPic->getPicYuvRecDbg(), uiAbsPartIdx, uiDepth );
+#endif
 }
 
@@ -626 +724 @@
   // inter prediction
   m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth] );
-  
 #if HHI_MPI
   if( pcCU->getTextureModeDepth( 0 ) != -1 )

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCu.h

@@ -46 +46 @@
 #include "TLibCommon/TComPrediction.h"
 #include "TDecEntropy.h"
+#if DEBUGIMGOUT || DEBUGLOGOUT
+#include "TLibCommon/DebugLog.h"
+#endif
 
 //! \ingroup TLibDecoder
@@ -64 +67 @@
   TComYuv**           m_ppcYuvResPred;    ///< residual prediction buffer
 #endif
+#if VSP_N
+  TComYuv**           m_ppcYuvAvail;      ///< array of available map buffer
+  TComYuv**           m_ppcYuvSynth;      ///< array of synth buffer
+#endif
   TComDataCU**        m_ppcCU;            ///< CU data array
   
@@ -77 +84 @@
   virtual ~TDecCu();
   
+#if DEBUGLOGOUT
+  DebugLog            m_cDebug;
+#endif
+
   /// initialize access channels
   Void  init                    ( TDecEntropy* pcEntropyDecoder, TComTrQuant* pcTrQuant, TComPrediction* pcPrediction );
@@ -121 +132 @@
   Void xFillPCMBuffer           (TComDataCU* pCU, UInt absPartIdx, UInt depth);
 #endif
+#if DEBUGIMGOUT
+  Void xColsetToPic             ( TComDataCU* pcCU, TComPicYuv* pcPicYuv, UInt uiZorderIdx, UInt uiDepth );
+  Void xColsetToPicMerge        ( TComDataCU* pcCU, TComPicYuv* pcPicYuv, UInt uiZorderIdx, UInt uiDepth );
+#endif
 };
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecEntropy.cpp

@@ -54 +54 @@
 }
 
+#if FORCE_REF_VSP==1
+Void TDecEntropy::decodeVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  m_pcEntropyDecoderIf->parseVspFlag( pcCU, uiAbsPartIdx, uiDepth );
+}
+#endif
+
 /** decode merge flag
  * \param pcSubCU
@@ -301 +308 @@
         {
           decodeRefFrmIdxPU( pcCU,    uiSubPartIdx,              uiDepth, uiPartIdx, RefPicList( uiRefListIdx ) );
+#if VSP_MV_ZERO
+          Int iRefIdx = pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx(uiSubPartIdx);
+          if( pcCU->getSlice()->getViewId() && iRefIdx >= 0 && (pcCU->getSlice()->getRefViewId( RefPicList( uiRefListIdx ), iRefIdx ) == NUM_VIEW_VSP) )
+          {
+            pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvd( TComMv(0, 0), pcCU->getPartitionSize( uiSubPartIdx ), uiSubPartIdx, uiDepth, uiPartIdx );
+            pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMv ( TComMv(0, 0), pcCU->getPartitionSize( uiSubPartIdx ), uiSubPartIdx, uiDepth, uiPartIdx );
+            pcCU->setMVPIdxSubParts( -1, RefPicList( uiRefListIdx ), uiSubPartIdx, uiPartIdx, pcCU->getDepth(uiSubPartIdx));
+            pcCU->setMVPNumSubParts( -1, RefPicList( uiRefListIdx ), uiSubPartIdx, uiPartIdx, pcCU->getDepth(uiSubPartIdx));
+          }
+          else
+          {
+#endif
           decodeMvdPU      ( pcCU,    uiSubPartIdx,              uiDepth, uiPartIdx, RefPicList( uiRefListIdx ) );
           decodeMVPIdxPU   ( pcSubCU, uiSubPartIdx-uiAbsPartIdx, uiDepth, uiPartIdx, RefPicList( uiRefListIdx ) );
+#if VSP_MV_ZERO
+          }
+#endif
         }
       }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecEntropy.h

@@ -103 +103 @@
 public:
   virtual Void parseSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
+#if FORCE_REF_VSP==1
+  virtual Void parseVspFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
+#endif
   virtual Void parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
   virtual Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx ) = 0;
@@ -196 +199 @@
   Void decodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
   Void decodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#if FORCE_REF_VSP==1
+  Void decodeVspFlag           ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#endif
   Void decodeMergeFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
   Void decodeMergeIndex        ( TComDataCU* pcSubCU, UInt uiPartIdx, UInt uiPartAddr, PartSize eCUMode, UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, UInt uiDepth );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecSbac.cpp

@@ -578 +578 @@
 }
 
+#if FORCE_REF_VSP==1
+Void TDecSbac::parseVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
+  if( pcCU->getSlice()->isIntra() || pcCU->getSlice()->getViewId()==0 )
+  {
+    return;
+  }
+  
+  UInt uiSymbol = 0;
+  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx );
+  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
+  DTRACE_CABAC_VL( g_nSymbolCounter++ );
+  DTRACE_CABAC_T( "\tVspFlag" );
+  DTRACE_CABAC_T( "\tuiCtxSkip: ");
+  DTRACE_CABAC_V( uiCtxSkip );
+  DTRACE_CABAC_T( "\tuiSymbol: ");
+  DTRACE_CABAC_V( uiSymbol );
+  DTRACE_CABAC_T( "\n");
+  
+  if( uiSymbol )
+  {
+    pcCU->setPredModeSubParts( MODE_SYNTH, uiAbsPartIdx, uiDepth );
+  }
+}
+#endif
+
 /** parse merge flag
  * \param pcCU
@@ -610 +636 @@
   uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
 #if HHI_MPI
+#if VSP_TEXT_ONLY
+  TComDataCU* pcTextCU = pcCU->getSlice()->getSPS()->getUseMVI() ? pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() ) : NULL;
+  Int aiRefIdxVsp[2] = { pcTextCU ? pcTextCU->getCUMvField( RefPicList(0) )->getRefIdx( uiAbsPartIdx ) : -1,
+                         pcTextCU ? pcTextCU->getCUMvField( RefPicList(1) )->getRefIdx( uiAbsPartIdx ) : -1 };
+  const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE
+    && !( aiRefIdxVsp[0] >= 0 && pcTextCU->getSlice()->getRefViewId( RefPicList(0), aiRefIdxVsp[0] ) == NUM_VIEW_VSP )
+    && !( aiRefIdxVsp[1] >= 0 && pcTextCU->getSlice()->getRefViewId( RefPicList(1), aiRefIdxVsp[1] ) == NUM_VIEW_VSP );
+#else
   const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
+#endif
   const UInt uiMviMergePos = bMVIAvailable ? HHI_MPI_MERGE_POS : uiNumCand;
 #endif

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecSbac.h

@@ -166 +166 @@
 
   Void parseSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#if FORCE_REF_VSP==1
+  Void parseVspFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
+#endif
   Void parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
   Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecSlice.cpp

@@ -102 +102 @@
   rpcPic->setPicYuvResi( 0 );
   
+#if DEBUGLOGOUT
+  char fname[128];
+  sprintf(fname, "%sV%02d_%05d%s.csv", "DecLog", rpcPic->getSlice(0)->getViewId(), rpcPic->getPOC(), rpcPic->getSlice(0)->getIsDepth() ? "depth":"text");
+  m_pcCuDecoder->m_cDebug.DebugLogFileOpen( fname );
+#endif
 #if ENC_DEC_TRACE
   g_bJustDoIt = g_bEncDecTraceEnable;
@@ -439 +444 @@
 #endif
   }
+#if DEBUGLOGOUT
+  m_pcCuDecoder->m_cDebug.DebugLogFileClose();
+#endif
 
 }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecTop.cpp

@@ -56 +56 @@
     m_aaiCodedScale       [ uiId ] = new Int [ MAX_VIEW_NUM ];
   }
+
+#if VSP_N
+  xCreateLUTs( (UInt)MAX_VIEW_NUM, (UInt)MAX_VIEW_NUM, m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+  m_iLog2Precision   = LOG2_DISP_PREC_LUT;
+  m_uiBitDepthForLUT = 8; //fixed
+#if NTT_SUBPEL
+  xCreateLUTs_Subpel( (UInt)MAX_VIEW_NUM, (UInt)MAX_VIEW_NUM,  m_aiBaseViewShiftLUT_ipel,  m_aiBaseViewShiftLUT_fpos);
+#endif
+#endif
 }
 
@@ -69 +78 @@
   delete [] m_aiViewOrderIndex;
   delete [] m_aiViewReceived;
+
+#if VSP_N
+  xDeleteArray( m_adBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+  xDeleteArray( m_aiBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+#if NTT_SUBPEL
+  xDeleteArray( m_aiBaseViewShiftLUT_ipel, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+  xDeleteArray( m_aiBaseViewShiftLUT_fpos, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
+#endif
+#endif
 }
 
@@ -82 +100 @@
   m_uiMaxViewId             = 0;
 }
+
+#if VSP_N
+Void
+CamParsCollector::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT)
+{
+  //AOF( m_uiBitDepthForLUT == 8 );
+  //AOF(radLUT == NULL && raiLUT == NULL );
+
+  uiNumberSourceViews = Max( 1, uiNumberSourceViews );
+  uiNumberTargetViews = Max( 1, uiNumberTargetViews );
+
+  radLUT         = new Double***[ uiNumberSourceViews ];
+  raiLUT         = new Int   ***[ uiNumberSourceViews ];
+
+  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
+  {
+    radLUT        [ uiSourceView ] = new Double**[ uiNumberTargetViews ];
+    raiLUT        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+
+    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
+    {
+      radLUT        [ uiSourceView ][ uiTargetView ]      = new Double*[ 2 ];
+      radLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Double [ 257 ];
+      radLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Double [ 257 ];
+
+      raiLUT        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+    }
+  }
+}
+
+Void 
+CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
+{
+  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
+  Int     iLog2DivChroma = iLog2DivLuma + 1;
+
+  iOffset <<= m_uiBitDepthForLUT;
+
+  Double dScale  = (Double) iScale  / (( Double ) ( 1 << iLog2DivLuma ));
+  Double dOffset = (Double) iOffset / (( Double ) ( 1 << iLog2DivLuma ));
+
+  // offsets including rounding offsets
+  Int64 iOffsetLuma   = iOffset + ( ( 1 << iLog2DivLuma   ) >> 1 );
+  Int64 iOffsetChroma = iOffset + ( ( 1 << iLog2DivChroma ) >> 1 );
+
+
+  for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
+  {
+
+    // real-valued look-up tables
+#if POZNAN_NONLINEAR_DEPTH
+    Double  dShiftLuma;
+    if( m_bUseNonlinearDepth )
+      dShiftLuma      = ( m_cNonlinearDepthModel.BackwardD( (Double)uiDepthValue, dScale) + dOffset ) * Double( 1 << m_iLog2Precision );
+    else
+      dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
+#else
+    Double  dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
+#endif
+    Double  dShiftChroma    = dShiftLuma / 2;
+    radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = dShiftLuma;
+    radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = dShiftChroma;
+
+    // integer-valued look-up tables
+#if POZNAN_NONLINEAR_DEPTH
+    Int64   iTempScale;
+    if( m_bUseNonlinearDepth )
+      iTempScale      = (Int64)m_cNonlinearDepthModel.BackwardI(uiDepthValue, iScale);
+    else
+      iTempScale      = (Int64)uiDepthValue * iScale;
+#else
+    Int64   iTempScale      = (Int64)uiDepthValue * iScale;
+#endif
+    Int64   iShiftLuma      = ( iTempScale + iOffsetLuma   ) >> iLog2DivLuma;
+    Int64   iShiftChroma    = ( iTempScale + iOffsetChroma ) >> iLog2DivChroma;
+    raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = (Int)iShiftLuma;
+    raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = (Int)iShiftChroma;
+
+    // maximum deviation
+    //dMaxDispDev     = Max( dMaxDispDev,    fabs( Double( (Int) iTestScale   ) - dShiftLuma * Double( 1 << iLog2DivLuma ) ) / Double( 1 << iLog2DivLuma ) );
+    //dMaxRndDispDvL  = Max( dMaxRndDispDvL, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) );
+    //dMaxRndDispDvC  = Max( dMaxRndDispDvC, fabs( Double( (Int) iShiftChroma ) - dShiftChroma ) );
+  }
+
+  radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+  raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+}
+
+Bool
+CamParsCollector::getNearestBaseView( Int iSynthViewIdx, Int &riNearestViewIdx, Int &riRelDistToLeft, Bool& rbRenderFromLeft)
+{
+  /*
+  riNearestViewIdx = 0;
+
+  Bool bDecencdingVN = ( m_aiSortedBaseViews.size() >= 2 && m_aiSortedBaseViews[ 0 ] > m_aiSortedBaseViews[ 1 ] );
+  Int  iFactor       = ( bDecencdingVN ? -1 : 1 );
+
+  if( ( m_aiBaseId2SortedId[iSynthViewIdx] - m_aiBaseId2SortedId[riNearestViewIdx] ) * iFactor  <= 0 )
+  {
+    rbRenderFromLeft = true;
+  }
+  else
+  {
+    rbRenderFromLeft = false;
+  }
+
+  riRelDistToLeft = 128; //Not used for now;
+//*/
+  return true;
+}
+
+#if NTT_SUBPEL
+Void
+CamParsCollector::xCreateLUTs_Subpel( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Int****& raiLUT0, Int****& raiLUT1 )
+{
+  uiNumberSourceViews = Max( 1, uiNumberSourceViews );
+  uiNumberTargetViews = Max( 1, uiNumberTargetViews );
+
+  raiLUT0         = new Int   ***[ uiNumberSourceViews ];
+  raiLUT1         = new Int   ***[ uiNumberSourceViews ];
+
+  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
+  {
+    raiLUT0        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+    raiLUT1        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
+
+    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
+    {
+      raiLUT0        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT0        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT0        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
+      raiLUT1        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
+    }
+  }
+}
+Void 
+CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Int****& raiLUT_ipel, Int****& raiLUT_fpos)
+{
+  Int   iLog2Div = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2Div > 0 );
+  Int64 iOffset64   = ( Int64(iOffset) << m_uiBitDepthForLUT ) + ( ( 1 << iLog2Div ) >> 1 );
+
+  for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
+  {
+    Int64   iTempScale      = (Int64)uiDepthValue * iScale;
+    Int     iShiftSubpel    = (Int) (( iTempScale + iOffset64 ) >> iLog2Div);
+    Int     iShiftPelLuma   = iShiftSubpel >> m_iLog2Precision; // better to have rounding ?
+    Int     iShiftPelChroma = iShiftPelLuma >> 1;
+
+    raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = iShiftPelLuma;
+    raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = iShiftPelChroma;
+    raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = iShiftSubpel - ( iShiftPelLuma << m_iLog2Precision );
+    raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = iShiftSubpel - ( iShiftPelChroma << (m_iLog2Precision+1) );
+
+#if 0 // NTT bugfix
+    if ( raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] < 0 )
+      raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = -4 - raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ];
+    if ( raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] < 0 )
+      raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = -8 - raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ];
+#endif
+
+#if _DEBUG
+    AOF( (raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ]>> m_iLog2Precision   ) == 0 );
+    AOF( (raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ]>>(m_iLog2Precision+1)) == 0 );
+#endif
+  }
+
+  raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT_ipel[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+  raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
+  raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT_fpos[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
+}
+#endif
+
+#endif
 
 Void
@@ -164 +362 @@
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
+#if VSP_N
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
+#if NTT_SUBPEL
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+#endif
+#endif  
       }
       else
@@ -171 +377 @@
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseId ];
+#if VSP_N
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+#if NTT_SUBPEL
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+#endif
+#endif
       }
     }
@@ -185 +399 @@
         m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
         m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
+#if VSP_N
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
+#if NTT_SUBPEL
+        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_aiBaseViewShiftLUT_ipel, m_aiBaseViewShiftLUT_fpos );
+#endif
+#endif
       }
     }
@@ -255 +477 @@
 #endif
 #if ENC_DEC_TRACE
-  g_hTrace = fopen( "TraceDec.txt", "wb" );
+  if(!g_hTrace) g_hTrace = fopen( "TraceDec.txt", "wb" );
   g_bJustDoIt = g_bEncDecTraceDisable;
   g_nSymbolCounter = 0;
@@ -266 +488 @@
   m_bFirstSliceInSequence   = true;
   m_pcCamParsCollector = 0;
+
+#if VSP_N
+  m_pcPicVSP = NULL;
+  m_pcPicAvail = NULL;
+#endif
 }
 
@@ -271 +498 @@
 {
 #if ENC_DEC_TRACE
-  fclose( g_hTrace );
+  if(g_hTrace) fclose( g_hTrace );
+  g_hTrace=NULL;
 #endif
 }
@@ -298 +526 @@
   m_cResidualGenerator.destroy();
 #endif
+
+#if VSP_N
+  if( m_pcPicVSP )
+  {
+    m_pcPicVSP->destroy();
+    delete m_pcPicVSP;
+    m_pcPicVSP = NULL;
+  }
+  if( m_pcPicAvail )
+  {
+    m_pcPicAvail->destroy();
+    delete m_pcPicAvail;
+    m_pcPicAvail = NULL;
+  }
+#endif
+
 }
 
@@ -732 +976 @@
     //  Get a new picture buffer
     xGetNewPicBuffer (m_apcSlicePilot, pcPic);
+#if VSP_N
+#if VSP_SLICE_HEADER
+    if( m_apcSlicePilot->getVspFlag() )
+#endif
+    {
+      if( m_pcPicVSP == NULL )
+      {
+        m_pcPicVSP = new TComPic;
+        m_pcPicVSP->create( m_apcSlicePilot->getSPS()->getPicWidthInLumaSamples(), m_apcSlicePilot->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+        m_pcPicVSP->setCurrSliceIdx(0);
+        m_pcPicVSP->getCurrSlice()->setViewId( NUM_VIEW_VSP );
+        m_pcPicVSP->getCurrSlice()->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx() );
+        m_pcPicVSP->getCurrSlice()->setSPS( m_apcSlicePilot->getSPS() );
+        m_pcPicVSP->getCurrSlice()->setPPS( m_apcSlicePilot->getPPS() );
+        m_pcPicVSP->getCurrSlice()->setPPSId( m_apcSlicePilot->getPPS()->getPPSId() );
+        m_pcPicVSP->getPicSym()->setNumColumnsMinus1( m_apcSlicePilot->getSPS()->getNumColumnsMinus1() );
+        m_pcPicVSP->getPicSym()->setNumRowsMinus1( m_apcSlicePilot->getSPS()->getNumRowsMinus1() );
+        m_pcPicVSP->getPicSym()->xCreateTComTileArray();
+        for (int i=0;i<m_pcPicVSP->getPicSym()->getNumberOfCUsInFrame();i++)
+        {
+          m_pcPicVSP->getPicSym()->getCU(i)->getCUMvField(RefPicList(0))->clearMvField();
+          m_pcPicVSP->getPicSym()->getCU(i)->getCUMvField(RefPicList(1))->clearMvField();
+        }
+#if DEPTH_MAP_GENERATION
+        UInt uiPdm                  = ( m_viewId ? m_apcSlicePilot->getSPS()->getPredDepthMapGeneration() : m_tAppDecTop->getSPSAccess()->getPdm() );
+        Bool bNeedPrdDepthMapBuffer = ( !m_isDepth && uiPdm > 0 );
+        if( bNeedPrdDepthMapBuffer )
+        {
+          m_pcPicVSP->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(uiPdm), PDM_SUB_SAMP_EXP_Y(uiPdm) );
+        }
+#endif
+      }
+      if( m_pcPicAvail == NULL )
+      {
+        m_pcPicAvail = new TComPic;
+        m_pcPicAvail->create( m_apcSlicePilot->getSPS()->getPicWidthInLumaSamples(), m_apcSlicePilot->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+        m_pcPicAvail->setCurrSliceIdx(0);
+        m_pcPicAvail->getCurrSlice()->setViewId( 99 );
+        m_pcPicAvail->getCurrSlice()->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx() );
+        m_pcPicAvail->getCurrSlice()->setSPS( m_apcSlicePilot->getSPS() );
+        m_pcPicAvail->getCurrSlice()->setPPS( m_apcSlicePilot->getPPS() );
+        m_pcPicAvail->getCurrSlice()->setPPSId( m_apcSlicePilot->getPPS()->getPPSId() );
+        m_pcPicAvail->getPicSym()->setNumColumnsMinus1( m_apcSlicePilot->getSPS()->getNumColumnsMinus1() );
+        m_pcPicAvail->getPicSym()->setNumRowsMinus1( m_apcSlicePilot->getSPS()->getNumRowsMinus1() );
+        m_pcPicAvail->getPicSym()->xCreateTComTileArray();
+        for (int i=0;i<m_pcPicAvail->getPicSym()->getNumberOfCUsInFrame();i++)
+        {
+          m_pcPicAvail->getPicSym()->getCU(i)->getCUMvField(RefPicList(0))->clearMvField();
+          m_pcPicAvail->getPicSym()->getCU(i)->getCUMvField(RefPicList(1))->clearMvField();
+        }
+#if DEPTH_MAP_GENERATION
+        UInt uiPdm                  = ( m_viewId ? m_apcSlicePilot->getSPS()->getPredDepthMapGeneration() : m_tAppDecTop->getSPSAccess()->getPdm() );
+        Bool bNeedPrdDepthMapBuffer = ( !m_isDepth && uiPdm > 0 );
+        if( bNeedPrdDepthMapBuffer )
+        {
+          m_pcPicAvail->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(uiPdm), PDM_SUB_SAMP_EXP_Y(uiPdm) );
+        }
+#endif
+      }
+    }
+#endif
 
 #if SONY_COLPIC_AVAILABILITY
@@ -759 +1064 @@
     m_cResidualGenerator.create( true, m_apcSlicePilot->getSPS()->getPicWidthInLumaSamples(), m_apcSlicePilot->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiBitDepth + g_uiBitIncrement );
 #endif
+#if !QC_MULTI_DIS_CAN
+#if VSP_N
+#if VSP_SLICE_HEADER
+    if( m_apcSlicePilot->getVspFlag() )
+#endif
+    {
+      UInt uiPdm                  = ( m_viewId ? m_apcSlicePilot->getSPS()->getPredDepthMapGeneration() : m_tAppDecTop->getSPSAccess()->getPdm() );
+      Bool bNeedPrdDepthMapBuffer = ( !m_isDepth && uiPdm > 0 );
+      if( bNeedPrdDepthMapBuffer )
+      {
+        if( m_pcPicVSP && m_pcPicVSP->getPredDepthMap() )
+        {
+          m_cDepthMapGenerator.clearDepthMap( m_pcPicVSP );
+        }
+        if( m_pcPicAvail && m_pcPicAvail->getPredDepthMap() )
+        {
+          m_cDepthMapGenerator.clearDepthMap( m_pcPicAvail );
+        }
+      }
+    }
+#endif
+#endif
   }
 
@@ -973 +1300 @@
 
     std::vector<TComPic*> apcInterViewRefPics = m_tAppDecTop->getInterViewRefPics( m_viewId, pcSlice->getPOC(), m_isDepth, pcSlice->getSPS() );
+#if VSP_N
+    Bool bUseVsp = (m_viewId!=0);
+#if VSP_TEXT_ONLY
+    if( m_isDepth ) bUseVsp = false;
+#endif
+#if VSP_SLICE_HEADER
+    if( !pcSlice->getVspFlag() ) bUseVsp = false;
+#endif
+
+#if VSP_SLICE_HEADER
+    if( bUseVsp )
+#endif
+      m_pcPicVSP->getCurrSlice()->setPOC( pcPic->getPOC() );
+
+    pcSlice->setRefPicListMvc( m_cListPic, apcInterViewRefPics, bUseVsp ? m_pcPicVSP : NULL );
+
+#else
     pcSlice->setRefPicListMvc( m_cListPic, apcInterViewRefPics );
+#endif
 
     // For generalized B
@@ -1068 +1413 @@
 #endif
 
+#if VSP_N
+  if( m_pcCamParsCollector )
+  {
+    m_pcCamParsCollector->setSlice( pcSlice );
+  }
+#if VSP_SLICE_HEADER
+  if( pcSlice->getVspFlag() )
+#endif
+  if( getTAppDecTop()->getUseDepth() )
+  {
+    getTAppDecTop()->storeVSPInBuffer( m_pcPicVSP, m_pcPicAvail, pcSlice->getViewId(), pcSlice->getSPS()->getViewOrderIdx(), pcSlice->getPOC(), m_isDepth );
+  }
+#endif
+
   //  Decode a picture
   m_cGopDecoder.decompressGop(nalu.m_Bitstream, pcPic, false);
@@ -1108 +1467 @@
 #if LCU_SYNTAX_ALF
   m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+#endif
+
+#if VSP_N
+  if( !sps->isDepth() && sps->getViewId() == 0 && getTAppDecTop()->getVSPRendererTop() )
+  {
+#if NTT_SUBPEL
+    getTAppDecTop()->getVSPRendererTop()->init( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 5, 1, 0, 6 );
+#else
+    getTAppDecTop()->getVSPRendererTop()->init( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 4, 1, 0, 6 );
+#endif
+  }
 #endif
 }

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecTop.h

@@ -77 +77 @@
   Bool  isInitialized() const { return m_bInitialized; }
 
+#if VSP_N
+  Double****          getBaseViewShiftLUTD      ()  { return m_adBaseViewShiftLUT;   }
+  Int****             getBaseViewShiftLUTI      ()  { return m_aiBaseViewShiftLUT;   }
+  Int**               getBaseViewOffsetI        ()  { return m_aaiCodedOffset;   }
+  Int**               getBaseViewScaleI         ()  { return m_aaiCodedScale;   }
+  Bool                getNearestBaseView        ( Int iSynthViewIdx, Int &riNearestViewIdx, Int &riRelDistToLeft, Bool& rbRenderFromLeft);
+#if NTT_SUBPEL
+  Int****             getBaseViewIPelLUT        ()  { return m_aiBaseViewShiftLUT_ipel;   }
+  Int****             getBaseViewFPosLUT        ()  { return m_aiBaseViewShiftLUT_fpos;   }
+#endif
+#endif
+
 private:
   Bool  xIsComplete ();
@@ -94 +106 @@
   Int     m_iLastPOC;
   UInt    m_uiMaxViewId;
+
+#if VSP_N
+  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 );
+
+#if NTT_SUBPEL
+  Int****             m_aiBaseViewShiftLUT_ipel;              ///< Disparity LUT
+  Int****             m_aiBaseViewShiftLUT_fpos;              ///< Disparity LUT
+  Void xCreateLUTs_Subpel ( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Int****& raiLUT0, Int****& raiLUT1 );
+  Void xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Int****& raiLUT_ipel, Int****& raiLUT_fpos);
+#endif
+#endif
 };
+
+#if VSP_N
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2, UInt uiSize3 )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
+    {
+      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
+      {
+        for( UInt uiM = 0; uiM < uiSize3; uiM++ )
+        {
+          delete[] rpt[ uiK ][ uiL ][ uiM ];
+        }
+        delete[] rpt[ uiK ][ uiL ];
+      }
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+
+
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2 )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
+    {
+      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
+      {
+        delete[] rpt[ uiK ][ uiL ];
+      }
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+
+
+template <class T>
+Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize )
+{
+  if( rpt )
+  {
+    for( UInt uiK = 0; uiK < uiSize; uiK++ )
+    {
+      delete[] rpt[ uiK ];
+    }
+    delete[] rpt;
+  }
+  rpt = NULL;
+};
+#endif
 
 /// decoder class
@@ -155 +246 @@
   NalUnitType             m_nalUnitTypeBaseView;  
 
+#if VSP_N
+  TComPic*                m_pcPicVSP; //view synthesis prediction buffer for current POC to be coded
+  TComPic*                m_pcPicAvail;
+#endif
+
 public:
   TDecTop();
@@ -195 +291 @@
   TAppDecTop*         getTAppDecTop()                           { return  m_tAppDecTop; }
   NalUnitType         getNalUnitTypeBaseView()                  { return m_nalUnitTypeBaseView; }
+
+#if VSP_N
+  TComPic*            getVSPBuf()                               { return m_pcPicVSP; }
+#endif
 
 protected:

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCavlc.cpp

@@ -1179 +1179 @@
   WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
 #endif
+
+#if VSP_SLICE_HEADER
+  if( pcSlice->getSPS()->getViewId()!=0 
+#if VSP_TEXT_ONLY
+      && !(pcSlice->getSPS()->isDepth()) 
+#endif
+    )
+  {
+    WRITE_FLAG( pcSlice->getVspFlag()?1:0, "vsp_flag" );
+//    printf("[VSP: %d] ", pcSlice->getVspFlag()?1:0);
+  }
+#endif
+
 }
 
@@ -1426 +1439 @@
   assert(0);
 }
+
+#if FORCE_REF_VSP==1
+Void TEncCavlc::codeVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
+{
+  assert(0);
+}
+#endif
 
 Void TEncCavlc::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCavlc.h

@@ -164 +164 @@
 
   Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
+#if FORCE_REF_VSP==1
+  Void codeVspFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
+#endif
   Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
   Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCu.cpp

@@ -453 +453 @@
   // get Original YUV data from picture
   m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
+#if FORCE_REF_VSP
+  //Bool bWholeCUCanBeSynthesized = false;
+  //Bool bOneSubCUCanNotBeSynthesied = false;
+  Bool bSubCUCanBeSynthesized[4];
+  if( rpcBestCU->getSlice()->getViewId() )
+  {
+    Bool * pbSubCUCanBeSynthesized = bSubCUCanBeSynthesized;
+    pcPic->checkSynthesisAvailability(/*rpcBestCU, */rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth, pbSubCUCanBeSynthesized); //KUBA SYNTH
+    //Int  iSubCUCanNotBeSynthesized = 0;  // Dong: Compiling error, set but not used. DONG_CHECK
+    Int  iSubCUCanBeSynthesizedCnt = 0;
+    for(Int i = 0; i < 4; i++)
+    {
+      if (!bSubCUCanBeSynthesized[i])
+      {
+        //iSubCUCanNotBeSynthesized = i;
+      }
+      else
+      {
+        iSubCUCanBeSynthesizedCnt ++;
+      }
+    }
+    if(iSubCUCanBeSynthesizedCnt == 4)
+    {
+      //bWholeCUCanBeSynthesized = true;
+    }
+    //else if(iSubCUCanBeSynthesizedCnt == 3)
+    //{
+    //  bOneSubCUCanNotBeSynthesied = true;
+    //}
+    //bWholeCUCanBeSynthesized = true;
+  }
+#endif
 
   // variables for fast encoder decision
@@ -654 +686 @@
             doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
           }
+
+#if FORCE_REF_VSP==1
+#if VSP_TEXT_ONLY
+          if( !rpcBestCU->getSlice()->getSPS()->isDepth() )
+#endif
+#if HHI_INTER_VIEW_RESIDUAL_PRED
+            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
+#endif
+#if HHI_INTERVIEW_SKIP
+            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec, false, true ); // VSP
+#else
+            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
+#endif
+            rpcTempCU->initEstData( uiDepth, iQP );
+#endif
         }
 #if HHI_INTER_VIEW_RESIDUAL_PRED
@@ -1581 +1628 @@
     {
       m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
+
+#if FORCE_REF_VSP==1
+      if( (pcCU->isSkipped( uiAbsPartIdx ) || pcCU->isVspMode( uiAbsPartIdx )) && pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+      if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+      {
+        m_pcEntropyCoder->encodeVspFlag( pcCU, uiAbsPartIdx );
+      }
+#endif
     }
 
     if( pcCU->isSkipped( uiAbsPartIdx ) )
+#if FORCE_REF_VSP==1
+    if( !pcCU->isVspMode( uiAbsPartIdx ) )
+#endif
     {
       m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
       finishCU(pcCU,uiAbsPartIdx,uiDepth);
+#if DEBUGLOGOUT
+      m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
       xRestoreDepthWidthHeight( pcCU );
       return;
@@ -1635 +1698 @@
   {
     m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
+
+#if FORCE_REF_VSP==1
+    if( (pcCU->isSkipped( uiAbsPartIdx ) || pcCU->isVspMode( uiAbsPartIdx )) && pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+    if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+    {
+      m_pcEntropyCoder->encodeVspFlag( pcCU, uiAbsPartIdx );
+    }
+#endif
   }
   
   if( pcCU->isSkipped( uiAbsPartIdx ) )
+#if FORCE_REF_VSP==1
+  if( !pcCU->isVspMode( uiAbsPartIdx ) )
+#endif
   {
     m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
@@ -1644 +1720 @@
 #endif
     finishCU(pcCU,uiAbsPartIdx,uiDepth);
+#if DEBUGLOGOUT
+    m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
     return;
   }
+
+#if FORCE_REF_VSP==1
+  if( pcCU->isVspMode( uiAbsPartIdx ) )
+  {
+    finishCU(pcCU,uiAbsPartIdx,uiDepth);
+#if DEBUGLOGOUT
+    m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
+    return;
+  }
+#endif
+
 #if HHI_MPI
   if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
@@ -1662 +1753 @@
       // Encode slice finish
       finishCU(pcCU,uiAbsPartIdx,uiDepth);
+#if DEBUGLOGOUT
+      m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
       return;
     }
@@ -1685 +1779 @@
   // --- write terminating bit ---
   finishCU(pcCU,uiAbsPartIdx,uiDepth);
+#if DEBUGLOGOUT
+  m_cDebug.DebugLogOut( pcCU, uiAbsPartIdx, uiDepth );
+#endif
 }
 
@@ -1873 +1970 @@
 #if AMP_MRG
 #if HHI_INTERVIEW_SKIP
-Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes, Bool bUseMRG)
+Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes, Bool bUseMRG
+#if FORCE_REF_VSP==1
+                               , Bool bForceRefVsp
+#endif
+                               )
 #else
 Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bUseMRG)
@@ -1910 +2011 @@
   rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
 #endif
+#if FORCE_REF_VSP==1
+  if( bForceRefVsp )
+    rpcTempCU->setPredModeSubParts  ( MODE_SYNTH, 0, uhDepth );
+  else
+#endif
   rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
   
@@ -1925 +2031 @@
   #if HHI_INTERVIEW_SKIP
 #if LG_RESTRICTEDRESPRED_M24766
-  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcResPredTmp[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG  );
+  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcResPredTmp[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG
+#if FORCE_REF_VSP==1
+    , bForceRefVsp
+#endif
+    );
 #else
   m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG  );
@@ -2494 +2604 @@
     for( UInt ui = 0; ui < rpcTempCU->getTotalNumPart(); ui++ )
     {
-      if( pcTextureCU->isIntra( rpcTempCU->getZorderIdxInCU() + ui ) )
+      if( pcTextureCU->isIntra( rpcTempCU->getZorderIdxInCU() + ui ) 
+#if FORCE_REF_VSP==1
+       || pcTextureCU->isVspMode( rpcTempCU->getZorderIdxInCU() + ui )
+#endif
+      )
       {
         return;
       }
+#if VSP_N
+#if !(!VSP_TEXT_ONLY && FORCE_REF_VSP==2)
+      else // inter
+      {
+        Int aiRefIdx[2] = {NOT_VALID, NOT_VALID};
+        for( Int iList = 0; iList < 2; iList++ )
+        {
+          aiRefIdx[iList] = pcTextureCU->getCUMvField( RefPicList(iList) )->getRefIdx( rpcTempCU->getZorderIdxInCU() + ui );
+          if( aiRefIdx[iList] >= 0 && pcTextureCU->getSlice()->getRefViewId( RefPicList(iList), aiRefIdx[iList] ) == NUM_VIEW_VSP )
+          {
+            return;
+          }
+        }
+        //if( aiRefIdx[0] == NOT_VALID && aiRefIdx[1] == NOT_VALID )
+        //{
+        //  return;
+        //}
+      }
+#endif
+#endif
     }
   }
@@ -2694 +2828 @@
   m_pcEntropyCoder->encodeSplitFlag( pcCU, 0, uhDepth, true );
   m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
+#if FORCE_REF_VSP==1
+  if( (pcCU->isSkipped( 0 ) || pcCU->isVspMode( 0 )) && pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+  if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+    m_pcEntropyCoder->encodeVspFlag ( pcCU, 0, true );
+#endif
 
   if( pcCU->isSkipped( 0 ) )
+#if FORCE_REF_VSP==1
+  if( !pcCU->isVspMode( 0 ) )
+#endif
   {
     m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, 0, true );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCu.h

@@ -46 +46 @@
 #include "TLibCommon/TComBitCounter.h"
 #include "TLibCommon/TComDataCU.h"
+#if DEBUGLOGOUT
+#include "TLibCommon/DebugLog.h"
+#endif
 
 #include "TEncEntropy.h"
@@ -113 +116 @@
 
 public:
+#if DEBUGLOGOUT
+  DebugLog                m_cDebug;
+#endif
+
   /// copy parameters from encoder class
   Void  init                ( TEncTop* pcEncTop );
@@ -148 +155 @@
 #if AMP_MRG
 #if HHI_INTERVIEW_SKIP
-  Void xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bFullyRendered, Bool bUseMRG = false  ) ;
+  Void xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bFullyRendered, Bool bUseMRG = false
+#if FORCE_REF_VSP==1
+    , Bool bForceRefVsp = false
+#endif
+    ) ;
 #else
   Void  xCheckRDCostInter   ( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bUseMRG = false  );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncEntropy.cpp

@@ -169 +169 @@
 }
 
+
+#if FORCE_REF_VSP==1
+Void TEncEntropy::encodeVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
+{
+  if ( pcCU->getSlice()->isIntra() || pcCU->getSlice()->getViewId() == 0 )
+  {
+    return;
+  }
+  if( bRD )
+  {
+    uiAbsPartIdx = 0;
+  }
+  m_pcEntropyCoderIf->codeVspFlag( pcCU, uiAbsPartIdx );
+}
+#endif
+
 Void TEncEntropy::codeFiltCountBit(ALFParam* pAlfParam, Int64* ruiRate)
 {
@@ -1285 +1301 @@
     uiAbsPartIdx = 0;
   }
+
+#if FORCE_REF_VSP==1
+  if( pcCU->isVspMode( uiAbsPartIdx ) )
+  {
+    return;
+  }
+#endif
   
   PartSize eSize = pcCU->getPartitionSize( uiAbsPartIdx );
@@ -1345 +1368 @@
         {
           encodeRefFrmIdxPU ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
+#if VSP_MV_ZERO
+          Int iRefIdx = pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx(uiSubPartIdx);
+          if( !(pcCU->getSlice()->getViewId() && iRefIdx >= 0 && pcCU->getSlice()->getRefViewId( RefPicList( uiRefListIdx ), iRefIdx ) == NUM_VIEW_VSP) )
+          {
+#endif
           encodeMvdPU       ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
           encodeMVPIdxPU    ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
+#if VSP_MV_ZERO
+          }
+#endif
         }
       }
@@ -1632 +1663 @@
   {
     {
+#if FORCE_REF_VSP==1
+      if( !pcCU->isVspMode( uiAbsPartIdx ) )
+#endif
 #if HHI_MPI
       if( !(pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N &&

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncEntropy.h

@@ -115 +115 @@
   
   virtual Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
+#if FORCE_REF_VSP==1
+  virtual Void codeVspFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
+#endif
   virtual Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
   virtual Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
@@ -251 +254 @@
   Void encodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
   Void encodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
+#if FORCE_REF_VSP==1
+  Void encodeVspFlag           ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
+#endif
   Void encodePUWise       ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
   Void encodeInterDirPU   ( TComDataCU* pcSubCU, UInt uiAbsPartIdx  );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncGOP.cpp

@@ -332 +332 @@
 #endif
 
+#if VSP_N
+      Int NumberOfVspRefs = ( ( pcPic->getViewId()==0
+#if VSP_TEXT_ONLY
+                                || m_pcEncTop->getIsDepth()
+#endif
+#if VSP_SLICE_HEADER
+                                || !m_pcEncTop->getUseVSP()
+#endif
+                              ) ? 0 : 1 );
+      pcSlice->setNumRefIdx( REF_PIC_LIST_0, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive + NumberOfVspRefs, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs() + NumberOfVspRefs) ) );
+      pcSlice->setNumRefIdx( REF_PIC_LIST_1, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive + NumberOfVspRefs, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs() + NumberOfVspRefs) ) );
+#else
       pcSlice->setNumRefIdx( REF_PIC_LIST_0, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs()) ) );
       pcSlice->setNumRefIdx( REF_PIC_LIST_1, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs()) ) );
+#endif
 
       TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
@@ -358 +371 @@
 
       std::vector<TComPic*> apcInterViewRefPics = tAppEncTop->getInterViewRefPics( m_pcEncTop->getViewId(), pcSlice->getPOC(), m_pcEncTop->getIsDepth(), pcSlice->getSPS() );
+#if VSP_N
+      Bool bUseVsp = (pcPic->getViewId()!=0);
+#if VSP_TEXT_ONLY
+      if( m_pcEncTop->getIsDepth() ) bUseVsp = false;
+#endif
+#if VSP_SLICE_HEADER
+      if( !m_pcEncTop->getUseVSP() ) bUseVsp = false;
+#endif
+      pcSlice->setRefPicListMvc( rcListPic, apcInterViewRefPics, bUseVsp ? m_pcEncTop->getVSPBuf() : NULL );
+#else
       pcSlice->setRefPicListMvc( rcListPic, apcInterViewRefPics );
+#endif
+#if VSP_SLICE_HEADER
+      pcSlice->setVspFlag( bUseVsp );
+#endif
 
       //  Slice info. refinement
@@ -1130 +1157 @@
           m_pcSbacCoder->load( &pcSbacCoders[0] );
 
+#if DEBUGLOGOUT
+        char fname[128];
+        sprintf(fname, "%sV%02d_%05d%s.csv", "Log", pcSlice->getViewId(), uiPOCCurr, pcSlice->getIsDepth() ? "depth":"text");
+        getSliceEncoder()->getCUEncoder()->m_cDebug.DebugLogFileOpen( fname );
+#endif
+
         pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
         if (!bEntropySlice)
@@ -1140 +1173 @@
           m_pcSliceEncoder->encodeSlice(pcPic, &nalu.m_Bitstream, pcSubstreamsOut); // nalu.m_Bitstream is only used for CAVLC tile position info.
         }
+
+#if DEBUGLOGOUT
+        getSliceEncoder()->getCUEncoder()->m_cDebug.DebugLogFileClose();
+#endif
 
         {

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncGOP.h

@@ -146 +146 @@
   Void freeAPS     (TComAPS* pAPS, TComSPS* pSPS);
   Void allocAPS    (TComAPS* pAPS, TComSPS* pSPS);
+
 protected:
   Void encodeAPS   (TComAPS* pcAPS, TComOutputBitstream& APSbs, TComSlice* pcSlice);            //!< encode APS syntax elements

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncSbac.cpp

@@ -718 +718 @@
 {
   // get context function is here
+#if FORCE_REF_VSP==1
+  UInt uiSymbol = (pcCU->isSkipped( uiAbsPartIdx ) || pcCU->isVspMode( uiAbsPartIdx )) ? 1 : 0;
+#else
   UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
+#endif
   UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
   m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
@@ -730 +734 @@
 }
 
+#if FORCE_REF_VSP==1
+Void TEncSbac::codeVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
+{
+  // get context function is here
+  UInt uiSymbol = (UInt)pcCU->isVspMode( uiAbsPartIdx );
+  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
+  m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
+  DTRACE_CABAC_VL( g_nSymbolCounter++ );
+  DTRACE_CABAC_T( "\tVspFlag" );
+  DTRACE_CABAC_T( "\tuiCtxSkip: ");
+  DTRACE_CABAC_V( uiCtxSkip );
+  DTRACE_CABAC_T( "\tuiSymbol: ");
+  DTRACE_CABAC_V( uiSymbol );
+  DTRACE_CABAC_T( "\n");
+}
+#endif
+
 /** code merge flag
  * \param pcCU
@@ -764 +785 @@
   uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
 #if HHI_MPI
+#if VSP_TEXT_ONLY
+  TComDataCU* pcTextCU = pcCU->getSlice()->getSPS()->getUseMVI() ? pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() ) : NULL;
+  Int aiRefIdxVsp[2] = { pcTextCU ? pcTextCU->getCUMvField( RefPicList(0) )->getRefIdx( uiAbsPartIdx ) : -1,
+                         pcTextCU ? pcTextCU->getCUMvField( RefPicList(1) )->getRefIdx( uiAbsPartIdx ) : -1 };
+  const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE
+    && !( aiRefIdxVsp[0] >= 0 && pcTextCU->getSlice()->getRefViewId( RefPicList(0), aiRefIdxVsp[0] ) == NUM_VIEW_VSP )
+    && !( aiRefIdxVsp[1] >= 0 && pcTextCU->getSlice()->getRefViewId( RefPicList(1), aiRefIdxVsp[1] ) == NUM_VIEW_VSP );
+#else
   const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
+#endif
   if( bMVIAvailable )
   {

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncSbac.h

@@ -202 +202 @@
   Void codeAlfCtrlFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx );
   Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
+#if FORCE_REF_VSP==1
+  Void codeVspFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
+#endif
   Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
   Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncSearch.cpp

@@ -683 +683 @@
 UInt TEncSearch::xPatternRefinement( TComPattern* pcPatternKey,
                                     TComMv baseRefMv,
-                                    Int iFrac, TComMv& rcMvFrac )
+                                    Int iFrac, TComMv& rcMvFrac
+#if VSP_MV_ZERO
+                                   ,Bool bIsVsp
+#endif
+                                   )
 {
   UInt  uiDist;
@@ -699 +703 @@
   TComMv* pcMvRefine = (iFrac == 2 ? s_acMvRefineH : s_acMvRefineQ);
   
+#if VSP_MV_ZERO
+  UInt iAround = ( bIsVsp )? 1:9;
+  for (UInt i = 0; i < iAround; i++)
+#else
   for (UInt i = 0; i < 9; i++)
+#endif
   {
     TComMv cMvTest = pcMvRefine[i];
@@ -871 +880 @@
       {
         m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
+#if FORCE_REF_VSP==1
+        if( pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+        if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+          m_pcEntropyCoder->encodeVspFlag ( pcCU, 0, true );
+#endif
         m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
       }
@@ -2751 +2767 @@
 #if AMP_MRG
 #if LG_RESTRICTEDRESPRED_M24766
-Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* rpcResiPredYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes, Bool bUseMRG )
-#else
-Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes, Bool bUseMRG )
+Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* rpcResiPredYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes, Bool bUseMRG 
+#if FORCE_REF_VSP==1
+                                 , Bool bForceRefVsp
+#endif
+                                 )
+#else
+Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes, Bool bUseMRG
+#if FORCE_REF_VSP==1
+                                 , Bool bForceRefVsp
+#endif
+                                 )
 #endif
 #else
@@ -2813 +2837 @@
 #endif
 
+#if FORCE_REF_VSP==1
+  if( bForceRefVsp )
+  {
+    assert( ePartSize == SIZE_2Nx2N );
+
+    //  Clear Motion Field
+    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), ePartSize, 0, pcCU->getDepth(0), 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), ePartSize, 0, pcCU->getDepth(0), 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,       ePartSize, 0, pcCU->getDepth(0), 0 );
+    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( cMvZero,       ePartSize, 0, pcCU->getDepth(0), 0 );
+
+    //pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_0), ePartSize, 0, pcCU->getDepth(0), 0 );
+    //pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_1), ePartSize, 0, pcCU->getDepth(0), 0 );
+
+    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, 0, 0, pcCU->getDepth(0));
+    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, 0, 0, pcCU->getDepth(0));
+    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, 0, 0, pcCU->getDepth(0));
+    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, 0, 0, pcCU->getDepth(0));
+
+    rpcPredYuv->copyFromPicYuv( pcCU->getPic()->getPicYuvSynth(), pcCU->getAddr(), pcCU->getZorderIdxInCU() );
+    setWpScalingDistParam( pcCU, -1, REF_PIC_LIST_X );
+
+    return;
+  }
+#endif
+
 #if ZERO_MVD_EST
   Int           aiZeroMvdMvpIdx[2] = {-1, -1};
@@ -2833 +2883 @@
 #if HHI_INTER_VIEW_MOTION_PRED
   Int iNumAMVPCands = AMVP_MAX_NUM_CANDS + ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
+#endif
+
+#if VSP_MV_ZERO
+  bool bIsVsp = false;
+  //Bool bWholeCUCanBeSynthesized = false;
+  //Bool bSubCUCanBeSynthesized[4];
+  //if( pcCU->getSlice()->getViewId() )
+  //{
+  //  Bool * pbSubCUCanBeSynthesized = bSubCUCanBeSynthesized;
+  //  pcCU->getPic()->checkSynthesisAvailability(/*rpcBestCU, */pcCU->getAddr(), pcCU->getZorderIdxInCU(), pcCU->getDepth(0), pbSubCUCanBeSynthesized); //KUBA SYNTH
+  //  Int  iSubCUCanBeSynthesizedCnt = 0;
+  //  for(Int i = 0; i < 4; i++)
+  //  {
+  //    if (bSubCUCanBeSynthesized[i])
+  //    {
+  //      iSubCUCanBeSynthesizedCnt ++;
+  //    }
+  //  }
+  //  if(iSubCUCanBeSynthesizedCnt == 4)
+  //  {
+  //    bWholeCUCanBeSynthesized = true;
+  //  }
+  //}
 #endif
 
@@ -2857 +2930 @@
     for (Int iNumRef=0; iNumRef < MAX_NUM_REF; iNumRef++) uiCostTempL0[iNumRef] = MAX_UINT;
     UInt          uiBitsTempL0[MAX_NUM_REF];
+
 #if LG_RESTRICTEDRESPRED_M24766
     Int iPUResiPredShift[4] = {0, 0, 0, 0};
@@ -2885 +2959 @@
       for ( Int iRefIdxTemp = 0; iRefIdxTemp < pcCU->getSlice()->getNumRefIdx(eRefPicList); iRefIdxTemp++ )
       {
+#if VSP_MV_ZERO
+        bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(eRefPicList, iRefIdxTemp) == NUM_VIEW_VSP);
+        //if( bIsVsp && !bWholeCUCanBeSynthesized )
+        //{
+        //  continue;
+        //}
+#endif
 #if LG_RESTRICTEDRESPRED_M24766
         if( pcCU->getResPredFlag( 0 ))
@@ -2908 +2989 @@
           if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
         }
+#if VSP_MV_ZERO
+        if( bIsVsp )
+        {
+          aaiMvpIdx[iRefList][iRefIdxTemp] = -1;
+          aaiMvpNum[iRefList][iRefIdxTemp] = -1;
+          cMvPred[iRefList][iRefIdxTemp].setZero();
+        }
+        else
+        {
+#endif
 #if H0111_MVD_L1_ZERO
 #if ZERO_MVD_EST
@@ -2937 +3028 @@
 #else
         uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
+#endif
+#if VSP_MV_ZERO
+        } // if( bIsVsp )
 #endif
 #if ZERO_MVD_EST
@@ -2973 +3067 @@
               else
               {
+#if VSP_MV_ZERO
+                if( pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(eRefPicList, iRefIdxTemp) == NUM_VIEW_VSP )
+                {
+                  cMvTemp[1][iRefIdxTemp].setZero();
+                  uiCostTemp = 0;
+                }
+                else
+                {
+#endif
                 cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)]; 
                 uiCostTemp = uiCostTempL0[pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)];
                 /*first subtract the bit-rate part of the cost of the other list*/
                 uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)] );
+#if VSP_MV_ZERO
+                }
+#endif
               }
               /*correct the bit-rate part of the current ref*/
@@ -2986 +3092 @@
             else
             {
+#if VSP_MV_ZERO
+              xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], bIsVsp, uiBitsTemp, uiCostTemp );
+#else
               xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
+#endif
             }
         }
@@ -2998 +3108 @@
           else
           { 
+#if VSP_MV_ZERO
+            xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], bIsVsp, uiBitsTemp, uiCostTemp );
+#else
             xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
+#endif
           }        
         }
 #else
         xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
+#endif
+#if VSP_MV_ZERO
+        if( bIsVsp )
+        {
+          cMvPred[iRefList][iRefIdxTemp].setZero();
+        }
+        else
+        {
 #endif
         xCopyAMVPInfo(pcCU->getCUMvField(eRefPicList)->getAMVPInfo(), &aacAMVPInfo[iRefList][iRefIdxTemp]); // must always be done ( also when AMVP_MODE = AM_NONE )
@@ -3009 +3131 @@
           xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
         }
+#if VSP_MV_ZERO
+        }
+#endif
 
         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag())
@@ -3088 +3213 @@
       if(pcCU->getSlice()->getMvdL1ZeroFlag())
       {
+#if VSP_MV_ZERO
+        bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_1, bestBiPRefIdxL1) == NUM_VIEW_VSP);
+
+        if( bIsVsp )
+        {
+          cMvPredBi[1][bestBiPRefIdxL1].setZero();
+        }
+        else
+        {
+#endif
         xCopyAMVPInfo(&aacAMVPInfo[1][bestBiPRefIdxL1], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
         pcCU->setMVPIdxSubParts( bestBiPMvpL1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
         aaiMvpIdxBi[1][bestBiPRefIdxL1] = bestBiPMvpL1;
         cMvPredBi[1][bestBiPRefIdxL1]   = pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo()->m_acMvCand[bestBiPMvpL1];
+#if VSP_MV_ZERO
+        }
+#endif
 
         cMvBi[1] = cMvPredBi[1][bestBiPRefIdxL1];
@@ -3109 +3247 @@
         }
 
+#if VSP_MV_ZERO
+        if( !bIsVsp )
+        {
+#endif
 #if HHI_INTER_VIEW_MOTION_PRED
         uiMotBits[1] += m_auiMVPIdxCost[aaiMvpIdxBi[1][bestBiPRefIdxL1]][iNumAMVPCands];
 #else
         uiMotBits[1] += m_auiMVPIdxCost[aaiMvpIdxBi[1][bestBiPRefIdxL1]][AMVP_MAX_NUM_CANDS];
+#endif
+#if VSP_MV_ZERO
+        }
 #endif
 
@@ -3168 +3313 @@
         for ( Int iRefIdxTemp = iRefStart; iRefIdxTemp <= iRefEnd; iRefIdxTemp++ )
         {
+#if VSP_MV_ZERO
+          bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(eRefPicList, iRefIdxTemp) == NUM_VIEW_VSP);
+          //if( bIsVsp && !bWholeCUCanBeSynthesized )
+          //{
+          //  continue;
+          //}
+#endif
           uiBitsTemp = uiMbBits[2] + uiMotBits[1-iRefList];
           if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
@@ -3174 +3326 @@
             if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
           }
+#if VSP_MV_ZERO
+          if( !bIsVsp )
+          {
+#endif
 #if HHI_INTER_VIEW_MOTION_PRED
           uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdxBi[iRefList][iRefIdxTemp]][iNumAMVPCands];
 #else
           uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdxBi[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
+#endif
+#if VSP_MV_ZERO
+          }
 #endif
 #if LG_RESTRICTEDRESPRED_M24766
@@ -3211 +3370 @@
 #endif
           // call ME
+#if VSP_MV_ZERO
+          xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPredBi[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], bIsVsp, uiBitsTemp, uiCostTemp, true );
+#else
           xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPredBi[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp, true );
+#endif
+#if VSP_MV_ZERO
+          if( !bIsVsp )
+          {
+#endif
           if ( pcCU->getAMVPMode(uiPartAddr) == AM_EXPL )
           {
@@ -3217 +3384 @@
             xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPredBi[iRefList][iRefIdxTemp], aaiMvpIdxBi[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
           }
-          
+#if VSP_MV_ZERO
+          }
+#endif
+
           if ( uiCostTemp < uiCostBi )
           {
@@ -3249 +3419 @@
           if ( uiCostBi <= uiCost[0] && uiCostBi <= uiCost[1] && pcCU->getAMVPMode(uiPartAddr) == AM_EXPL )
           {
+#if VSP_MV_ZERO
+            bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_0, iRefIdxBi[0]) == NUM_VIEW_VSP);
+
+            if( !bIsVsp )
+            {
+#endif
             xCopyAMVPInfo(&aacAMVPInfo[0][iRefIdxBi[0]], pcCU->getCUMvField(REF_PIC_LIST_0)->getAMVPInfo());
             xCheckBestMVP(pcCU, REF_PIC_LIST_0, cMvBi[0], cMvPredBi[0][iRefIdxBi[0]], aaiMvpIdxBi[0][iRefIdxBi[0]], uiBits[2], uiCostBi);
+#if VSP_MV_ZERO
+            }
+#endif
 #if H0111_MVD_L1_ZERO
             if(!pcCU->getSlice()->getMvdL1ZeroFlag())
             {
 #endif
+#if VSP_MV_ZERO
+              bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_1, iRefIdxBi[1]) == NUM_VIEW_VSP);
+
+              if( !bIsVsp )
+              {
+#endif
               xCopyAMVPInfo(&aacAMVPInfo[1][iRefIdxBi[1]], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
               xCheckBestMVP(pcCU, REF_PIC_LIST_1, cMvBi[1], cMvPredBi[1][iRefIdxBi[1]], aaiMvpIdxBi[1][iRefIdxBi[1]], uiBits[2], uiCostBi);
+#if VSP_MV_ZERO
+              }
+#endif
 #if H0111_MVD_L1_ZERO
             }
@@ -3417 +3605 @@
       pcCU->setInterDirSubParts( 3, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
       
+#if VSP_MV_ZERO
+      bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_0, iRefIdxBi[0]) == NUM_VIEW_VSP);
+      if( !bIsVsp )
+      {
+#endif
       pcCU->setMVPIdxSubParts( aaiMvpIdxBi[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
       pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
+#if VSP_MV_ZERO
+      }
+      bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_1, iRefIdxBi[1]) == NUM_VIEW_VSP);
+      if( !bIsVsp )
+      {
+#endif
       pcCU->setMVPIdxSubParts( aaiMvpIdxBi[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
       pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
+#if VSP_MV_ZERO
+      }
+#endif
 
       uiMEBits = uiBits[2];
@@ -3435 +3637 @@
       pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
       
+#if VSP_MV_ZERO
+      bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_0, iRefIdx[0]) == NUM_VIEW_VSP);
+      if( !bIsVsp )
+      {
+#endif
       pcCU->setMVPIdxSubParts( aaiMvpIdx[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
       pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
+#if VSP_MV_ZERO
+      }
+#endif
 
       uiMEBits = uiBits[0];
@@ -3451 +3661 @@
       pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
       
+#if VSP_MV_ZERO
+      bIsVsp = (pcCU->getSlice()->getViewId() && pcCU->getSlice()->getRefViewId(REF_PIC_LIST_1, iRefIdx[1]) == NUM_VIEW_VSP);
+      if( !bIsVsp )
+      {
+#endif
       pcCU->setMVPIdxSubParts( aaiMvpIdx[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
       pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
+#if VSP_MV_ZERO
+      }
+#endif
 
       uiMEBits = uiBits[1];
@@ -3888 +4106 @@
 }
 
+#if VSP_MV_ZERO
+Void TEncSearch::xMotionEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, RefPicList eRefPicList, TComMv* pcMvPred, Int iRefIdxPred, TComMv& rcMv, Bool bIsVsp, UInt& ruiBits, UInt& ruiCost, Bool bBi  )
+#else
 Void TEncSearch::xMotionEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, RefPicList eRefPicList, TComMv* pcMvPred, Int iRefIdxPred, TComMv& rcMv, UInt& ruiBits, UInt& ruiCost, Bool bBi  )
+#endif
 {
   UInt          uiPartAddr;
@@ -3901 +4123 @@
   m_iSearchRange = m_aaiAdaptSR[eRefPicList][iRefIdxPred];
   
+#if VSP_MV_ZERO
+  Int           iSrchRng      = ( bIsVsp ? 0 : ( bBi ? m_bipredSearchRange : m_iSearchRange ) );
+#else
   Int           iSrchRng      = ( bBi ? m_bipredSearchRange : m_iSearchRange );
+#endif
   TComPattern*  pcPatternKey  = pcCU->getPattern        ();
   
@@ -3947 +4173 @@
   m_pcRdCost->setCostScale  ( 2 );
 
+#if VSP_MV_ZERO
+  if( !bIsVsp )
+#endif
 #if HHI_INTER_VIEW_MOTION_PRED
   { // init inter-view regularization
@@ -3965 +4194 @@
   }
 #endif
+#if VSP_MV_ZERO
+  else { // bIsVsp
+    m_pcRdCost->setMultiviewReg( 0 );
+  }
+#endif
 
   setWpScalingDistParam( pcCU, iRefIdxPred, eRefPicList );
   //  Do integer search
+#if VSP_MV_ZERO
+  if ( !m_iFastSearch || bBi || bIsVsp )
+#else
   if ( !m_iFastSearch || bBi )
+#endif
   {
     xPatternSearch      ( pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost );
@@ -3979 +4217 @@
   
   m_pcRdCost->getMotionCost( 1, 0 );
+
 #if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
   if( ! pcCU->getSlice()->getIsDepth() )
@@ -3988 +4227 @@
     xPatternSearchFracDIF( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost
                           ,bBi
+#if VSP_MV_ZERO
+                          ,bIsVsp
+#endif
                           );
   }
@@ -4006 +4248 @@
     ruiCost += m_pcRdCost->getCost( uiMvBits );
 #endif
-  
+
+#if VSP_MV_ZERO
+  if( bIsVsp ) {
+    uiMvBits = 0; // vector zero & not output
+    assert( rcMv.getHor()==0 && rcMv.getVer()==0 );
+  }
+#endif
+
   ruiBits      += uiMvBits;
   ruiCost       = (UInt)( floor( fWeight * ( (Double)ruiCost - (Double)m_pcRdCost->getCost( uiMvBits ) ) ) + (Double)m_pcRdCost->getCost( ruiBits ) );
@@ -4304 +4553 @@
                                        UInt& ruiCost
                                        ,Bool biPred
+#if VSP_MV_ZERO
+                                       ,Bool bIsVsp
+#endif
                                        )
 {
@@ -4322 +4574 @@
   rcMvHalf = *pcMvInt;   rcMvHalf <<= 1;    // for mv-cost
   TComMv baseRefMv(0, 0);
-  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 2, rcMvHalf   );
+  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 2, rcMvHalf
+#if VSP_MV_ZERO
+                                   ,bIsVsp
+#endif
+    );
   
   m_pcRdCost->setCostScale( 0 );
@@ -4332 +4588 @@
   rcMvQter = *pcMvInt;   rcMvQter <<= 1;    // for mv-cost
   rcMvQter += rcMvHalf;  rcMvQter <<= 1;
-  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 1, rcMvQter );
+  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 1, rcMvQter
+#if VSP_MV_ZERO
+                                   ,bIsVsp
+#endif
+    );
 }
 
@@ -4367 +4627 @@
 #endif
   //  No residual coding : SKIP mode
-  if ( ePredMode == MODE_SKIP && bSkipRes )
+  if ( (ePredMode == MODE_SKIP && bSkipRes) 
+#if FORCE_REF_VSP==1
+    || ePredMode == MODE_SYNTH
+#endif
+    )
   {
     rpcYuvResi->clear();
@@ -5737 +6001 @@
     m_pcEntropyCoder->resetBits();
     m_pcEntropyCoder->encodeSkipFlag(pcCU, 0, true);
+#if FORCE_REF_VSP==1
+    if( pcCU->getSlice()->getViewId() != 0 )
+#if VSP_TEXT_ONLY
+    if( !pcCU->getSlice()->getSPS()->isDepth() )
+#endif
+      m_pcEntropyCoder->encodeVspFlag ( pcCU, 0, true );
+#endif
     m_pcEntropyCoder->encodeMergeIndex(pcCU, 0, 0, true);
 #if HHI_INTER_VIEW_RESIDUAL_PRED
@@ -5743 +6014 @@
     ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
   }
+#if FORCE_REF_VSP==1
+  else if( pcCU->isVspMode( 0 ) )
+  {
+    m_pcEntropyCoder->resetBits();
+    m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
+    m_pcEntropyCoder->encodeVspFlag ( pcCU, 0, true );
+    ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
+  }
+#endif
   else
   {

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncSearch.h

@@ -144 +144 @@
   UInt  xPatternRefinement( TComPattern* pcPatternKey,
                            TComMv baseRefMv,
-                           Int iFrac, TComMv& rcMvFrac );
+                           Int iFrac, TComMv& rcMvFrac
+#if VSP_MV_ZERO
+                          ,Bool bIsVsp
+#endif
+                          );
   
   typedef struct
@@ -197 +201 @@
 #if AMP_MRG
                                  ,Bool        bUseMRG = false
+#endif
+#if FORCE_REF_VSP==1
+                                 ,Bool        bForceRefVsp = false
 #endif
                                 );
@@ -486 +493 @@
                                     Int           iRefIdxPred,
                                     TComMv&       rcMv,
+#if VSP_MV_ZERO
+                                    Bool          bIsVsp,
+#endif
                                     UInt&         ruiBits,
                                     UInt&         ruiCost,
@@ -531 +541 @@
                                     UInt&         ruiCost 
                                    ,Bool biPred
+#if VSP_MV_ZERO
+                                   ,Bool bIsVsp
+#endif
                                    );
   

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncTop.cpp

@@ -79 +79 @@
   m_pcBitCounters          = NULL;
   m_pcRdCosts              = NULL;
+
+#if VSP_N
+  m_pcPicVSP = NULL;
+  m_pcPicAvail = NULL;
+#endif
+
+#if VSP_SLICE_HEADER
+  m_bUseVSP = false;
+#endif
+
 }
 
@@ -184 +194 @@
   }
 #endif
+
+#if VSP_N
+  m_pcPicVSP = new TComPic;
+  m_pcPicVSP->create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+  //m_pcPicVSP->getCurrSlice()->setViewId( this->getViewId() );
+  m_pcPicVSP->getCurrSlice()->setViewId( NUM_VIEW_VSP );
+  m_pcPicVSP->getCurrSlice()->setViewOrderIdx( m_iViewOrderIdx );
+
+  m_pcPicAvail = new TComPic;
+  m_pcPicAvail->create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+  m_pcPicAvail->getCurrSlice()->setViewId( 99 );
+  m_pcPicAvail->getCurrSlice()->setViewOrderIdx( m_iViewOrderIdx );
+#endif
+
 }
 
@@ -325 +349 @@
   }
   
+#if VSP_N
+  if( m_pcPicVSP )
+  {
+    m_pcPicVSP->destroy();
+    delete m_pcPicVSP;
+    m_pcPicVSP = NULL;
+  }
+  if( m_pcPicAvail )
+  {
+    m_pcPicAvail->destroy();
+    delete m_pcPicAvail;
+    m_pcPicAvail = NULL;
+  }
+#endif
+
   return;
 }
@@ -391 +430 @@
 
   m_iMaxRefPicNum = 0;
+
+#if VSP_N
+  m_pcPicVSP->setCurrSliceIdx( 0 );
+  m_pcPicVSP->getCurrSlice()->setSPS( this->getSPS() );
+  m_pcPicVSP->getCurrSlice()->setPPS( this->getPPS() );
+  m_pcPicVSP->getCurrSlice()->setPPSId( this->getPPS()->getPPSId() );
+  //initialize the motion vector field with zeros - How about the RefIdx ????
+  //IS THIS REALLY NECESSARY ????
+  for ( int i=0; i<m_pcPicVSP->getPicSym()->getNumberOfCUsInFrame(); i++ )
+  {
+    m_pcPicVSP->getPicSym()->getCU(i)->getCUMvField(RefPicList(0))->clearMvField();
+    m_pcPicVSP->getPicSym()->getCU(i)->getCUMvField(RefPicList(1))->clearMvField();
+  }
+#if DEPTH_MAP_GENERATION
+#if !QC_MULTI_DIS_CAN
+  // add extra pic buffers
+  Bool  bNeedPrdDepthMapBuf = ( m_uiPredDepthMapGeneration > 0 );
+  if( bNeedPrdDepthMapBuf && !m_pcPicVSP->getPredDepthMap() )
+  {
+    m_pcPicVSP->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(m_uiPredDepthMapGeneration), PDM_SUB_SAMP_EXP_Y(m_uiPredDepthMapGeneration) );
+    m_cDepthMapGenerator.clearDepthMap( m_pcPicVSP );
+  }
+#endif
+#endif
+  m_pcPicAvail->setCurrSliceIdx( 0 );
+  m_pcPicAvail->getCurrSlice()->setSPS( this->getSPS() );
+  m_pcPicAvail->getCurrSlice()->setPPS( this->getPPS() );
+  m_pcPicAvail->getCurrSlice()->setPPSId( this->getPPS()->getPPSId() );
+  //initialize the motion vector field with zeros - How about the RefIdx ????
+  //IS THIS REALLY NECESSARY ????
+  for ( int i=0; i<m_pcPicAvail->getPicSym()->getNumberOfCUsInFrame(); i++ )
+  {
+    m_pcPicAvail->getPicSym()->getCU(i)->getCUMvField(RefPicList(0))->clearMvField();
+    m_pcPicAvail->getPicSym()->getCU(i)->getCUMvField(RefPicList(1))->clearMvField();
+  }
+#if DEPTH_MAP_GENERATION
+#if !QC_MULTI_DIS_CAN
+  // add extra pic buffers
+  bNeedPrdDepthMapBuf = ( m_uiPredDepthMapGeneration > 0 );
+  if( bNeedPrdDepthMapBuf && !m_pcPicVSP->getPredDepthMap() )
+  {
+    m_pcPicAvail->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(m_uiPredDepthMapGeneration), PDM_SUB_SAMP_EXP_Y(m_uiPredDepthMapGeneration) );
+    m_cDepthMapGenerator.clearDepthMap( m_pcPicAvail );
+  }
+#endif
+#endif
+#endif
 }
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncTop.h

@@ -145 +145 @@
   TEncAnalyze             m_cAnalyzeB;
 
+#if VSP_N
+  TComPic*                m_pcPicVSP;                     ///< view synthesis prediction buffer for current POC to be coded
+  TComPic*                m_pcPicAvail;
+#endif
+
+#if VSP_SLICE_HEADER
+  Bool                    m_bUseVSP;
+#endif
+
 protected:
   Void  xGetNewPicBuffer  ( TComPic*& rpcPic );           ///< get picture buffer which will be processed
@@ -237 +246 @@
   TComResidualGenerator*  getResidualGenerator  () { return  &m_cResidualGenerator;   }
 #endif
+#if VSP_N
+  TComPic*                getVSPBuf             () { return m_pcPicVSP; }
+  TComPic*                getVSPAvailBuf        () { return m_pcPicAvail; }
+#endif
+
+#if VSP_SLICE_HEADER
+  Void                    setUseVSP   ( Bool val ) { m_bUseVSP = val; }
+  Bool                    getUseVSP             () { return m_bUseVSP; }
+#endif
 
   // -------------------------------------------------------------------------------------------------------------------

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenFilter.cpp

@@ -1154 +1154 @@
 }
 
+#if NTT_SUBPEL
+// Convert luma sample
+Void TRenFilter::sampleConv( Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT )
+{
+  TRenInterpFilter cFilter;
+
+  xDistributeArrayOnDepthCondition  ( pcInputPlaneData, iInputStride, 1 , 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 1, 1, pcDepthPlaneData, iDepthStride, 1, 1, ppiFposLUT);
+  cFilter.xCTI_FilterQuarter0Hor    ( pcInputPlaneData, iInputStride, 1, iInputWidth, iHeight, iOutputStride, 1, pcOutputPlaneData, pcDepthPlaneData, iDepthStride, 1, ppiFposLUT );
+  cFilter.xCTI_FilterHalfHor        ( pcInputPlaneData, iInputStride, 1, iInputWidth, iHeight, iOutputStride, 1, pcOutputPlaneData, pcDepthPlaneData, iDepthStride, 1, ppiFposLUT );
+  cFilter.xCTI_FilterQuarter1Hor    ( pcInputPlaneData, iInputStride, 1, iInputWidth, iHeight, iOutputStride, 1, pcOutputPlaneData, pcDepthPlaneData, iDepthStride, 1, ppiFposLUT );
+}
+
+Void TRenFilter::sampleCVerUp( Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride  )
+{
+  xDistributeArray( pcInputPlaneData-3, iInputStride, 1, 1, iInputWidth+6, iHeight, pcOutputPlaneData              -3, iOutputStride, 1, 2 );
+  xInterpVerChroma( pcInputPlaneData-3, iInputStride, 1, 1, iInputWidth+6, iHeight, pcOutputPlaneData+iOutputStride-3, iOutputStride, 1, 2, &TRenInterpFilter::xCTI_Filter_VPS04_C_HAL );
+}
+
+Void TRenFilter::sampleCConv( Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT )
+{
+  // assume quater resolution depth 
+  xDistributeArrayOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 1, 1, pcDepthPlaneData, iDepthStride, 2, 2, ppiFposLUT);
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 1, 1, pcDepthPlaneData, iDepthStride, 2, 2, ppiFposLUT, 1, &TRenInterpFilter::xCTI_Filter_VP04_C_QUA0 );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 1, 1, pcDepthPlaneData, iDepthStride, 2, 2, ppiFposLUT, 2, &TRenInterpFilter::xCTI_Filter_VPS04_C_HAL );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 1, 1, pcDepthPlaneData, iDepthStride, 2, 2, ppiFposLUT, 3, &TRenInterpFilter::xCTI_Filter_VP04_C_QUA1 );
+}
+
+Void TRenFilter::sampleCConvHorUp( Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT )
+{
+  xDistributeArrayOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT);
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 1, &TRenInterpFilter::xCTI_Filter_VP04_C_OCT0 );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 2, &TRenInterpFilter::xCTI_Filter_VP04_C_QUA0 );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 3, &TRenInterpFilter::xCTI_Filter_VP04_C_OCT1 );
+
+  pcOutputPlaneData++; pcDepthPlaneData++;
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 0, &TRenInterpFilter::xCTI_Filter_VPS04_C_HAL );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 1, &TRenInterpFilter::xCTI_Filter_VP04_C_OCT2 );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 2, &TRenInterpFilter::xCTI_Filter_VP04_C_QUA1 );
+  xInterpHorChromaOnDepthCondition( pcInputPlaneData, iInputStride, 1, 1, iInputWidth, iHeight, pcOutputPlaneData, iOutputStride, 2, 1, pcDepthPlaneData, iDepthStride, 2, 1, ppiFposLUT, 3, &TRenInterpFilter::xCTI_Filter_VP04_C_OCT3 );
+}
+#endif
 
 // Down Sampling
@@ -1224 +1265 @@
   }
 }
+
+#if NTT_SUBPEL
+Void TRenFilter::xDistributeArrayOnDepthCondition(Pel* pcSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* pcDst, Int iDstStride, Int iDstStepX, Int iDstStepY, Pel* pcDep, Int iDepStride, Int iDepStepX, Int iDepStepY, Int** ppiFposLUT)
+{
+  iDstStride *= iDstStepY;
+  iSrcStride *= iSrcStepY;
+  iDepStride *= iDepStepY;
+
+  for (Int iYPos = 0; iYPos < iHeight; iYPos++ )
+  {
+    Pel* pcCurDst = pcDst;
+    Pel* pcCurSrc = pcSrc;
+    Pel* pcCurDep = pcDep;
+
+    for (Int iXPos = 0; iXPos < iWidth; iXPos ++)
+    {
+      if( ppiFposLUT[0][ *pcCurDep ] == 0 )
+      {
+        *pcCurDst = *pcCurSrc;
+      }
+      pcCurDst += iDstStepX;
+      pcCurSrc += iSrcStepX;
+      pcCurDep += iDepStepX;
+    }
+    pcDst  += iDstStride;
+    pcSrc  += iSrcStride;
+    pcDep  += iDepStride;
+  }
+}
+
+Void TRenFilter::xInterpHorChromaOnDepthCondition( Pel* piSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* piDst, Int iDstStride, Int iDstStepX, Int iDstStepY, Pel* piDep, Int iDepStride, Int iDepStepX, Int iDepStepY, Int** ppiFposLUT, Int iTargetFpos, FpChromaIntFilt fpFilter )
+{
+  Int   iSum;
+  Pel*  piSrcTmpP;
+  Pel*  piSrcTmpN;
+  Pel*  piSrcTmp;
+
+  Int   iDepX;
+
+  TRenInterpFilter cFilter;
+  for ( Int y = 0; y < iHeight; y++ )
+  {
+    piSrcTmpP = piSrc - iSrcStepX;
+    piSrcTmpN = piSrc - iSrcStepX*2;
+    iDepX = 0;
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+#if 0 // NTT bugfix
+      if( abs(ppiFposLUT[0][ piDep[iDepX] ]) == iTargetFpos )
+#else
+      if( ppiFposLUT[0][ piDep[iDepX] ] == iTargetFpos || ppiFposLUT[0][ piDep[iDepX] ]+4 == iTargetFpos )
+#endif
+      {
+        piSrcTmp = ppiFposLUT[0][ piDep[ iDepX ] ] >= 0 ? piSrcTmpP : piSrcTmpN;
+        iSum      = (cFilter.*fpFilter)( piSrcTmp,  iSrcStepX );
+        piDst[x * iDstStepX ] =  Clip ((iSum +  32) >>  6 );
+      }
+      piSrcTmpP += iSrcStepX;
+      piSrcTmpN += iSrcStepX;
+      iDepX += iDepStepX;
+    }
+    piSrc += iSrcStride * iSrcStepY;
+    piDst += iDstStride * iDstStepY;
+    piDep += iDepStride * iDepStepY;
+  }
+}
+#endif
 
 

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenFilter.h

@@ -103 +103 @@
   static Void sampleCUpHorUp    (Int iLog2HorSampFac, Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight,      Pel* pcOutputPlaneData, Int iOutputStride );
 
+#if NTT_SUBPEL
+  static Void sampleConv        (Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT );
+  static Void sampleCVerUp      (Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride );
+  static Void sampleCConv       (Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT );
+  static Void sampleCConvHorUp  (Pel* pcInputPlaneData, Int iInputStride, Int iInputWidth, Int iHeight, Pel* pcOutputPlaneData, Int iOutputStride, Pel* pcDepthPlaneData, Int iDepthStride, Int** ppiFposLUT );
+#endif
+
   //// Down sampling (13 tap)
 
@@ -131 +138 @@
   static Void xDistributeArray(Pel* pcSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* pcDst, Int iDstStride, Int iDstStepX, Int iDstStepY );
 
+#if NTT_SUBPEL
+  static Void xDistributeArrayOnDepthCondition(Pel* pcSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* pcDst, Int iDstStride, Int iDstStepX, Int iDstStepY, Pel* pcDep, Int iDepStride, Int iDepStepX, Int iDepStepY, Int** ppiFposLUT);
+  static Void xInterpHorChromaOnDepthCondition(Pel* piSrc, Int iSrcStride, Int iSrcStepX, Int iSrcStepY, Int iWidth, Int iHeight, Pel* piDst, Int iDstStride, Int iDstStepX, Int iDstStepY, Pel* piDep, Int iDepStride, Int iDepStepX, Int iDepStepY, Int** ppiFposLUT, Int iTargetFpos, FpChromaIntFilt fpFilter );
+#endif
+
   // Binominal Filtering
   static Pel  xFiltBinom3     (Pel* pcInputData, Int iStride );

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenInterpFilter.h

@@ -72 +72 @@
   __inline Void xCTI_FilterQuarter1Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst);
   __inline Void xCTI_FilterQuarter1Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst);
-  
+
+#if NTT_SUBPEL
+  __inline Void xCTI_FilterHalfHor    (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT);
+  __inline Void xCTI_FilterQuarter0Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT);
+  __inline Void xCTI_FilterQuarter1Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT);
+#endif
+
   __inline Void xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst, Int iDstStridePel, Pel*& rpiDstPel );
   __inline Void xCTI_FilterHalfVer (Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Int*& rpiDst );
@@ -683 +689 @@
 }
 
+#if NTT_SUBPEL
+__inline Void TRenInterpFilter::xCTI_FilterHalfHor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT)
+{
+  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;
+
+  Pel *piSrcTmpP, *piSrcTmpN;
+  Int iDepX;
+
+  for ( Int y = iHeight; y != 0; y-- )
+  {
+    piSrcTmpP = &piSrc[ -3*iSrcStep ];
+    piSrcTmpN = &piSrc[ -4*iSrcStep ];
+    iDepX = 0;
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+      // { -1,4,-11,40,40,-11,4,-1   } 
+#if 0 // NTT bugfix
+      if( abs(ppiFposLUT[0][ piDep[ iDepX ] ]) == 2 )
+#else
+      if( ppiFposLUT[0][ piDep[ iDepX ] ] == 2 ||  ppiFposLUT[0][ piDep[ iDepX ] ] == -2 )
+#endif
+      {
+        piSrcTmp = ppiFposLUT[0][ piDep[ iDepX ] ] > 0 ? piSrcTmpP : piSrcTmpN;
+
+        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] = Clip( (iSum +  32) >>  6 );
+      }
+      piSrcTmpP += iSrcStep;
+      piSrcTmpN += iSrcStep;
+      iDepX += iDepStep;
+    }
+    piSrc += iSrcStride;
+    piDst += iDstStride;
+    piDep += iDepStride;
+  }
+  return;
+}
+
+__inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT)
+{
+  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;
+
+  Pel *piSrcTmpP, *piSrcTmpN;
+  Int iDepX;
+
+  for ( Int y = iHeight; y != 0; y-- )
+  {
+    piSrcTmpP = &piSrc[ -3*iSrcStep ];
+    piSrcTmpN = &piSrc[ -4*iSrcStep ];
+    iDepX = 0;
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+      // {-1,   4,  -10,  57,   19,  -7,   3,   -1  },
+#if 0 // NTT bugfix
+      if( abs(ppiFposLUT[0][ piDep[ iDepX ] ]) == 1 )
+#else
+      if( ppiFposLUT[0][ piDep[ iDepX ] ] == 1 ||  ppiFposLUT[0][ piDep[ iDepX ] ] == -3 )
+#endif
+      {
+        piSrcTmp = ppiFposLUT[0][ piDep[ iDepX ] ] > 0 ? piSrcTmpP : piSrcTmpN;
+
+        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] = Clip(( (iSum +  32) >>  6 )+ piSrcTmp[iSrcStep3]);
+      }
+      piSrcTmpP += iSrcStep;
+      piSrcTmpN += iSrcStep;
+      iDepX += iDepStep;
+    }
+    piSrc += iSrcStride;
+    piDst += iDstStride;
+    piDep += iDepStride;
+  }
+  return;
+}
+
+__inline Void TRenInterpFilter::xCTI_FilterQuarter1Hor(Pel* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst, Pel* piDep, Int iDepStride, Int iDepStep, Int** ppiFposLUT)
+{
+  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;
+
+  Pel *piSrcTmpP, *piSrcTmpN;
+  Int iDepX;
+
+  for ( Int y = iHeight; y != 0; y-- )
+  {
+    piSrcTmpP = &piSrc[ -3*iSrcStep ];
+    piSrcTmpN = &piSrc[ -4*iSrcStep ];
+    iDepX = 0;
+    for ( Int x = 0; x < iWidth; x++ )
+    {
+      // {-1,   3,  -7,  19,   57,  -10,   4,   -1  },
+#if 0 // NTT bugfix
+      if( abs(ppiFposLUT[0][ piDep[ iDepX ] ]) == 3 )
+#else
+      if( ppiFposLUT[0][ piDep[ iDepX ] ] == 3 ||  ppiFposLUT[0][ piDep[ iDepX ] ] == -1 )
+#endif
+      {
+        piSrcTmp = ppiFposLUT[0][ piDep[ iDepX ] ] > 0 ? piSrcTmpP : piSrcTmpN;
+
+        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] );
+      }
+      piSrcTmpP += iSrcStep;
+      piSrcTmpN += iSrcStep;
+      iDepX += iDepStep;
+    }
+    piSrc += iSrcStride;
+    piDst += iDstStride;
+    piDep += iDepStride;
+  }
+  return;
+}
+#endif
+
 __inline Void TRenInterpFilter::xCTI_FilterQuarter0Hor(Int* piSrc, Int iSrcStride, Int iSrcStep, Int iWidth, Int iHeight, Int iDstStride, Int iDstStep, Pel*& rpiDst)
 {

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenModel.cpp

@@ -700 +700 @@
   }
 }
+

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenSingleModel.cpp

@@ -1943 +1943 @@
 }
 #endif
+

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenTop.cpp

@@ -127 +127 @@
 }
 
+#if NTT_SUBPEL
+Void TRenTop::xConvertInputVideoSubpel( PelImage* pcOrgInputImage, PelImage* pcConvInputImage, PelImage* pcInputDepth, Bool bMirror )
+{
+  PelImagePlane*  pcOrgPlane;
+  PelImagePlane*  pcConvPlane;
+  PelImagePlane*  pcDepthPlane;
+  PelImagePlane*  pcTmpPlane;
+
+  Int    ** ppiFposLUT = bMirror ? m_ppiFposLUTRightMirror : m_ppiFposLUTLeft;
+
+  AOT( m_iLog2SamplingFactor );
+  AOF( m_iInterpolationMode == eRenInt8Tap2 );
+
+  pcDepthPlane = pcInputDepth->getPlane( 0 );
+  pcTmpPlane = pcConvInputImage->getPlane( 0 );
+
+  AOF( m_bUVUp ); // Currently only m_bUVUp=true is supported
+  for (UInt uiPlane = 1; uiPlane < 3; uiPlane++)
+  {
+    pcOrgPlane  = pcOrgInputImage ->getPlane(uiPlane);
+    pcConvPlane = pcConvInputImage->getPlane(uiPlane);
+
+    if ( m_bUVUp )
+    {
+      TRenFilter::sampleCVerUp    (pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight()  , pcTmpPlane ->getPlaneData(), pcTmpPlane ->getStride() );
+      TRenFilter::sampleCConvHorUp(pcTmpPlane->getPlaneData(), pcTmpPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight()*2, pcConvPlane->getPlaneData(), pcConvPlane->getStride(), pcDepthPlane->getPlaneData(), pcDepthPlane->getStride(), ppiFposLUT );
+    }
+    else
+    {
+      TRenFilter::sampleCConv     (pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight()*2, pcConvPlane->getPlaneData(), pcConvPlane->getStride(), pcDepthPlane->getPlaneData(), pcDepthPlane->getStride(), ppiFposLUT );
+    }
+  }
+
+  pcOrgPlane  = pcOrgInputImage ->getPlane(0);
+  pcConvPlane = pcConvInputImage->getPlane(0);
+  TRenFilter::sampleConv(pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride(), pcDepthPlane->getPlaneData(), pcDepthPlane->getStride(), ppiFposLUT);
+}
+
+Void TRenTop::xConvertInputDepthSubpel( PelImage* pcOrgInputImage, PelImage* pcConvInputImage)
+{
+  PelImagePlane*  pcOrgPlane ;
+  PelImagePlane*  pcConvPlane;
+
+  // Full Plane
+  pcOrgPlane  = pcOrgInputImage ->getPlane(0);
+  pcConvPlane = pcConvInputImage->getPlane(0);
+
+  AOT( m_iLog2SamplingFactor );
+  AOF( m_iInterpolationMode == eRenInt8Tap2 );
+
+  TRenFilter::sampleHorUp(m_iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
+
+  AOF( m_bUVUp );
+  if ( !m_bUVUp ) //GT: depth down
+  {
+    // Quarter Plane
+    PelImagePlane* pcTempPlane = new PelImagePlane(pcOrgInputImage->getPlane(0)->getWidth(), ( pcOrgInputImage->getPlane(0)->getHeight() >> 1), REN_LUMA_MARGIN );
+
+    TRenFilter::sampleVerDown2Tap13(pcOrgInputImage->getPlane(0), pcTempPlane, PICYUV_PAD);
+    pcConvPlane = pcConvInputImage->getPlane(1);
+
+    if ( m_iLog2SamplingFactor == 0 )
+    {
+      TRenFilter::sampleHorDown2Tap13(pcTempPlane, pcConvPlane, 0 );
+    }
+    else
+    {
+      TRenFilter::sampleHorUp    ( m_iLog2SamplingFactor - 1, pcTempPlane->getPlaneData(), pcTempPlane->getStride(), pcTempPlane->getWidth(), pcTempPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
+    }
+    delete pcTempPlane;
+  }
+}
+#endif
+
 Void TRenTop::xConvertInputDepth( PelImage* pcOrgInputImage, PelImage* pcConvInputImage)
 {
@@ -193 +267 @@
 }
 
+#if NTT_SUBPEL
+Void TRenTop::xConvertInputDataSubpel( PelImage* pcOrgInputImage, PelImage* pcOrgInputDepth, PelImage* pcConvInputImage, PelImage* pcConvInputDepth, Bool bMirror )
+{
+  //ToDo: remove unnecessary copying
+  if ( bMirror )
+  {
+    m_pcTempImage->getPlane(0)->assign( pcOrgInputDepth->getPlane(0) );
+    TRenFilter::mirrorHor( m_pcTempImage->getPlane(0) );
+    m_pcTempImage->getPlane(0)->extendMargin();
+    xConvertInputDepthSubpel( m_pcTempImage, pcConvInputDepth );
+
+    m_pcTempImage->assign( pcOrgInputImage );
+    TRenFilter::mirrorHor( m_pcTempImage );
+    m_pcTempImage->extendMargin();
+    xConvertInputVideoSubpel( m_pcTempImage, pcConvInputImage, pcConvInputDepth, bMirror );
+  }
+  else
+  {
+    m_pcTempImage->getPlane(0)->assign( pcOrgInputDepth->getPlane(0) );
+    m_pcTempImage->getPlane(0)->extendMargin();
+    xConvertInputDepthSubpel( m_pcTempImage, pcConvInputDepth );
+
+    m_pcTempImage->assign( pcOrgInputImage );
+    m_pcTempImage->extendMargin();
+    xConvertInputVideoSubpel( m_pcTempImage, pcConvInputImage, pcConvInputDepth, bMirror );
+  }
+}
+#endif
 
 Void TRenTop::xConvertOutputData( PelImage* pcOrgOutputImage, PelImage* pcConvOutputImage, Bool bMirror )
@@ -229 +331 @@
 }
 
+#if VSP_N
+Void TRenTop::xConvertOutputDataPlane0( PelImage* pcOrgOutputImage, PelImage* pcConvOutputImage, Bool bMirror )
+{
+  Int iLog2SamplingFactor = m_iLog2SamplingFactor;
+
+  PelImagePlane* pcOrgPlane  = pcOrgOutputImage ->getPlane(0);
+  PelImagePlane* pcConvPlane = pcConvOutputImage->getPlane(0);
+
+  pcOrgPlane->extendMargin();
+
+  TRenFilter::sampleHorDown( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
+
+  if ( bMirror )
+  {
+    TRenFilter::mirrorHor( pcConvOutputImage );
+  }
+
+}
+#endif
+
 Void TRenTop::setShiftLUTs( Double** ppdShiftLUTLeft, Int** ppiShiftLUTLeft, Int** ppiBaseShiftLUTLeft, Double** ppdShiftLUTRight, Int** ppiShiftLUTRight, Int** ppiBaseShiftLUTRight,  Int iRelDistToLeft )
 {
@@ -254 +376 @@
   }
 }
+
+#if NTT_SUBPEL
+Void TRenTop::setFposLUTs( Int** ppiFposLUTLeft, Int** ppiFposLUTRight )
+{
+  m_ppiFposLUTLeft  = ppiFposLUTLeft;
+  m_ppiFposLUTRight = ppiFposLUTRight;
+
+  if (  m_ppiFposLUTRight != NULL )
+  {
+    for( UInt uiPlane = 0; uiPlane < 2; uiPlane++)
+    {
+      for (UInt uiDepthValue = 0; uiDepthValue <= 256; uiDepthValue++)
+      {
+        m_ppiFposLUTRightMirror[uiPlane][uiDepthValue] = - m_ppiFposLUTRight[uiPlane][uiDepthValue];
+      }
+    }
+  }
+}
+#endif
 
 Void TRenTop::extrapolateView( TComPicYuv* pcPicYuvVideo, TComPicYuv* pcPicYuvDepth, TComPicYuv* pcPicYuvSynthOut, Bool bRenderFromLeft )
@@ -278 +419 @@
   xCutMargin        ( &cOutputImage );
 };
+
+#if VSP_N
+Void TRenTop::extrapolateAvailabilityView( TComPicYuv* pcPicYuvVideo, TComPicYuv* pcPicYuvDepth, TComPicYuv* pcPicYuvSynthOut, TComPicYuv* pcPicYuvAvailOut, Bool bRenderFromLeft )
+{
+  AOF( m_bExtrapolate );
+  AOF( bRenderFromLeft ? m_ppiShiftLUTLeft || m_ppdShiftLUTLeft : m_ppiShiftLUTRight || m_ppdShiftLUTRight );
+  AOF( m_auiInputResolution[0] == pcPicYuvVideo->getWidth ());
+  AOF( m_auiInputResolution[1] == pcPicYuvVideo->getHeight());
+
+  PelImage cInputImage ( pcPicYuvVideo    );
+  PelImage cInputDepth ( pcPicYuvDepth    , true);
+  PelImage cOutputImage( pcPicYuvSynthOut );
+  PelImage cFillImage  ( pcPicYuvAvailOut );
+
+  m_pcOutputImage->init();
+  m_pcFilled     ->assign(REN_IS_HOLE);
+
+  xPreProcessDepth ( &cInputDepth,  &cInputDepth);
+#if NTT_SUBPEL
+  if( m_iInterpolationMode == eRenInt8Tap2 )
+    xConvertInputDataSubpel(&cInputImage, &cInputDepth, m_pcInputImage, m_pcInputDepth, !bRenderFromLeft );
+  else
+    xConvertInputData( &cInputImage, &cInputDepth, m_pcInputImage, m_pcInputDepth, !bRenderFromLeft );
+#else
+  xConvertInputData( &cInputImage, &cInputDepth, m_pcInputImage, m_pcInputDepth, !bRenderFromLeft );
+#endif
+  xShiftPixels(m_pcInputImage, m_pcInputDepth, m_pcOutputImage, m_pcFilled, bRenderFromLeft);
+  xRemBoundaryNoise ( m_pcOutputImage, m_pcFilled, m_pcOutputImage, bRenderFromLeft); // Erode
+  xFillHoles        ( m_pcOutputImage, m_pcFilled, m_pcOutputImage, bRenderFromLeft);
+  xConvertOutputData( m_pcOutputImage, &cOutputImage, !bRenderFromLeft );
+  //if (!bRenderFromLeft)  TRenFilter::mirrorHor( &cFillImage );
+  xConvertOutputDataPlane0( m_pcFilled, &cFillImage, !bRenderFromLeft );
+  xPostProcessImage (&cOutputImage, &cOutputImage);
+  xCutMargin        ( &cOutputImage );
+};
+#endif
 
 Void TRenTop::getUsedSamplesMap( TComPicYuv* pcPicYuvDepth, TComPicYuv* pcUsedSampleMap, Bool bRenderFromLeft )
@@ -751 +928 @@
   {
   case eRenIntFullPel:
+#if NTT_SUBPEL
+  case eRenInt8Tap2:
+#endif
     xShiftPlanePixelsFullPel( apcInPlane, pcDepthPlane, apcOutPlane, pcPlaneFilled, uiNumberOfPlanes);
     break;
@@ -826 +1006 @@
           }
           pcFilledData[iShiftedPos] = REN_IS_FILLED;
+
+#if NTT_SUBPEL
+          if(m_bInstantHoleFilling && (iDiff > 0) )
+          {
+            Int iRefPos = (iPrevShiftedPos == -1) ? iShiftedPos : iPrevShiftedPos;
+            
+            for (Int iCurPos = iPrevShiftedPos+1; iCurPos < iShiftedPos; iCurPos++)
+            {
+              for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
+              {
+                apcOutputData[uiCurPlane][iCurPos] =  apcOutputData[uiCurPlane][iRefPos];
+              }
+              pcFilledData[iCurPos] = REN_IS_FILLED;
+            }
+          }
+#endif
         }
         iPrevShiftedPos = iShiftedPos;
       }
     }
+#if NTT_SUBPEL
+    if( (iPrevShiftedPos+1) != iWidth )
+    {
+      for (Int iCurPos = iPrevShiftedPos+1; iCurPos < iWidth; iCurPos++)
+      {
+        for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
+        {
+          apcOutputData[uiCurPlane][iCurPos] =  apcOutputData[uiCurPlane][iPrevShiftedPos];
+        }
+        pcFilledData[iCurPos] = REN_IS_FILLED;
+      }
+    }
+#endif
     for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
     {
@@ -1450 +1659 @@
 
     for( Int iXPos = iSourcePos + 1; iXPos <  iWidth; iXPos++)
-        {
+    {
       for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
-          {
+      {
         apcOutputData[uiCurPlane][iXPos] = apcInputData[uiCurPlane][iSourcePos];
       }
-            }
+    }
 
     // Fill Left Gap
@@ -1469 +1678 @@
       {
         apcOutputData[uiCurPlane][iXPos] = apcInputData[uiCurPlane][iSourcePos];
-          }
-        }
+      }
+    }
 
     // Go to next line
@@ -2032 +2241 @@
   m_ppiShiftLUTRightMirror[0] = new Int[257];
   m_ppiShiftLUTRightMirror[1] = new Int[257];
+
+#if NTT_SUBPEL
+  m_ppiFposLUTLeft   = 0;
+  m_ppiFposLUTRight  = 0;
+  m_ppiFposLUTRightMirror    = new Int*[2];
+  m_ppiFposLUTRightMirror[0] = new Int[257];
+  m_ppiFposLUTRightMirror[1] = new Int[257];
+#endif
 
   m_aiShiftLUTCur    = 0;
@@ -2116 +2333 @@
   m_iHoleFillingMode = iHoleFillingMode;
 
+#if NTT_SUBPEL
+  m_bInstantHoleFilling   = (m_iInterpolationMode == eRenInt8Tap || m_iInterpolationMode == eRenInt8Tap2 ) && (m_iHoleFillingMode != 0 );
+#else
   m_bInstantHoleFilling   = (m_iInterpolationMode == eRenInt8Tap ) && (m_iHoleFillingMode != 0 );
+#endif
 
   // PostProcessing
@@ -2154 +2375 @@
     {
       m_aaiSubPelShift[uiEntry] = new Int[ iNumEntries ];
-        }
+    }
 
     TRenFilter::setSubPelShiftLUT(m_iRelShiftLUTPrec, m_aaiSubPelShift, -1);
@@ -2184 +2405 @@
   };
 
+#if NTT_SUBPEL
+  if ( m_ppiFposLUTRightMirror != NULL )
+  {
+    delete[] m_ppiFposLUTRightMirror[0];
+    delete[] m_ppiFposLUTRightMirror[1];
+    delete[] m_ppiFposLUTRightMirror;
+  };
+#endif
+
   if (m_piInvZLUTLeft      != NULL ) delete[] m_piInvZLUTLeft   ;
   if (m_piInvZLUTLeft      != NULL ) delete[] m_piInvZLUTRight  ;

branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenTop.h

@@ -50 +50 @@
   // Interpolation Modes
 
+#if NTT_SUBPEL
+  enum { eRenIntFullPel = 0, eRenIntLinInt = 1, eRenIntLinReal = 2, eRenIntFEM = 3, eRenInt8Tap = 4, eRenInt8Tap2 = 5 };
+#else
   enum { eRenIntFullPel = 0, eRenIntLinInt = 1, eRenIntLinReal = 2, eRenIntFEM = 3, eRenInt8Tap = 4 };
+#endif
 
   // HoleFilling
@@ -93 +97 @@
                            Int**    ppiBaseShiftLUTRight,
                            Int      iRelDistLeft );
+#if NTT_SUBPEL
+  Void setFposLUTs      ( Int**    ppiFposLUTLeft, Int**    ppiFposLUTRight );
+  Void setInterpolationMode ( Int iMode ) { m_iInterpolationMode = iMode; }
+#endif
 
   // View Synthesis
@@ -99 +107 @@
                            TComPicYuv* pcPicYuvSynthOut,
                            Bool bRenderFromLeft );
+
+#if VSP_N
+  Void extrapolateAvailabilityView   ( TComPicYuv* pcPicYuvVideo,
+                                       TComPicYuv* pcPicYuvDepth,
+                                       TComPicYuv* pcPicYuvSynthOut,
+                                       TComPicYuv* pcPicYuvAvailOut,
+                                       Bool bRenderFromLeft );
+#endif
 
   Void interpolateView   ( TComPicYuv* pcPicYuvVideoLeft,
@@ -166 +182 @@
   Void xConvertInputData         ( PelImage* pcOrgInputImage, PelImage* pcOrgInputDepth, PelImage* pcConvInputImage, PelImage* pcConvInputDepth, Bool bMirror);
   Void xConvertOutputData        ( PelImage* pOrgOutputImage, PelImage* pConvOutputImage, Bool bMirror);
+#if VSP_N
+  Void xConvertOutputDataPlane0  ( PelImage* pOrgOutputImage, PelImage* pConvOutputImage, Bool bMirror);
+#endif
+#if NTT_SUBPEL
+  Void xConvertInputDataSubpel   ( PelImage* pcOrgInputImage, PelImage* pcOrgInputDepth, PelImage* pcConvInputImage, PelImage* pcConvInputDepth, Bool bMirror);
+  Void xConvertInputVideoSubpel  ( PelImage* pcOrgInputImage, PelImage* pcConvInputImage, PelImage* pcInputDepth, Bool bMirror );
+  Void xConvertInputDepthSubpel  ( PelImage* pcOrgInputImage, PelImage* pcConvInputImage);
+#endif
 
   Void xGetDataPointers          ( PelImage*& rpcInputImage,  PelImage*& rpcOutputImage, PelImage*& rpcInputDepth, PelImage*& rpcOutputDepth, PelImage*& rpcFilled, Bool bRenderDepth );
@@ -229 +253 @@
   Int**    m_ppiShiftLUTRightMirror; // For rendering the mirrored view
   Int*     m_aiShiftLUTCur;
+#if NTT_SUBPEL
+  Int**    m_ppiFposLUTLeft;
+  Int**    m_ppiFposLUTRight;
+  Int**    m_ppiFposLUTRightMirror; // For rendering the mirrored view
+#endif
 
   // Look up tables Z