Changeset 1313 in 3DVCSoftware for trunk/source/Lib/TLibEncoder/TEncTop.cpp


Ignore:
Timestamp:
13 Aug 2015, 17:38:13 (9 years ago)
Author:
tech
Message:

Merged 14.1-update-dev1@1312.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/Lib/TLibEncoder/TEncTop.cpp

    r1196 r1313  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    6 * Copyright (c) 2010-2015, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
    … …  
    3939#include "TEncTop.h"
    4040#include "TEncPic.h"
     41#include "TLibCommon/TComChromaFormat.h"
    4142#if FAST_BIT_EST
    4243#include "TLibCommon/ContextModel.h"
    4344#endif
    44 #if H_MV
     45#if NH_MV
    4546#include "../../App/TAppEncoder/TAppEncTop.h"
    4647#endif
    … …  
    6263  m_cRDGoOnSbacCoder.init( &m_cRDGoOnBinCoderCABAC );
    6364#if ENC_DEC_TRACE
    64   g_hTrace = fopen( "TraceEnc.txt", "wb" );
     65  if (g_hTrace == NULL)
     66  {
     67    g_hTrace = fopen( "TraceEnc.txt", "wb" );
     68  }
    6569  g_bJustDoIt = g_bEncDecTraceDisable;
    6670  g_nSymbolCounter = 0;
    … …  
    7276  ContextModel::buildNextStateTable();
    7377#endif
    74 #if H_MV
    75   m_iNumSubstreams         = 0;
    76 #endif
    77 
    78   m_pcSbacCoders           = NULL;
    79   m_pcBinCoderCABACs       = NULL;
    80   m_ppppcRDSbacCoders      = NULL;
    81   m_ppppcBinCodersCABAC    = NULL;
    82   m_pcRDGoOnSbacCoders     = NULL;
    83   m_pcRDGoOnBinCodersCABAC = NULL;
    84   m_pcBitCounters          = NULL;
    85   m_pcRdCosts              = NULL;
    86 #if H_MV
     78#if NH_MV
    8779  m_ivPicLists = NULL;
    8880#endif
    89 #if H_3D_IC
     81#if NH_3D_IC
    9082  m_aICEnableCandidate = NULL;
    9183  m_aICEnableNum = NULL;
    9284#endif
    93 #if H_3D
     85#if NH_3D
    9486  m_cCavlcCoder.setEncTop(this);
    9587#endif
     88
    9689}
    9790
    … …  
    9992{
    10093#if ENC_DEC_TRACE
    101   fclose( g_hTrace );
     94  if (g_hTrace != stdout)
     95  {
     96    fclose( g_hTrace );
     97  }
    10298#endif
    10399}
    … …  
    105101Void TEncTop::create ()
    106102{
    107 #if !H_MV
     103#if !NH_MV
    108104  // initialize global variables
    109105  initROM();
    110106#endif
    111  
     107
    112108  // create processing unit classes
    113   m_cGOPEncoder.        create();
    114   m_cSliceEncoder.      create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    115   m_cCuEncoder.         create( g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight );
     109  m_cGOPEncoder.        create( );
     110  m_cSliceEncoder.      create( getSourceWidth(), getSourceHeight(), m_chromaFormatIDC, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth );
     111  m_cCuEncoder.         create( m_maxTotalCUDepth, m_maxCUWidth, m_maxCUHeight, m_chromaFormatIDC );
    116112  if (m_bUseSAO)
    117113  {
    118     m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    119 #if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
    120     m_cEncSAO.createEncData(getSaoLcuBoundary());
    121 #else
    122     m_cEncSAO.createEncData();
    123 #endif
     114    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), m_chromaFormatIDC, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth, m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA], m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA] );
     115    m_cEncSAO.createEncData(getSaoCtuBoundary());
    124116  }
    125117#if ADAPTIVE_QP_SELECTION
    … …  
    129121  }
    130122#endif
    131   m_cLoopFilter.        create( g_uiMaxCUDepth );
     123
     124  m_cLoopFilter.create( m_maxTotalCUDepth );
    132125
    133126  if ( m_RCEnableRateControl )
    … …  
    138131#else
    139132    m_cRateCtrl.init( m_framesToBeEncoded, m_RCTargetBitrate, m_iFrameRate, m_iGOPSize, m_iSourceWidth, m_iSourceHeight,
    140                       g_uiMaxCUWidth, g_uiMaxCUHeight, m_RCKeepHierarchicalBit, m_RCUseLCUSeparateModel, m_GOPList );
    141 #endif
    142   }
    143     m_pppcRDSbacCoder = new TEncSbac** [g_uiMaxCUDepth+1];
     133        m_maxCUWidth, m_maxCUHeight, m_RCKeepHierarchicalBit, m_RCUseLCUSeparateModel, m_GOPList );
     134#endif
     135  }
     136
     137  m_pppcRDSbacCoder = new TEncSbac** [m_maxTotalCUDepth+1];
    144138#if FAST_BIT_EST
    145     m_pppcBinCoderCABAC = new TEncBinCABACCounter** [g_uiMaxCUDepth+1];
     139  m_pppcBinCoderCABAC = new TEncBinCABACCounter** [m_maxTotalCUDepth+1];
    146140#else
    147     m_pppcBinCoderCABAC = new TEncBinCABAC** [g_uiMaxCUDepth+1];
    148 #endif
    149    
    150     for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    151     {
    152       m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
     141  m_pppcBinCoderCABAC = new TEncBinCABAC** [m_maxTotalCUDepth+1];
     142#endif
     143
     144  for ( Int iDepth = 0; iDepth < m_maxTotalCUDepth+1; iDepth++ )
     145  {
     146    m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
    153147#if FAST_BIT_EST
    154       m_pppcBinCoderCABAC[iDepth] = new TEncBinCABACCounter* [CI_NUM];
     148    m_pppcBinCoderCABAC[iDepth] = new TEncBinCABACCounter* [CI_NUM];
    155149#else
    156       m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
    157 #endif
    158      
    159       for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
    160       {
    161         m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
     150    m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
     151#endif
     152
     153    for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
     154    {
     155      m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
    162156#if FAST_BIT_EST
    163         m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABACCounter;
     157      m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABACCounter;
    164158#else
    165         m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
    166 #endif
    167         m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
    168       }
    169     }
    170   }
    171 
    172 /**
    173  - Allocate coders required for wavefront for the nominated number of substreams.
    174  .
    175  \param iNumSubstreams Determines how much information to allocate.
    176  */
    177 Void TEncTop::createWPPCoders(Int iNumSubstreams)
    178 {
    179   if (m_pcSbacCoders != NULL)
    180   {
    181     return; // already generated.
    182   }
    183 
    184   m_iNumSubstreams         = iNumSubstreams;
    185   m_pcSbacCoders           = new TEncSbac       [iNumSubstreams];
    186   m_pcBinCoderCABACs       = new TEncBinCABAC   [iNumSubstreams];
    187   m_pcRDGoOnSbacCoders     = new TEncSbac       [iNumSubstreams];
    188   m_pcRDGoOnBinCodersCABAC = new TEncBinCABAC   [iNumSubstreams];
    189   m_pcBitCounters          = new TComBitCounter [iNumSubstreams];
    190   m_pcRdCosts              = new TComRdCost     [iNumSubstreams];
    191 
    192   for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
    193   {
    194     m_pcRDGoOnSbacCoders[ui].init( &m_pcRDGoOnBinCodersCABAC[ui] );
    195     m_pcSbacCoders[ui].init( &m_pcBinCoderCABACs[ui] );
    196   }
    197 
    198     m_ppppcRDSbacCoders      = new TEncSbac***    [iNumSubstreams];
    199     m_ppppcBinCodersCABAC    = new TEncBinCABAC***[iNumSubstreams];
    200     for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ )
    201     {
    202       m_ppppcRDSbacCoders[ui]  = new TEncSbac** [g_uiMaxCUDepth+1];
    203       m_ppppcBinCodersCABAC[ui]= new TEncBinCABAC** [g_uiMaxCUDepth+1];
    204      
    205       for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    206       {
    207         m_ppppcRDSbacCoders[ui][iDepth]  = new TEncSbac*     [CI_NUM];
    208         m_ppppcBinCodersCABAC[ui][iDepth]= new TEncBinCABAC* [CI_NUM];
    209 
    210         for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
    211         {
    212           m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx] = new TEncSbac;
    213           m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] = new TEncBinCABAC;
    214           m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx]->init( m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] );
    215         }
    216       }
    217     }
    218   }
     159      m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
     160#endif
     161      m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
     162    }
     163  }
     164}
    219165
    220166Void TEncTop::destroy ()
    … …  
    224170  m_cSliceEncoder.      destroy();
    225171  m_cCuEncoder.         destroy();
    226   if (m_cSPS.getUseSAO())
    227   {
    228     m_cEncSAO.destroyEncData();
    229     m_cEncSAO.destroy();
    230   }
     172  m_cEncSAO.            destroyEncData();
     173  m_cEncSAO.            destroy();
    231174  m_cLoopFilter.        destroy();
    232175  m_cRateCtrl.          destroy();
    233 
    234     Int iDepth;
    235     for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    236     {
    237       for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
    238       {
    239 #if H_MV
    240         xDelete( false, m_pppcRDSbacCoder, iDepth, iCIIdx);
    241         xDelete( false, m_pppcBinCoderCABAC, iDepth, iCIIdx);
    242 #else
    243         delete m_pppcRDSbacCoder[iDepth][iCIIdx];
    244         delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
    245 #endif
    246       }
    247     }
    248    
    249     for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    250     {
    251 #if H_MV
    252       xDelete( true, m_pppcRDSbacCoder  , iDepth);
    253       xDelete( true, m_pppcBinCoderCABAC, iDepth);
    254 #else
    255       delete [] m_pppcRDSbacCoder[iDepth];
    256       delete [] m_pppcBinCoderCABAC[iDepth];
    257 #endif
    258     }
    259 
    260 #if H_MV
    261      xDelete( true, m_pppcRDSbacCoder  );
    262      xDelete( true, m_pppcBinCoderCABAC);
    263 #else
    264     delete [] m_pppcRDSbacCoder;
    265     delete [] m_pppcBinCoderCABAC;
    266 #endif
    267     for ( UInt ui = 0; ui < m_iNumSubstreams; ui++ )
    268     {
    269       for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    270       {
    271         for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
    272         {
    273 #if H_MV
    274           xDelete(false, m_ppppcRDSbacCoders  ,ui, iDepth, iCIIdx);
    275           xDelete(false, m_ppppcBinCodersCABAC,ui, iDepth, iCIIdx);
    276 #else
    277           delete m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx];
    278           delete m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx];
    279 #endif
    280         }
    281       }
    282 
    283       for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
    284       {
    285 #if H_MV
    286         xDelete(true, m_ppppcRDSbacCoders  ,ui, iDepth);
    287         xDelete(true, m_ppppcBinCodersCABAC,ui, iDepth);       
    288 #else
    289         delete [] m_ppppcRDSbacCoders  [ui][iDepth];
    290         delete [] m_ppppcBinCodersCABAC[ui][iDepth];
    291 #endif
    292       }
    293 
    294 
    295 #if H_MV
    296       xDelete(true, m_ppppcRDSbacCoders,   ui);
    297       xDelete(true, m_ppppcBinCodersCABAC, ui);     
    298 #else
    299       delete[] m_ppppcRDSbacCoders  [ui];
    300       delete[] m_ppppcBinCodersCABAC[ui];
    301 #endif
    302     }
    303 #if H_MV
    304     xDelete(true, m_ppppcRDSbacCoders    ) ;
    305     xDelete(true, m_ppppcBinCodersCABAC);
    306     xDelete(true, m_pcSbacCoders);
    307     xDelete(true, m_pcBinCoderCABACs);
    308     xDelete(true, m_pcRDGoOnSbacCoders); 
    309     xDelete(true, m_pcRDGoOnBinCodersCABAC);
    310     xDelete(true, m_pcBitCounters);
    311     xDelete(true, m_pcRdCosts);
    312 #else
    313     delete[] m_ppppcRDSbacCoders;
    314     delete[] m_ppppcBinCodersCABAC;
    315   delete[] m_pcSbacCoders;
    316   delete[] m_pcBinCoderCABACs;
    317   delete[] m_pcRDGoOnSbacCoders; 
    318   delete[] m_pcRDGoOnBinCodersCABAC;
    319   delete[] m_pcBitCounters;
    320   delete[] m_pcRdCosts;
    321 #endif
    322 
    323 #if !H_MV
    324     // destroy ROM
     176  m_cSearch.            destroy();
     177  Int iDepth;
     178  for ( iDepth = 0; iDepth < m_maxTotalCUDepth+1; iDepth++ )
     179  {
     180    for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
     181    {
     182      delete m_pppcRDSbacCoder[iDepth][iCIIdx];
     183      delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
     184    }
     185  }
     186
     187  for ( iDepth = 0; iDepth < m_maxTotalCUDepth+1; iDepth++ )
     188  {
     189    delete [] m_pppcRDSbacCoder[iDepth];
     190    delete [] m_pppcBinCoderCABAC[iDepth];
     191  }
     192
     193  delete [] m_pppcRDSbacCoder;
     194  delete [] m_pppcBinCoderCABAC;
     195
     196#if !NH_MV
     197  // destroy ROM
    325198  destroyROM();
    326199#endif
    … …  
    341214#endif
    342215  xInitSPS();
    343  
    344   /* set the VPS profile information */
    345 #if H_MV
     216  xInitVPS();
     217
     218  m_cRdCost.setCostMode(m_costMode);
     219
     220#if NH_MV
    346221  // This seems to be incorrect, but irrelevant for the MV-HEVC
    347222  *(m_cVPS->getPTL()) = *m_cSPS.getPTL();
    348223  m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
    349 #else
    350   *m_cVPS.getPTL() = *m_cSPS.getPTL();
    351   m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
    352224#endif
    353225  // initialize PPS
    354   m_cPPS.setSPS(&m_cSPS);
    355226  xInitPPS();
    356227  xInitRPS(isFieldCoding);
    357228
    358229  xInitPPSforTiles();
    359 #if H_3D_IC
     230#if NH_3D_IC
    360231  m_aICEnableCandidate = new Int[ 10 ];
    361232  m_aICEnableNum = new Int[ 10 ];
    … …  
    372243  m_cSliceEncoder.init( this );
    373244  m_cCuEncoder.   init( this );
    374  
     245
    375246#if KWU_RC_MADPRED_E0227
    376247  m_pcTAppEncTop = pcTAppEncTop;
    … …  
    378249  // initialize transform & quantization class
    379250  m_pcCavlcCoder = getCavlcCoder();
    380  
     251
    381252  m_cTrQuant.init( 1 << m_uiQuadtreeTULog2MaxSize,
    382                   m_useRDOQ,
    383                   m_useRDOQTS,
    384                   true
     253                   m_useRDOQ,
     254                   m_useRDOQTS,
     255#if T0196_SELECTIVE_RDOQ
     256                   m_useSelectiveRDOQ,
     257#endif
     258                   true
    385259                  ,m_useTransformSkipFast
    386 #if ADAPTIVE_QP_SELECTION                 
    387                   , m_bUseAdaptQpSelect
     260#if ADAPTIVE_QP_SELECTION
     261                  ,m_bUseAdaptQpSelect
    388262#endif
    389263                  );
    390  
     264
    391265  // initialize encoder search class
    392   m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, 0, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
     266  m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
    393267
    394268  m_iMaxRefPicNum = 0;
     269
     270  xInitScalingLists();
     271}
     272
     273Void TEncTop::xInitScalingLists()
     274{
     275  // Initialise scaling lists
     276  // The encoder will only use the SPS scaling lists. The PPS will never be marked present.
     277  const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE] =
     278  {
     279      m_cSPS.getMaxLog2TrDynamicRange(CHANNEL_TYPE_LUMA),
     280      m_cSPS.getMaxLog2TrDynamicRange(CHANNEL_TYPE_CHROMA)
     281  };
     282  if(getUseScalingListId() == SCALING_LIST_OFF)
     283  {
     284    getTrQuant()->setFlatScalingList(maxLog2TrDynamicRange, m_cSPS.getBitDepths());
     285    getTrQuant()->setUseScalingList(false);
     286    m_cSPS.setScalingListPresentFlag(false);
     287    m_cPPS.setScalingListPresentFlag(false);
     288  }
     289  else if(getUseScalingListId() == SCALING_LIST_DEFAULT)
     290  {
     291    m_cSPS.getScalingList().setDefaultScalingList ();
     292    m_cSPS.setScalingListPresentFlag(false);
     293    m_cPPS.setScalingListPresentFlag(false);
     294
     295    getTrQuant()->setScalingList(&(m_cSPS.getScalingList()), maxLog2TrDynamicRange, m_cSPS.getBitDepths());
     296    getTrQuant()->setUseScalingList(true);
     297  }
     298  else if(getUseScalingListId() == SCALING_LIST_FILE_READ)
     299  {
     300    m_cSPS.getScalingList().setDefaultScalingList ();
     301    if(m_cSPS.getScalingList().xParseScalingList(getScalingListFile()))
     302    {
     303      Bool bParsedScalingList=false; // Use of boolean so that assertion outputs useful string
     304      assert(bParsedScalingList);
     305      exit(1);
     306    }
     307    m_cSPS.getScalingList().checkDcOfMatrix();
     308    m_cSPS.setScalingListPresentFlag(m_cSPS.getScalingList().checkDefaultScalingList());
     309    m_cPPS.setScalingListPresentFlag(false);
     310    getTrQuant()->setScalingList(&(m_cSPS.getScalingList()), maxLog2TrDynamicRange, m_cSPS.getBitDepths());
     311    getTrQuant()->setUseScalingList(true);
     312  }
     313  else
     314  {
     315    printf("error : ScalingList == %d not supported\n",getUseScalingListId());
     316    assert(0);
     317  }
     318
     319  if (getUseScalingListId() != SCALING_LIST_OFF)
     320  { 
     321    // Prepare delta's:
     322  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
     323  {
     324    const Int predListStep = (sizeId == SCALING_LIST_32x32? (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) : 1); // if 32x32, skip over chroma entries.
     325
     326    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId+=predListStep)
     327    {
     328      m_cSPS.getScalingList().checkPredMode( sizeId, listId );
     329    }
     330  }
     331  }
    395332}
    396333
    … …  
    399336// ====================================================================================================================
    400337
    401 #if H_MV
     338#if NH_MV
    402339Void TEncTop::initNewPic( TComPicYuv* pcPicYuvOrg )
    403340{
    … …  
    413350    m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
    414351  }
    415 #if H_MV
     352#if NH_MV
    416353  pcPicCurr->setLayerId( getLayerId());
    417354#endif
    418 #if H_3D
     355#if NH_3D
    419356  pcPicCurr->setScaleOffset( m_cameraParameters->getCodedScale(), m_cameraParameters->getCodedOffset() );
    420357#endif
    421358}
    422359#endif
     360
    423361Void TEncTop::deletePicBuffer()
    424362{
    425363  TComList<TComPic*>::iterator iterPic = m_cListPic.begin();
    426364  Int iSize = Int( m_cListPic.size() );
    427  
     365
    428366  for ( Int i = 0; i < iSize; i++ )
    429367  {
    430368    TComPic* pcPic = *(iterPic++);
    431    
     369
    432370    pcPic->destroy();
    433371    delete pcPic;
    … …  
    443381 \param   flush               cause encoder to encode a partial GOP
    444382 \param   pcPicYuvOrg         original YUV picture
     383 \param   pcPicYuvTrueOrg     
     384 \param   snrCSC
    445385 \retval  rcListPicYuvRecOut  list of reconstruction YUV pictures
    446  \retval  rcListBitstreamOut  list of output bitstreams
     386 \retval  accessUnitsOut      list of output access units
    447387 \retval  iNumEncoded         number of encoded pictures
    448388 */
    449 #if H_MV
    450 Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded , Int gopId )
     389#if NH_MV
     390Void TEncTop::encode( Bool flush, TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, Int gopId )
    451391{
    452392#else
    453 Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
    454 {
    455 #endif
    456 #if H_3D
     393Void TEncTop::encode( Bool flush, TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
     394{
     395#endif
     396#if NH_3D
    457397  TComPic* picLastCoded = getPic( getGOPEncoder()->getPocLastCoded() );
    458398  if( picLastCoded )
    … …  
    461401  }
    462402#endif
    463 #if H_MV
     403#if NH_MV
    464404  if( gopId == 0)
    465405  {
    466406    m_cGOPEncoder.initGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut); 
    467407#else
    468   if (pcPicYuvOrg) {
     408  if (pcPicYuvOrg != NULL)
     409  {
    469410    // get original YUV
    470411    TComPic* pcPicCurr = NULL;
     412
    471413    xGetNewPicBuffer( pcPicCurr );
    472414    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
     415    pcPicYuvTrueOrg->copyToPic( pcPicCurr->getPicYuvTrueOrg() );
    473416
    474417    // compute image characteristics
    … …  
    478421    }
    479422  }
    480  
    481   if (!m_iNumPicRcvd || (!flush && m_iPOCLast != 0 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize))
     423
     424  if ((m_iNumPicRcvd == 0) || (!flush && (m_iPOCLast != 0) && (m_iNumPicRcvd != m_iGOPSize) && (m_iGOPSize != 0)))
    482425  {
    483426    iNumEncoded = 0;
    … …  
    485428  }
    486429#endif
    487  
    488430  if ( m_RCEnableRateControl )
    489431  {
    490432    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
    491433  }
    492 #if H_MV
    493   }
    494   m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, gopId, false, false );
     434#if NH_MV
     435  }
     436  m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE, gopId);
    495437
    496438  if( gopId + 1 == m_cGOPEncoder.getGOPSize() )
    … …  
    498440#else
    499441  // compress GOP
    500   m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false);
    501 #endif
    502 
     442  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE);
     443#endif
    503444  if ( m_RCEnableRateControl )
    504445  {
    505446    m_cRateCtrl.destroyRCGOP();
    506447  }
    507  
     448
    508449  iNumEncoded         = m_iNumPicRcvd;
    509450  m_iNumPicRcvd       = 0;
    510451  m_uiNumAllPicCoded += iNumEncoded;
    511 #if H_MV
    512 }
    513 #endif
    514 }
     452#if NH_MV
     453}
     454#endif
     455}
     456
    515457/**------------------------------------------------
    516458 Separate interlaced frame into two fields
    517459 -------------------------------------------------**/
    518 void separateFields(Pel* org, Pel* dstField, UInt stride, UInt width, UInt height, bool isTop)
     460Void separateFields(Pel* org, Pel* dstField, UInt stride, UInt width, UInt height, Bool isTop)
    519461{
    520462  if (!isTop)
    … …  
    528470      dstField[x] = org[x];
    529471    }
    530    
     472
    531473    dstField += stride;
    532474    org += stride*2;
    533475  }
    534  
    535 }
    536 
    537 #if H_MV
    538 Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, bool isTff, Int gopId )
     476
     477}
     478#if NH_MV
     479Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, Bool isTff, Int gopId )
    539480{
    540481  assert( 0 ); // Field coding and multiview need to be further harmonized.
    541482}
    542483#else
    543 Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, bool isTff)
    544 {
    545   /* -- TOP FIELD -- */
    546  
    547   if (pcPicYuvOrg)
    548   {
    549    
    550     /* -- Top field initialization -- */
    551    
    552     TComPic *pcTopField;
    553     xGetNewPicBuffer( pcTopField );
    554     pcTopField->setReconMark (false);
    555    
    556     pcTopField->getSlice(0)->setPOC( m_iPOCLast );
    557     pcTopField->getPicYuvRec()->setBorderExtension(false);
    558     pcTopField->setTopField(isTff);
    559    
    560     int nHeight = pcPicYuvOrg->getHeight();
    561     int nWidth = pcPicYuvOrg->getWidth();
    562     int nStride = pcPicYuvOrg->getStride();
    563     int nPadLuma = pcPicYuvOrg->getLumaMargin();
    564     int nPadChroma = pcPicYuvOrg->getChromaMargin();
    565    
    566     // Get pointers
    567     Pel * PicBufY = pcPicYuvOrg->getBufY();
    568     Pel * PicBufU = pcPicYuvOrg->getBufU();
    569     Pel * PicBufV = pcPicYuvOrg->getBufV();
    570    
    571     Pel * pcTopFieldY =  pcTopField->getPicYuvOrg()->getLumaAddr();
    572     Pel * pcTopFieldU =  pcTopField->getPicYuvOrg()->getCbAddr();
    573     Pel * pcTopFieldV =  pcTopField->getPicYuvOrg()->getCrAddr();
    574    
    575     /* -- Defield -- */
    576    
    577     bool isTop = isTff;
    578    
    579     separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcTopFieldY, nStride, nWidth, nHeight, isTop);
    580     separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
    581     separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
    582    
    583     // compute image characteristics
    584     if ( getUseAdaptiveQP() )
    585     {
    586       m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcTopField ) );
    587     }   
    588   }
    589  
    590   if (m_iPOCLast == 0) // compress field 0
    591   {
    592     m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
    593   }
    594  
    595   /* -- BOTTOM FIELD -- */
    596  
    597   if (pcPicYuvOrg)
    598   {
    599    
    600     /* -- Bottom field initialization -- */
    601    
    602     TComPic* pcBottomField;
    603     xGetNewPicBuffer( pcBottomField );
    604     pcBottomField->setReconMark (false);
    605    
    606     TComPicYuv* rpcPicYuvRec;
    607     if ( rcListPicYuvRecOut.size() == (UInt)m_iGOPSize )
    608     {
    609       rpcPicYuvRec = rcListPicYuvRecOut.popFront();
    610     }
    611     else
    612     {
    613       rpcPicYuvRec = new TComPicYuv;
    614       rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    615     }
    616     rcListPicYuvRecOut.pushBack( rpcPicYuvRec );
    617    
    618     pcBottomField->getSlice(0)->setPOC( m_iPOCLast);
    619     pcBottomField->getPicYuvRec()->setBorderExtension(false);
    620     pcBottomField->setTopField(!isTff);
    621    
    622     int nHeight = pcPicYuvOrg->getHeight();
    623     int nWidth = pcPicYuvOrg->getWidth();
    624     int nStride = pcPicYuvOrg->getStride();
    625     int nPadLuma = pcPicYuvOrg->getLumaMargin();
    626     int nPadChroma = pcPicYuvOrg->getChromaMargin();
    627    
    628     // Get pointers
    629     Pel * PicBufY = pcPicYuvOrg->getBufY();
    630     Pel * PicBufU = pcPicYuvOrg->getBufU();
    631     Pel * PicBufV = pcPicYuvOrg->getBufV();
    632    
    633     Pel * pcBottomFieldY =  pcBottomField->getPicYuvOrg()->getLumaAddr();
    634     Pel * pcBottomFieldU =  pcBottomField->getPicYuvOrg()->getCbAddr();
    635     Pel * pcBottomFieldV =  pcBottomField->getPicYuvOrg()->getCrAddr();
    636    
    637     /* -- Defield -- */
    638    
    639     bool isTop = !isTff;
    640    
    641     separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcBottomFieldY, nStride, nWidth, nHeight, isTop);
    642     separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
    643     separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
    644    
    645     // Compute image characteristics
    646     if ( getUseAdaptiveQP() )
    647     {
    648       m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcBottomField ) );
    649     }   
    650   }
    651  
    652   if ( ( !(m_iNumPicRcvd) || (!flush && m_iPOCLast != 1 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize)) )
    653   {
    654     iNumEncoded = 0;
    655     return;
    656   }
    657  
    658   // compress GOP
    659   m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
    660  
    661   iNumEncoded = m_iNumPicRcvd;
    662   m_iNumPicRcvd = 0;
    663   m_uiNumAllPicCoded += iNumEncoded;
     484Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, Bool isTff)
     485{
     486  iNumEncoded = 0;
     487
     488  for (Int fieldNum=0; fieldNum<2; fieldNum++)
     489  {
     490    if (pcPicYuvOrg)
     491    {
     492
     493      /* -- field initialization -- */
     494      const Bool isTopField=isTff==(fieldNum==0);
     495
     496      TComPic *pcField;
     497      xGetNewPicBuffer( pcField );
     498      pcField->setReconMark (false);                     // where is this normally?
     499
     500      if (fieldNum==1)                                   // where is this normally?
     501      {
     502        TComPicYuv* rpcPicYuvRec;
     503
     504        // org. buffer
     505        if ( rcListPicYuvRecOut.size() >= (UInt)m_iGOPSize+1 ) // need to maintain field 0 in list of RecOuts while processing field 1. Hence +1 on m_iGOPSize.
     506        {
     507          rpcPicYuvRec = rcListPicYuvRecOut.popFront();
     508        }
     509        else
     510        {
     511          rpcPicYuvRec = new TComPicYuv;
     512          rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth, true);
     513        }
     514        rcListPicYuvRecOut.pushBack( rpcPicYuvRec );
     515      }
     516
     517      pcField->getSlice(0)->setPOC( m_iPOCLast );        // superfluous?
     518      pcField->getPicYuvRec()->setBorderExtension(false);// where is this normally?
     519
     520      pcField->setTopField(isTopField);                  // interlaced requirement
     521
     522      for (UInt componentIndex = 0; componentIndex < pcPicYuvOrg->getNumberValidComponents(); componentIndex++)
     523      {
     524        const ComponentID component = ComponentID(componentIndex);
     525        const UInt stride = pcPicYuvOrg->getStride(component);
     526
     527        separateFields((pcPicYuvOrg->getBuf(component) + pcPicYuvOrg->getMarginX(component) + (pcPicYuvOrg->getMarginY(component) * stride)),
     528                       pcField->getPicYuvOrg()->getAddr(component),
     529                       pcPicYuvOrg->getStride(component),
     530                       pcPicYuvOrg->getWidth(component),
     531                       pcPicYuvOrg->getHeight(component),
     532                       isTopField);
     533
     534        separateFields((pcPicYuvTrueOrg->getBuf(component) + pcPicYuvTrueOrg->getMarginX(component) + (pcPicYuvTrueOrg->getMarginY(component) * stride)),
     535                       pcField->getPicYuvTrueOrg()->getAddr(component),
     536                       pcPicYuvTrueOrg->getStride(component),
     537                       pcPicYuvTrueOrg->getWidth(component),
     538                       pcPicYuvTrueOrg->getHeight(component),
     539                       isTopField);
     540      }
     541
     542      // compute image characteristics
     543      if ( getUseAdaptiveQP() )
     544      {
     545        m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcField ) );
     546      }
     547    }
     548
     549    if ( m_iNumPicRcvd && ((flush&&fieldNum==1) || (m_iPOCLast/2)==0 || m_iNumPicRcvd==m_iGOPSize ) )
     550    {
     551      // compress GOP
     552      m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff, snrCSC, m_printFrameMSE);
     553
     554      iNumEncoded += m_iNumPicRcvd;
     555      m_uiNumAllPicCoded += m_iNumPicRcvd;
     556      m_iNumPicRcvd = 0;
     557    }
     558  }
    664559}
    665560#endif
    … …  
    677572Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic )
    678573{
     574  // At this point, the SPS and PPS can be considered activated - they are copied to the new TComPic.
     575
    679576  TComSlice::sortPicList(m_cListPic);
    680  
     577
     578
    681579  if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
    682580  {
    … …  
    697595    {
    698596      TEncPic* pcEPic = new TEncPic;
    699       pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
    700                       m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
     597      pcEPic->create( m_cSPS, m_cPPS, m_cPPS.getMaxCuDQPDepth()+1, false);
    701598      rpcPic = pcEPic;
    702599    }
    … …  
    704601    {
    705602      rpcPic = new TComPic;
    706 
    707       rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth,
    708                       m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
    709     }
     603      rpcPic->create( m_cSPS, m_cPPS, false );
     604    }
     605
    710606    m_cListPic.pushBack( rpcPic );
    711607  }
    712608  rpcPic->setReconMark (false);
    713  
     609
    714610  m_iPOCLast++;
    715611  m_iNumPicRcvd++;
    716  
     612
    717613  rpcPic->getSlice(0)->setPOC( m_iPOCLast );
    718614  // mark it should be extended
    719615  rpcPic->getPicYuvRec()->setBorderExtension(false);
    720 
    721 #if H_MV
     616#if NH_MV
    722617  rpcPic->getPicYuvOrg()->setBorderExtension(false);
    723618#endif
     619
     620}
     621
     622Void TEncTop::xInitVPS()
     623{
     624  // The SPS must have already been set up.
     625  // set the VPS profile information.
     626#if NH_MV
     627  // Do initialization in TAppEncTop
     628#else
     629  *m_cVPS.getPTL() = *m_cSPS.getPTL();
     630  m_cVPS.setMaxOpSets(1);
     631  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
     632  m_cVPS.setNumHrdParameters( 0 );
     633
     634  m_cVPS.createHrdParamBuffer();
     635  for( UInt i = 0; i < m_cVPS.getNumHrdParameters(); i ++ )
     636  {
     637    m_cVPS.setHrdOpSetIdx( 0, i );
     638    m_cVPS.setCprmsPresentFlag( false, i );
     639    // Set up HrdParameters here.
     640  }
     641#endif
    724642}
    725643
    726644Void TEncTop::xInitSPS()
    727645{
    728 #if H_MV
     646#if NH_MV
    729647  m_cSPS.setSPSId( getLayerIdInVps() );
    730648  m_cSPS.setLayerId( getLayerId() );
    … …  
    740658  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
    741659  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
    742  
    743   if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
     660  profileTierLevel.setBitDepthConstraint(m_bitDepthConstraintValue);
     661  profileTierLevel.setChromaFormatConstraint(m_chromaFormatConstraintValue);
     662  profileTierLevel.setIntraConstraintFlag(m_intraConstraintFlag);
     663  profileTierLevel.setOnePictureOnlyConstraintFlag(m_onePictureOnlyConstraintFlag);
     664  profileTierLevel.setLowerBitRateConstraintFlag(m_lowerBitRateConstraintFlag);
     665
     666  if ((m_profile == Profile::MAIN10) && (m_bitDepth[CHANNEL_TYPE_LUMA] == 8) && (m_bitDepth[CHANNEL_TYPE_CHROMA] == 8))
    744667  {
    745668    /* The above constraint is equal to Profile::MAIN */
    … …  
    754677  /* XXX: may be a good idea to refactor the above into a function
    755678   * that chooses the actual compatibility based upon options */
    756 
    757 #if H_MV 
     679#if NH_MV 
    758680  m_cSPS.setUpdateRepFormatFlag           ( false );   
    759681  Bool multiLayerExtensionFlag  = ( getLayerId() > 0 ) && ( m_cVPS->getNumRefLayers( getLayerId() ) > 0 );
    … …  
    764686    m_cSPS.setSpsInferScalingListFlag   ( true );
    765687    m_cSPS.setSpsScalingListRefLayerId( m_cVPS->getIdRefLayer( getLayerId(), 0 ) );
    766 #if H_MV
     688#if NH_MV
    767689    if ( m_bUseDisparitySearchRangeRestriction )
    768690    {
    … …  
    773695  m_cSPS.setSpsExtensionPresentFlag       ( true );
    774696  m_cSPS.setSpsMultilayerExtensionFlag    ( true );
    775 #if H_3D
     697#if NH_3D
    776698  m_cSPS.setSps3dExtensionFlag            ( true );
    777699#endif
    778700#endif
    779   m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
    780   m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
    781   m_cSPS.setConformanceWindow             ( m_conformanceWindow );
    782   m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
    783   m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
    784   m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
    785 #if H_3D_DISABLE_CHROMA
    786   m_cSPS.setChromaFormatIdc( getIsDepth() ? CHROMA_400 : CHROMA_420 );
    787 #endif
    788 
    789   Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
     701
     702  m_cSPS.setPicWidthInLumaSamples  ( m_iSourceWidth      );
     703  m_cSPS.setPicHeightInLumaSamples ( m_iSourceHeight     );
     704  m_cSPS.setConformanceWindow      ( m_conformanceWindow );
     705  m_cSPS.setMaxCUWidth             ( m_maxCUWidth        );
     706  m_cSPS.setMaxCUHeight            ( m_maxCUHeight       );
     707  m_cSPS.setMaxTotalCUDepth        ( m_maxTotalCUDepth   );
     708#if NH_3D
     709  assert( !getIsDepth()  || m_chromaFormatIDC == CHROMA_400 );
     710#endif
     711  m_cSPS.setChromaFormatIdc( m_chromaFormatIDC);
     712  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_log2DiffMaxMinCodingBlockSize);
     713
     714  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getLog2DiffMaxMinCodingBlockSize() );
    790715  Int log2MinCUSize = 0;
    791716  while(minCUSize > 1)
    … …  
    796721
    797722  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
    798   m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
    799  
     723
    800724  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
    801725  m_cSPS.setUsePCM        ( m_usePCM           );
    … …  
    806730  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
    807731  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
    808  
    809   m_cSPS.setTMVPFlagsPresent(false);
     732
     733  m_cSPS.setTMVPFlagsPresent((getTMVPModeId() == 2 || getTMVPModeId() == 1));
    810734
    811735  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
    812  
    813   Int i;
    814  
    815   for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
    816   {
    817     m_cSPS.setAMPAcc( i, m_useAMP );
    818     //m_cSPS.setAMPAcc( i, 1 );
    819   }
    820736
    821737  m_cSPS.setUseAMP ( m_useAMP );
    822738
    823   for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
    824   {
    825     m_cSPS.setAMPAcc(i, 0);
    826   }
    827 
    828   m_cSPS.setBitDepthY( g_bitDepthY );
    829   m_cSPS.setBitDepthC( g_bitDepthC );
    830 
    831   m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
    832   m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
    833 
    834   m_cSPS.setUseSAO( m_bUseSAO );
     739  for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++)
     740  {
     741    m_cSPS.setBitDepth      (ChannelType(channelType), m_bitDepth[channelType] );
     742#if O0043_BEST_EFFORT_DECODING
     743    m_cSPS.setStreamBitDepth(ChannelType(channelType), m_bitDepth[channelType] );
     744#endif
     745    m_cSPS.setQpBDOffset  (ChannelType(channelType), (6 * (m_bitDepth[channelType] - 8)));
     746    m_cSPS.setPCMBitDepth (ChannelType(channelType), m_PCMBitDepth[channelType]         );
     747  }
     748#if NH_MV
     749  m_cSPS.inferRepFormat( m_cVPS, getLayerId(), true );
     750#endif
     751m_cSPS.setUseSAO( m_bUseSAO );
    835752
    836753  m_cSPS.setMaxTLayers( m_maxTempLayer );
    837754  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
    838   for ( i = 0; i < min(m_cSPS.getMaxTLayers(),(UInt) MAX_TLAYER); i++ )
     755
     756  for (Int i = 0; i < min(m_cSPS.getMaxTLayers(),(UInt) MAX_TLAYER); i++ )
    839757  {
    840758    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
    841759    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
    842760  }
    843 #if H_MV
     761#if NH_MV
    844762  for ( Int ols = 0; ols < m_cVPS->getNumOutputLayerSets(); ols++)
    845763  {
    … …  
    855773  }
    856774#endif
    857   m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
    858   m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
     775
     776
    859777  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
    860 
    861   m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
    862 
     778  m_cSPS.setScalingListFlag ( (m_useScalingListId == SCALING_LIST_OFF) ? 0 : 1 );
    863779  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
    864 
    865780  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
     781
    866782  if (m_cSPS.getVuiParametersPresentFlag())
    867783  {
    … …  
    873789    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
    874790    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
    875 #if H_MV
     791#if NH_MV
    876792    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag() && getLayerId() == 0 );
    877793#else
    878    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
     794    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
    879795#endif
    880796    pcVUI->setVideoFormat(getVideoFormat());
    … …  
    903819    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
    904820  }
    905 }
     821  m_cSPS.setNumLongTermRefPicSPS(NUM_LONG_TERM_REF_PIC_SPS);
     822  assert (NUM_LONG_TERM_REF_PIC_SPS <= MAX_NUM_LONG_TERM_REF_PICS);
     823  for (Int k = 0; k < NUM_LONG_TERM_REF_PIC_SPS; k++)
     824  {
     825    m_cSPS.setLtRefPicPocLsbSps(k, 0);
     826    m_cSPS.setUsedByCurrPicLtSPSFlag(k, 0);
     827  }
     828  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
     829  {
     830    xInitHrdParameters();
     831  }
     832  if( getBufferingPeriodSEIEnabled() || getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
     833  {
     834    m_cSPS.getVuiParameters()->setHrdParametersPresentFlag( true );
     835  }
     836
     837  // Set up SPS range extension settings
     838  m_cSPS.getSpsRangeExtension().setTransformSkipRotationEnabledFlag(m_transformSkipRotationEnabledFlag);
     839  m_cSPS.getSpsRangeExtension().setTransformSkipContextEnabledFlag(m_transformSkipContextEnabledFlag);
     840  for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
     841  {
     842    m_cSPS.getSpsRangeExtension().setRdpcmEnabledFlag(RDPCMSignallingMode(signallingModeIndex), m_rdpcmEnabledFlag[signallingModeIndex]);
     843  }
     844  m_cSPS.getSpsRangeExtension().setExtendedPrecisionProcessingFlag(m_extendedPrecisionProcessingFlag);
     845  m_cSPS.getSpsRangeExtension().setIntraSmoothingDisabledFlag( m_intraSmoothingDisabledFlag );
     846  m_cSPS.getSpsRangeExtension().setHighPrecisionOffsetsEnabledFlag(m_highPrecisionOffsetsEnabledFlag);
     847  m_cSPS.getSpsRangeExtension().setPersistentRiceAdaptationEnabledFlag(m_persistentRiceAdaptationEnabledFlag);
     848  m_cSPS.getSpsRangeExtension().setCabacBypassAlignmentEnabledFlag(m_cabacBypassAlignmentEnabledFlag);
     849#if NH_MV
     850  m_cSPS.setSpsRangeExtensionsFlag( m_cSPS.getSpsRangeExtension().settingsDifferFromDefaults() );
     851#endif
     852
     853}
     854
     855Void TEncTop::xInitHrdParameters()
     856{
     857  Bool useSubCpbParams = (getSliceMode() > 0) || (getSliceSegmentMode() > 0);
     858  Int  bitRate         = getTargetBitrate();
     859  Bool isRandomAccess  = getIntraPeriod() > 0;
     860
     861  if( !getVuiParametersPresentFlag() )
     862  {
     863    return;
     864  }
     865
     866  TComVUI *vui = m_cSPS.getVuiParameters();
     867  TComHRD *hrd = vui->getHrdParameters();
     868
     869  TimingInfo *timingInfo = vui->getTimingInfo();
     870  timingInfo->setTimingInfoPresentFlag( true );
     871  switch( getFrameRate() )
     872  {
     873  case 24:
     874    timingInfo->setNumUnitsInTick( 1125000 );    timingInfo->setTimeScale    ( 27000000 );
     875    break;
     876  case 25:
     877    timingInfo->setNumUnitsInTick( 1080000 );    timingInfo->setTimeScale    ( 27000000 );
     878    break;
     879  case 30:
     880    timingInfo->setNumUnitsInTick( 900900 );     timingInfo->setTimeScale    ( 27000000 );
     881    break;
     882  case 50:
     883    timingInfo->setNumUnitsInTick( 540000 );     timingInfo->setTimeScale    ( 27000000 );
     884    break;
     885  case 60:
     886    timingInfo->setNumUnitsInTick( 450450 );     timingInfo->setTimeScale    ( 27000000 );
     887    break;
     888  default:
     889    timingInfo->setNumUnitsInTick( 1001 );       timingInfo->setTimeScale    ( 60000 );
     890    break;
     891  }
     892
     893  Bool rateCnt = ( bitRate > 0 );
     894  hrd->setNalHrdParametersPresentFlag( rateCnt );
     895  hrd->setVclHrdParametersPresentFlag( rateCnt );
     896
     897  hrd->setSubPicCpbParamsPresentFlag( useSubCpbParams );
     898
     899  if( hrd->getSubPicCpbParamsPresentFlag() )
     900  {
     901    hrd->setTickDivisorMinus2( 100 - 2 );                          //
     902    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
     903    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
     904    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
     905  }
     906  else
     907  {
     908    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
     909  }
     910
     911  hrd->setBitRateScale( 4 );                                       // in units of 2^( 6 + 4 ) = 1,024 bps
     912  hrd->setCpbSizeScale( 6 );                                       // in units of 2^( 4 + 6 ) = 1,024 bit
     913  hrd->setDuCpbSizeScale( 6 );                                     // in units of 2^( 4 + 6 ) = 1,024 bit
     914
     915  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
     916  if( isRandomAccess )
     917  {
     918    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
     919    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
     920  }
     921  else
     922  {
     923    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
     924    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
     925  }
     926
     927  // Note: parameters for all temporal layers are initialized with the same values
     928  Int i, j;
     929  UInt bitrateValue, cpbSizeValue;
     930  UInt duCpbSizeValue;
     931  UInt duBitRateValue = 0;
     932
     933  for( i = 0; i < MAX_TLAYER; i ++ )
     934  {
     935    hrd->setFixedPicRateFlag( i, 1 );
     936    hrd->setPicDurationInTcMinus1( i, 0 );
     937    hrd->setLowDelayHrdFlag( i, 0 );
     938    hrd->setCpbCntMinus1( i, 0 );
     939
     940    //! \todo check for possible PTL violations
     941    // BitRate[ i ] = ( bit_rate_value_minus1[ i ] + 1 ) * 2^( 6 + bit_rate_scale )
     942    bitrateValue = bitRate / (1 << (6 + hrd->getBitRateScale()) );      // bitRate is in bits, so it needs to be scaled down
     943    // CpbSize[ i ] = ( cpb_size_value_minus1[ i ] + 1 ) * 2^( 4 + cpb_size_scale )
     944    cpbSizeValue = bitRate / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
     945
     946    // DU CPB size could be smaller (i.e. bitrateValue / number of DUs), but we don't know
     947    // in how many DUs the slice segment settings will result
     948    duCpbSizeValue = bitrateValue;
     949    duBitRateValue = cpbSizeValue;
     950
     951    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
     952    {
     953      hrd->setBitRateValueMinus1( i, j, 0, ( bitrateValue - 1 ) );
     954      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
     955      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( duCpbSizeValue - 1 ) );
     956      hrd->setDuBitRateValueMinus1( i, j, 0, ( duBitRateValue - 1 ) );
     957      hrd->setCbrFlag( i, j, 0, false );
     958
     959      hrd->setBitRateValueMinus1( i, j, 1, ( bitrateValue - 1) );
     960      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
     961      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( duCpbSizeValue - 1 ) );
     962      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
     963      hrd->setCbrFlag( i, j, 1, false );
     964    }
     965  }
     966}
     967
    906968
    907969Void TEncTop::xInitPPS()
    908970{
    909 #if H_MV
     971#if NH_MV
    910972  m_cPPS.setLayerId( getLayerId() );
    911 #if H_3D
     973#if NH_3D
    912974  // Check if this condition is still correct
    913975  if( getVPS()->getNumRefListLayers( getLayerId() ) > 0 )
    … …  
    921983  m_cPPS.setSPSId( getLayerIdInVps() );
    922984  m_cPPS.setPpsMultilayerExtensionFlag    ( true );
    923 #if H_3D
    924   m_cPPS.setPps3dExtensionFlag            ( true );
    925 #endif
    926 #endif
    927 
    928 #if H_3D
    929   m_cPPS.setDLT( getDLT() );
    930 #endif
     985#if NH_3D
     986  // Might be used for DLT
     987  m_cPPS.setPps3dExtensionFlag            ( getIsDepth() );
     988#endif
     989#endif
     990
     991#if NH_3D_DLT
     992  // create mapping from depth layer indexes to layer ids
     993  Int j=0;
     994  for( Int i=0; i<=getVPS()->getMaxLayersMinus1(); i++ )
     995  {
     996    Int layerId = getVPS()->getLayerIdInNuh(i);
     997    if( getVPS()->getDepthId(layerId) )
     998      m_cDLT.setDepthIdxToLayerId(j++, layerId);
     999  }
     1000  m_cPPS.setDLT( m_cDLT );
     1001#endif
     1002
    9311003  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
    9321004  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
    9331005
    934       if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
    935       {
    936         bUseDQP = true;
    937       }
    938 
    939   if(bUseDQP)
     1006  if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
     1007  {
     1008    bUseDQP = true;
     1009  }
     1010
     1011  if (m_costMode==COST_SEQUENCE_LEVEL_LOSSLESS || m_costMode==COST_LOSSLESS_CODING)
     1012  {
     1013    bUseDQP=false;
     1014  }
     1015
     1016
     1017  if ( m_RCEnableRateControl )
     1018  {
     1019    m_cPPS.setUseDQP(true);
     1020    m_cPPS.setMaxCuDQPDepth( 0 );
     1021  }
     1022  else if(bUseDQP)
    9401023  {
    9411024    m_cPPS.setUseDQP(true);
    9421025    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
    943     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
    9441026  }
    9451027  else
    … …  
    9471029    m_cPPS.setUseDQP(false);
    9481030    m_cPPS.setMaxCuDQPDepth( 0 );
    949     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
    950   }
    951 
    952   if ( m_RCEnableRateControl )
    953   {
    954     m_cPPS.setUseDQP(true);
    955     m_cPPS.setMaxCuDQPDepth( 0 );
    956     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
    957   }
    958 
    959   m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
    960   m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
    961 
    962   m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
     1031  }
     1032
     1033  if ( m_diffCuChromaQpOffsetDepth >= 0 )
     1034  {
     1035    m_cPPS.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(m_diffCuChromaQpOffsetDepth);
     1036    m_cPPS.getPpsRangeExtension().clearChromaQpOffsetList();
     1037    m_cPPS.getPpsRangeExtension().setChromaQpOffsetListEntry(1, 6, 6);
     1038    /* todo, insert table entries from command line (NB, 0 should not be touched) */
     1039  }
     1040  else
     1041  {
     1042    m_cPPS.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(0);
     1043    m_cPPS.getPpsRangeExtension().clearChromaQpOffsetList();
     1044  }
     1045  m_cPPS.getPpsRangeExtension().setCrossComponentPredictionEnabledFlag(m_crossComponentPredictionEnabledFlag);
     1046  m_cPPS.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_LUMA,   m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA  ]);
     1047  m_cPPS.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA]);
     1048
     1049  m_cPPS.setQpOffset(COMPONENT_Cb, m_chromaCbQpOffset );
     1050  m_cPPS.setQpOffset(COMPONENT_Cr, m_chromaCrQpOffset );
     1051
    9631052  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
    9641053  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
    … …  
    9661055  m_cPPS.setWPBiPred( m_useWeightedBiPred );
    9671056  m_cPPS.setOutputFlagPresentFlag( false );
    968 #if H_MV
     1057#if NH_MV
     1058#if NH_MV_FIX_TICKET_100
     1059  m_cPPS.setNumExtraSliceHeaderBits( 2 );
     1060#else
    9691061  m_cPPS.setNumExtraSliceHeaderBits( 3 );
     1062#endif
    9701063#endif
    9711064  m_cPPS.setSignHideFlag(getSignHideFlag());
    9721065  if ( getDeblockingFilterMetric() )
    9731066  {
    974     m_cPPS.setDeblockingFilterControlPresentFlag (true);
    9751067    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
    9761068    m_cPPS.setPicDisableDeblockingFilterFlag(false);
     1069  }
     1070  else
     1071  {
     1072      m_cPPS.setDeblockingFilterOverrideEnabledFlag( !getLoopFilterOffsetInPPS() );
     1073      m_cPPS.setPicDisableDeblockingFilterFlag( getLoopFilterDisable() );
     1074    }
     1075
     1076  if (! m_cPPS.getPicDisableDeblockingFilterFlag())
     1077  {
     1078    m_cPPS.setDeblockingFilterBetaOffsetDiv2( getLoopFilterBetaOffset() );
     1079    m_cPPS.setDeblockingFilterTcOffsetDiv2( getLoopFilterTcOffset() );
     1080  }
     1081  else
     1082  {
    9771083    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
    9781084    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
    979   }
    980   else
    981   {
    982     m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
    983   }
     1085  }
     1086
     1087  // deblockingFilterControlPresentFlag is true if any of the settings differ from the inferred values:
     1088  const Bool deblockingFilterControlPresentFlag = m_cPPS.getDeblockingFilterOverrideEnabledFlag() ||
     1089                                                  m_cPPS.getPicDisableDeblockingFilterFlag()      ||
     1090                                                  m_cPPS.getDeblockingFilterBetaOffsetDiv2() != 0 ||
     1091                                                  m_cPPS.getDeblockingFilterTcOffsetDiv2() != 0;
     1092
     1093  m_cPPS.setDeblockingFilterControlPresentFlag(deblockingFilterControlPresentFlag);
     1094
    9841095  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
    9851096  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
    9861097  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
     1098
     1099
    9871100  Int histogram[MAX_NUM_REF + 1];
    9881101  for( Int i = 0; i <= MAX_NUM_REF; i++ )
    … …  
    9901103    histogram[i]=0;
    9911104  }
    992   for( Int i = 0; i < getGOPSize(); i++ )
     1105  for( Int i = 0; i < getGOPSize(); i++)
    9931106  {
    9941107    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
    9951108    histogram[getGOPEntry(i).m_numRefPicsActive]++;
    9961109  }
     1110
    9971111  Int maxHist=-1;
    9981112  Int bestPos=0;
    … …  
    10101124  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
    10111125  m_cPPS.setUseTransformSkip( m_useTransformSkip );
    1012   if (m_sliceSegmentMode)
     1126  m_cPPS.getPpsRangeExtension().setLog2MaxTransformSkipBlockSize( m_log2MaxTransformSkipBlockSize  );
     1127
     1128  if (m_sliceSegmentMode != NO_SLICES)
    10131129  {
    10141130    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
    1015   }
    1016   if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
    1017   {
    1018     Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
    1019     m_cSliceEncoder.initCtxMem( NumCtx );
    1020     for ( UInt st = 0; st < NumCtx; st++ )
    1021     {
    1022       TEncSbac* ctx = NULL;
    1023       ctx = new TEncSbac;
    1024       ctx->init( &m_cBinCoderCABAC );
    1025       m_cSliceEncoder.setCtxMem( ctx, st );
    1026     }
    10271131  }
    10281132}
    … …  
    10321136{
    10331137  TComReferencePictureSet*      rps;
    1034  
    1035   m_cSPS.createRPSList(getGOPSize()+m_extraRPSs+1);
     1138
     1139  m_cSPS.createRPSList(getGOPSize() + m_extraRPSs + 1);
    10361140  TComRPSList* rpsList = m_cSPS.getRPSList();
    10371141
    1038   for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
     1142  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++)
    10391143  {
    10401144    GOPEntry ge = getGOPEntry(i);
    … …  
    10611165
    10621166    // handle inter RPS intialization from the config file.
    1063 #if AUTO_INTER_RPS
    10641167    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
    10651168    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
    1066     TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
     1169    TComReferencePictureSet*     RPSRef = i>0 ? rpsList->getReferencePictureSet(i-1): NULL;  // get the reference RPS
    10671170
    10681171    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
    10691172    {
     1173      assert (RPSRef!=NULL);
    10701174      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
    10711175      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
    … …  
    10801184        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
    10811185        {
    1082           if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS. 
     1186          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
    10831187          {
    10841188              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
    … …  
    10961200    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
    10971201    {
     1202      assert (RPSRef!=NULL);
    10981203      rps->setDeltaRPS(ge.m_deltaRPS);
    10991204      rps->setNumRefIdc(ge.m_numRefIdc);
    … …  
    11021207        rps->setRefIdc(j, ge.m_refIdc[j]);
    11031208      }
    1104 #if WRITE_BACK
    1105       // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
     1209      // the following code overwrite the deltaPOC and Used by current values read from the config file with the ones
    11061210      // computed from the RefIdc.  A warning is printed if they are not identical.
    11071211      numNeg = 0;
    … …  
    11411245      RPSTemp.setNumberOfNegativePictures(numNeg);
    11421246      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
    1143       // check if Delta POC and Used are the same 
     1247      // check if Delta POC and Used are the same
    11441248      // print warning if they are not.
    11451249      for (Int j = 0; j < ge.m_numRefIdc; j++ )
    … …  
    11561260        }
    11571261      }
    1158 #endif
    1159     }
    1160 #else
    1161     rps->setInterRPSPrediction(ge.m_interRPSPrediction);
    1162     if (ge.m_interRPSPrediction)
    1163     {
    1164       rps->setDeltaRIdxMinus1(0);
    1165       rps->setDeltaRPS(ge.m_deltaRPS);
    1166       rps->setNumRefIdc(ge.m_numRefIdc);
    1167       for (Int j = 0; j < ge.m_numRefIdc; j++ )
    1168       {
    1169         rps->setRefIdc(j, ge.m_refIdc[j]);
    1170       }
    1171 #if WRITE_BACK
    1172       // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
    1173       // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
    1174       numNeg = 0;
    1175       numPos = 0;
    1176       TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
    1177 
    1178       for (Int j = 0; j < ge.m_numRefIdc; j++ )
    1179       {
    1180         if (ge.m_refIdc[j])
    1181         {
    1182           Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
    1183           rps->setDeltaPOC((numNeg+numPos),deltaPOC);
    1184           rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
    1185           if (deltaPOC<0)
    1186           {
    1187             numNeg++;
    1188           }
    1189           else
    1190           {
    1191             numPos++;
    1192           }
    1193         }
    1194       }
    1195       rps->setNumberOfNegativePictures(numNeg);
    1196       rps->setNumberOfPositivePictures(numPos);
    1197       rps->sortDeltaPOC();
    1198 #endif
    1199     }
    1200 #endif //INTER_RPS_AUTO
    1201   }
    1202   //In case of field coding, we need to set special parameters for the first bottom field of the sequence, since it is not specified in the cfg file.
    1203   //The position = GOPSize + extraRPSs which is (a priori) unused is reserved for this field in the RPS.
    1204   if (isFieldCoding)
     1262    }
     1263  }
     1264  //In case of field coding, we need to set special parameters for the first bottom field of the sequence, since it is not specified in the cfg file.
     1265  //The position = GOPSize + extraRPSs which is (a priori) unused is reserved for this field in the RPS.
     1266  if (isFieldCoding)
    12051267  {
    12061268    rps = rpsList->getReferencePictureSet(getGOPSize()+m_extraRPSs);
    … …  
    12161278    rps->setDeltaRPS(0);
    12171279    rps->setNumRefIdc(0);
    1218 }
    1219 }
    1220 
    1221    // This is a function that 
    1222    // determines what Reference Picture Set to use 
     1280  }
     1281}
     1282
     1283   // This is a function that
     1284   // determines what Reference Picture Set to use
    12231285   // for a specific slice (with POC = POCCurr)
    12241286Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
    12251287{
    1226 #if H_MV
     1288#if NH_MV
    12271289  if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
    12281290  {
    … …  
    12401302
    12411303  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
    1242   {   
     1304  {
    12431305    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
    12441306    {
    … …  
    12611323    }
    12621324  }
     1325
    12631326  if(POCCurr == 1 && slice->getPic()->isField())
    12641327  {
    … …  
    12661329  }
    12671330
    1268   slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
    1269   slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
    1270 #if H_MV
    1271   }
    1272 #endif
    1273 
    1274 }
    1275 
    1276 Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
    1277 {
    1278   int rpsIdx = GOPid;
     1331  const TComReferencePictureSet *rps = (slice->getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
     1332  slice->setRPS(rps);
     1333#if NH_MV
     1334  }
     1335#endif
     1336
     1337}
     1338
     1339Int TEncTop::getReferencePictureSetIdxForSOP(Int POCCurr, Int GOPid )
     1340{
     1341  Int rpsIdx = GOPid;
    12791342
    12801343  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
    1281   {   
     1344  {
    12821345    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
    12831346    {
    … …  
    13171380
    13181381  // # substreams is "per tile" when tiles are independent.
    1319   if (m_iWaveFrontSynchro )
    1320   {
    1321     m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
    1322   }
    13231382}
    13241383
    13251384Void  TEncCfg::xCheckGSParameters()
    13261385{
    1327   Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
    1328   Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
     1386  Int   iWidthInCU = ( m_iSourceWidth%m_maxCUWidth ) ? m_iSourceWidth/m_maxCUWidth + 1 : m_iSourceWidth/m_maxCUWidth;
     1387  Int   iHeightInCU = ( m_iSourceHeight%m_maxCUHeight ) ? m_iSourceHeight/m_maxCUHeight + 1 : m_iSourceHeight/m_maxCUHeight;
    13291388  UInt  uiCummulativeColumnWidth = 0;
    13301389  UInt  uiCummulativeRowHeight = 0;
    … …  
    13731432  {
    13741433    for(Int i=0; i<m_iNumRowsMinus1; i++)
     1434    {
    13751435      uiCummulativeRowHeight += m_tileRowHeight[i];
     1436    }
    13761437
    13771438    if( uiCummulativeRowHeight >= iHeightInCU )
    … …  
    13821443  }
    13831444}
    1384 #if H_MV
    1385 Void TEncTop::printSummary( Int numAllPicCoded, Bool isField )
    1386 {
    1387   assert ( !isField ); // Multiview and field coding need to be further unified
    1388   assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
    1389 
    1390   //--CFG_KDY
    1391   m_cAnalyzeAll.setFrmRate( getFrameRate() );
    1392   m_cAnalyzeI.setFrmRate( getFrameRate() );
    1393   m_cAnalyzeP.setFrmRate( getFrameRate() );
    1394   m_cAnalyzeB.setFrmRate( getFrameRate() );
    1395 
    1396   //-- all
    1397   printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
    1398 
    1399   m_cAnalyzeAll.printOut('a');
    1400 
    1401   printf( "\n\nI Slices--------------------------------------------------------\n" );
    1402   m_cAnalyzeI.printOut('i');
    1403 
    1404   printf( "\n\nP Slices--------------------------------------------------------\n" );
    1405   m_cAnalyzeP.printOut('p');
    1406 
    1407   printf( "\n\nB Slices--------------------------------------------------------\n" );
    1408   m_cAnalyzeB.printOut('b');
    1409 
    1410 #if _SUMMARY_OUT_
    1411   m_cAnalyzeAll.printSummaryOut();
    1412 #endif
    1413 #if _SUMMARY_PIC_
    1414   m_cAnalyzeI.printSummary('I');
    1415   m_cAnalyzeP.printSummary('P');
    1416   m_cAnalyzeB.printSummary('B');
    1417 #endif
    1418 }
    1419 
     1445
     1446#if NH_MV
    14201447Int TEncTop::getFrameId(Int iGOPid) 
    14211448{
    … …  
    14441471  return pcPic;
    14451472}
    1446 #endif
    1447 
    1448 #if H_3D_VSO
    1449 Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
     1473
     1474#endif
     1475
     1476#if NH_3D_VSO
     1477Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset, Int maxCuHeight )
    14501478{
    14511479  TRenModel* rendererModel = m_cRdCost.getRenModel();
    1452   rendererModel->setupPart( iHorOffset, std::min( (Int) g_uiMaxCUHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ;
     1480  rendererModel->setupPart( iHorOffset, std::min( maxCuHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ;
    14531481 
    14541482  Int iEncViewSIdx = m_cameraParameters->getBaseId2SortedId()[ iEncViewIdx ];
    … …  
    15451573}
    15461574#endif
     1575
    15471576//! \}
Note: See TracChangeset for help on using the changeset viewer.