Changeset 1413 in 3DVCSoftware for trunk/source/App/TAppEncoder/TAppEncTop.cpp


Ignore:
Timestamp:
11 Jul 2018, 15:19:49 (6 years ago)
Author:
tech
Message:

Merged HTM-16.2-dev@1412

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

    r1405 r1413  
    44 * granted under this license.
    55 *
    6  * Copyright (c) 2010-2016, ITU/ISO/IEC
     6 * Copyright (c) 2010-2017, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4747#include "TLibEncoder/AnnexBwrite.h"
    4848
     49#if EXTENSION_360_VIDEO
     50#include "TAppEncHelper360/TExt360AppEncTop.h"
     51#endif
     52
    4953using namespace std;
    5054
     
    5761
    5862TAppEncTop::TAppEncTop()
     63#if NH_MV
     64  : m_spsMap( MAX_NUM_SPS ),
     65    m_ppsMap( MAX_NUM_PPS )
     66#endif
    5967{
    60 
    6168#if NH_MV
    6269  m_vps = new TComVPS;
     
    8895 
    8996#if NH_3D
    90   vps.createCamPars(m_iNumberOfViews); 
    91 #endif
    92 
    93 #if NH_3D_DLT
    94   TComDLT dlt = TComDLT();
     97  vps.createCamPars(m_iNumberOfViews);   
    9598#endif
    9699
     
    140143  xSetDimensionIdAndLength ( vps );
    141144  xSetDependencies         ( vps );
    142   xSetRepFormat            ( vps );
    143   xSetProfileTierLevel     ( vps );
    144   xSetLayerSets            ( vps );
     145  xSetRepFormat            ( vps );  
     146  xSetLayerSets            ( vps ); 
     147  xSetProfileTierLevel     ( vps ); 
    145148  xSetDpbSize              ( vps );
    146149  xSetVPSVUI               ( vps );
     
    151154  m_ivPicLists.setVPS      ( &vps );
    152155#endif
    153 #if NH_3D_DLT
     156#if NH_3D
     157  TComDLT dlt = TComDLT();
    154158  xDeriveDltArray          ( vps, &dlt );
    155159#endif
     160
     161
     162  xDeriveParameterSetIds( vps );
     163
    156164  if ( m_targetEncLayerIdList.size() == 0 )
    157165  {
     
    182190    vps.printLayerSets();
    183191    vps.printPTL();
     192    vps.printRepFormat();
    184193  }
    185194
     
    188197  for (Int d = 0; d < 2; d++)
    189198  { 
    190     m_sps3dExtension.setIvDiMcEnabledFlag          ( d, m_ivMvPredFlag[d]       );
    191     m_sps3dExtension.setIvMvScalEnabledFlag       ( d, m_ivMvScalingFlag[d]    );
     199    m_sps3dExtension.setIvDiMcEnabledFlag             ( d, m_ivMvPredFlag[d]       );
     200    m_sps3dExtension.setIvMvScalEnabledFlag           ( d, m_ivMvScalingFlag[d]    );
    192201    if (d == 0 )
    193202    {   
    194       m_sps3dExtension.setLog2IvmcSubPbSizeMinus3   ( d, m_log2SubPbSizeMinus3   );
    195       m_sps3dExtension.setIvResPredEnabledFlag         ( d, m_ivResPredFlag         );
    196       m_sps3dExtension.setDepthRefEnabledFlag   ( d, m_depthRefinementFlag   );
    197       m_sps3dExtension.setVspMcEnabledFlag ( d, m_viewSynthesisPredFlag );
    198       m_sps3dExtension.setDbbpEnabledFlag ( d, m_depthBasedBlkPartFlag );
     203      m_sps3dExtension.setLog2IvmcSubPbSizeMinus3     ( d, m_log2SubPbSizeMinus3   );
     204      m_sps3dExtension.setIvResPredEnabledFlag        ( d, m_ivResPredFlag         );
     205      m_sps3dExtension.setDepthRefEnabledFlag         ( d, m_depthRefinementFlag   );
     206      m_sps3dExtension.setVspMcEnabledFlag            ( d, m_viewSynthesisPredFlag );
     207      m_sps3dExtension.setDbbpEnabledFlag             ( d, m_depthBasedBlkPartFlag );
    199208    }
    200209    else
    201210    {   
    202       m_sps3dExtension.setTexMcEnabledFlag               ( d, m_mpiFlag               );
    203       m_sps3dExtension.setLog2TexmcSubPbSizeMinus3( d, m_log2MpiSubPbSizeMinus3);
    204       m_sps3dExtension.setIntraContourEnabledFlag      ( d, m_intraContourFlag      );
    205       m_sps3dExtension.setIntraDcOnlyWedgeEnabledFlag     ( d, m_intraSdcFlag || m_intraWedgeFlag     );
    206       m_sps3dExtension.setCqtCuPartPredEnabledFlag            ( d, m_qtPredFlag            );
    207       m_sps3dExtension.setInterDcOnlyEnabledFlag          ( d, m_interSdcFlag          );
    208       m_sps3dExtension.setSkipIntraEnabledFlag    ( d, m_depthIntraSkipFlag    ); 
     211      m_sps3dExtension.setTexMcEnabledFlag            ( d, m_mpiFlag               );
     212      m_sps3dExtension.setLog2TexmcSubPbSizeMinus3    ( d, m_log2MpiSubPbSizeMinus3);
     213      m_sps3dExtension.setIntraContourEnabledFlag     ( d, m_intraContourFlag      );
     214      m_sps3dExtension.setIntraDcOnlyWedgeEnabledFlag ( d, m_intraSdcFlag || m_intraWedgeFlag     );
     215      m_sps3dExtension.setCqtCuPartPredEnabledFlag    ( d, m_qtPredFlag            );
     216      m_sps3dExtension.setInterDcOnlyEnabledFlag      ( d, m_interSdcFlag          );
     217      m_sps3dExtension.setSkipIntraEnabledFlag        ( d, m_depthIntraSkipFlag    ); 
    209218    }
    210219  }
     
    216225  {
    217226    m_frameRcvd                 .push_back(0);
     227#if NH_MV
     228    m_acTEncTopList             .push_back(new TEncTop( m_spsMap, m_ppsMap ) );
     229#else
    218230    m_acTEncTopList             .push_back(new TEncTop);
     231#endif
    219232    m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
    220233    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
     
    261274  for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
    262275  {
     276    Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layerIdInVps];
    263277    m_cListPicYuvRec            .push_back(new TComList<TComPicYuv*>) ;
    264 
    265 #if !NH_MV
    266     m_ivPicLists.push_back( m_acTEncTopList[ layerIdInVps ]->getListPic()  );
    267 #endif
    268 
    269278    TEncTop& m_cTEncTop = *m_acTEncTopList[ layerIdInVps ];  // It is not a member, but this name helps avoiding code duplication !!!
    270279
    271280    Int layerId = vps.getLayerIdInNuh          ( layerIdInVps );
    272 #if NH_MV
    273281    m_ivPicLists.getSubDpb( layerId, true );
    274 #endif
    275282
    276283    m_cTEncTop.setLayerIdInVps                 ( layerIdInVps );
     
    278285    m_cTEncTop.setViewId                       ( vps.getViewId      (  layerId ) );
    279286    m_cTEncTop.setViewIndex                    ( vps.getViewIndex   (  layerId ) );
     287    m_cTEncTop.setSendParameterSets            ( m_sendParameterSets[ layerIdInVps ]  );
     288    m_cTEncTop.setParameterSetId               ( m_parameterSetId   [ layerIdInVps ]  );
    280289#if NH_3D_VSO || NH_3D
    281290    Bool isDepth    = ( vps.getDepthId     ( layerId ) != 0  ) ;
     
    305314#endif // H_3D_VSO
    306315#if NH_3D
    307 #if NH_3D_IC
    308316    m_cTEncTop.setUseIC                        ( vps.getViewIndex( layerId ) == 0 || isDepth ? false : m_abUseIC );
    309317    m_cTEncTop.setUseICLowLatencyEnc           ( m_bUseLowLatencyICEnc );
    310 #endif
    311 
    312    
     318
    313319    m_cTEncTop.setUseDMM                       ( isDepth ? m_intraWedgeFlag   : false );
    314320    m_cTEncTop.setUseSDC                       ( isDepth ? m_intraSdcFlag     : false );
    315321    m_cTEncTop.setUseDLT                       ( isDepth ? m_useDLT   : false );
    316 #endif
    317 #if NH_3D_QTL
     322
    318323    m_cTEncTop.setUseQTL                       ( isDepth || isAuxDepth ? m_bUseQTL  : false );
    319 #endif
    320 #if NH_3D
     324
    321325    m_cTEncTop.setSps3dExtension               ( m_sps3dExtension );
    322326#endif // NH_3D
     
    326330  m_cTEncTop.setVPS(&vps);
    327331
    328 #if NH_3D_DLT
     332#if NH_3D
    329333  m_cTEncTop.setDLT(dlt);
    330334#endif
    331335
    332336#if NH_MV
    333   m_cTEncTop.setProfile                                           ( m_profiles[0]);
    334   m_cTEncTop.setLevel                                             ( m_levelTier[0], m_level[0] );
     337  // These values go to the SPS of the base layer only and should apply as follows:
     338  // –  If the profile_tier_level( ) syntax structure is included in an active SPS for the base layer
     339  //    or is the profile_tier_level( ) syntax structure VpsProfileTierLevel[ 0 ],
     340  //    it applies to the OLS containing all layers in the bitstream but with only the base layer being the output layer.
     341  // –  Otherwise, if the profile_tier_level( ) syntax structure is included in an active SPS
     342  //    for an independent non-base layer with nuh_layer_id equal to layerId, it applies to the output bitstream
     343  //    of the independent non-base layer rewriting process of clause F.10.2 with the input variables assignedBaseLayerId equal to layerId and tIdTarget equal to 6.
     344
     345  m_cTEncTop.setProfile                                           ( m_profiles[0]                       );
     346  m_cTEncTop.setLevel                                             ( m_levelTier[0], m_level[0]          );
     347  m_cTEncTop.setProgressiveSourceFlag                             ( m_progressiveSourceFlags        [0] );
     348  m_cTEncTop.setInterlacedSourceFlag                              ( m_interlacedSourceFlags         [0] );
     349  m_cTEncTop.setNonPackedConstraintFlag                           ( m_nonPackedConstraintFlags      [0] );
     350  m_cTEncTop.setFrameOnlyConstraintFlag                           ( m_frameOnlyConstraintFlags      [0] );
     351  m_cTEncTop.setBitDepthConstraintValue                           ( m_bitDepthConstraints           [0] );
     352  m_cTEncTop.setChromaFormatConstraintValue                       ( m_chromaFormatConstraints       [0] );
     353  m_cTEncTop.setIntraConstraintFlag                               ( m_intraConstraintFlags          [0] );
     354  m_cTEncTop.setOnePictureOnlyConstraintFlag                      ( m_onePictureOnlyConstraintFlags [0] );
     355  m_cTEncTop.setLowerBitRateConstraintFlag                        ( m_lowerBitRateConstraintFlags   [0] );
    335356#else
    336357  m_cTEncTop.setProfile                                           ( m_profile);
    337358  m_cTEncTop.setLevel                                             ( m_levelTier, m_level);
    338 #endif
    339359  m_cTEncTop.setProgressiveSourceFlag                             ( m_progressiveSourceFlag);
    340360  m_cTEncTop.setInterlacedSourceFlag                              ( m_interlacedSourceFlag);
     
    347367  m_cTEncTop.setLowerBitRateConstraintFlag                        ( m_lowerBitRateConstraintFlag );
    348368
     369#endif
     370
    349371  m_cTEncTop.setPrintMSEBasedSequencePSNR                         ( m_printMSEBasedSequencePSNR);
    350372  m_cTEncTop.setPrintFrameMSE                                     ( m_printFrameMSE);
    351373  m_cTEncTop.setPrintSequenceMSE                                  ( m_printSequenceMSE);
     374#if JVET_F0064_MSSSIM
     375  m_cTEncTop.setPrintMSSSIM                                       ( m_printMSSSIM );
     376#endif
    352377  m_cTEncTop.setCabacZeroWordPaddingEnabled                       ( m_cabacZeroWordPaddingEnabled );
    353378
     
    355380  m_cTEncTop.setFrameSkip                                         ( m_FrameSkip );
    356381  m_cTEncTop.setTemporalSubsampleRatio                            ( m_temporalSubsampleRatio );
     382#if NH_MV
     383  m_cTEncTop.setSourceWidth                                       ( m_iSourceWidths [repFormatIdx] );
     384  m_cTEncTop.setSourceHeight                                      ( m_iSourceHeights[repFormatIdx] );
     385
     386  m_cTEncTop.setConformanceWindow                                 ( m_confWinLefts[repFormatIdx], m_confWinRights[repFormatIdx], m_confWinTops[repFormatIdx], m_confWinBottoms[repFormatIdx] );
     387#else
    357388  m_cTEncTop.setSourceWidth                                       ( m_iSourceWidth );
    358389  m_cTEncTop.setSourceHeight                                      ( m_iSourceHeight );
    359390  m_cTEncTop.setConformanceWindow                                 ( m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
     391#endif
    360392  m_cTEncTop.setFramesToBeEncoded                                 ( m_framesToBeEncoded );
    361393
     
    368400  m_cTEncTop.setDecodingRefreshType                               ( m_iDecodingRefreshType );
    369401  m_cTEncTop.setGOPSize                                           ( m_iGOPSize );
    370 #if NH_MV
    371   m_cTEncTop.setGopList                                           ( m_GOPListMvc[layerIdInVps] );
     402#if JCTVC_Y0038_PARAMS
     403  m_cTEncTop.setReWriteParamSetsFlag                              ( m_bReWriteParamSetsFlag );
     404#endif
     405#if NH_MV
     406  m_cTEncTop.setGopList                                           ( xGetGopEntries(layerIdInVps) );
    372407  m_cTEncTop.setExtraRPSs                                         ( m_extraRPSsMvc[layerIdInVps] );
    373408  for(Int i = 0; i < MAX_TLAYER; i++)
     
    398433#endif
    399434
     435#if X0038_LAMBDA_FROM_QP_CAPABILITY
     436  m_cTEncTop.setIntraQPOffset                                     ( m_intraQPOffset );
     437  m_cTEncTop.setLambdaFromQPEnable                                ( m_lambdaFromQPEnable );
     438#endif
     439#if NH_MV
     440  m_cTEncTop.setPad                                               ( &m_aiPads[ repFormatIdx ][0] );
     441#else
    400442  m_cTEncTop.setPad                                               ( m_aiPad );
     443#endif
     444
    401445  m_cTEncTop.setAccessUnitDelimiter                               ( m_AccessUnitDelimiter );
    402446#if NH_MV
     
    418462  m_cTEncTop.setLoopFilterBetaOffset                              ( m_loopFilterBetaOffsetDiv2  );
    419463  m_cTEncTop.setLoopFilterTcOffset                                ( m_loopFilterTcOffsetDiv2    );
    420 #if W0038_DB_OPT
    421464  m_cTEncTop.setDeblockingFilterMetric                            ( m_deblockingFilterMetric );
    422 #else
    423   m_cTEncTop.setDeblockingFilterMetric                            ( m_DeblockingFilterMetric );
    424 #endif
    425465
    426466  //====== Motion search ========
     
    444484  m_cTEncTop.setChromaCbQpOffset                                  ( m_cbQpOffset     );
    445485  m_cTEncTop.setChromaCrQpOffset                                  ( m_crQpOffset  );
    446 #if W0038_CQP_ADJ
     486  m_cTEncTop.setWCGChromaQpControl                                ( m_wcgChromaQpControl );
    447487  m_cTEncTop.setSliceChromaOffsetQpIntraOrPeriodic                ( m_sliceChromaQpOffsetPeriodicity, m_sliceChromaQpOffsetIntraOrPeriodic );
    448 #endif
    449 
    450 #if NH_3D
    451   m_cTEncTop.setChromaFormatIdc                                   ( isDepth ? CHROMA_400 : m_chromaFormatIDC );
     488
     489#if NH_MV
     490  m_cTEncTop.setChromaFormatIdc                                   ( m_chromaFormatIDCs[ repFormatIdx ] );
    452491#else
    453492  m_cTEncTop.setChromaFormatIdc                                   ( m_chromaFormatIDC  );
     
    466505
    467506  //====== Tool list ========
     507  m_cTEncTop.setLumaLevelToDeltaQPControls                        ( m_lumaLevelToDeltaQPMapping );
     508#if X0038_LAMBDA_FROM_QP_CAPABILITY
     509  m_cTEncTop.setDeltaQpRD( (m_costMode==COST_LOSSLESS_CODING) ? 0 : m_uiDeltaQpRD );
     510#else
    468511  m_cTEncTop.setDeltaQpRD                                         ( m_uiDeltaQpRD  );
     512#endif
    469513  m_cTEncTop.setFastDeltaQp                                       ( m_bFastDeltaQP  );
    470514  m_cTEncTop.setUseASR                                            ( m_bUseASR      );
     
    477521  m_cTEncTop.setUseRDOQ                                           ( m_useRDOQ     );
    478522  m_cTEncTop.setUseRDOQTS                                         ( m_useRDOQTS   );
    479 #if T0196_SELECTIVE_RDOQ
    480523  m_cTEncTop.setUseSelectiveRDOQ                                  ( m_useSelectiveRDOQ );
    481 #endif
    482524  m_cTEncTop.setRDpenalty                                         ( m_rdPenalty );
    483525  m_cTEncTop.setMaxCUWidth                                        ( m_uiMaxCUWidth );
    484526  m_cTEncTop.setMaxCUHeight                                       ( m_uiMaxCUHeight );
     527#if NH_MV
     528  m_cTEncTop.setMaxTotalCUDepth                                   ( m_uiMaxTotalCUDepth[ repFormatIdx] );
     529#else
    485530  m_cTEncTop.setMaxTotalCUDepth                                   ( m_uiMaxTotalCUDepth );
     531#endif
    486532  m_cTEncTop.setLog2DiffMaxMinCodingBlockSize                     ( m_uiLog2DiffMaxMinCodingBlockSize );
    487533  m_cTEncTop.setQuadtreeTULog2MaxSize                             ( m_uiQuadtreeTULog2MaxSize );
     
    524570  for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++)
    525571  {
     572#if NH_MV
     573    m_cTEncTop.setBitDepth((ChannelType)channelType, m_internalBitDepths[repFormatIdx][channelType]);
     574    m_cTEncTop.setPCMBitDepth((ChannelType)channelType, m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepths[repFormatIdx][channelType] : m_internalBitDepths[repFormatIdx][channelType]);
     575#else
    526576    m_cTEncTop.setBitDepth((ChannelType)channelType, m_internalBitDepth[channelType]);
    527577    m_cTEncTop.setPCMBitDepth((ChannelType)channelType, m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepth[channelType] : m_internalBitDepth[channelType]);
     578#endif
    528579  }
    529580
     
    562613
    563614  m_cTEncTop.setSaoCtuBoundary                                    ( m_saoCtuBoundary);
    564 #if OPTIONAL_RESET_SAO_ENCODING_AFTER_IRAP
    565615  m_cTEncTop.setSaoResetEncoderStateAfterIRAP                     ( m_saoResetEncoderStateAfterIRAP);
    566 #endif
    567616  m_cTEncTop.setPCMInputBitDepthFlag                              ( m_bPCMInputBitDepthFlag);
    568617  m_cTEncTop.setPCMFilterDisableFlag                              ( m_bPCMFilterDisableFlag);
     
    620669  m_cTEncTop.setScalableNestingSEIEnabled                         ( m_scalableNestingSEIEnabled );
    621670  m_cTEncTop.setTMCTSSEIEnabled                                   ( m_tmctsSEIEnabled );
     671#if MCTS_ENC_CHECK
     672  m_cTEncTop.setTMCTSSEITileConstraint                            ( m_tmctsSEITileConstraint );
     673#endif
    622674  m_cTEncTop.setTimeCodeSEIEnabled                                ( m_timeCodeSEIEnabled );
    623675  m_cTEncTop.setNumberOfTimeSets                                  ( m_timeCodeSEINumTs );
     
    639691  m_cTEncTop.setColourRemapInfoSEIFileRoot                        ( m_colourRemapSEIFileRoot );
    640692  m_cTEncTop.setMasteringDisplaySEI                               ( m_masteringDisplay );
    641 #if U0033_ALTERNATIVE_TRANSFER_CHARACTERISTICS_SEI
    642693  m_cTEncTop.setSEIAlternativeTransferCharacteristicsSEIEnable    ( m_preferredTransferCharacteristics>=0     );
    643694  m_cTEncTop.setSEIPreferredTransferCharacteristics               ( UChar(m_preferredTransferCharacteristics) );
    644 #endif
    645 
     695  m_cTEncTop.setSEIGreenMetadataInfoSEIEnable                     ( m_greenMetadataType > 0 );
     696  m_cTEncTop.setSEIGreenMetadataType                              ( UChar(m_greenMetadataType) );
     697  m_cTEncTop.setSEIXSDMetricType                                  ( UChar(m_xsdMetricType) );
    646698#if NH_MV
    647699  m_cTEncTop.setSeiMessages                                       ( &m_seiMessages );
     
    667719  m_cTEncTop.setUseScalingListId                                  ( m_useScalingListId  );
    668720  m_cTEncTop.setScalingListFileName                               ( m_scalingListFileName );
    669   m_cTEncTop.setSignHideFlag                                      ( m_signHideFlag);
     721  m_cTEncTop.setSignDataHidingEnabledFlag                         ( m_signDataHidingEnabledFlag);
     722
    670723#if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
    671724  if(!m_cTEncTop.getIsDepth())    //only for texture
     
    688741  m_cTEncTop.setInitialQP                                         ( m_RCInitialQP );
    689742  m_cTEncTop.setForceIntraQP                                      ( m_RCForceIntraQP );
    690 #if U0132_TARGET_BITS_SATURATION
    691743  m_cTEncTop.setCpbSaturationEnabled                              ( m_RCCpbSaturationEnabled );
    692744  m_cTEncTop.setCpbSize                                           ( m_RCCpbSize );
    693745  m_cTEncTop.setInitialCpbFullness                                ( m_RCInitialCpbFullness );
    694 #endif
    695746
    696747#if KWU_RC_MADPRED_E0227
     
    761812  }
    762813#endif
    763   m_cTEncTop.setTransquantBypassEnableFlag                        ( m_TransquantBypassEnableFlag );
     814  m_cTEncTop.setTransquantBypassEnabledFlag                       ( m_TransquantBypassEnabledFlag );
    764815  m_cTEncTop.setCUTransquantBypassFlagForceValue                  ( m_CUTransquantBypassFlagForce );
    765816  m_cTEncTop.setCostMode                                          ( m_costMode );
     
    812863    if ( m_uiVSOMode == 4 )
    813864    {
     865
     866      for( Int i = 1; i < m_numRepFormats; i++)
     867      {
     868        if ( m_iSourceWidths[0] != m_iSourceWidths[i] || m_iSourceHeights[0] != m_iSourceHeights[i] )
     869        {
     870          std::cout << "Enabling the RM requires equal size of all layers." << std::endl;
     871          AOF( false );
     872        }
     873      }
     874
    814875#if H_3D_VSO_EARLY_SKIP
    815       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, true, m_bVSOEarlySkip );
    816 #else
    817       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 , true);
     876      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidths[0], m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, true, m_bVSOEarlySkip );
     877#else
     878      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidths[0], m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 , true);
    818879#endif
    819880      for ( Int layer = 0; layer < m_numberOfLayers ; layer++ )
     
    851912  // initialize global variables
    852913  initROM();
    853 #if NH_3D_DMM
     914#if NH_3D
    854915  initWedgeLists( true );
    855916#endif
     
    857918  for( Int layer=0; layer < m_numberOfLayers; layer++)
    858919  {
    859     m_acTVideoIOYuvInputFileList[layer]->open( m_pchInputFileList[layer],     false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );  // read  mode
    860     m_acTVideoIOYuvInputFileList[layer]->skipFrames( m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
     920    Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layer];
     921    m_acTVideoIOYuvInputFileList[layer]->open( m_pchInputFileList[layer],     false, &m_inputBitDepths[repFormatIdx][0], &m_MSBExtendedBitDepths[repFormatIdx][0], &m_internalBitDepths[repFormatIdx][0] );  // read  mode
     922    m_acTVideoIOYuvInputFileList[layer]->skipFrames( m_FrameSkip, m_iSourceWidths[repFormatIdx] - m_aiPads[repFormatIdx][0], m_iSourceHeights[repFormatIdx] - m_aiPads[repFormatIdx][1], m_InputChromaFormatIDC[repFormatIdx]);
    861923
    862924    if (m_pchReconFileList[layer])
    863925    {
    864       m_acTVideoIOYuvReconFileList[layer]->open( m_pchReconFileList[layer], true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth);  // write mode
     926      m_acTVideoIOYuvReconFileList[layer]->open( m_pchReconFileList[layer], true, &m_outputBitDepths[repFormatIdx][0], &m_outputBitDepths[repFormatIdx][0], &m_internalBitDepths[repFormatIdx][0]);  // write mode
    865927    }
    866928    m_acTEncTopList[layer]->create();
     
    869931  // Video I/O
    870932  m_cTVideoIOYuvInputFile.open( m_inputFileName,     false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );  // read  mode
    871   m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
     933  m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_inputFileWidth, m_inputFileHeight, m_InputChromaFormatIDC);
    872934
    873935  if (!m_reconFileName.empty())
     
    9491011  }
    9501012
    951 #if !NH_3D
     1013#if !NH_MV
    9521014  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
    9531015#endif
     
    9581020  xCreateLib();
    9591021  xInitLib(m_isField);
    960 
     1022#if NH_MV
    9611023  printChromaFormat();
     1024#endif
    9621025
    9631026  // main encoder loop
     
    9851048  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
    9861049 
    987 #if NH_3D
    988   TComPicYuv* picYuvOrg[2];
    989   TComPicYuv  picYuvTrueOrg[2];
    990   for (Int d = 0; d < 2 ; d++)
    991   {
     1050#if NH_MV
     1051  std::vector<TComPicYuv*> picYuvOrg    ( m_numRepFormats );
     1052  std::vector<TComPicYuv > picYuvTrueOrg( m_numRepFormats );
     1053  for (Int d = 0; d < m_numRepFormats ; d++)
     1054  { 
    9921055    picYuvOrg[d] = new TComPicYuv;
    993     picYuvOrg[d]   ->create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    994     picYuvTrueOrg[d].create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
     1056    picYuvOrg[d]   ->create( m_iSourceWidths[d], m_isField ? m_iSourceHeightOrgs[d] : m_iSourceHeights[d], m_chromaFormatIDCs[d], m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth[d], true );
     1057    picYuvTrueOrg[d].create( m_iSourceWidths[d], m_isField ? m_iSourceHeightOrgs[d] : m_iSourceHeights[d], m_chromaFormatIDCs[d], m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth[d], true );
    9951058  }
    9961059#else
     
    10091072  }
    10101073#endif
     1074
     1075
     1076#if EXTENSION_360_VIDEO
     1077  TExt360AppEncTop           ext360(*this, m_cTEncTop.getGOPEncoder()->getExt360Data(), *(m_cTEncTop.getGOPEncoder()), *pcPicYuvOrg);
     1078#endif
     1079
    10111080#if NH_MV
    10121081  while ( (m_targetEncLayerIdList.size() != 0 ) && !allEos )
     
    10141083    for(Int layer=0; layer < m_numberOfLayers; layer++ )
    10151084    {
    1016 #if NH_3D
    1017       TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ m_depthFlag[layer] ];
    1018       TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ m_depthFlag[layer] ];
    1019 #endif
     1085      Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layer];
     1086
     1087      TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ repFormatIdx ];
     1088      TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ repFormatIdx ];
     1089
    10201090      if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
    10211091      {
     
    10301100
    10311101        // read input YUV file       
    1032         m_acTVideoIOYuvInputFileList[layer]->read      ( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC );
     1102        m_acTVideoIOYuvInputFileList[layer]->read      ( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, &m_aiPads[repFormatIdx][0], m_InputChromaFormatIDC[repFormatIdx] );
    10331103        m_acTEncTopList             [layer]->initNewPic( pcPicYuvOrg );
    10341104
     
    10621132      for(Int layer=0; layer < m_numberOfLayers; layer++ )
    10631133      {
    1064 #if NH_3D
    1065         TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ m_depthFlag[layer] ];
    1066         TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ m_depthFlag[layer] ];
     1134        Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layer];
     1135#if NH_MV
     1136        TComPicYuv* pcPicYuvOrg    =  picYuvOrg    [ repFormatIdx ];
     1137        TComPicYuv& cPicYuvTrueOrg =  picYuvTrueOrg[ repFormatIdx ];
    10671138#endif
    10681139        if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
     
    11041175    // get buffers
    11051176    xGetBuffer(pcPicYuvRec);
    1106 
    11071177    // read input YUV file
     1178#if EXTENSION_360_VIDEO
     1179    if (ext360.isEnabled())
     1180    {
     1181      ext360.read(m_cTVideoIOYuvInputFile, *pcPicYuvOrg, cPicYuvTrueOrg, ipCSC);
     1182    }
     1183    else
     1184    {
     1185      m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
     1186    }
     1187#else
    11081188    m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
     1189#endif
    11091190
    11101191    // increase number of received frames
     
    11421223    if( m_temporalSubsampleRatio > 1 )
    11431224    {
    1144       m_cTVideoIOYuvInputFile.skipFrames(m_temporalSubsampleRatio-1, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
     1225      m_cTVideoIOYuvInputFile.skipFrames(m_temporalSubsampleRatio-1, m_inputFileWidth, m_inputFileHeight, m_InputChromaFormatIDC);
    11451226    }
    11461227  }
     
    11491230#endif
    11501231
    1151 #if NH_3D
     1232#if NH_MV
    11521233  // delete original YUV buffer
    1153   for (Int d = 0; d < 2; d++)
     1234  for (Int d = 0; d < m_numRepFormats; d++)
    11541235  {
    11551236    picYuvOrg[d]->destroy();
     
    11691250  // delete used buffers in encoder class
    11701251  m_cTEncTop.deletePicBuffer();
    1171 #endif
    1172 #if !NH_3D
    11731252  cPicYuvTrueOrg.destroy();
    11741253#endif
     
    12121291  // org. buffer
    12131292#if NH_MV
     1293  Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layer];
     1294
    12141295  if ( m_cListPicYuvRec[layer]->size() == (UInt)m_iGOPSize )
    12151296  {
     
    12241305  {
    12251306    rpcPicYuvRec = new TComPicYuv;
    1226 #if NH_3D
    1227     rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_depthFlag[layer] > 0 ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
     1307#if NH_MV
     1308    rpcPicYuvRec->create( m_iSourceWidths[ repFormatIdx ], m_iSourceHeights[ repFormatIdx ], m_chromaFormatIDCs[ repFormatIdx ], m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth[repFormatIdx], true );
    12281309#else
    12291310    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
     
    13061387      if (m_pchReconFileList[layerIdx])
    13071388      {
     1389        Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layerIdx];
    13081390#if NH_3D
    1309         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 );
    1310 #else
    1311         m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
     1391        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLefts[repFormatIdx], m_confWinRights[repFormatIdx], m_confWinTops[repFormatIdx], m_confWinBottoms[repFormatIdx], m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT, m_isTopFieldFirst );
     1392#else
     1393        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLefts[repFormatIdx], m_confWinRights[repFormatIdx], m_confWinTops[repFormatIdx], m_confWinBottoms[repFormatIdx], NUM_CHROMA_FORMAT, m_isTopFieldFirst );
    13121394#endif
    13131395      }
     
    13611443      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
    13621444#if NH_MV
     1445      Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layerIdx];
    13631446      if (m_pchReconFileList[layerIdx])
    13641447      {
    13651448#if NH_3D
    1366         m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT  );
    1367 #else
    1368         m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
     1449        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLefts[repFormatIdx], m_confWinRights[repFormatIdx], m_confWinTops[repFormatIdx], m_confWinBottoms[repFormatIdx], m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT  );
     1450#else
     1451        m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLefts[repFormatIdx], m_confWinRights[repFormatIdx], m_confWinTops[repFormatIdx], m_confWinBottoms[repFormatIdx] );
    13691452#endif
    13701453
     
    14541537Void TAppEncTop::printChromaFormat()
    14551538{
     1539 
     1540#if NH_MV   
     1541  std::cout << "Input ChromaFormatIDC             : ";
     1542  for (Int i = 0; i < m_numRepFormats; i++)
     1543  {
     1544   
     1545   
     1546    switch (m_InputChromaFormatIDC[i])
     1547#else
    14561548  std::cout << std::setw(43) << "Input ChromaFormatIDC = ";
    14571549  switch (m_InputChromaFormatIDC)
     1550#endif
    14581551  {
    14591552  case CHROMA_400:  std::cout << "  4:0:0"; break;
     
    14651558    exit(1);
    14661559  }
     1560#if NH_MV
     1561  std::cout << " ";
     1562}
     1563#endif
     1564
    14671565  std::cout << std::endl;
    14681566
    14691567#if NH_MV
    1470   for (Int i = 0; i < m_numberOfLayers; i++)
    1471   {
    1472     std::cout << "Layer " << i << std::setw( 43 - (i > 9 ? 6 : 7) ) << "Internal ChromaFormatIDC = ";
    1473     switch (m_acTEncTopList[i]->getChromaFormatIdc())
     1568  std::cout << "Output (internal) ChromaFormatIDC : ";
     1569  for (Int i = 0; i < m_numRepFormats; i++)
     1570  {
     1571   
     1572    switch ( m_chromaFormatIDCs[i] )
    14741573#else
    14751574    std::cout << std::setw(43) << "Output (internal) ChromaFormatIDC = ";
     
    14861585    }
    14871586#if NH_MV
    1488     std::cout << std::endl;
     1587    std::cout << " ";
    14891588  }
    14901589#endif
     
    14921591}
    14931592
    1494 #if NH_3D_DLT
     1593#if NH_3D
    14951594Void TAppEncTop::xAnalyzeInputBaseDepth(UInt layer, UInt uiNumFrames, TComVPS* vps, TComDLT* dlt)
    14961595{
     1596  Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[layer];
     1597
    14971598  TComPicYuv*       pcDepthPicYuvOrg = new TComPicYuv;
    14981599  TComPicYuv*       pcDepthPicYuvTrueOrg = new TComPicYuv;
    14991600  // allocate original YUV buffer
    1500   pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
    1501   pcDepthPicYuvTrueOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
     1601  pcDepthPicYuvOrg->create( m_iSourceWidths[ repFormatIdx ], m_iSourceHeights[ repFormatIdx ], CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight    , m_uiMaxTotalCUDepth[repFormatIdx], false );
     1602  pcDepthPicYuvTrueOrg->create( m_iSourceWidths[ repFormatIdx ], m_iSourceHeights[ repFormatIdx ], CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth[repFormatIdx], false );
    15021603 
    15031604  TVideoIOYuv* depthVideoFile = new TVideoIOYuv;
    15041605 
    1505   UInt uiMaxDepthValue = ((1 << m_inputBitDepth[CHANNEL_TYPE_LUMA])-1);
     1606  UInt uiMaxDepthValue = ((1 << m_inputBitDepths[repFormatIdx][CHANNEL_TYPE_LUMA])-1);
    15061607 
    15071608  std::vector<Bool> abValidDepths(256, false);
    15081609 
    1509   depthVideoFile->open( m_pchInputFileList[layer], false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );
     1610  depthVideoFile->open( m_pchInputFileList[layer], false, &m_inputBitDepths[repFormatIdx][0], &m_MSBExtendedBitDepths[repFormatIdx][0], &m_internalBitDepths[repFormatIdx][0] );
    15101611 
    15111612  Int iHeight   = pcDepthPicYuvOrg->getHeight(COMPONENT_Y);
     
    15151616  Pel* pInDM    = pcDepthPicYuvOrg->getAddr(COMPONENT_Y);
    15161617 
     1618 
    15171619  for(Int uiFrame=0; uiFrame < uiNumFrames; uiFrame++ )
    15181620  {
    1519     depthVideoFile->read( pcDepthPicYuvOrg, pcDepthPicYuvTrueOrg, IPCOLOURSPACE_UNCHANGED, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
     1621    depthVideoFile->read( pcDepthPicYuvOrg, pcDepthPicYuvTrueOrg, IPCOLOURSPACE_UNCHANGED, &m_aiPads[repFormatIdx][0], m_InputChromaFormatIDC[repFormatIdx], m_bClipInputVideoToRec709Range );
    15201622   
    15211623    // check all pixel values
     
    15511653  }
    15521654 
    1553   if( uiNumFrames == 0 || gCeilLog2(iNumDepthValues) == m_inputBitDepth[CHANNEL_TYPE_LUMA] )
     1655  if( uiNumFrames == 0 || gCeilLog2(iNumDepthValues) == m_inputBitDepths[repFormatIdx][CHANNEL_TYPE_LUMA] )
    15541656  {
    15551657    dlt->setUseDLTFlag(layer, false);
     
    16531755    for( Int i = 0; i < getGOPSize(); i++ )
    16541756    {
    1655       GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][i];
     1757      GOPEntry geCur =  xGetGopEntries(curLayerIdInVps)[i];
    16561758      curSubLayersMaxMinus1 = std::max( curSubLayersMaxMinus1, geCur.m_temporalId );
    16571759    } 
     
    16791781          for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    16801782          {       
    1681             GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1682             GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
     1783            GOPEntry geCur =  xGetGopEntries(curLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
     1784            GOPEntry geRef =  xGetGopEntries(refLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
    16831785            for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++)
    16841786            {
     
    17051807              for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    17061808              {       
    1707                 GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1708                 GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
     1809                GOPEntry geCur =  xGetGopEntries(curLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
     1810                GOPEntry geRef =  xGetGopEntries(refLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
    17091811                if ( geCur.m_interCompPredFlag )
    17101812                {
     
    17191821            for( Int i = 0; i < ( getGOPSize() + 1); i++ )
    17201822            {       
    1721               GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
    1722               GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
     1823              GOPEntry geCur =  xGetGopEntries(curLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
     1824              GOPEntry geRef =  xGetGopEntries(refLayerIdInVps)[( i < getGOPSize()  ? i : MAX_GOP )];
    17231825
    17241826              if ( geCur.m_interCompPredFlag )
     
    17611863    for( Int i = 0; i < ( getGOPSize() + 1) && maxOneActiveRefLayerFlag; i++ )
    17621864    {       
    1763       GOPEntry ge =  m_GOPListMvc[layerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
     1865      GOPEntry ge =  xGetGopEntries(layerIdInVps)[ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    17641866      maxOneActiveRefLayerFlag =  maxOneActiveRefLayerFlag && (ge.m_numActiveRefLayerPics <= 1);
    17651867    }           
     
    17841886    for( Int i = 0; i < ( getGOPSize() + 1) && allRefLayersActiveFlag; i++ )
    17851887    {       
    1786       GOPEntry ge =  m_GOPListMvc[layerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
     1888      GOPEntry ge =  xGetGopEntries(layerIdInVps)[ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    17871889      Int tId = ge.m_temporalId;  // Should be equal for all layers.
    17881890     
     
    18381940
    18391941
    1840 GOPEntry* TAppEncTop::xGetGopEntry( Int layerIdInVps, Int poc )
    1841 {
    1842   GOPEntry* geFound = NULL;
    1843   for( Int i = 0; i < ( getGOPSize() + 1) && geFound == NULL ; i++ )
    1844   {
    1845     GOPEntry* ge = &(m_GOPListMvc[layerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ]);
    1846     if ( ge->m_POC == poc )
    1847     {
    1848       geFound = ge;       
    1849     }
    1850   }
    1851   assert( geFound != NULL );
    1852   return geFound;
    1853 }
    1854 
    1855 
    18561942Void TAppEncTop::xSetTimingInfo( TComVPS& vps )
    18571943{
     
    19051991{
    19061992
     1993  xDeriveProfAndConstrFlags( vps ); 
     1994  xCheckProfiles           ( vps );
     1995  xPrintProfiles           (  );
     1996 
    19071997  // SET PTL
    19081998  assert( m_profiles.size() == m_level.size() && m_profiles.size() == m_levelTier.size() );
     
    19122002    if ( ptlIdx > 1 )
    19132003    {
    1914       Bool vpsProfilePresentFlag = ( m_profiles[ptlIdx] != m_profiles[ptlIdx - 1] )
    1915         || ( m_inblFlag[ptlIdx ] != m_inblFlag[ptlIdx - 1] );
     2004      Bool vpsProfilePresentFlag =
     2005           ( m_profiles                [ptlIdx ] != m_profiles                [ptlIdx - 1] )
     2006        || ( m_progressiveSourceFlags  [ptlIdx ] != m_progressiveSourceFlags  [ptlIdx - 1] )
     2007        || ( m_interlacedSourceFlags   [ptlIdx ] != m_interlacedSourceFlags   [ptlIdx - 1] )
     2008        || ( m_nonPackedConstraintFlags[ptlIdx ] != m_nonPackedConstraintFlags[ptlIdx - 1] )
     2009        || ( m_frameOnlyConstraintFlags[ptlIdx ] != m_frameOnlyConstraintFlags[ptlIdx - 1] )
     2010        || ( m_inblFlag                [ptlIdx ] != m_inblFlag                [ptlIdx - 1] );
     2011
     2012     
     2013      if ( m_profiles[ ptlIdx ] >= 4 && m_profiles[ ptlIdx ] <= 7 )
     2014      {
     2015
     2016        vpsProfilePresentFlag = vpsProfilePresentFlag
     2017          || ( m_profiles                [ptlIdx ] != m_profiles                [ptlIdx - 1] )
     2018          || ( m_progressiveSourceFlags  [ptlIdx ] != m_progressiveSourceFlags  [ptlIdx - 1] )
     2019          || ( m_interlacedSourceFlags   [ptlIdx ] != m_interlacedSourceFlags   [ptlIdx - 1] )
     2020          || ( m_nonPackedConstraintFlags[ptlIdx ] != m_nonPackedConstraintFlags[ptlIdx - 1] )
     2021          || ( m_frameOnlyConstraintFlags[ptlIdx ] != m_frameOnlyConstraintFlags[ptlIdx - 1] )
     2022          || ( m_inblFlag                [ptlIdx ] != m_inblFlag                [ptlIdx - 1] );
     2023
     2024      }
     2025
     2026     
    19162027      vps.setVpsProfilePresentFlag( ptlIdx, vpsProfilePresentFlag );
    19172028    }
    19182029
    19192030    xSetProfileTierLevel( vps, ptlIdx, -1, m_profiles[ptlIdx], m_level[ptlIdx],
    1920       m_levelTier[ ptlIdx ], m_progressiveSourceFlag, m_interlacedSourceFlag,
    1921       m_nonPackedConstraintFlag, m_frameOnlyConstraintFlag,  m_inblFlag[ptlIdx] );     
    1922   } 
    1923 }
    1924 
    1925 Void TAppEncTop::xSetProfileTierLevel(TComVPS& vps, Int profileTierLevelIdx, Int subLayer, Profile::Name profile, Level::Name level, Level::Tier tier, Bool progressiveSourceFlag, Bool interlacedSourceFlag, Bool nonPackedConstraintFlag, Bool frameOnlyConstraintFlag, Bool inbldFlag)
     2031      m_levelTier[ ptlIdx ], m_progressiveSourceFlags[ptlIdx], m_interlacedSourceFlags[ptlIdx],
     2032      m_nonPackedConstraintFlags[ptlIdx], m_frameOnlyConstraintFlags[ptlIdx],  m_inblFlag[ptlIdx] );     
     2033  }
     2034}
     2035
     2036Void TAppEncTop::xSetProfileTierLevel(TComVPS& vps, Int ptlIdx, Int subLayer, Profile::Name profile, Level::Name level, Level::Tier tier, Bool progressiveSourceFlag, Bool interlacedSourceFlag, Bool nonPackedConstraintFlag, Bool frameOnlyConstraintFlag, Bool inbldFlag)
    19262037{
    1927   TComPTL* ptlStruct = vps.getPTL( profileTierLevelIdx );   
     2038 
     2039  TComPTL* ptlStruct = vps.getPTL( ptlIdx );   
    19282040  assert( ptlStruct != NULL );
    19292041
     
    19402052  assert( ptl != NULL );
    19412053
    1942   ptl->setProfileIdc( profile );
    1943   ptl->setTierFlag  ( tier    );
    1944   ptl->setLevelIdc  ( level   );
    1945   ptl->setProfileCompatibilityFlag( profile, true );
    1946   ptl->setInbldFlag( inbldFlag );
    1947 
    1948   switch ( profile )
    1949   {
    1950   case Profile::MAIN:
    1951     break;
    1952   case Profile::MULTIVIEWMAIN:
    1953 #if NH_3D
    1954   case Profile::MAIN3D:
    1955 #endif
    1956     ptl->setMax12bitConstraintFlag      ( true  );
    1957     ptl->setMax12bitConstraintFlag      ( true  );
    1958     ptl->setMax10bitConstraintFlag      ( true  );
    1959     ptl->setMax8bitConstraintFlag       ( true  );
    1960     ptl->setMax422chromaConstraintFlag  ( true  );
    1961     ptl->setMax420chromaConstraintFlag  ( true  );
    1962     ptl->setMaxMonochromeConstraintFlag ( false );
    1963     ptl->setIntraConstraintFlag         ( false );
    1964     ptl->setOnePictureOnlyConstraintFlag( false );
    1965     ptl->setLowerBitRateConstraintFlag  ( true  );       
    1966     break;
    1967   default:
    1968     assert( 0 ); // other profiles currently not supported
    1969     break;
    1970   }
     2054  ptl->setProfileIdc              ( m_profiles [ ptlIdx ] );
     2055  ptl->setTierFlag                ( m_levelTier[ ptlIdx ] );
     2056  ptl->setLevelIdc                ( m_level    [ ptlIdx ] );
     2057  ptl->setProfileCompatibilityFlag( m_profiles [ ptlIdx ], true );
     2058  ptl->setInbldFlag               ( m_inblFlag [ ptlIdx ] );
     2059
     2060  Int        bitDepth = m_bitDepthConstraints[ptlIdx];
     2061  ChromaFormat chroma = m_chromaFormatConstraints[ptlIdx];
     2062
     2063  ptl->setMax12bitConstraintFlag      (  bitDepth <= 12  );   
     2064  ptl->setMax10bitConstraintFlag      (  bitDepth <= 10 );
     2065  ptl->setMax8bitConstraintFlag       (  bitDepth <= 8 );
     2066  ptl->setMax422chromaConstraintFlag  ( chroma == CHROMA_400 || chroma == CHROMA_420 || chroma == CHROMA_422    );
     2067  ptl->setMax420chromaConstraintFlag  ( chroma == CHROMA_400 || chroma == CHROMA_420                            );                         ;
     2068  ptl->setMaxMonochromeConstraintFlag ( chroma == CHROMA_400                       );
     2069  ptl->setIntraConstraintFlag         ( m_intraConstraintFlags[ ptlIdx ]           );
     2070  ptl->setOnePictureOnlyConstraintFlag( m_onePictureOnlyConstraintFlags[ ptlIdx ]  );
     2071  ptl->setLowerBitRateConstraintFlag  ( m_lowerBitRateConstraintFlags[ ptlIdx ]    );   
    19712072}
    19722073
    19732074Void TAppEncTop::xSetRepFormat( TComVPS& vps )
    19742075{
    1975 
    1976   Bool anyDepth = false;
    1977 #if NH_3D
    1978   for ( Int i = 0; i < m_numberOfLayers; i++ )
    1979   {
    1980     vps.setVpsRepFormatIdx( i, m_depthFlag[ i ] ? 1 : 0 );
    1981     anyDepth = anyDepth || m_depthFlag[ i ];
    1982   }
    1983 #endif
    1984 
    1985   vps.setRepFormatIdxPresentFlag( anyDepth );
    1986   vps.setVpsNumRepFormatsMinus1 ( anyDepth ? 1 : 0     );
     2076  vps.setVpsNumRepFormatsMinus1 ( m_numRepFormats - 1 );
    19872077
    19882078
     
    19912081  for ( Int j = 0; j <= vps.getVpsNumRepFormatsMinus1(); j++ )
    19922082  {           
    1993     repFormat[j].setBitDepthVpsChromaMinus8   ( m_internalBitDepth[CHANNEL_TYPE_LUMA  ] - 8 );
    1994     repFormat[j].setBitDepthVpsLumaMinus8     ( m_internalBitDepth[CHANNEL_TYPE_CHROMA] - 8 );
    1995     repFormat[j].setChromaFormatVpsIdc        ( j == 1 ? CHROMA_400 :  CHROMA_420 );
    1996     repFormat[j].setPicHeightVpsInLumaSamples ( m_iSourceHeight );
    1997     repFormat[j].setPicWidthVpsInLumaSamples  ( m_iSourceWidth  );   
     2083    repFormat[j].setBitDepthVpsChromaMinus8   ( m_internalBitDepths[j][CHANNEL_TYPE_LUMA  ] - 8 );
     2084    repFormat[j].setBitDepthVpsLumaMinus8     ( m_internalBitDepths[j][CHANNEL_TYPE_CHROMA] - 8 );
     2085    repFormat[j].setChromaFormatVpsIdc        ( m_chromaFormatIDCs[j] );
     2086    repFormat[j].setPicHeightVpsInLumaSamples ( m_iSourceHeights[j] );
     2087    repFormat[j].setPicWidthVpsInLumaSamples  ( m_iSourceWidths [j] );   
    19982088    repFormat[j].setChromaAndBitDepthVpsPresentFlag( true );   
    19992089    // ToDo not supported yet.
     
    20012091
    20022092    repFormat[j].setConformanceWindowVpsFlag( true );
    2003     repFormat[j].setConfWinVpsLeftOffset    ( m_confWinLeft  / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
    2004     repFormat[j].setConfWinVpsRightOffset   ( m_confWinRight  / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
    2005     repFormat[j].setConfWinVpsTopOffset     ( m_confWinTop    / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
    2006     repFormat[j].setConfWinVpsBottomOffset  ( m_confWinBottom / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
     2093    repFormat[j].setConfWinVpsLeftOffset    ( m_confWinLefts  [j] / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
     2094    repFormat[j].setConfWinVpsRightOffset   ( m_confWinRights [j] / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
     2095    repFormat[j].setConfWinVpsTopOffset     ( m_confWinTops   [j] / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
     2096    repFormat[j].setConfWinVpsBottomOffset  ( m_confWinBottoms[j] / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
    20072097  }
    20082098
    20092099  vps.setRepFormat( repFormat );
     2100
     2101
     2102  if ( vps.getVpsNumRepFormatsMinus1() > 0 )
     2103  {
     2104    Bool repFormatIdxPresentFlag = false;
     2105    for( Int i = vps.getVpsBaseLayerInternalFlag() ? 1 : 0; i <= vps.getMaxLayersMinus1(); i++ )
     2106    {
     2107      repFormatIdxPresentFlag = repFormatIdxPresentFlag ||  ( m_layerIdxInVpsToRepFormatIdx[i]  != vps.inferVpsRepFormatIdx( i ) );
     2108    }
     2109    vps.setRepFormatIdxPresentFlag( repFormatIdxPresentFlag );
     2110  }
     2111
     2112  for( Int i =  0; i <=  vps.getMaxLayersMinus1(); i++ )
     2113  {
     2114    // When base_layer_internal_flag is equal to 1, the first repFormatIdx cannot be signaled but is inferred.
     2115    if( !vps.getRepFormatIdxPresentFlag() || ( vps.getVpsBaseLayerInternalFlag() && i == 0 )   )
     2116    {
     2117      vps.setVpsRepFormatIdx( i, vps.inferVpsRepFormatIdx( i ) );
     2118      AOF( vps.getVpsRepFormatIdx( i ) == m_layerIdxInVpsToRepFormatIdx[i] );
     2119    }
     2120    else
     2121    {
     2122      vps.setVpsRepFormatIdx( i, m_layerIdxInVpsToRepFormatIdx[i] );         
     2123    }
     2124  }
     2125
     2126
     2127  xConfirmRepFormat( vps );
    20102128
    20112129}
     
    24312549
    24322550
    2433 #if NH_3D_DLT
     2551#if NH_3D
    24342552Void TAppEncTop::xDeriveDltArray( TComVPS& vps, TComDLT* dlt )
    24352553{
     2554  std::cout << "Analyzing input depth for DLT ";
    24362555  Int  iNumDepthViews  = 0;
    24372556  Bool bDltPresentFlag = false;
     
    24492568    if( dlt->getUseDLTFlag( layer ) )
    24502569    {
     2570      std::cout << ".";
    24512571      xAnalyzeInputBaseDepth(layer, max(m_iIntraPeriod[layer], 24), &vps, dlt);
    24522572      bDltPresentFlag = bDltPresentFlag || dlt->getUseDLTFlag(layer);
     
    25232643     
    25242644      // bit map branch
    2525       uiNumBitsBitMap = 1 << m_inputBitDepth[CHANNEL_TYPE_LUMA];
     2645      Int repFormatIdx = m_layerIdxInVpsToRepFormatIdx[ layer ];
     2646      uiNumBitsBitMap = 1 << m_inputBitDepths[repFormatIdx][CHANNEL_TYPE_LUMA];
    25262647     
    25272648      // determine bDltBitMapFlag
     
    25292650     
    25302651      dlt->setUseBitmapRep(layer, bDltBitMapRepFlag);
    2531     }
     2652
     2653      AOF( m_inputBitDepths[repFormatIdx][CHANNEL_TYPE_LUMA] == m_inputBitDepths[0][CHANNEL_TYPE_LUMA] )
     2654    }
     2655   
    25322656  }
    25332657
    25342658  dlt->setDltPresentFlag( bDltPresentFlag );
    25352659  dlt->setNumDepthViews ( iNumDepthViews  );
    2536   dlt->setDepthViewBitDepth( m_inputBitDepth[CHANNEL_TYPE_LUMA] );
     2660  dlt->setDepthViewBitDepth( m_inputBitDepths[CHANNEL_TYPE_LUMA][0] );
     2661  std::cout << " done." << std::endl;
    25372662}
    25382663#endif
Note: See TracChangeset for help on using the changeset viewer.