Ignore:
Timestamp:
7 Sep 2015, 18:40:35 (10 years ago)
Author:
tech
Message:

Removed 3D-HEVC.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/HTM-15.1-MV-draft-4/source/App/TAppEncoder/TAppEncTop.cpp

    r1321 r1325  
    8787#endif
    8888 
    89 #if NH_3D
    90   vps.createCamPars(m_iNumberOfViews); 
    91 #endif
    92 
    93 #if NH_3D_DLT
    94   TComDLT dlt = TComDLT();
    95 #endif
     89
    9690
    9791#if NH_MV
    … …  
    145139  xSetDpbSize              ( vps );
    146140  xSetVPSVUI               ( vps );
    147 #if NH_3D
    148   xSetCamPara              ( vps );
    149   m_ivPicLists.setVPS      ( &vps );
    150 #endif
    151 #if NH_3D_DLT
    152   xDeriveDltArray          ( vps, &dlt );
    153 #endif
    154141  if ( m_targetEncLayerIdList.size() == 0 )
    155142  {
    … …  
    182169  }
    183170
    184 #if NH_3D
    185   // Set 3d tool parameters
    186   for (Int d = 0; d < 2; d++)
    187   { 
    188     m_sps3dExtension.setIvMvPredFlag          ( d, m_ivMvPredFlag[d]       );
    189     m_sps3dExtension.setIvMvScalingFlag       ( d, m_ivMvScalingFlag[d]    );
    190     if (d == 0 )
    191     {   
    192       m_sps3dExtension.setLog2SubPbSizeMinus3   ( d, m_log2SubPbSizeMinus3   );
    193       m_sps3dExtension.setIvResPredFlag         ( d, m_ivResPredFlag         );
    194       m_sps3dExtension.setDepthRefinementFlag   ( d, m_depthRefinementFlag   );
    195       m_sps3dExtension.setViewSynthesisPredFlag ( d, m_viewSynthesisPredFlag );
    196       m_sps3dExtension.setDepthBasedBlkPartFlag ( d, m_depthBasedBlkPartFlag );
    197     }
    198     else
    199     {   
    200       m_sps3dExtension.setMpiFlag               ( d, m_mpiFlag               );
    201       m_sps3dExtension.setLog2MpiSubPbSizeMinus3( d, m_log2MpiSubPbSizeMinus3);
    202       m_sps3dExtension.setIntraContourFlag      ( d, m_intraContourFlag      );
    203       m_sps3dExtension.setIntraSdcWedgeFlag     ( d, m_intraSdcFlag || m_intraWedgeFlag     );
    204       m_sps3dExtension.setQtPredFlag            ( d, m_qtPredFlag            );
    205       m_sps3dExtension.setInterSdcFlag          ( d, m_interSdcFlag          );
    206       m_sps3dExtension.setDepthIntraSkipFlag    ( d, m_depthIntraSkipFlag    ); 
    207     }
    208   }
    209 #endif
    210171
    211172
    … …  
    217178    m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
    218179    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
    219 #if NH_3D   
    220     Int profileIdc = -1;
    221     for (Int olsIdx = 0; olsIdx < vps.getNumOutputLayerSets(); olsIdx++ )
    222     {   
    223       Int lsIdx = vps.olsIdxToLsIdx( olsIdx );
    224       for(Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++ )
    225       {
    226         if( vps.getLayerIdInNuh( layerIdInVps) == vps.getLayerSetLayerIdList(lsIdx, i) )
    227         {
    228           Int ptlIdx = vps.getProfileTierLevelIdx( olsIdx, i );
    229           if ( ptlIdx != -1 )
    230           {
    231             Int curProfileIdc = vps.getPTL(ptlIdx)->getGeneralPTL()->getProfileIdc();
    232             if (profileIdc == -1)   
    233             {
    234               profileIdc = curProfileIdc;
    235             }
    236             else
    237             {   
    238               if ( profileIdc != curProfileIdc )
    239               {             
    240                 fprintf(stderr, "Error: ProfileIdc for layer with index %d in VPS not equal in all OLSs. \n", layerIdInVps );
    241                 exit(EXIT_FAILURE);
    242               }
    243             }
    244           }
    245         }
    246       }
    247     }
    248 
    249     if (profileIdc == -1 )
    250     {
    251       fprintf(stderr, "Error: No profile given for layer with index %d in VPS not equal in all OLS. \n", layerIdInVps );
    252       exit(EXIT_FAILURE);
    253     }
    254     m_acTEncTopList[ layerIdInVps ]->setProfileIdc( profileIdc );
    255 #endif
    256180  }
    257181
    … …  
    276200    m_cTEncTop.setViewId                       ( vps.getViewId      (  layerId ) );
    277201    m_cTEncTop.setViewIndex                    ( vps.getViewIndex   (  layerId ) );
    278 #if NH_3D
    279     Bool isDepth = ( vps.getDepthId     ( layerId ) != 0 ) ;
    280     m_cTEncTop.setIsDepth                      ( isDepth );
    281     //====== Camera Parameters =========
    282     m_cTEncTop.setCameraParameters             ( &m_cCameraData );     
    283 #if NH_3D_VSO
    284     //====== VSO =========
    285     m_cTEncTop.setRenderModelParameters        ( &m_cRenModStrParser );
    286     m_cTEncTop.setForceLambdaScaleVSO          ( isDepth ? m_bForceLambdaScaleVSO : false );
    287     m_cTEncTop.setLambdaScaleVSO               ( isDepth ? m_dLambdaScaleVSO      : 1     );
    288     m_cTEncTop.setVSOMode                      ( isDepth ? m_uiVSOMode            : 0     );
    289 
    290     m_cTEncTop.setAllowNegDist                 ( isDepth ? m_bAllowNegDist        : false );
    291 
    292     // SAIT_VSO_EST_A0033
    293     m_cTEncTop.setUseEstimatedVSD              ( isDepth ? m_bUseEstimatedVSD     : false );
    294 
    295     // LGE_WVSO_A0119
    296     m_cTEncTop.setUseWVSO                      ( isDepth ? m_bUseWVSO             : false );   
    297     m_cTEncTop.setVSOWeight                    ( isDepth ? m_iVSOWeight           : 0     );
    298     m_cTEncTop.setVSDWeight                    ( isDepth ? m_iVSDWeight           : 0     );
    299     m_cTEncTop.setDWeight                      ( isDepth ? m_iDWeight             : 0     );
    300 #endif // H_3D_VSO
    301 #if NH_3D_IC
    302     m_cTEncTop.setUseIC                        ( vps.getViewIndex( layerId ) == 0 || isDepth ? false : m_abUseIC );
    303     m_cTEncTop.setUseICLowLatencyEnc           ( m_bUseLowLatencyICEnc );
    304 #endif
    305 
    306    
    307     m_cTEncTop.setUseDMM                       ( isDepth ? m_intraWedgeFlag   : false );
    308     m_cTEncTop.setUseSDC                       ( isDepth ? m_intraSdcFlag     : false );
    309     m_cTEncTop.setUseDLT                       ( isDepth ? m_useDLT   : false );
    310     m_cTEncTop.setUseQTL                       ( isDepth ? m_bUseQTL  : false );
    311     m_cTEncTop.setSps3dExtension               ( m_sps3dExtension );
    312 #endif // NH_3D
    313202
    314203    m_cTEncTop.setIvPicLists                   ( &m_ivPicLists );
    … …  
    316205  m_cTEncTop.setVPS(&vps);
    317206
    318 #if NH_3D_DLT
    319   m_cTEncTop.setDLT(dlt);
    320 #endif
    321207
    322208#if NH_MV
    … …  
    425311  m_cTEncTop.setChromaCrQpOffset                                  ( m_crQpOffset  );
    426312
    427 #if NH_3D
    428   m_cTEncTop.setChromaFormatIdc                                   ( isDepth ? CHROMA_400 : m_chromaFormatIDC );
    429 #else
    430313  m_cTEncTop.setChromaFormatIdc                                   ( m_chromaFormatIDC  );
    431 #endif
    432314
    433315#if ADAPTIVE_QP_SELECTION
    … …  
    643525  m_cTEncTop.setScalingListFile                                   ( m_scalingListFile   );
    644526  m_cTEncTop.setSignHideFlag                                      ( m_signHideFlag);
    645 #if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
    646   if(!m_cTEncTop.getIsDepth())    //only for texture
    647   {
    648     m_cTEncTop.setUseRateCtrl                                     ( m_RCEnableRateControl );
    649   }                                                         
    650   else                                                       
    651   {                                                         
    652     m_cTEncTop.setUseRateCtrl                                     ( 0 );
    653   }
    654 #else
    655527  m_cTEncTop.setUseRateCtrl                                       ( m_RCEnableRateControl );
    656 #endif
    657 #if !KWU_RC_VIEWRC_E0227
    658528  m_cTEncTop.setTargetBitrate                                     ( m_RCTargetBitrate );
    659 #endif
    660529  m_cTEncTop.setKeepHierBit                                       ( m_RCKeepHierarchicalBit );
    661530  m_cTEncTop.setLCULevelRC                                        ( m_RCLCULevelRC );
    … …  
    663532  m_cTEncTop.setInitialQP                                         ( m_RCInitialQP );
    664533  m_cTEncTop.setForceIntraQP                                      ( m_RCForceIntraQP );
    665 #if KWU_RC_MADPRED_E0227
    666   if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
    667   {
    668     m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred       : 0);
    669     if(m_cTEncTop.getUseDepthMADPred())
    670     {
    671       m_cTEncTop.setCamParam(&m_cCameraData);
    672     }
    673   }
    674 #endif
    675 #if KWU_RC_VIEWRC_E0227
    676   if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
    677   {
    678     m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
    679     if(m_iNumberOfViews == 1)
    680     {
    681       if(m_viewWiseRateCtrl)
    682       {
    683         m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
    684       }
    685       else
    686       {
    687         m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
    688       }
    689     }
    690     else
    691     {
    692       if(m_viewWiseRateCtrl)
    693       {
    694         m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
    695       }
    696       else
    697       {
    698         if(m_iNumberOfViews == 2)
    699         {
    700           if(m_cTEncTop.getViewId() == 0)
    701           {
    702             m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*80)/100 );
    703           }
    704           else if(m_cTEncTop.getViewId() == 1)
    705           {
    706             m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*20)/100 );
    707           }
    708         }
    709         else if(m_iNumberOfViews == 3)
    710         {
    711           if(m_cTEncTop.getViewId() == 0)
    712           {
    713             m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*66)/100 );
    714           }
    715           else if(m_cTEncTop.getViewId() == 1)
    716           {
    717             m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*17)/100 );
    718           }
    719           else if(m_cTEncTop.getViewId() == 2)
    720           {
    721             m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*17)/100 );
    722           }
    723         }
    724         else
    725         {
    726           m_cTEncTop.setTargetBitrate              ( m_RCTargetBitrate );
    727         }
    728       }
    729     }
    730   }
    731 #endif
    732534  m_cTEncTop.setTransquantBypassEnableFlag                        ( m_TransquantBypassEnableFlag );
    733535  m_cTEncTop.setCUTransquantBypassFlagForceValue                  ( m_CUTransquantBypassFlagForce );
    … …  
    776578  }
    777579#endif
    778 #if NH_3D_VSO
    779   if ( m_bUseVSO )
    780   {
    781     if ( m_uiVSOMode == 4 )
    782     {
    783 #if H_3D_VSO_EARLY_SKIP
    784       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, m_bVSOEarlySkip );
    785 #else
    786       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 );
    787 #endif
    788       for ( Int layer = 0; layer < m_numberOfLayers ; layer++ )
    789       {
    790         TEncTop* pcEncTop =  m_acTEncTopList[ layer ];
    791         Int iViewNum      = pcEncTop->getViewIndex();
    792         Int iContent      = pcEncTop->getIsDepth() ? 1 : 0;
    793         Int iNumOfModels  = m_cRenModStrParser.getNumOfModelsForView(iViewNum, iContent);
    794 
    795         Bool bUseVSO      = (iNumOfModels != 0);
    796 
    797         pcEncTop->setUseVSO( bUseVSO );
    798         pcEncTop->getRdCost()->setRenModel( bUseVSO ? &m_cRendererModel : NULL );
    799 
    800         for (Int iCurModel = 0; iCurModel < iNumOfModels; iCurModel++ )
    801         {
    802           Int iModelNum; Int iLeftViewNum; Int iRightViewNum; Int iDump; Int iOrgRefNum; Int iBlendMode;
    803 
    804           m_cRenModStrParser.getSingleModelData  ( iViewNum, iContent, iCurModel, iModelNum, iBlendMode, iLeftViewNum, iRightViewNum, iOrgRefNum, iDump ) ;
    805           m_cRendererModel  .createSingleModel   ( iViewNum, iContent, iModelNum, iLeftViewNum, iRightViewNum, (iOrgRefNum != -1), iBlendMode );
    806         }           
    807       }
    808     }
    809     else
    810     {
    811       AOT(true);
    812     }
    813   }
    814 #endif
    815580}
    816581
    … …  
    820585  // initialize global variables
    821586  initROM();
    822 #if NH_3D_DMM
    823   initWedgeLists( true );
    824 #endif
    825587
    826588  for( Int layer=0; layer < m_numberOfLayers; layer++)
    … …  
    886648  for(Int layer=0; layer<m_numberOfLayers; layer++)
    887649  {
    888 #if KWU_RC_MADPRED_E0227
    889     m_acTEncTopList[layer]->init( isFieldCoding, this );
    890 #else
    891650    m_acTEncTopList[layer]->init( isFieldCoding );
    892 #endif
    893651  }
    894652#else
    … …  
    918676  }
    919677
    920 #if !NH_3D
    921678  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
    922 #endif
    923679  TComPicYuv*       pcPicYuvRec = NULL;
    924680
    … …  
    954710  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
    955711 
    956 #if NH_3D
    957   TComPicYuv* picYuvOrg[2];
    958   TComPicYuv  picYuvTrueOrg[2];
    959   for (Int d = 0; d < 2 ; d++)
    960   {
    961     picYuvOrg[d] = new TComPicYuv;
    962     picYuvOrg[d]   ->create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    963     picYuvTrueOrg[d].create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    964   }
    965 #else
    966712  TComPicYuv cPicYuvTrueOrg;
    967713
    … …  
    977723    cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    978724  }
    979 #endif
    980725#if NH_MV
    981726  while ( (m_targetEncLayerIdList.size() != 0 ) && !allEos )
    … …  
    983728    for(Int layer=0; layer < m_numberOfLayers; layer++ )
    984729    {
    985 #if NH_3D
    986       TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ m_depthFlag[layer] ];
    987       TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ m_depthFlag[layer] ];
    988 #endif
    989730      if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
    990731      {
    … …  
    1022763    for ( Int gopId=0; gopId < gopSize; gopId++ )
    1023764    {
    1024 #if NH_3D
    1025       UInt iNextPoc = m_acTEncTopList[0] -> getFrameId( gopId );
    1026       if ( iNextPoc < m_framesToBeEncoded )
    1027       {
    1028         m_cCameraData.update( iNextPoc );
    1029       }
    1030 #endif
    1031765      for(Int layer=0; layer < m_numberOfLayers; layer++ )
    1032766      {
    1033 #if NH_3D
    1034         TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ m_depthFlag[layer] ];
    1035         TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ m_depthFlag[layer] ];
    1036 #endif
    1037767        if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
    1038768        {
    … …  
    1040770        }
    1041771
    1042 #if NH_3D_VSO       
    1043           if( m_bUseVSO && m_bUseEstimatedVSD && iNextPoc < m_framesToBeEncoded )
    1044           {
    1045             m_cCameraData.setDispCoeff( iNextPoc, m_acTEncTopList[layer]->getViewIndex() );
    1046             m_acTEncTopList[layer]  ->setDispCoeff( m_cCameraData.getDispCoeff() );
    1047           }
    1048 #endif
    1049772
    1050773        Int   iNumEncoded = 0;
    … …  
    1113836#endif
    1114837
    1115 #if NH_3D
    1116   // delete original YUV buffer
    1117   for (Int d = 0; d < 2; d++)
    1118   {
    1119     picYuvOrg[d]->destroy();
    1120     delete picYuvOrg[d];
    1121     picYuvOrg[d] = NULL;
    1122 
    1123     picYuvTrueOrg[d].destroy();
    1124   }
    1125 #else
    1126838  // delete original YUV buffer
    1127839  pcPicYuvOrg->destroy();
    1128840  delete pcPicYuvOrg;
    1129841  pcPicYuvOrg = NULL;
    1130 #endif
    1131842
    1132843#if !NH_MV
    … …  
    1134845  m_cTEncTop.deletePicBuffer();
    1135846#endif
    1136 #if !NH_3D
    1137847  cPicYuvTrueOrg.destroy();
    1138 #endif
    1139848
    1140849  // delete buffers & classes
    … …  
    1144853  printRateSummary();
    1145854
    1146 #if H_3D_REN_MAX_DEV_OUT
    1147   Double dMaxDispDiff = m_cCameraData.getMaxShiftDeviation();
    1148 
    1149   if ( !(dMaxDispDiff < 0) )
    1150   { 
    1151     printf("\n Max. possible shift error: %12.3f samples.\n", dMaxDispDiff );
    1152   }
    1153 #endif
    1154855
    1155856  return;
    … …  
    1188889  {
    1189890    rpcPicYuvRec = new TComPicYuv;
    1190 #if NH_3D
    1191     rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_depthFlag[layer] > 0 ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    1192 #else
    1193891    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    1194 #endif
    1195892
    1196893  }
    … …  
    1270967      if (m_pchReconFileList[layerIdx])
    1271968      {
    1272 #if NH_3D
    1273         m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT, m_isTopFieldFirst );
    1274 #else
    1275969        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
    1276 #endif
    1277970      }
    1278971    }
    … …  
    13271020      if (m_pchReconFileList[layerIdx])
    13281021      {
    1329 #if NH_3D
    1330         m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT  );
    1331 #else
    13321022        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
    1333 #endif
    13341023
    13351024      }   
    … …  
    14561145}
    14571146
    1458 #if NH_3D_DLT
    1459 Void TAppEncTop::xAnalyzeInputBaseDepth(UInt layer, UInt uiNumFrames, TComVPS* vps, TComDLT* dlt)
    1460 {
    1461   TComPicYuv*       pcDepthPicYuvOrg = new TComPicYuv;
    1462   TComPicYuv*       pcDepthPicYuvTrueOrg = new TComPicYuv;
    1463   // allocate original YUV buffer
    1464   pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
    1465   pcDepthPicYuvTrueOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
    1466  
    1467   TVideoIOYuv* depthVideoFile = new TVideoIOYuv;
    1468  
    1469   UInt uiMaxDepthValue = ((1 << m_inputBitDepth[CHANNEL_TYPE_LUMA])-1);
    1470  
    1471   std::vector<Bool> abValidDepths(256, false);
    1472  
    1473   depthVideoFile->open( m_pchInputFileList[layer], false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );
    1474  
    1475   Int iHeight   = pcDepthPicYuvOrg->getHeight(COMPONENT_Y);
    1476   Int iWidth    = pcDepthPicYuvOrg->getWidth(COMPONENT_Y);
    1477   Int iStride   = pcDepthPicYuvOrg->getStride(COMPONENT_Y);
    1478  
    1479   Pel* pInDM    = pcDepthPicYuvOrg->getAddr(COMPONENT_Y);
    1480  
    1481   for(Int uiFrame=0; uiFrame < uiNumFrames; uiFrame++ )
    1482   {
    1483     depthVideoFile->read( pcDepthPicYuvOrg, pcDepthPicYuvTrueOrg, IPCOLOURSPACE_UNCHANGED, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
    1484    
    1485     // check all pixel values
    1486     for (Int i=0; i<iHeight; i++)
    1487     {
    1488       Int rowOffset = i*iStride;
    1489      
    1490       for (Int j=0; j<iWidth; j++)
    1491       {
    1492         Pel depthValue = pInDM[rowOffset+j];
    1493         abValidDepths[depthValue] = true;
    1494       }
    1495     }
    1496   }
    1497  
    1498   depthVideoFile->close();
    1499   delete depthVideoFile;
    1500  
    1501   pcDepthPicYuvOrg->destroy();
    1502   delete pcDepthPicYuvOrg;
    1503   pcDepthPicYuvTrueOrg->destroy();
    1504   delete pcDepthPicYuvTrueOrg;
    1505  
    1506   // convert boolean array to idx2Depth LUT
    1507   std::vector<Int> aiIdx2DepthValue(256, 0);
    1508   Int iNumDepthValues = 0;
    1509   for(Int p=0; p<=uiMaxDepthValue; p++)
    1510   {
    1511     if( abValidDepths[p] == true)
    1512     {
    1513       aiIdx2DepthValue[iNumDepthValues++] = p;
    1514     }
    1515   }
    1516  
    1517   if( uiNumFrames == 0 || gCeilLog2(iNumDepthValues) == m_inputBitDepth[CHANNEL_TYPE_LUMA] )
    1518   {
    1519     dlt->setUseDLTFlag(layer, false);
    1520   }
    1521  
    1522   // assign LUT
    1523   if( dlt->getUseDLTFlag(layer) )
    1524   {
    1525     dlt->setDepthLUTs(layer, aiIdx2DepthValue, iNumDepthValues);
    1526   }
    1527 }
    1528 #endif
    15291147
    15301148#if NH_MV
    … …  
    15561174
    15571175
    1558 #if NH_3D
    1559   vps.initViewCompLayer( );
    1560 #endif
    15611176}
    15621177
    … …  
    16351250      Int curLayerIdInNuh = vps.getLayerIdInNuh( curLayerIdInVps );     
    16361251      Int maxTid = -1;
    1637 #if NH_3D
    1638       if ( vps.getDirectDependencyFlag( curLayerIdInVps, refLayerIdInVps ) )
    1639       {
    1640         if ( m_depthFlag[ curLayerIdInVps] == m_depthFlag[ refLayerIdInVps ] )
    1641         {
    1642 #endif
    16431252          for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    16441253          {       
    … …  
    16471256            for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++)
    16481257            {
    1649 #if NH_3D
    1650               if ( vps.getIdRefListLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[ j ] ) == refLayerIdInNuh )
    1651 #else
    16521258              if ( vps.getIdDirectRefLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[ j ] ) == refLayerIdInNuh )
    1653 #endif
    16541259              {
    16551260                Bool refLayerZero   = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
    … …  
    16581263            }
    16591264          }             
    1660 #if NH_3D
    1661         }
    1662         else
    1663         {       
    1664           if( m_depthFlag[ curLayerIdInVps ] && ( m_mpiFlag|| m_qtPredFlag || m_intraContourFlag ) )
    1665           {         
    1666             Int nuhLayerIdTex = vps.getLayerIdInNuh( vps.getViewIndex( curLayerIdInNuh ), false );
    1667             if ( nuhLayerIdTex == refLayerIdInNuh )
    1668             {
    1669               for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    1670               {       
    1671                 GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1672                 GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1673                 if ( geCur.m_interCompPredFlag )
    1674                 {
    1675                   Bool refLayerZero   = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
    1676                   maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
    1677                 }
    1678               }
    1679             }
    1680           }
    1681           if( !m_depthFlag[ curLayerIdInVps ] && vps.getNumRefListLayers( curLayerIdInNuh) > 0  && ( m_depthRefinementFlag || m_viewSynthesisPredFlag || m_depthBasedBlkPartFlag ) )
    1682           {             
    1683             for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    1684             {       
    1685               GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1686               GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1687 
    1688               if ( geCur.m_interCompPredFlag )
    1689               {
    1690                 for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++ )
    1691                 {
    1692                   Int nuhLayerIdDep = vps.getLayerIdInNuh( vps.getViewIndex( vps.getIdRefListLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[j] ) ), true );
    1693                   if ( nuhLayerIdDep == refLayerIdInNuh )
    1694                   {
    1695                     Bool refLayerZero   = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
    1696                     maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
    1697                   }
    1698                 }
    1699               }
    1700             }
    1701           }       
    1702         }
    1703       } // if ( vps.getDirectDependencyFlag( curLayerIdInVps, refLayerIdInVps ) )
    1704       vps.setMaxTidIlRefPicsPlus1( refLayerIdInVps, curLayerIdInVps, maxTid + 1 );
    1705 #endif
    17061265    }  // Loop curLayerIdInVps
    17071266  } // Loop refLayerIdInVps
    … …  
    17521311     
    17531312      // check if all reference layers when allRefLayerActiveFlag is equal to 1 are reference layer pictures specified in the gop entry
    1754 #if NH_3D
    1755       for (Int k = 0; k < vps.getNumRefListLayers( layerIdInNuh ) && allRefLayersActiveFlag; k++ )
    1756       {
    1757         Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdRefListLayer( layerIdInNuh , k ) );
    1758 #else
    17591313      for (Int k = 0; k < vps.getNumDirectRefLayers( layerIdInNuh ) && allRefLayersActiveFlag; k++ )
    17601314      {
    17611315        Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdDirectRefLayer( layerIdInNuh , k ) );
    1762 #endif
    17631316        if ( vps.getSubLayersVpsMaxMinus1(refLayerIdInVps) >= tId  && ( tId == 0 || vps.getMaxTidIlRefPicsPlus1(refLayerIdInVps,layerIdInVps) > tId )  )
    17641317        {
    … …  
    17781331      {   
    17791332        Bool referenceLayerFoundFlag = false;
    1780 #if NH_3D
    1781         for (Int k = 0; k < vps.getNumRefListLayers( layerIdInNuh ); k++ )
    1782         {
    1783           Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdRefListLayer( layerIdInNuh, k) );
    1784 #else
    17851333        for (Int k = 0; k < vps.getNumDirectRefLayers( layerIdInNuh ); k++ )
    17861334        {
    17871335          Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdDirectRefLayer( layerIdInNuh, k) );
    1788 #endif
    17891336          if ( vps.getSubLayersVpsMaxMinus1(refLayerIdInVps) >= tId  && ( tId == 0 || vps.getMaxTidIlRefPicsPlus1(refLayerIdInVps,layerIdInVps) > tId )  )
    17901337          {         
    … …  
    19151462    break;
    19161463  case Profile::MULTIVIEWMAIN:
    1917 #if NH_3D
    1918   case Profile::MAIN3D:
    1919 #endif
    19201464    ptl->setMax12bitConstraintFlag      ( true  );
    19211465    ptl->setMax12bitConstraintFlag      ( true  );
    … …  
    19391483
    19401484  Bool anyDepth = false;
    1941 #if NH_3D
    1942   for ( Int i = 0; i < m_numberOfLayers; i++ )
    1943   {
    1944     vps.setVpsRepFormatIdx( i, m_depthFlag[ i ] ? 1 : 0 );
    1945     anyDepth = anyDepth || m_depthFlag[ i ];
    1946   }
    1947 #endif
    19481485
    19491486  vps.setRepFormatIdxPresentFlag( anyDepth );
    … …  
    23501887}
    23511888
    2352 #if NH_3D
    2353 Void TAppEncTop::xSetCamPara                ( TComVPS& vps )
    2354 {
    2355   vps.setCpPrecision( m_cCameraData.getCamParsCodedPrecision());
    2356 
    2357   for ( Int n = 1; n < vps.getNumViews(); n++ )
    2358   { 
    2359     Int i      = vps.getViewOIdxList( n );
    2360     Int iInVps = vps.getVoiInVps    ( i );
    2361     vps.setNumCp( iInVps,  n);   
    2362 
    2363     if ( vps.getNumCp( iInVps ) > 0 )
    2364     {
    2365       vps.setCpInSliceSegmentHeaderFlag( iInVps, m_cCameraData.getVaryingCameraParameters() );
    2366 
    2367       for( Int m = 0; m < vps.getNumCp( iInVps ); m++ )
    2368       {
    2369         vps.setCpRefVoi( iInVps, m, vps.getViewOIdxList( m ) );
    2370         if( !vps.getCpInSliceSegmentHeaderFlag( iInVps ) )
    2371         {
    2372           Int j = vps.getCpRefVoi( iInVps, m );
    2373           Int jInVps = vps.getVoiInVps( j );         
    2374 
    2375           vps.setVpsCpScale   ( iInVps, jInVps, m_cCameraData.getCodedScale() [ jInVps ][ iInVps ] ) ;
    2376           vps.setVpsCpInvScale( iInVps, jInVps, m_cCameraData.getCodedScale() [ iInVps ][ jInVps ] ) ;
    2377           vps.setVpsCpOff     ( iInVps, jInVps, m_cCameraData.getCodedOffset()[ jInVps ][ iInVps ] ) ;
    2378           vps.setVpsCpInvOff  ( iInVps, jInVps, m_cCameraData.getCodedOffset()[ iInVps ][ jInVps ] ) ;
    2379         }
    2380       }
    2381     }
    2382   }
    2383   vps.deriveCpPresentFlag();
    2384 }
    2385 #endif
    23861889
    23871890
    … …  
    23951898
    23961899
    2397 #if NH_3D_DLT
    2398 Void TAppEncTop::xDeriveDltArray( TComVPS& vps, TComDLT* dlt )
    2399 {
    2400   Int  iNumDepthViews  = 0;
    2401   Bool bDltPresentFlag = false;
    2402 
    2403   for ( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
    2404   {
    2405     Bool isDepth = ( vps.getDepthId( layer ) == 1 );
    2406 
    2407     if ( isDepth )
    2408     {
    2409       iNumDepthViews++;
    2410     }
    2411 
    2412     dlt->setUseDLTFlag( layer , isDepth && m_useDLT );
    2413     if( dlt->getUseDLTFlag( layer ) )
    2414     {
    2415       xAnalyzeInputBaseDepth(layer, max(m_iIntraPeriod[layer], 24), &vps, dlt);
    2416       bDltPresentFlag = bDltPresentFlag || dlt->getUseDLTFlag(layer);
    2417       dlt->setInterViewDltPredEnableFlag(layer, (dlt->getUseDLTFlag(layer) && (layer>1)));
    2418      
    2419       // ----------------------------- determine whether to use bit-map -----------------------------
    2420       Bool bDltBitMapRepFlag       = false;
    2421       UInt uiNumBitsNonBitMap      = 0;
    2422       UInt uiNumBitsBitMap         = 0;
    2423      
    2424       UInt uiMaxDiff               = 0;
    2425       UInt uiMinDiff               = MAX_INT;
    2426       UInt uiLengthMinDiff         = 0;
    2427       UInt uiLengthDltDiffMinusMin = 0;
    2428      
    2429       std::vector<Int> aiIdx2DepthValue_coded(256, 0);
    2430       UInt uiNumDepthValues_coded = 0;
    2431      
    2432       uiNumDepthValues_coded = dlt->getNumDepthValues(layer);
    2433       for( UInt ui = 0; ui<uiNumDepthValues_coded; ui++ )
    2434       {
    2435         aiIdx2DepthValue_coded[ui] = dlt->idx2DepthValue(layer, ui);
    2436       }
    2437      
    2438       if( dlt->getInterViewDltPredEnableFlag( layer ) )
    2439       {
    2440         AOF( vps.getDepthId( 1 ) == 1 );
    2441         AOF( layer > 1 );
    2442         // assumes ref layer id to be 1
    2443         std::vector<Int> piRefDLT = dlt->idx2DepthValue( 1 );
    2444         UInt uiRefNum = dlt->getNumDepthValues( 1 );
    2445         dlt->getDeltaDLT(layer, piRefDLT, uiRefNum, aiIdx2DepthValue_coded, uiNumDepthValues_coded);
    2446       }
    2447      
    2448       std::vector<UInt> puiDltDiffValues(uiNumDepthValues_coded, 0);
    2449      
    2450       for (UInt d = 1; d < uiNumDepthValues_coded; d++)
    2451       {
    2452         puiDltDiffValues[d] = aiIdx2DepthValue_coded[d] - aiIdx2DepthValue_coded[d-1];
    2453        
    2454         if ( uiMaxDiff < puiDltDiffValues[d] )
    2455         {
    2456           uiMaxDiff = puiDltDiffValues[d];
    2457         }
    2458        
    2459         if ( uiMinDiff > puiDltDiffValues[d] )
    2460         {
    2461           uiMinDiff = puiDltDiffValues[d];
    2462         }
    2463       }
    2464      
    2465       // counting bits
    2466       // diff coding branch
    2467       uiNumBitsNonBitMap += 8;                          // u(v) bits for num_depth_values_in_dlt[layerId] (i.e. num_entry[ layerId ])
    2468      
    2469       if ( uiNumDepthValues_coded > 1 )
    2470       {
    2471         uiNumBitsNonBitMap += 8;                        // u(v) bits for max_diff[ layerId ]
    2472       }
    2473      
    2474       if ( uiNumDepthValues_coded > 2 )
    2475       {
    2476         uiLengthMinDiff    = (UInt) gCeilLog2(uiMaxDiff + 1);
    2477         uiNumBitsNonBitMap += uiLengthMinDiff;          // u(v)  bits for min_diff[ layerId ]
    2478       }
    2479      
    2480       uiNumBitsNonBitMap += 8;                          // u(v) bits for dlt_depth_value0[ layerId ]
    2481      
    2482       if (uiMaxDiff > uiMinDiff)
    2483       {
    2484         uiLengthDltDiffMinusMin = (UInt) gCeilLog2(uiMaxDiff - uiMinDiff + 1);
    2485         uiNumBitsNonBitMap += uiLengthDltDiffMinusMin * (uiNumDepthValues_coded - 1);  // u(v) bits for dlt_depth_value_diff_minus_min[ layerId ][ j ]
    2486       }
    2487      
    2488       // bit map branch
    2489       uiNumBitsBitMap = 1 << m_inputBitDepth[CHANNEL_TYPE_LUMA];
    2490      
    2491       // determine bDltBitMapFlag
    2492       bDltBitMapRepFlag = (uiNumBitsBitMap > uiNumBitsNonBitMap) ? false : true;
    2493      
    2494       dlt->setUseBitmapRep(layer, bDltBitMapRepFlag);
    2495     }
    2496   }
    2497 
    2498   dlt->setDltPresentFlag( bDltPresentFlag );
    2499   dlt->setNumDepthViews ( iNumDepthViews  );
    2500   dlt->setDepthViewBitDepth( m_inputBitDepth[CHANNEL_TYPE_LUMA] );
    2501 }
    2502 #endif
    25031900//! \}
Note: See TracChangeset for help on using the changeset viewer.