source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp @ 1166

Last change on this file since 1166 was 1164, checked in by seregin, 9 years ago

macro cleanup: P0307_VPS_NON_VUI_EXTENSION

  • Property svn:eol-style set to native
File size: 130.5 KB
RevLine 
[313]1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
[1029]4 * granted under this license.
[313]5 *
[595]6 * Copyright (c) 2010-2014, ITU/ISO/IEC
[313]7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TComSlice.cpp
35    \brief    slice header and SPS class
36*/
37
38#include "CommonDef.h"
39#include "TComSlice.h"
40#include "TComPic.h"
41#include "TLibEncoder/TEncSbac.h"
42#include "TLibDecoder/TDecSbac.h"
43
[1029]44
[313]45//! \ingroup TLibCommon
46//! \{
47
48#if SVC_EXTENSION
[1029]49#include <numeric>
[442]50ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
[834]51ParameterSetMap<TComSPS> ParameterSetManager::m_spsMap(MAX_NUM_SPS);
52ParameterSetMap<TComPPS> ParameterSetManager::m_ppsMap(MAX_NUM_PPS);
[442]53Int ParameterSetManager::m_activeVPSId = -1;
[313]54#endif
55
56TComSlice::TComSlice()
57: m_iPPSId                        ( -1 )
[1029]58, m_PicOutputFlag                 ( true )
[313]59, m_iPOC                          ( 0 )
60, m_iLastIDR                      ( 0 )
[1029]61, m_iAssociatedIRAP               ( 0 )
62, m_iAssociatedIRAPType           ( NAL_UNIT_INVALID )
63, m_pcRPS                         ( 0 )
64, m_LocalRPS                      ( )
65, m_iBDidx                        ( 0 )
66, m_RefPicListModification        ( )
[313]67, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
68, m_eSliceType                    ( I_SLICE )
69, m_iSliceQp                      ( 0 )
[1029]70, m_dependentSliceSegmentFlag     ( false )
[313]71#if ADAPTIVE_QP_SELECTION
72, m_iSliceQpBase                  ( 0 )
73#endif
[1029]74, m_ChromaQpAdjEnabled            ( false )
75, m_deblockingFilterDisable       ( false )
76, m_deblockingFilterOverrideFlag  ( false )
77, m_deblockingFilterBetaOffsetDiv2( 0 )
78, m_deblockingFilterTcOffsetDiv2  ( 0 )
[313]79, m_bCheckLDC                     ( false )
80, m_iSliceQpDelta                 ( 0 )
81, m_iDepth                        ( 0 )
82, m_bRefenced                     ( false )
[1029]83, m_pcVPS                         ( NULL )
[313]84, m_pcSPS                         ( NULL )
85, m_pcPPS                         ( NULL )
86, m_pcPic                         ( NULL )
[1029]87#if ADAPTIVE_QP_SELECTION
88, m_pcTrQuant                     ( NULL )
89#endif
[313]90, m_colFromL0Flag                 ( 1 )
[713]91, m_noOutputPriorPicsFlag         ( false )
92, m_noRaslOutputFlag              ( false )
93, m_handleCraAsBlaFlag            ( false )
[313]94, m_colRefIdx                     ( 0 )
[1029]95, m_maxNumMergeCand               ( 0 )
[313]96, m_uiTLayer                      ( 0 )
97, m_bTLayerSwitchingFlag          ( false )
[1029]98, m_sliceMode                     ( NO_SLICES )
99, m_sliceArgument                 ( 0 )
100, m_sliceCurStartCtuTsAddr        ( 0 )
101, m_sliceCurEndCtuTsAddr          ( 0 )
102, m_sliceIdx                      ( 0 )
103, m_sliceSegmentMode              ( NO_SLICES )
104, m_sliceSegmentArgument          ( 0 )
105, m_sliceSegmentCurStartCtuTsAddr ( 0 )
106, m_sliceSegmentCurEndCtuTsAddr   ( 0 )
107, m_nextSlice                     ( false )
108, m_nextSliceSegment              ( false )
109, m_sliceBits                     ( 0 )
110, m_sliceSegmentBits              ( 0 )
[313]111, m_bFinalized                    ( false )
[1029]112, m_substreamSizes                ( )
113, m_scalingList                   ( NULL )
[313]114, m_cabacInitFlag                 ( false )
115, m_bLMvdL1Zero                   ( false )
116, m_temporalLayerNonReferenceFlag ( false )
[1029]117, m_LFCrossSliceBoundaryFlag      ( false )
[313]118, m_enableTMVPFlag                ( true )
[1029]119#if SVC_EXTENSION
[1092]120, m_firstSliceInPic               ( false )
[850]121#if R0226_SLICE_TMVP
122, m_availableForTMVPRefFlag       ( true )
123#endif
[494]124, m_layerId                     ( 0 )
125#if REF_IDX_MFM
126, m_bMFMEnabledFlag               ( false )
127#endif
128, m_bDiscardableFlag              ( false )
[540]129, m_bCrossLayerBLAFlag            ( false )
[644]130#if POC_RESET_IDC_SIGNALLING
131, m_pocResetIdc                   ( 0 )
132, m_pocResetPeriodId              ( 0 )
133, m_fullPocResetFlag              ( false )
134, m_pocLsbVal                     ( 0 )
135, m_pocMsbVal                     ( 0 )
136, m_pocMsbValRequiredFlag         ( false )
[904]137, m_pocMsbValPresentFlag          ( false )
[903]138#if P0297_VPS_POC_LSB_ALIGNED_FLAG
139, m_pocMsbValNeeded               ( false )
140#endif
[644]141#endif
[815]142#if POC_RESET_IDC_DECODER || POC_RESET_IDC_ENCODER
143, m_picOrderCntLsb (0)
144#endif
[494]145#endif //SVC_EXTENSION
[313]146{
[1029]147  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
148  {
149    m_aiNumRefIdx[i] = 0;
150  }
[313]151
152#if SVC_EXTENSION
153  memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
154  m_activeNumILRRefIdx        = 0; 
155  m_interLayerPredEnabledFlag = 0;
156  ::memset( m_interLayerPredLayerIdc, 0, sizeof(m_interLayerPredLayerIdc) );
[494]157#endif //SVC_EXTENSION
[313]158
[1029]159  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
[540]160  {
[1029]161    m_lambdas            [component] = 0.0;
162    m_iSliceChromaQpDelta[component] = 0;
[540]163  }
[1029]164
165  initEqualRef();
166
[313]167  for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
168  {
169    m_list1IdxToList0Idx[idx] = -1;
170  }
[1029]171
[313]172  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
173  {
[1029]174    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
175    {
176      m_apcRefPicList [i][iNumCount] = NULL;
177      m_aiRefPOCList  [i][iNumCount] = 0;
178    }
[313]179  }
[1029]180
[313]181  resetWpScaling();
182  initWpAcDcParam();
[1029]183
184  for(Int ch=0; ch < MAX_NUM_CHANNEL_TYPE; ch++)
185  {
186    m_saoEnabledFlag[ch] = false;
187  }
[313]188}
189
190TComSlice::~TComSlice()
191{
192}
193
194
195#if SVC_EXTENSION
196Void TComSlice::initSlice( UInt layerId )
197#else
198Void TComSlice::initSlice()
199#endif
200{
201#if SVC_EXTENSION
202  m_layerId = layerId;
203  m_activeNumILRRefIdx        = 0;
204  m_interLayerPredEnabledFlag = 0;
[442]205#endif
[1029]206
207  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
208  {
209    m_aiNumRefIdx[i]      = 0;
210  }
[313]211  m_colFromL0Flag = 1;
[1029]212
[313]213  m_colRefIdx = 0;
214  initEqualRef();
[1029]215
[313]216  m_bCheckLDC = false;
217
[1029]218  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = 0;
219
[313]220  m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
221
222  m_bFinalized=false;
223
[1029]224  m_substreamSizes.clear();
[313]225  m_cabacInitFlag        = false;
226  m_enableTMVPFlag = true;
[815]227#if POC_RESET_IDC_SIGNALLING
228  m_pocResetIdc                   = 0;
229  m_pocResetPeriodId              = 0;
230  m_fullPocResetFlag              = false;
231  m_pocLsbVal                     = 0;
232  m_pocMsbVal                     = 0;
233  m_pocMsbValRequiredFlag         = false;
234  m_pocMsbValPresentFlag          = false;
235#endif
236#if POC_RESET_IDC_DECODER || POC_RESET_IDC_ENCODER
237  m_picOrderCntLsb = 0;
238#endif
[903]239#if P0297_VPS_POC_LSB_ALIGNED_FLAG
240  m_pocMsbValNeeded  = false;
241  m_pocResetDeltaPoc = 0;
242#endif
[313]243}
244
245Bool TComSlice::getRapPicFlag()
246{
247  return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
248      || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
249      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
250      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
251      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
252      || getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
253}
[890]254
[873]255
[1029]256Void  TComSlice::sortPicList        (TComList<TComPic*>& rcListPic)
[313]257{
258  TComPic*    pcPicExtract;
259  TComPic*    pcPicInsert;
[1029]260
[313]261  TComList<TComPic*>::iterator    iterPicExtract;
262  TComList<TComPic*>::iterator    iterPicExtract_1;
263  TComList<TComPic*>::iterator    iterPicInsert;
[1029]264
[313]265  for (Int i = 1; i < (Int)(rcListPic.size()); i++)
266  {
267    iterPicExtract = rcListPic.begin();
268    for (Int j = 0; j < i; j++) iterPicExtract++;
269    pcPicExtract = *(iterPicExtract);
270    pcPicExtract->setCurrSliceIdx(0);
[1029]271
[313]272    iterPicInsert = rcListPic.begin();
273    while (iterPicInsert != iterPicExtract)
274    {
275      pcPicInsert = *(iterPicInsert);
276      pcPicInsert->setCurrSliceIdx(0);
277      if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
278      {
279        break;
280      }
[1029]281
[313]282      iterPicInsert++;
283    }
[1029]284
[313]285    iterPicExtract_1 = iterPicExtract;    iterPicExtract_1++;
[1029]286
[313]287    //  swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
288    rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
289    rcListPic.erase  (iterPicExtract);
290  }
291}
292
[1029]293TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic, Int poc)
[313]294{
[1029]295  TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
[313]296  TComPic*                      pcPic = *(iterPic);
297  while ( iterPic != rcListPic.end() )
298  {
[815]299#if POC_RESET_IDC_ENCODER
300    if( (pcPic->getPOC() == poc) && (pcPic->getSlice(0)->isReferenced()) )
301#else
[313]302    if(pcPic->getPOC() == poc)
[815]303#endif
[313]304    {
305      break;
306    }
307    iterPic++;
[540]308#if SVC_EXTENSION
309    // return NULL, if picture with requested POC is not in the list, otherwise iterator goes outside of the list
310    if( iterPic == rcListPic.end() )
311    {
312      return NULL;
313    }
314#endif
[313]315    pcPic = *(iterPic);
316  }
[1093]317#if POC_RESET_IDC_DECODER
[442]318  assert( pcPic->getSlice(0)->isReferenced() );
319#endif
[313]320  return  pcPic;
321}
322
323
324TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
325{
[1029]326  TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
[313]327  TComPic*                      pcPic = *(iterPic);
328  TComPic*                      pcStPic = pcPic;
[1029]329
[313]330  Int pocCycle = 1 << getSPS()->getBitsForPOC();
331  if (!pocHasMsb)
332  {
[442]333    poc = poc & (pocCycle - 1);
[313]334  }
[1029]335
[313]336  while ( iterPic != rcListPic.end() )
337  {
338    pcPic = *(iterPic);
339    if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
340    {
341      Int picPoc = pcPic->getPOC();
342      if (!pocHasMsb)
343      {
[442]344        picPoc = picPoc & (pocCycle - 1);
[313]345      }
346     
347      if (poc == picPoc)
348      {
[1029]349        if(pcPic->getIsLongTerm())
350        {
351          return pcPic;
352        }
353        else
354        {
355          pcStPic = pcPic;
356        }
357        break;
[313]358      }
359    }
360
361    iterPic++;
362  }
[1029]363
[313]364  return  pcStPic;
365}
366
[1029]367Void TComSlice::setRefPOCList       ()
[313]368{
[1029]369  for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
[313]370  {
371    for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
372    {
373      m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
374    }
375  }
376
377}
378
379Void TComSlice::setList1IdxToList0Idx()
380{
381  Int idxL0, idxL1;
382  for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
383  {
384    m_list1IdxToList0Idx[idxL1] = -1;
385    for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
386    {
387      if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
388      {
389        m_list1IdxToList0Idx[idxL1] = idxL0;
390        break;
391      }
392    }
393  }
394}
395
396#if SVC_EXTENSION
397Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr, TComPic** ilpPic)
398#else
399Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
400#endif
401{
402  if (!checkNumPocTotalCurr)
403  {
404    if (m_eSliceType == I_SLICE)
405    {
406      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
407      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
[1029]408
[313]409      return;
410    }
[1029]411
412    m_aiNumRefIdx[REF_PIC_LIST_0] = getNumRefIdx(REF_PIC_LIST_0);
413    m_aiNumRefIdx[REF_PIC_LIST_1] = getNumRefIdx(REF_PIC_LIST_1);
[313]414  }
415
416  TComPic*  pcRefPic= NULL;
[1029]417  static const UInt MAX_NUM_NEGATIVE_PICTURES=16;
418  TComPic*  RefPicSetStCurr0[MAX_NUM_NEGATIVE_PICTURES];
419  TComPic*  RefPicSetStCurr1[MAX_NUM_NEGATIVE_PICTURES];
420  TComPic*  RefPicSetLtCurr[MAX_NUM_NEGATIVE_PICTURES];
[313]421  UInt NumPocStCurr0 = 0;
422  UInt NumPocStCurr1 = 0;
423  UInt NumPocLtCurr = 0;
424  Int i;
425
[442]426#if SVC_EXTENSION
[313]427  if( m_layerId == 0 || ( m_layerId > 0 && ( m_activeNumILRRefIdx == 0 || !((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ) ) )
428  {
429#endif
430  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
431  {
432    if(m_pcRPS->getUsed(i))
433    {
434      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
435      pcRefPic->setIsLongTerm(0);
436      pcRefPic->getPicYuvRec()->extendPicBorder();
437      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
438      NumPocStCurr0++;
[1029]439      pcRefPic->setCheckLTMSBPresent(false);
[313]440    }
441  }
[1029]442
[313]443  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
444  {
445    if(m_pcRPS->getUsed(i))
446    {
447      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
448      pcRefPic->setIsLongTerm(0);
449      pcRefPic->getPicYuvRec()->extendPicBorder();
450      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
451      NumPocStCurr1++;
[1029]452      pcRefPic->setCheckLTMSBPresent(false);
[313]453    }
454  }
[1029]455
[313]456  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
457  {
458    if(m_pcRPS->getUsed(i))
459    {
460      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
461      pcRefPic->setIsLongTerm(1);
462      pcRefPic->getPicYuvRec()->extendPicBorder();
463      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
464      NumPocLtCurr++;
465    }
[1029]466    if(pcRefPic==NULL)
[313]467    {
468      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
469    }
[1029]470    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
[313]471  }
[442]472#if SVC_EXTENSION
[313]473  }
474#endif
475
476  // ref_pic_list_init
477  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
478  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
[442]479#if SVC_EXTENSION
[313]480  Int numInterLayerRPSPics = 0;
481  if( m_layerId > 0 && m_activeNumILRRefIdx > 0 )
482  {
483    for( i=0; i < m_pcVPS->getNumDirectRefLayers( m_layerId ); i++ )
484    {
[1085]485      Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[i]->getSlice(0)->getLayerIdx(), getLayerIdx());
486
[442]487      if( ((Int)(ilpPic[i]->getSlice(0)->getTLayer())<= maxTidIlRefPicsPlus1-1) || (maxTidIlRefPicsPlus1==0 && ilpPic[i]->getSlice(0)->getRapPicFlag() ) )
[313]488      {
489        numInterLayerRPSPics++;
[588]490#if DISCARDABLE_PIC_RPS
491        assert( ilpPic[i]->getSlice(0)->getDiscardableFlag() == 0 );    // Inter-layer RPS shall not contain picture with discardable_flag = 1.
492#endif
[313]493      }
494    }
495    if (numInterLayerRPSPics < m_activeNumILRRefIdx)
496    {
497      m_activeNumILRRefIdx = numInterLayerRPSPics;
498    }
[442]499#if MAX_ONE_RESAMPLING_DIRECT_LAYERS
[815]500    if( m_pcVPS->getScalabilityMask( SCALABILITY_ID ) )
[313]501    {
502      Int numResampler = 0;
[442]503#if MOTION_RESAMPLING_CONSTRAINT
504      Int numMotionResamplers = 0;
505      Int refResamplingLayer[MAX_LAYERS];
506      memset( refResamplingLayer, 0, sizeof( refResamplingLayer ) );
507#endif
[313]508
509      for( i=0; i < m_activeNumILRRefIdx; i++ )
510      {
511        UInt refLayerIdc = m_interLayerPredLayerIdc[i];
[713]512        UInt refLayerId = m_pcVPS->getRefLayerId( m_layerId, refLayerIdc );
[1122]513
[849]514        const Window &scalEL = getPPS()->getScaledRefLayerWindowForLayer(refLayerId);
[1147]515
[540]516        Int scalingOffset = ((scalEL.getWindowLeftOffset()   == 0 ) && 
517                             (scalEL.getWindowRightOffset()  == 0 ) && 
518                             (scalEL.getWindowTopOffset()    == 0 ) && 
519                             (scalEL.getWindowBottomOffset() == 0 ) 
520                            );
[1122]521
[713]522#if O0194_DIFFERENT_BITDEPTH_EL_BL
[1029]523        Bool sameBitDepths = ( g_bitDepthLayer[CHANNEL_TYPE_LUMA][m_layerId] == g_bitDepthLayer[CHANNEL_TYPE_LUMA][refLayerId] ) && ( g_bitDepthLayer[CHANNEL_TYPE_CHROMA][m_layerId] == g_bitDepthLayer[CHANNEL_TYPE_CHROMA][refLayerId] );
[713]524
[815]525        if( !( g_posScalingFactor[refLayerIdc][0] == 65536 && g_posScalingFactor[refLayerIdc][1] == 65536 ) || !scalingOffset || !sameBitDepths
[713]526#if Q0048_CGS_3D_ASYMLUT
527          || getPPS()->getCGSFlag()
528#endif
529          ) // ratio 1x
530#else
[442]531        if(!( g_posScalingFactor[refLayerIdc][0] == 65536 && g_posScalingFactor[refLayerIdc][1] == 65536 ) || (!scalingOffset)) // ratio 1x
[713]532#endif
[313]533        {
[442]534#if MOTION_RESAMPLING_CONSTRAINT
[713]535          UInt predType = m_pcVPS->getDirectDependencyType( m_layerId, refLayerId ) + 1;
[442]536
537          if( predType & 0x1 )
538          {
539            numResampler++;
540            refResamplingLayer[i] = refLayerIdc + 1;
541          }
542
543          if( predType & 0x2 )
544          {
545            numMotionResamplers++;
546            refResamplingLayer[i] -= refLayerIdc + 1;
547          }
548#else
[313]549          numResampler++;
[442]550#endif
[313]551        }
552      }
[442]553     
554      // When both picture sample values and picture motion field resampling processes are invoked for decoding of a particular picture, they shall be applied to the same reference layer picture.
555      if( m_activeNumILRRefIdx > 1 && numResampler > 0 )
556      {
557        for( i=0; i < m_activeNumILRRefIdx; i++ )
558        {
559          assert( refResamplingLayer[i] >= 0 && "Motion and sample inter-layer prediction shall be from the same layer" );
560        }
561      }
[313]562
[442]563      // Bitstream constraint for SHVC: The picture resampling process as specified in subclause G.8.1.4.1 shall not be invoked more than once for decoding of each particular picture.
[313]564      assert(numResampler <= 1);
[442]565#if MOTION_RESAMPLING_CONSTRAINT
566      assert( numMotionResamplers <= 1  && "Up to 1 motion resampling is allowed" );
567#endif
[313]568    }
569#endif
570  }
571  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_activeNumILRRefIdx;
[494]572#else //SVC_EXTENSION
[313]573  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
[494]574#endif //SVC_EXTENSION
[540]575
[313]576  if (checkNumPocTotalCurr)
577  {
578    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
[588]579#if SVC_EXTENSION    // inter-layer prediction is allowed for BLA, CRA pictures of nuh_layer_id>0
[713]580    // - If the current picture is a BLA or CRA picture with nuh_layer_id equal to 0, the value of NumPocTotalCurr shall be equal to 0.
581    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
[313]582    if (getRapPicFlag() && getLayerId()==0)
583#else
[713]584    // - If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
585    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
[313]586    if (getRapPicFlag())
587#endif
588    {
589      assert(numPocTotalCurr == 0);
590    }
591
592    if (m_eSliceType == I_SLICE)
[588]593    {
[313]594      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
595      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
[588]596
[313]597      return;
598    }
[588]599
[313]600    assert(numPocTotalCurr > 0);
[588]601
[313]602    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
603    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
604  }
605
[1029]606  Int cIdx = 0;
607  for ( i=0; i<NumPocStCurr0; i++, cIdx++)
608  {
609    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
610  }
611
[442]612#if SVC_EXTENSION
[345]613#if RPL_INIT_N0316_N0082
614    if( m_layerId > 0 )
[494]615    {     
[345]616      for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)     
617      {
618        Int refLayerIdc = m_interLayerPredLayerIdc[i];
[1085]619        Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx());
[442]620        if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) || (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
[494]621        {
[345]622          rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
[494]623        }
[345]624      }
625    }
626#endif
[494]627#endif //SVC_EXTENSION
[313]628    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
629    {
630      rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
631    }
632    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
633    {
634      rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
[1029]635    } 
[345]636#if !RPL_INIT_N0316_N0082
[442]637#if SVC_EXTENSION
[313]638    if( m_layerId > 0 )
639    {
640      for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)     
641      {
642        Int refLayerIdc = m_interLayerPredLayerIdc[i];
[1085]643        Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx());
[442]644        if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) || (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
[494]645        {
646          rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
647        }
[313]648      }
649    }
650#endif
[345]651#endif
[313]652  assert(cIdx == numPocTotalCurr);
653
654  if (m_eSliceType==B_SLICE)
655  {
656    cIdx = 0;
657    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
658    {
659      rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
660    }
661    for ( i=0; i<NumPocStCurr0; i++, cIdx++)
662    {
663      rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
664    }
665    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
666    {
667      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
668    }   
669
[442]670#if SVC_EXTENSION
[313]671    if( m_layerId > 0 )
672    {
673      for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
674      {
675        Int refLayerIdc = m_interLayerPredLayerIdc[i];
[1085]676        Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1( ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx() );
[442]677        if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) || (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
[494]678        {
679          rpsCurrList1[cIdx] = ilpPic[refLayerIdc];
680        }
[313]681      }
682    }
[494]683#endif //SVC_EXTENSION
[313]684
685    assert(cIdx == numPocTotalCurr);
686  }
687
688  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
689
[1029]690  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_0]; rIdx ++)
[313]691  {
692    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
693    assert(cIdx >= 0 && cIdx < numPocTotalCurr);
[1029]694    m_apcRefPicList[REF_PIC_LIST_0][rIdx] = rpsCurrList0[ cIdx ];
[349]695#if RPL_INIT_N0316_N0082
[442]696    m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 && cIdx < NumPocStCurr0 + m_activeNumILRRefIdx ) || ( cIdx >= NumPocStCurr0 + NumPocStCurr1 + m_activeNumILRRefIdx );
[349]697#else
[1029]698    m_bIsUsedAsLongTerm[REF_PIC_LIST_0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
[349]699#endif
[313]700  }
701  if ( m_eSliceType != B_SLICE )
702  {
[1029]703    m_aiNumRefIdx[REF_PIC_LIST_1] = 0;
704    ::memset( m_apcRefPicList[REF_PIC_LIST_1], 0, sizeof(m_apcRefPicList[REF_PIC_LIST_1]));
[313]705  }
706  else
707  {
[1029]708    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_1]; rIdx ++)
[313]709    {
710      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
711      assert(cIdx >= 0 && cIdx < numPocTotalCurr);
[1029]712      m_apcRefPicList[REF_PIC_LIST_1][rIdx] = rpsCurrList1[ cIdx ];
713      m_bIsUsedAsLongTerm[REF_PIC_LIST_1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
[313]714    }
715  }
716}
717
718Int TComSlice::getNumRpsCurrTempList()
719{
720  Int numRpsCurrTempList = 0;
721
[442]722#if SVC_EXTENSION
[644]723  if( m_eSliceType == I_SLICE || ( m_layerId && 
[313]724    (m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
725    (m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) ) )
726#else
[1029]727  if (m_eSliceType == I_SLICE)
[313]728#endif
729  {
[442]730#if SVC_EXTENSION
[313]731    return m_activeNumILRRefIdx;
732#else
733    return 0;
734#endif
735  }
736  for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
737  {
738    if(m_pcRPS->getUsed(i))
739    {
740      numRpsCurrTempList++;
741    }
742  }
[442]743#if SVC_EXTENSION
[313]744  if( m_layerId > 0 )
745  {
746    numRpsCurrTempList += m_activeNumILRRefIdx;
[644]747  }
[313]748#endif
749
750  return numRpsCurrTempList;
751}
752
753Void TComSlice::initEqualRef()
754{
[1029]755  for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
[313]756  {
757    for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
758    {
759      for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
760      {
761        m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
762      }
763    }
764  }
765}
766
767Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
768{
769  Int i;
770  TComSlice* curSlice = pic->getSlice(curSliceIdx);
[1029]771  Int currColRefPOC =  curSlice->getRefPOC( RefPicList(1 - curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
[313]772  TComSlice* preSlice;
773  Int preColRefPOC;
774  for(i=curSliceIdx-1; i>=0; i--)
775  {
776    preSlice = pic->getSlice(i);
777    if(preSlice->getSliceType() != I_SLICE)
778    {
[1029]779      preColRefPOC  = preSlice->getRefPOC( RefPicList(1 - preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
[313]780      if(currColRefPOC != preColRefPOC)
781      {
782        printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
783        exit(EXIT_FAILURE);
784      }
785      else
786      {
787        break;
788      }
789    }
790  }
791}
792
[442]793Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic)
[313]794{
795  for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
796  {
797    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
798    {
799      assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
800    }
801  }
802  for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
803  {
804    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
805    {
806      if (!pReferencePictureSet->getCheckLTMSBPresent(i))
807      {
808        assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
809      }
810      else
811      {
[1029]812        assert(pReferencePictureSet->getPOC(i) >= pocCRA);
813      }
[313]814    }
815  }
816  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
817  {
818    pocCRA = getPOC();
[442]819    associatedIRAPType = getNalUnitType();
[313]820  }
821  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
822  {
823    pocCRA = getPOC();
[442]824    associatedIRAPType = getNalUnitType();
[313]825  }
826  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
827         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
828         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
829  {
830    pocCRA = getPOC();
[442]831    associatedIRAPType = getNalUnitType();
[313]832  }
833}
834
835/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
836 * \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
837 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
838 * \param rcListPic reference to the reference picture list
839 * This function marks the reference pictures as "unused for reference" in the following conditions.
[1029]840 * If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
[313]841 * are marked as "unused for reference"
842 *    If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
843 * Otherwise
[1029]844 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
845 *    temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
846 *    mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
[313]847 *    the bRefreshPending flag to false.
[1029]848 *    If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
[313]849 *    reference of the current picture.
850 * Note that the current picture is already placed in the reference list and its marking is not changed.
851 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
852 */
[540]853#if NO_CLRAS_OUTPUT_FLAG
[1005]854Void TComSlice::decodingRefreshMarking( TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag, UInt smallestLayerId )
[713]855{
856  if( !isIRAP() )
857  {
858    return;
859  }
860
861  Int pocCurr = getPOC();
862  TComPic* rpcPic = NULL;
863
[1029]864  // When the current picture is an IRAP picture with nuh_layer_id equal to 0 and NoClrasOutputFlag is equal to 1,
[713]865  // all reference pictures with any value of nuh_layer_id currently in the DPB (if any) are marked as "unused for reference".
[1005]866  if (m_layerId == smallestLayerId && noClrasOutputFlag)
[713]867  {
868    // mark all pictures for all layers as not used for reference
869    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
870    while( iterPic != rcListPic.end() )
871    {
872      rpcPic = *(iterPic);
873      if( rpcPic->getPOC() != pocCurr )
874      {
875        rpcPic->getSlice(0)->setReferenced(false);
876      }
877      iterPic++;
878    }
879  }
880
881  // When the current picture is an IRAP picture with NoRaslOutputFlag equal to 1,
882  // all reference pictures with nuh_layer_id equal to currPicLayerId currently in the DPB (if any) are marked as "unused for reference".
883  if( m_noRaslOutputFlag )
884  {
885    // mark all pictures of a current layer as not used for reference
886    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
887    while( iterPic != rcListPic.end() )
888    {
889      rpcPic = *(iterPic);
890      if( rpcPic->getPOC() != pocCurr && rpcPic->getLayerId() == m_layerId )
891      {
892        rpcPic->getSlice(0)->setReferenced(false);
893      }
894      iterPic++;
895    }
896  }
897}
898
[540]899Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag)
900#else
[313]901Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
[540]902#endif
[313]903{
[1029]904  TComPic* rpcPic;
905  Int      pocCurr = getPOC();
[313]906
907  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
908    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
909    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
910    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
911    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )  // IDR or BLA picture
912  {
913    // mark all pictures as not used for reference
914    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
915    while (iterPic != rcListPic.end())
916    {
917      rpcPic = *(iterPic);
918      rpcPic->setCurrSliceIdx(0);
[540]919#if NO_CLRAS_OUTPUT_FLAG
[815]920#if POC_RESET_IDC_ENCODER
[540]921      if (noClrasOutputFlag)
922      {
[815]923        rpcPic->getSlice(0)->setReferenced(false);  // all layers // TODO. This does not mark all layers
924      }
925      else
926      {
927        if (rpcPic->getLayerId() == m_layerId) rpcPic->getSlice(0)->setReferenced(false);  // only current layer
928      }
929#else
930      if (noClrasOutputFlag)
931      {
[540]932        if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);  // all layers
933      }
934      else
935      {
936        if (rpcPic->getPOC() != pocCurr && rpcPic->getLayerId() == m_layerId) rpcPic->getSlice(0)->setReferenced(false);  // only current layer
937      }
[815]938#endif
[540]939#else
[313]940      if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
[540]941#endif
[313]942      iterPic++;
943    }
[815]944#if POC_RESET_IDC_ENCODER
945    this->getPic()->getSlice(0)->setReferenced(true);   // Mark the current picture back as refererced.
946#endif
[313]947    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
948      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
949      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
950    {
951      pocCRA = pocCurr;
952    }
[713]953#if EFFICIENT_FIELD_IRAP
954    bRefreshPending = true;
955#endif
[313]956  }
957  else // CRA or No DR
958  {
[713]959#if EFFICIENT_FIELD_IRAP
960    if(getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
961    {
962      if (bRefreshPending==true && pocCurr > m_iLastIDR) // IDR reference marking pending
963      {
964        TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
965        while (iterPic != rcListPic.end())
966        {
967          rpcPic = *(iterPic);
968          if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != m_iLastIDR)
969          {
970            rpcPic->getSlice(0)->setReferenced(false);
971          }
972          iterPic++;
973        }
974        bRefreshPending = false; 
975      }
976    }
977    else
978    {
979#endif
[1029]980      if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
[313]981      {
[1029]982        TComList<TComPic*>::iterator iterPic = rcListPic.begin();
983        while (iterPic != rcListPic.end())
[313]984        {
[1029]985          rpcPic = *(iterPic);
986          if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
987          {
988            rpcPic->getSlice(0)->setReferenced(false);
989          }
990          iterPic++;
[313]991        }
[1029]992        bRefreshPending = false;
[313]993      }
[713]994#if EFFICIENT_FIELD_IRAP
995    }
996#endif
[313]997    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
998    {
[1029]999      bRefreshPending = true;
[313]1000      pocCRA = pocCurr;
1001    }
1002  }
1003}
1004
1005Void TComSlice::copySliceInfo(TComSlice *pSrc)
1006{
1007  assert( pSrc != NULL );
1008
1009  Int i, j, k;
1010
1011  m_iPOC                 = pSrc->m_iPOC;
1012  m_eNalUnitType         = pSrc->m_eNalUnitType;
1013  m_eSliceType           = pSrc->m_eSliceType;
1014  m_iSliceQp             = pSrc->m_iSliceQp;
1015#if ADAPTIVE_QP_SELECTION
1016  m_iSliceQpBase         = pSrc->m_iSliceQpBase;
1017#endif
[1029]1018  m_ChromaQpAdjEnabled = pSrc->m_ChromaQpAdjEnabled;
[313]1019  m_deblockingFilterDisable   = pSrc->m_deblockingFilterDisable;
1020  m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
1021  m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
1022  m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
[1029]1023
1024  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
[313]1025  {
1026    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
1027  }
1028
1029  for (i = 0; i < MAX_NUM_REF; i++)
1030  {
1031    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
[1029]1032  }
1033
[313]1034  m_bCheckLDC             = pSrc->m_bCheckLDC;
1035  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
[1029]1036  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = pSrc->m_iSliceChromaQpDelta[component];
1037  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
[313]1038  {
1039    for (j = 0; j < MAX_NUM_REF; j++)
1040    {
1041      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
1042      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
1043      m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
1044    }
[1029]1045    m_bIsUsedAsLongTerm[i][MAX_NUM_REF] = pSrc->m_bIsUsedAsLongTerm[i][MAX_NUM_REF];
[313]1046  }
1047  m_iDepth               = pSrc->m_iDepth;
1048
1049  // referenced slice
1050  m_bRefenced            = pSrc->m_bRefenced;
1051
1052  // access channel
1053#if SVC_EXTENSION
1054  m_pcVPS                = pSrc->m_pcVPS;
[494]1055  m_layerId              = pSrc->m_layerId;
[313]1056  m_activeNumILRRefIdx         = pSrc->m_activeNumILRRefIdx;
1057  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag;
1058  memcpy( m_interLayerPredLayerIdc, pSrc->m_interLayerPredLayerIdc, sizeof( m_interLayerPredLayerIdc ) );
1059#endif
1060  m_pcSPS                = pSrc->m_pcSPS;
1061  m_pcPPS                = pSrc->m_pcPPS;
1062  m_pcRPS                = pSrc->m_pcRPS;
1063  m_iLastIDR             = pSrc->m_iLastIDR;
1064
1065  m_pcPic                = pSrc->m_pcPic;
1066
1067  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
1068  m_colRefIdx            = pSrc->m_colRefIdx;
[1029]1069
[540]1070  setLambdas(pSrc->getLambdas());
[1029]1071
1072  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
[313]1073  {
1074    for (j = 0; j < MAX_NUM_REF; j++)
1075    {
1076      for (k =0; k < MAX_NUM_REF; k++)
1077      {
1078        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1079      }
1080    }
1081  }
1082
1083  m_uiTLayer                      = pSrc->m_uiTLayer;
1084  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
1085
[1029]1086  m_sliceMode                     = pSrc->m_sliceMode;
1087  m_sliceArgument                 = pSrc->m_sliceArgument;
1088  m_sliceCurStartCtuTsAddr        = pSrc->m_sliceCurStartCtuTsAddr;
1089  m_sliceCurEndCtuTsAddr          = pSrc->m_sliceCurEndCtuTsAddr;
1090  m_sliceIdx                      = pSrc->m_sliceIdx;
1091  m_sliceSegmentMode              = pSrc->m_sliceSegmentMode;
1092  m_sliceSegmentArgument          = pSrc->m_sliceSegmentArgument;
1093  m_sliceSegmentCurStartCtuTsAddr = pSrc->m_sliceSegmentCurStartCtuTsAddr;
1094  m_sliceSegmentCurEndCtuTsAddr   = pSrc->m_sliceSegmentCurEndCtuTsAddr;
1095  m_nextSlice                     = pSrc->m_nextSlice;
1096  m_nextSliceSegment              = pSrc->m_nextSliceSegment;
1097
1098  for ( UInt e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
[313]1099  {
[1029]1100    for ( UInt n=0 ; n<MAX_NUM_REF ; n++ )
[313]1101    {
[1029]1102      memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(WPScalingParam)*MAX_NUM_COMPONENT );
[313]1103    }
1104  }
[1029]1105
1106  for( UInt ch = 0 ; ch < MAX_NUM_CHANNEL_TYPE; ch++)
1107  {
1108    m_saoEnabledFlag[ch] = pSrc->m_saoEnabledFlag[ch];
1109  }
1110
[313]1111  m_cabacInitFlag                = pSrc->m_cabacInitFlag;
1112
1113  m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1114  m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1115  m_enableTMVPFlag                = pSrc->m_enableTMVPFlag;
1116  m_maxNumMergeCand               = pSrc->m_maxNumMergeCand;
1117}
1118
[1029]1119
[442]1120Int TComSlice::m_prevTid0POC = 0;
[313]1121
1122/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1123 * \param uiTLayer Temporal layer ID of the current slice
[1029]1124 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1125 * the SPS's temporal_id_nesting_flag and the parsed PPS.  Then, current slice's temporal layer ID and
[313]1126 * temporal_layer_switching_point_flag is set accordingly.
1127 */
1128Void TComSlice::setTLayerInfo( UInt uiTLayer )
1129{
1130  m_uiTLayer = uiTLayer;
1131}
1132
1133/** Function for checking if this is a switching-point
1134*/
[1029]1135Bool TComSlice::isTemporalLayerSwitchingPoint(TComList<TComPic*>& rcListPic)
[313]1136{
1137  TComPic* rpcPic;
1138  // loop through all pictures in the reference picture buffer
1139  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1140  while ( iterPic != rcListPic.end())
1141  {
1142    rpcPic = *(iterPic++);
1143    if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1144    {
1145      if(rpcPic->getTLayer() >= getTLayer())
1146      {
1147        return false;
1148      }
1149    }
1150  }
1151  return true;
1152}
1153
[1029]1154/** Function for checking if this is a STSA candidate
[313]1155 */
[1029]1156Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate(TComList<TComPic*>& rcListPic)
[313]1157{
[1029]1158  TComPic* rpcPic;
1159
1160  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1161  while ( iterPic != rcListPic.end())
1162  {
1163    rpcPic = *(iterPic++);
1164    if(rpcPic->getSlice(0)->isReferenced() &&  (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
[313]1165    {
[1029]1166      if(rpcPic->getTLayer() >= getTLayer())
1167      {
1168        return false;
1169      }
[313]1170    }
[1029]1171  }
1172  return true;
[313]1173}
1174
[815]1175#if POC_RESET_IDC_ENCODER
1176Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic, Bool usePocBeforeReset)
1177#else
[442]1178Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
[815]1179#endif
[442]1180{
1181  TComPic* rpcPic;
1182
1183  Int nalUnitType = this->getNalUnitType();
1184
1185  // When a picture is a leading picture, it shall be a RADL or RASL picture.
1186  if(this->getAssociatedIRAPPOC() > this->getPOC())
1187  {
1188    // Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1189    if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP ||
1190       nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1191    {
1192      assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1193             nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1194             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1195             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1196    }
1197  }
1198
1199  // When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1200  if(this->getAssociatedIRAPPOC() < this->getPOC())
1201  {
1202    assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1203           nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1204           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1205           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1206  }
1207
1208  // No RASL pictures shall be present in the bitstream that are associated
1209  // with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1210  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1211     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1212  {
1213    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1214           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1215  }
1216
1217  // No RASL pictures shall be present in the bitstream that are associated with
1218  // an IDR picture.
1219  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1220     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1221  {
1222    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP   &&
1223           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1224  }
1225
1226  // No RADL pictures shall be present in the bitstream that are associated with
1227  // a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1228  // with an IDR picture having nal_unit_type equal to IDR_N_LP.
1229  if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1230     nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1231  {
1232    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP   &&
1233           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1234  }
1235
1236  // loop through all pictures in the reference picture buffer
1237  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1238  while ( iterPic != rcListPic.end())
1239  {
1240    rpcPic = *(iterPic++);
[595]1241#if BUGFIX_INTRAPERIOD
1242    if(!rpcPic->getReconMark())
1243    {
1244      continue;
1245    }
1246#endif
[442]1247    if (rpcPic->getPOC() == this->getPOC())
1248    {
1249      continue;
1250    }
1251
1252    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1253    // in decoding order shall precede the IRAP picture in output order.
1254    // (Note that any picture following in output order would be present in the DPB)
[713]1255    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1 && !this->getNoOutputPriorPicsFlag())
[442]1256    {
1257      if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP    ||
1258         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP    ||
1259         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL  ||
1260         nalUnitType == NAL_UNIT_CODED_SLICE_CRA         ||
1261         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP    ||
1262         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1263      {
[815]1264#if POC_RESET_IDC_ENCODER
1265        if( usePocBeforeReset )
1266        {
1267          assert(rpcPic->getSlice(0)->getPocValueBeforeReset() < this->getPocValueBeforeReset());
1268        }
1269        else
1270        {
1271          assert(rpcPic->getPOC() < this->getPOC());
1272        }
1273#else
[442]1274        assert(rpcPic->getPOC() < this->getPOC());
[815]1275#endif
[442]1276      }
1277    }
1278
1279    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1280    // in decoding order shall precede any RADL picture associated with the IRAP
1281    // picture in output order.
1282    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1283    {
1284      if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1285          nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1286      {
1287        // rpcPic precedes the IRAP in decoding order
1288        if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1289        {
1290          // rpcPic must not be the IRAP picture
1291          if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1292          {
[815]1293#if POC_RESET_IDC_ENCODER
1294            if( usePocBeforeReset )
1295            {
1296              assert(rpcPic->getSlice(0)->getPocValueBeforeReset() < this->getPocValueBeforeReset());
1297            }
1298            else
1299            {
1300              assert(rpcPic->getPOC() < this->getPOC());
1301            }
1302#else
[442]1303            assert(rpcPic->getPOC() < this->getPOC());
[815]1304#endif
[442]1305          }
1306        }
1307      }
1308    }
1309
1310    // When a picture is a leading picture, it shall precede, in decoding order,
1311    // all trailing pictures that are associated with the same IRAP picture.
[1029]1312      if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1313         nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1314         nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1315         nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
[442]1316      {
[1029]1317        if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1318        {
1319          // rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1320          // rpcPic would violate the constraint if it was a trailing picture
[815]1321#if POC_RESET_IDC_ENCODER
[1029]1322          if( usePocBeforeReset )
1323          {
1324            assert(rpcPic->getPOC() <= this->getAssociatedIrapPocBeforeReset());
1325          }
1326          else
1327          {
1328            assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1329          }
1330#else
[815]1331          assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
[1029]1332#endif
[815]1333        }
[442]1334      }
1335
1336    // Any RASL picture associated with a CRA or BLA picture shall precede any
1337    // RADL picture associated with the CRA or BLA picture in output order
1338    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1339       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
[1029]1340    {
[442]1341      if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1342          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1343          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1344          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)       &&
1345          this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1346      {
1347        if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
1348           rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1349        {
1350          assert(rpcPic->getPOC() > this->getPOC());
1351        }
1352      }
1353    }
1354
1355    // Any RASL picture associated with a CRA picture shall follow, in output
1356    // order, any IRAP picture that precedes the CRA picture in decoding order.
1357    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1358       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1359    {
1360      if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1361      {
1362        if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1363           (rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1364            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1365            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1366            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP   ||
1367            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
1368            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1369        {
1370          assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1371        }
1372      }
1373    }
1374  }
1375}
1376
[595]1377
1378
[313]1379/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1380*/
1381Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1382{
1383  TComPic* rpcPic;
1384  Int i, isReference;
1385
[644]1386#if !ALIGNED_BUMPING
[442]1387  checkLeadingPictureRestrictions(rcListPic);
[644]1388#endif
[442]1389
[313]1390  // loop through all pictures in the reference picture buffer
1391  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1392  while ( iterPic != rcListPic.end())
1393  {
1394    rpcPic = *(iterPic++);
1395
1396    if(!rpcPic->getSlice( 0 )->isReferenced())
1397    {
1398      continue;
1399    }
1400
1401    isReference = 0;
1402    // loop through all pictures in the Reference Picture Set
1403    // to see if the picture should be kept as reference picture
1404    for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1405    {
1406      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1407      {
1408        isReference = 1;
1409        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1410        rpcPic->setIsLongTerm(0);
1411      }
1412    }
1413    for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1414    {
1415      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1416      {
1417        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1418        {
1419          isReference = 1;
1420          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1421        }
1422      }
1423      else 
1424      {
[442]1425        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1426        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1427        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1428        if(rpcPic->getIsLongTerm() && curPoc == refPoc)
[313]1429        {
1430          isReference = 1;
1431          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1432        }
1433      }
1434
1435    }
[588]1436#if DISCARDABLE_PIC_RPS
1437    if( isReference ) // Current picture is in the temporal RPS
1438    {
1439      assert( rpcPic->getSlice(0)->getDiscardableFlag() == 0 ); // Temporal RPS shall not contain picture with discardable_flag equal to 1
1440    }
1441#endif
[313]1442    // mark the picture as "unused for reference" if it is not in
1443    // the Reference Picture Set
[1029]1444    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
1445    {
1446      rpcPic->getSlice( 0 )->setReferenced( false );
[313]1447      rpcPic->setUsedByCurr(0);
1448      rpcPic->setIsLongTerm(0);
1449    }
1450    //check that pictures of higher temporal layers are not used
1451    assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
1452    //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
[540]1453    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
[313]1454    {
1455      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
1456    }
1457    //check that pictures marked as temporal layer non-reference pictures are not used for reference
1458    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1459    {
1460      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1461    }
1462  }
1463}
1464
1465/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1466*/
[713]1467#if ALLOW_RECOVERY_POINT_AS_RAP
1468Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess, Bool bUseRecoveryPoint)
1469#else
[313]1470Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
[713]1471#endif
[313]1472{
[713]1473#if ALLOW_RECOVERY_POINT_AS_RAP
1474  Int atLeastOneUnabledByRecoveryPoint = 0;
1475  Int atLeastOneFlushedByPreviousIDR = 0;
1476#endif
[313]1477  TComPic* rpcPic;
1478  Int i, isAvailable;
1479  Int atLeastOneLost = 0;
1480  Int atLeastOneRemoved = 0;
1481  Int iPocLost = 0;
1482
1483  // loop through all long-term pictures in the Reference Picture Set
1484  // to see if the picture should be kept as reference picture
1485  for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1486  {
1487    isAvailable = 0;
1488    // loop through all pictures in the reference picture buffer
1489    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1490    while ( iterPic != rcListPic.end())
1491    {
1492      rpcPic = *(iterPic++);
1493      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1494      {
1495        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1496        {
[713]1497#if ALLOW_RECOVERY_POINT_AS_RAP
1498          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1499          {
1500            isAvailable = 0;
1501          }
1502          else
1503          {
[1029]1504            isAvailable = 1;
1505          }
[713]1506#else
1507          isAvailable = 1;
1508#endif
1509        }
[313]1510      }
[1029]1511      else
[313]1512      {
[442]1513        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1514        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1515        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1516        if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
[313]1517        {
[713]1518#if ALLOW_RECOVERY_POINT_AS_RAP
1519          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1520          {
1521            isAvailable = 0;
1522          }
1523          else
1524          {
[1029]1525            isAvailable = 1;
1526          }
[713]1527#else
1528          isAvailable = 1;
1529#endif
1530        }
[313]1531      }
1532    }
1533    // if there was no such long-term check the short terms
1534    if(!isAvailable)
1535    {
1536      iterPic = rcListPic.begin();
1537      while ( iterPic != rcListPic.end())
1538      {
1539        rpcPic = *(iterPic++);
1540
1541        Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1542        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1543        Int refPoc = pReferencePictureSet->getPOC(i);
1544        if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1545        {
[442]1546          curPoc = curPoc & (pocCycle - 1);
1547          refPoc = refPoc & (pocCycle - 1);
[313]1548        }
[1029]1549
[313]1550        if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1551        {
[713]1552#if ALLOW_RECOVERY_POINT_AS_RAP
1553          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1554          {
1555            isAvailable = 0;
1556          }
1557          else
1558          {
[1029]1559            isAvailable = 1;
1560            rpcPic->setIsLongTerm(1);
1561            break;
1562          }
[713]1563#else
1564          isAvailable = 1;
1565          rpcPic->setIsLongTerm(1);
1566          break;
1567#endif
1568        }
[313]1569      }
1570    }
1571    // report that a picture is lost if it is in the Reference Picture Set
1572    // but not available as reference picture
[1029]1573    if(isAvailable == 0)
1574    {
[313]1575      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1576      {
1577        if(!pReferencePictureSet->getUsed(i) )
1578        {
1579          if(printErrors)
1580          {
1581            printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1582          }
1583          atLeastOneRemoved = 1;
1584        }
1585        else
1586        {
1587          if(printErrors)
1588          {
1589            printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1590          }
1591          atLeastOneLost = 1;
1592          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1593        }
1594      }
[713]1595#if ALLOW_RECOVERY_POINT_AS_RAP
1596      else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1597      {
1598        atLeastOneUnabledByRecoveryPoint = 1;
1599      }
1600      else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1601      {
1602        atLeastOneFlushedByPreviousIDR = 1;
1603      }
1604#endif
[313]1605    }
[1029]1606  }
[313]1607  // loop through all short-term pictures in the Reference Picture Set
1608  // to see if the picture should be kept as reference picture
1609  for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1610  {
1611    isAvailable = 0;
1612    // loop through all pictures in the reference picture buffer
1613    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1614    while ( iterPic != rcListPic.end())
1615    {
1616      rpcPic = *(iterPic++);
1617
1618      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1619      {
[713]1620#if ALLOW_RECOVERY_POINT_AS_RAP
1621        if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1622        {
1623          isAvailable = 0;
1624        }
1625        else
1626        {
[1029]1627          isAvailable = 1;
1628        }
[713]1629#else
1630        isAvailable = 1;
1631#endif
1632      }
[313]1633    }
1634    // report that a picture is lost if it is in the Reference Picture Set
1635    // but not available as reference picture
[1029]1636    if(isAvailable == 0)
1637    {
[815]1638#if !UNAVAILABLE_PIC_BUGFIX
[313]1639      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
[815]1640#endif
[313]1641      {
1642        if(!pReferencePictureSet->getUsed(i) )
1643        {
1644          if(printErrors)
1645          {
1646            printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1647          }
1648          atLeastOneRemoved = 1;
1649        }
1650        else
1651        {
1652          if(printErrors)
1653          {
1654            printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1655          }
1656          atLeastOneLost = 1;
1657          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1658        }
1659      }
[713]1660#if ALLOW_RECOVERY_POINT_AS_RAP
[815]1661#if UNAVAILABLE_PIC_BUGFIX
1662      if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1663#else
[713]1664      else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
[815]1665#endif
[713]1666      {
1667        atLeastOneUnabledByRecoveryPoint = 1;
1668      }
1669      else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1670      {
1671        atLeastOneFlushedByPreviousIDR = 1;
1672      }
1673#endif
[313]1674    }
[1029]1675  }
1676
[713]1677#if ALLOW_RECOVERY_POINT_AS_RAP
1678  if(atLeastOneUnabledByRecoveryPoint || atLeastOneFlushedByPreviousIDR)
1679  {
1680    return -1;
[313]1681  }   
[713]1682#endif
[313]1683  if(atLeastOneLost)
1684  {
1685    return iPocLost+1;
1686  }
1687  if(atLeastOneRemoved)
1688  {
1689    return -2;
1690  }
1691  else
1692  {
1693    return 0;
1694  }
1695}
1696
1697/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1698*/
[713]1699#if ALLOW_RECOVERY_POINT_AS_RAP
1700Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP, Int pocRandomAccess, Bool bUseRecoveryPoint)
1701#else
[313]1702Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
[713]1703#endif
[313]1704{
1705  TComPic* rpcPic;
1706  Int i, j;
1707  Int k = 0;
1708  Int nrOfNegativePictures = 0;
1709  Int nrOfPositivePictures = 0;
1710  TComReferencePictureSet* pcRPS = this->getLocalRPS();
[1029]1711#if EFFICIENT_FIELD_IRAP
1712  Bool irapIsInRPS = false;
1713#endif
[903]1714#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1715  Bool pocsAdjusted = false;
1716#endif
[313]1717
1718  // loop through all pictures in the Reference Picture Set
1719  for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1720  {
1721    j = 0;
1722    // loop through all pictures in the reference picture buffer
1723    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1724    while ( iterPic != rcListPic.end())
1725    {
1726      j++;
1727      rpcPic = *(iterPic++);
1728
[903]1729#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1730      // poc adjustement by poc reset needs to be taken into account here
1731      Int deltaPOC = pReferencePictureSet->getDeltaPOC(i) - rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc();
1732      if (rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc() != 0)
1733      {
1734        pocsAdjusted = true;
1735      }
1736
1737      if (rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + deltaPOC && rpcPic->getSlice(0)->isReferenced())
1738#else
[313]1739      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
[903]1740#endif
[313]1741      {
1742        // This picture exists as a reference picture
1743        // and should be added to the explicit Reference Picture Set
[903]1744#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1745        pcRPS->setDeltaPOC(k, deltaPOC);
1746#else
[313]1747        pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
[903]1748#endif
[313]1749        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
[713]1750#if ALLOW_RECOVERY_POINT_AS_RAP
[903]1751#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1752        pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + deltaPOC < pocRandomAccess) ); 
1753#else
[713]1754        pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess) ); 
1755#endif
[903]1756#endif
[313]1757        if(pcRPS->getDeltaPOC(k) < 0)
1758        {
1759          nrOfNegativePictures++;
1760        }
1761        else
1762        {
[1029]1763#if EFFICIENT_FIELD_IRAP
1764          if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1765          {
1766            irapIsInRPS = true;
1767          }
1768#endif
[313]1769          nrOfPositivePictures++;
1770        }
1771        k++;
1772      }
1773    }
1774  }
[1029]1775
[713]1776#if EFFICIENT_FIELD_IRAP
1777  Bool useNewRPS = false;
1778  // if current picture is complimentary field associated to IRAP, add the IRAP to its RPS.
[1029]1779  if(m_pcPic->isField() && !irapIsInRPS)
[713]1780  {
1781    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1782    while ( iterPic != rcListPic.end())
1783    {
1784      rpcPic = *(iterPic++);
1785      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1786      {
1787        pcRPS->setDeltaPOC(k, 1);
1788        pcRPS->setUsed(k, true);
1789        nrOfPositivePictures++;
1790        k ++;
1791        useNewRPS = true;
1792      }
1793    }
1794  }
1795#endif
[313]1796  pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1797  pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1798  pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
[1029]1799  // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
[313]1800  // inter RPS prediction with.  Here we just use the reference used by pReferencePictureSet.
1801  // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
[713]1802  if (!pReferencePictureSet->getInterRPSPrediction()
1803#if EFFICIENT_FIELD_IRAP
1804    || useNewRPS
1805#endif
[903]1806#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1807    || pocsAdjusted  // inter RPS prediction does not work if POCs have been adjusted
1808#endif
[713]1809    )
[313]1810  {
1811    pcRPS->setInterRPSPrediction(false);
1812    pcRPS->setNumRefIdc(0);
1813  }
1814  else
1815  {
1816    Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1817    Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1818    TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1819    Int iRefPics = pcRefRPS->getNumberOfPictures();
1820    Int iNewIdc=0;
[1029]1821    for(i=0; i<= iRefPics; i++)
[313]1822    {
1823      Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0);  // check if the reference abs POC is >= 0
1824      Int iRefIdc = 0;
1825      for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the  pictures in the new RPS
1826      {
1827        if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1828        {
1829          if (pcRPS->getUsed(j))
1830          {
1831            iRefIdc = 1;
1832          }
1833          else
1834          {
1835            iRefIdc = 2;
1836          }
1837        }
1838      }
1839      pcRPS->setRefIdc(i, iRefIdc);
1840      iNewIdc++;
1841    }
1842    pcRPS->setInterRPSPrediction(true);
1843    pcRPS->setNumRefIdc(iNewIdc);
[1029]1844    pcRPS->setDeltaRPS(deltaRPS);
[313]1845    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1846  }
1847
1848  this->setRPS(pcRPS);
1849  this->setRPSidx(-1);
1850}
1851
1852/** get AC and DC values for weighted pred
1853 * \param *wp
1854 * \returns Void
1855 */
[1029]1856Void  TComSlice::getWpAcDcParam(WPACDCParam *&wp)
[313]1857{
1858  wp = m_weightACDCParam;
1859}
1860
1861/** init AC and DC values for weighted pred
1862 * \returns Void
1863 */
1864Void  TComSlice::initWpAcDcParam()
1865{
[1029]1866  for(Int iComp = 0; iComp < MAX_NUM_COMPONENT; iComp++ )
[313]1867  {
1868    m_weightACDCParam[iComp].iAC = 0;
1869    m_weightACDCParam[iComp].iDC = 0;
1870  }
1871}
1872
1873/** get WP tables for weighted pred
1874 * \param RefPicList
1875 * \param iRefIdx
[1029]1876 * \param *&WPScalingParam
[313]1877 * \returns Void
1878 */
[1029]1879Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp )
[313]1880{
[1029]1881  assert (e<NUM_REF_PIC_LIST_01);
[313]1882  wp = m_weightPredTable[e][iRefIdx];
1883}
1884
[1029]1885/** reset Default WP tables settings : no weight.
1886 * \param WPScalingParam
[313]1887 * \returns Void
1888 */
1889Void  TComSlice::resetWpScaling()
1890{
[1029]1891  for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
[313]1892  {
1893    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1894    {
[1029]1895      for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
[313]1896      {
[1029]1897        WPScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
[313]1898        pwp->bPresentFlag      = false;
1899        pwp->uiLog2WeightDenom = 0;
1900        pwp->uiLog2WeightDenom = 0;
1901        pwp->iWeight           = 1;
1902        pwp->iOffset           = 0;
1903      }
1904    }
1905  }
1906}
1907
1908/** init WP table
1909 * \returns Void
1910 */
1911Void  TComSlice::initWpScaling()
1912{
[1029]1913  const Bool bUseHighPrecisionPredictionWeighting = getSPS()->getUseHighPrecisionPredictionWeighting();
1914  for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
[313]1915  {
1916    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1917    {
[1029]1918      for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
[313]1919      {
[1029]1920        WPScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1921        if ( !pwp->bPresentFlag )
[313]1922        {
1923          // Inferring values not present :
1924          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1925          pwp->iOffset = 0;
1926        }
1927
[1029]1928        const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (g_bitDepth[toChannelType(ComponentID(yuv))]-8));
1929
[313]1930        pwp->w      = pwp->iWeight;
[1029]1931        pwp->o      = pwp->iOffset * offsetScalingFactor; //NOTE: This value of the ".o" variable is never used - .o is set immediately before it gets used
[313]1932        pwp->shift  = pwp->uiLog2WeightDenom;
1933        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1934      }
1935    }
1936  }
1937}
1938
1939// ------------------------------------------------------------------------------------------------
1940// Video parameter set (VPS)
1941// ------------------------------------------------------------------------------------------------
[494]1942#if SVC_EXTENSION
[313]1943TComVPS::TComVPS()
1944: m_VPSId                     (  0)
[836]1945#if VPS_RESERVED_FLAGS
1946, m_baseLayerInternalFlag     (true)
1947, m_baseLayerAvailableFlag    (true)
1948#endif
[313]1949, m_uiMaxTLayers              (  1)
1950, m_uiMaxLayers               (  1)
1951, m_bTemporalIdNestingFlag    (false)
1952, m_numHrdParameters          (  0)
1953, m_hrdParameters             (NULL)
1954, m_hrdOpSetIdx               (NULL)
1955, m_cprmsPresentFlag          (NULL)
1956, m_maxLayerId                (0)
1957, m_numLayerSets              (0)
1958#if VPS_EXTN_OP_LAYER_SETS
1959, m_numOutputLayerSets        (0) 
1960#endif
1961, m_numProfileTierLevel       (0)
1962, m_numAddOutputLayerSets     (0)
[1157]1963, m_defaultTargetOutputLayerIdc(0)
[442]1964, m_bitRatePresentVpsFlag     (false)
1965, m_picRatePresentVpsFlag     (false)
1966#if REPN_FORMAT_IN_VPS
[713]1967, m_repFormatIdxPresentFlag   (false)
[442]1968, m_vpsNumRepFormats          (1)
1969#endif
1970#if VIEW_ID_RELATED_SIGNALING
[547]1971#if O0109_VIEW_ID_LEN
1972, m_viewIdLen                (0)
1973#else
[442]1974, m_viewIdLenMinus1           (0)
1975#endif
[547]1976#endif
[588]1977, m_vpsNonVuiExtLength (0)
[903]1978#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1979, m_vpsPocLsbAlignedFlag(false)
1980#endif
[313]1981{
1982  for( Int i = 0; i < MAX_TLAYER; i++)
1983  {
1984    m_numReorderPics[i] = 0;
[1029]1985    m_uiMaxDecPicBuffering[i] = 1;
[313]1986    m_uiMaxLatencyIncrease[i] = 0;
1987  }
[1029]1988
[874]1989  m_nonHEVCBaseLayerFlag = false;
[313]1990  m_splittingFlag = false;
[1161]1991  m_nuhLayerIdPresentFlag = false;
[313]1992  ::memset(m_scalabilityMask, 0, sizeof(m_scalabilityMask));
1993  ::memset(m_dimensionIdLen, 0, sizeof(m_dimensionIdLen));
1994  ::memset(m_layerIdInNuh, 0, sizeof(m_layerIdInNuh));
1995  ::memset(m_dimensionId, 0, sizeof(m_dimensionId));
1996
1997  m_numScalabilityTypes = 0;
[1043]1998  ::memset(m_layerIdxInVps, 0, sizeof(m_layerIdxInVps));
[1161]1999
[313]2000#if VPS_EXTN_PROFILE_INFO
2001  ::memset(m_profilePresentFlag, 0, sizeof(m_profilePresentFlag));
2002#endif
2003#if VPS_EXTN_OP_LAYER_SETS
2004  ::memset(m_layerIdIncludedFlag, 0, sizeof(m_layerIdIncludedFlag));
2005  // Consider dynamic allocation for outputLayerSetIdx and outputLayerFlag
2006  ::memset(m_outputLayerSetIdx, 0, sizeof(m_outputLayerSetIdx));
2007  ::memset(m_outputLayerFlag, 0, sizeof(m_outputLayerFlag));
2008#endif
[1148]2009
[313]2010  ::memset(m_directDependencyFlag, 0, sizeof(m_directDependencyFlag));
2011  ::memset(m_numDirectRefLayers,   0, sizeof(m_numDirectRefLayers  ));
2012  ::memset(m_refLayerId,           0, sizeof(m_refLayerId          ));
2013  m_directDepTypeLen = 2;
2014  ::memset(m_directDependencyType, 0, sizeof(m_directDependencyType));
[1148]2015
[313]2016  m_maxOneActiveRefLayerFlag = true;
[494]2017#if O0062_POC_LSB_NOT_PRESENT_FLAG
2018  ::memset(m_pocLsbNotPresentFlag, 0, sizeof(m_pocLsbNotPresentFlag));
2019#endif
[540]2020  m_crossLayerPictureTypeAlignFlag = true;
[442]2021  m_crossLayerIrapAlignFlag = true;
[644]2022  m_crossLayerAlignedIdrOnlyFlag = false;
[442]2023  m_maxTidRefPresentFlag = true;
[1046]2024  for( Int i = 0; i < MAX_VPS_LAYER_IDX_PLUS1 - 1; i++)
[313]2025  {
[1046]2026    for( Int j = 0; j < MAX_VPS_LAYER_IDX_PLUS1; j++)
[588]2027    {
2028      m_maxTidIlRefPicsPlus1[i][j] = m_uiMaxTLayers + 1;
2029    }
[313]2030  }
[540]2031#if VPS_VUI_TILES_NOT_IN_USE__FLAG
[588]2032  m_tilesNotInUseFlag = true;
2033  ::memset(m_tilesInUseFlag,  0, sizeof(m_tilesInUseFlag));
2034  ::memset(m_loopFilterNotAcrossTilesFlag,  0, sizeof(m_loopFilterNotAcrossTilesFlag));
[540]2035#endif
[588]2036  ::memset(m_tileBoundariesAlignedFlag,  0, sizeof(m_tileBoundariesAlignedFlag));
[540]2037#if VPS_VUI_WPP_NOT_IN_USE__FLAG
[588]2038  m_wppNotInUseFlag = true;
2039  ::memset(m_wppInUseFlag,  0, sizeof(m_wppInUseFlag));
[540]2040#endif
[442]2041#if N0160_VUI_EXT_ILP_REF
[588]2042  m_ilpRestrictedRefLayersFlag = false;
2043  ::memset(m_minSpatialSegmentOffsetPlus1,  0, sizeof(m_minSpatialSegmentOffsetPlus1));
2044  ::memset(m_ctuBasedOffsetEnabledFlag,     0, sizeof(m_ctuBasedOffsetEnabledFlag));
2045  ::memset(m_minHorizontalCtuOffsetPlus1,   0, sizeof(m_minHorizontalCtuOffsetPlus1));
[442]2046#endif
[540]2047#if VPS_VUI_VIDEO_SIGNAL
[588]2048  m_vidSigPresentVpsFlag=true;
2049  m_vpsVidSigInfo=1;
2050  ::memset( m_vpsVidSigIdx, 0, sizeof(m_vpsVidSigIdx) );
2051  m_vpsVidSigIdx[0]=0;
2052  for (Int i=0; i < 16; i++)
2053  {
2054    m_vpsVidFormat[i] = 5;
2055    m_vpsFullRangeFlag[i] = false;
2056    m_vpsColorPrimaries[i] = 2;
2057    m_vpsTransChar[i] = 2;
2058    m_vpsMatCoeff[i] = 2;
2059  }
[540]2060#endif
[442]2061  ::memset(m_bitRatePresentFlag, 0, sizeof(m_bitRatePresentFlag));
2062  ::memset(m_picRatePresentFlag, 0, sizeof(m_picRatePresentFlag));
2063  ::memset(m_avgBitRate        , 0, sizeof(m_avgBitRate)        );
2064  ::memset(m_maxBitRate        , 0, sizeof(m_maxBitRate)        );
2065  ::memset(m_constPicRateIdc   , 0, sizeof(m_constPicRateIdc)   );
2066  ::memset(m_avgPicRate        , 0, sizeof(m_avgPicRate)        );
2067#if REPN_FORMAT_IN_VPS
2068  ::memset( m_vpsRepFormatIdx, 0, sizeof(m_vpsRepFormatIdx) );
2069#endif
2070#if VIEW_ID_RELATED_SIGNALING
2071  ::memset(m_viewIdVal, 0, sizeof(m_viewIdVal));
2072#endif
[540]2073#if O0092_0094_DEPENDENCY_CONSTRAINT
2074  for (Int i = 0; i < MAX_NUM_LAYER_IDS; i++)
2075  {
2076    m_numberRefLayers[i] = 0;
2077    for (Int j = 0; j < MAX_NUM_LAYER_IDS; j++)
2078    {
2079      m_recursiveRefLayerFlag[i][j] = 0;
2080    }
2081  }
2082#endif
2083#if VPS_DPB_SIZE_TABLE
2084  ::memset( m_subLayerFlagInfoPresentFlag,  0, sizeof(m_subLayerFlagInfoPresentFlag ) );
2085  ::memset( m_subLayerDpbInfoPresentFlag,   0, sizeof(m_subLayerDpbInfoPresentFlag )  );
2086  ::memset( m_maxVpsDecPicBufferingMinus1,  0, sizeof(m_maxVpsDecPicBufferingMinus1 ) );
2087  ::memset( m_maxVpsNumReorderPics,         0, sizeof(m_maxVpsNumReorderPics )        );
2088  ::memset( m_maxVpsLatencyIncreasePlus1,   0, sizeof(m_maxVpsLatencyIncreasePlus1 )  );
2089  ::memset( m_numSubDpbs                ,   0, sizeof(m_numSubDpbs)                   );
2090#endif
[1034]2091  ::memset( m_baseLayerPSCompatibilityFlag, 0, sizeof(m_baseLayerPSCompatibilityFlag) );
[313]2092}
[494]2093#else
2094TComVPS::TComVPS()
2095: m_VPSId                     (  0)
2096, m_uiMaxTLayers              (  1)
2097, m_uiMaxLayers               (  1)
2098, m_bTemporalIdNestingFlag    (false)
2099, m_numHrdParameters          (  0)
2100, m_maxNuhReservedZeroLayerId (  0)
2101, m_hrdParameters             (NULL)
2102, m_hrdOpSetIdx               (NULL)
2103, m_cprmsPresentFlag          (NULL)
2104{
[1029]2105
[494]2106  for( Int i = 0; i < MAX_TLAYER; i++)
2107  {
2108    m_numReorderPics[i] = 0;
[1029]2109    m_uiMaxDecPicBuffering[i] = 1;
[494]2110    m_uiMaxLatencyIncrease[i] = 0;
2111  }
2112}
2113#endif //SVC_EXTENSION
[313]2114
2115TComVPS::~TComVPS()
2116{
2117  if( m_hrdParameters    != NULL )     delete[] m_hrdParameters;
2118  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
2119  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
2120}
[815]2121
[313]2122// ------------------------------------------------------------------------------------------------
2123// Sequence parameter set (SPS)
2124// ------------------------------------------------------------------------------------------------
2125
2126TComSPS::TComSPS()
2127: m_SPSId                     (  0)
2128, m_VPSId                     (  0)
2129, m_chromaFormatIdc           (CHROMA_420)
2130, m_uiMaxTLayers              (  1)
2131// Structure
2132, m_picWidthInLumaSamples     (352)
2133, m_picHeightInLumaSamples    (288)
2134, m_log2MinCodingBlockSize    (  0)
[1029]2135, m_log2DiffMaxMinCodingBlockSize(0)
[313]2136, m_uiMaxCUWidth              ( 32)
2137, m_uiMaxCUHeight             ( 32)
2138, m_uiMaxCUDepth              (  3)
2139, m_bLongTermRefsPresent      (false)
2140, m_uiQuadtreeTULog2MaxSize   (  0)
2141, m_uiQuadtreeTULog2MinSize   (  0)
2142, m_uiQuadtreeTUMaxDepthInter (  0)
2143, m_uiQuadtreeTUMaxDepthIntra (  0)
2144// Tool list
[1029]2145, m_usePCM                    (false)
[313]2146, m_pcmLog2MaxSize            (  5)
2147, m_uiPCMLog2MinSize          (  7)
[1029]2148, m_useExtendedPrecision      (false)
2149, m_useHighPrecisionPredictionWeighting(false)
2150, m_useResidualRotation       (false)
2151, m_useSingleSignificanceMapContext(false)
2152, m_useGolombRiceParameterAdaptation(false)
2153, m_alignCABACBeforeBypass    (false)
[313]2154, m_bPCMFilterDisableFlag     (false)
[1029]2155, m_disableIntraReferenceSmoothing(false)
[313]2156, m_uiBitsForPOC              (  8)
[1029]2157, m_numLongTermRefPicSPS      (  0)
[313]2158, m_uiMaxTrSize               ( 32)
[1029]2159, m_bUseSAO                   (false)
[313]2160, m_bTemporalIdNestingFlag    (false)
2161, m_scalingListEnabledFlag    (false)
2162, m_useStrongIntraSmoothing   (false)
2163, m_vuiParametersPresentFlag  (false)
2164, m_vuiParameters             ()
[494]2165#if SVC_EXTENSION
2166, m_layerId                   ( 0 )
[815]2167, m_extensionFlag             ( false )
[1120]2168, m_bV1CompatibleSPSFlag      (  0)
[442]2169#if REPN_FORMAT_IN_VPS
2170, m_updateRepFormatFlag       (false)
[540]2171, m_updateRepFormatIndex      (0)
[442]2172#endif
[540]2173#if SCALINGLIST_INFERRING
2174, m_inferScalingListFlag ( false )
2175, m_scalingListRefLayerId ( 0 )
2176#endif
[494]2177#endif //SVC_EXTENSION
[313]2178{
[1029]2179  for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2180  {
2181    m_uiBitDepth   [ch] = 8;
2182    m_uiPCMBitDepth[ch] = 8;
2183    m_qpBDOffset   [ch] = 0;
2184  }
2185
[313]2186  for ( Int i = 0; i < MAX_TLAYER; i++ )
2187  {
2188    m_uiMaxLatencyIncrease[i] = 0;
2189    m_uiMaxDecPicBuffering[i] = 1;
2190    m_numReorderPics[i]       = 0;
2191  }
[1029]2192
2193  for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
2194  {
2195    m_useResidualDPCM[signallingModeIndex] = false;
2196  }
2197
[313]2198  m_scalingList = new TComScalingList;
2199  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2200  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2201}
2202
2203TComSPS::~TComSPS()
2204{
[540]2205#if SCALINGLIST_INFERRING
2206  if( !m_inferScalingListFlag )
2207#endif
[313]2208  delete m_scalingList;
2209  m_RPSList.destroy();
2210}
2211
2212Void  TComSPS::createRPSList( Int numRPS )
[1029]2213{
[313]2214  m_RPSList.destroy();
2215  m_RPSList.create(numRPS);
2216}
2217
2218Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2219{
2220  if( !getVuiParametersPresentFlag() )
2221  {
2222    return;
2223  }
2224
2225  TComVUI *vui = getVuiParameters();
2226  TComHRD *hrd = vui->getHrdParameters();
2227
2228  TimingInfo *timingInfo = vui->getTimingInfo();
[815]2229#if SVC_EXTENSION
2230  if( m_layerId > 0 )
[313]2231  {
[442]2232    timingInfo->setTimingInfoPresentFlag( false );
[815]2233    return;
[313]2234  }
[815]2235#endif
2236
2237  timingInfo->setTimingInfoPresentFlag( true );
2238  switch( frameRate )
2239  {
2240  case 24:
2241    timingInfo->setNumUnitsInTick( 1125000 );    timingInfo->setTimeScale    ( 27000000 );
2242    break;
2243  case 25:
2244    timingInfo->setNumUnitsInTick( 1080000 );    timingInfo->setTimeScale    ( 27000000 );
2245    break;
2246  case 30:
2247    timingInfo->setNumUnitsInTick( 900900 );     timingInfo->setTimeScale    ( 27000000 );
2248    break;
2249  case 50:
2250    timingInfo->setNumUnitsInTick( 540000 );     timingInfo->setTimeScale    ( 27000000 );
2251    break;
2252  case 60:
2253    timingInfo->setNumUnitsInTick( 450450 );     timingInfo->setTimeScale    ( 27000000 );
2254    break;
2255  default:
2256    timingInfo->setNumUnitsInTick( 1001 );       timingInfo->setTimeScale    ( 60000 );
2257    break;
2258  }
2259
2260  Bool rateCnt = ( bitRate > 0 );
2261  hrd->setNalHrdParametersPresentFlag( rateCnt );
2262  hrd->setVclHrdParametersPresentFlag( rateCnt );
2263
2264  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2265
2266  if( hrd->getSubPicCpbParamsPresentFlag() )
2267  {
[1029]2268    hrd->setTickDivisorMinus2( 100 - 2 );                          //
[815]2269    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
2270    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2271    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2272  }
[442]2273  else
2274  {
[1029]2275    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
[815]2276  }
[313]2277
[815]2278  hrd->setBitRateScale( 4 );                                       // in units of 2~( 6 + 4 ) = 1,024 bps
2279  hrd->setCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2280  hrd->setDuCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
[313]2281
[815]2282  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2283  if( randomAccess )
2284  {
2285    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
2286    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
2287  }
2288  else
2289  {
2290    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
2291    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
2292  }
[313]2293
[1029]2294/*
2295   Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2296*/
[815]2297  Int i, j;
[1029]2298  UInt bitrateValue, cpbSizeValue;
2299  UInt duCpbSizeValue;
[815]2300  UInt duBitRateValue = 0;
[313]2301
[815]2302  for( i = 0; i < MAX_TLAYER; i ++ )
2303  {
2304    hrd->setFixedPicRateFlag( i, 1 );
2305    hrd->setPicDurationInTcMinus1( i, 0 );
2306    hrd->setLowDelayHrdFlag( i, 0 );
2307    hrd->setCpbCntMinus1( i, 0 );
[313]2308
[1029]2309    bitrateValue = bitRate;
[815]2310    cpbSizeValue = bitRate;                                     // 1 second
[1029]2311    duCpbSizeValue = bitRate/numDU;
[815]2312    duBitRateValue = bitRate;
[1029]2313
[815]2314    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
[313]2315    {
[1029]2316      hrd->setBitRateValueMinus1( i, j, 0, ( bitrateValue - 1 ) );
[815]2317      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
[1029]2318      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( duCpbSizeValue - 1 ) );
[815]2319      hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
[313]2320
[1029]2321      hrd->setBitRateValueMinus1( i, j, 1, ( bitrateValue - 1) );
[815]2322      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
[1029]2323      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( duCpbSizeValue - 1 ) );
[815]2324      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2325      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
[313]2326    }
2327  }
2328}
[1029]2329
[313]2330const Int TComSPS::m_winUnitX[]={1,2,2,1};
2331const Int TComSPS::m_winUnitY[]={1,2,1,1};
2332
2333TComPPS::TComPPS()
[1029]2334: m_PPSId                            (0)
2335, m_SPSId                            (0)
2336, m_picInitQPMinus26                 (0)
2337, m_useDQP                           (false)
2338, m_bConstrainedIntraPred            (false)
2339, m_bSliceChromaQpFlag               (false)
2340, m_pcSPS                            (NULL)
2341, m_uiMaxCuDQPDepth                  (0)
2342, m_uiMinCuDQPSize                   (0)
2343, m_MaxCuChromaQpAdjDepth            (0)
2344, m_MinCuChromaQpAdjSize             (0)
2345, m_ChromaQpAdjTableSize             (0)
2346, m_chromaCbQpOffset                 (0)
2347, m_chromaCrQpOffset                 (0)
2348, m_numRefIdxL0DefaultActive         (1)
2349, m_numRefIdxL1DefaultActive         (1)
2350, m_useCrossComponentPrediction      (false)
2351, m_TransquantBypassEnableFlag       (false)
2352, m_useTransformSkip                 (false)
2353, m_transformSkipLog2MaxSize         (2)
2354, m_dependentSliceSegmentsEnabledFlag(false)
2355, m_tilesEnabledFlag                 (false)
2356, m_entropyCodingSyncEnabledFlag     (false)
2357, m_loopFilterAcrossTilesEnabledFlag (true)
2358, m_uniformSpacingFlag               (false)
2359, m_numTileColumnsMinus1             (0)
2360, m_numTileRowsMinus1                (0)
2361, m_numSubstreams                    (1)
2362, m_signHideFlag                     (0)
2363, m_cabacInitPresentFlag             (false)
2364, m_encCABACTableIdx                 (I_SLICE)
2365, m_sliceHeaderExtensionPresentFlag  (false)
2366, m_loopFilterAcrossSlicesEnabledFlag(false)
2367, m_listsModificationPresentFlag     (0)
2368, m_numExtraSliceHeaderBits          (0)
2369
[815]2370#if SVC_EXTENSION
2371, m_extensionFlag(false)
[540]2372#if SCALINGLIST_INFERRING
[815]2373, m_layerId(0)
[540]2374, m_inferScalingListFlag ( false )
2375, m_scalingListRefLayerId ( 0 )
2376#endif
[644]2377#if POC_RESET_IDC
2378, m_pocResetInfoPresentFlag   (false)
2379#endif
[1030]2380, m_numRefLayerLocationOffsets  ( 0 )
[815]2381#if Q0048_CGS_3D_ASYMLUT
2382, m_nCGSFlag(0)
2383, m_nCGSOutputBitDepthY(0)
2384, m_nCGSOutputBitDepthC(0)
2385#endif
2386#endif //SVC_EXTENSION
[313]2387{
2388  m_scalingList = new TComScalingList;
[1029]2389  for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2390  {
2391    m_saoOffsetBitShift[ch] = 0;
2392  }
2393  m_ChromaQpAdjTable[0].u.comp.CbOffset = 0;
2394  m_ChromaQpAdjTable[0].u.comp.CrOffset = 0;
2395
2396#if SVC_EXTENSION
[849]2397  ::memset(m_scaledRefLayerOffsetPresentFlag,   0, sizeof(m_scaledRefLayerOffsetPresentFlag));
2398  ::memset(m_refRegionOffsetPresentFlag,   0, sizeof(m_refRegionOffsetPresentFlag));
2399  ::memset(m_resamplePhaseSetPresentFlag,   0, sizeof(m_resamplePhaseSetPresentFlag));
2400  ::memset(m_phaseHorLuma,   0, sizeof(m_phaseHorLuma));
2401  ::memset(m_phaseVerLuma,   0, sizeof(m_phaseVerLuma));
2402  ::memset(m_phaseHorChroma, 0, sizeof(m_phaseHorChroma));
2403  ::memset(m_phaseVerChroma, 0, sizeof(m_phaseVerChroma));
[1029]2404#endif //SVC_EXTENSION
[313]2405}
2406
2407TComPPS::~TComPPS()
2408{
[540]2409#if SCALINGLIST_INFERRING
2410  if( !m_inferScalingListFlag )
2411#endif
[313]2412  delete m_scalingList;
2413}
2414
2415TComReferencePictureSet::TComReferencePictureSet()
2416: m_numberOfPictures (0)
2417, m_numberOfNegativePictures (0)
2418, m_numberOfPositivePictures (0)
2419, m_numberOfLongtermPictures (0)
[1029]2420, m_interRPSPrediction (0)
2421, m_deltaRIdxMinus1 (0)
2422, m_deltaRPS (0)
2423, m_numRefIdc (0)
[313]2424{
2425  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2426  ::memset( m_POC, 0, sizeof(m_POC) );
2427  ::memset( m_used, 0, sizeof(m_used) );
2428  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
2429}
2430
2431TComReferencePictureSet::~TComReferencePictureSet()
2432{
2433}
2434
2435Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2436{
2437  m_used[bufferNum] = used;
2438}
2439
2440Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2441{
2442  m_deltaPOC[bufferNum] = deltaPOC;
2443}
2444
2445Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2446{
2447  m_numberOfPictures = numberOfPictures;
2448}
2449
2450Int TComReferencePictureSet::getUsed(Int bufferNum)
2451{
2452  return m_used[bufferNum];
2453}
2454
2455Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2456{
2457  return m_deltaPOC[bufferNum];
2458}
2459
2460Int TComReferencePictureSet::getNumberOfPictures()
2461{
2462  return m_numberOfPictures;
2463}
2464
2465Int TComReferencePictureSet::getPOC(Int bufferNum)
2466{
2467  return m_POC[bufferNum];
2468}
2469
2470Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2471{
2472  m_POC[bufferNum] = POC;
2473}
2474
2475Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2476{
2477  return m_bCheckLTMSB[bufferNum];
2478}
2479
2480Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2481{
2482  m_bCheckLTMSB[bufferNum] = b;
2483}
2484
2485/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2486 * \param uiBufferNum
2487 * \param iRefIdc
2488 * \returns Void
2489 */
2490Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2491{
2492  m_refIdc[bufferNum] = refIdc;
2493}
2494
2495/** get the reference idc value at uiBufferNum
2496 * \param uiBufferNum
2497 * \returns Int
2498 */
2499Int  TComReferencePictureSet::getRefIdc(Int bufferNum)
2500{
2501  return m_refIdc[bufferNum];
2502}
2503
2504/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2505 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
2506 *  +ve values are in increasing order.
2507 * \returns Void
2508 */
2509Void TComReferencePictureSet::sortDeltaPOC()
2510{
2511  // sort in increasing order (smallest first)
2512  for(Int j=1; j < getNumberOfPictures(); j++)
[1029]2513  {
[313]2514    Int deltaPOC = getDeltaPOC(j);
2515    Bool used = getUsed(j);
2516    for (Int k=j-1; k >= 0; k--)
2517    {
2518      Int temp = getDeltaPOC(k);
2519      if (deltaPOC < temp)
2520      {
2521        setDeltaPOC(k+1, temp);
2522        setUsed(k+1, getUsed(k));
2523        setDeltaPOC(k, deltaPOC);
2524        setUsed(k, used);
2525      }
2526    }
2527  }
2528  // flip the negative values to largest first
2529  Int numNegPics = getNumberOfNegativePictures();
2530  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
[1029]2531  {
[313]2532    Int deltaPOC = getDeltaPOC(j);
2533    Bool used = getUsed(j);
2534    setDeltaPOC(j, getDeltaPOC(k));
2535    setUsed(j, getUsed(k));
2536    setDeltaPOC(k, deltaPOC);
2537    setUsed(k, used);
2538  }
2539}
2540
2541/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2542 *  A "*" is added to the deltaPOC value if it is Used bu current.
2543 * \returns Void
2544 */
2545Void TComReferencePictureSet::printDeltaPOC()
2546{
2547  printf("DeltaPOC = { ");
2548  for(Int j=0; j < getNumberOfPictures(); j++)
2549  {
2550    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
[1029]2551  }
2552  if (getInterRPSPrediction())
[313]2553  {
2554    printf("}, RefIdc = { ");
2555    for(Int j=0; j < getNumRefIdc(); j++)
2556    {
2557      printf("%d ", getRefIdc(j));
[1029]2558    }
[313]2559  }
2560  printf("}\n");
2561}
2562
2563TComRPSList::TComRPSList()
2564:m_referencePictureSets (NULL)
2565{
2566}
2567
2568TComRPSList::~TComRPSList()
2569{
2570}
2571
2572Void TComRPSList::create( Int numberOfReferencePictureSets)
2573{
2574  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2575  m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2576}
2577
2578Void TComRPSList::destroy()
2579{
2580  if (m_referencePictureSets)
2581  {
2582    delete [] m_referencePictureSets;
2583  }
2584  m_numberOfReferencePictureSets = 0;
2585  m_referencePictureSets = NULL;
2586}
2587
2588
2589
2590TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2591{
2592  return &m_referencePictureSets[referencePictureSetNum];
2593}
2594
2595Int TComRPSList::getNumberOfReferencePictureSets()
2596{
2597  return m_numberOfReferencePictureSets;
2598}
2599
2600Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2601{
2602  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2603}
2604
2605TComRefPicListModification::TComRefPicListModification()
2606: m_bRefPicListModificationFlagL0 (false)
2607, m_bRefPicListModificationFlagL1 (false)
2608{
2609  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2610  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2611}
2612
2613TComRefPicListModification::~TComRefPicListModification()
2614{
2615}
2616
2617TComScalingList::TComScalingList()
2618{
2619  init();
2620}
[442]2621
[313]2622TComScalingList::~TComScalingList()
2623{
2624  destroy();
2625}
2626
2627/** set default quantization matrix to array
2628*/
2629Void TComSlice::setDefaultScalingList()
2630{
2631  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2632  {
[1029]2633    for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
[313]2634    {
[540]2635      getScalingList()->processDefaultMatrix(sizeId, listId);
[313]2636    }
2637  }
2638}
2639/** check if use default quantization matrix
2640 * \returns true if use default quantization matrix in all size
2641*/
2642Bool TComSlice::checkDefaultScalingList()
2643{
2644  UInt defaultCounter=0;
2645
2646  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2647  {
[1029]2648    for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
[313]2649    {
2650      if( !memcmp(getScalingList()->getScalingListAddress(sizeId,listId), getScalingList()->getScalingListDefaultAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
2651     && ((sizeId < SCALING_LIST_16x16) || (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
2652      {
2653        defaultCounter++;
2654      }
2655    }
2656  }
[1029]2657
2658  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM )) ? false : true;
[313]2659}
2660
2661/** get scaling matrix from RefMatrixID
2662 * \param sizeId size index
2663 * \param Index of input matrix
2664 * \param Index of reference matrix
2665 */
2666Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
2667{
2668  ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2669}
2670
[1029]2671/** parse syntax infomation
[313]2672 *  \param pchFile syntax infomation
2673 *  \returns false if successful
2674 */
[1029]2675
2676static Void outputScalingListHelp(std::ostream &os)
2677{
2678  os << "The scaling list file specifies all matrices and their DC values; none can be missing,\n"
2679         "but their order is arbitrary.\n\n"
2680         "The matrices are specified by:\n"
2681         "<matrix name><unchecked data>\n"
2682         "  <value>,<value>,<value>,....\n\n"
2683         "  Line-feeds can be added arbitrarily between values, and the number of values needs to be\n"
2684         "  at least the number of entries for the matrix (superfluous entries are ignored).\n"
2685         "  The <unchecked data> is text on the same line as the matrix that is not checked\n"
2686         "  except to ensure that the matrix name token is unique. It is recommended that it is ' ='\n"
2687         "  The values in the matrices are the absolute values (0-255), not the delta values as\n"
2688         "  exchanged between the encoder and decoder\n\n"
2689         "The DC values (for matrix sizes larger than 8x8) are specified by:\n"
2690         "<matrix name>_DC<unchecked data>\n"
2691         "  <value>\n";
2692
2693  os << "The permitted matrix names are:\n";
2694  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2695  {
2696    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
2697    {
2698      if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
2699      {
2700        os << "  " << MatrixType[sizeIdc][listIdc] << '\n';
2701      }
2702    }
2703  }
2704}
2705
2706Void TComScalingList::outputScalingLists(std::ostream &os) const
2707{
2708  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2709  {
2710    const UInt size = min(8,4<<(sizeIdc));
2711    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
2712    {
2713      if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
2714      {
2715        const Int *src = getScalingListAddress(sizeIdc, listIdc);
2716        os << (MatrixType[sizeIdc][listIdc]) << " =\n  ";
2717        for(UInt y=0; y<size; y++)
2718        {
2719          for(UInt x=0; x<size; x++, src++)
2720          {
2721            os << std::setw(3) << (*src) << ", ";
2722          }
2723          os << (y+1<size?"\n  ":"\n");
2724        }
2725        if(sizeIdc > SCALING_LIST_8x8)
2726        {
2727          os << MatrixType_DC[sizeIdc][listIdc] << " = \n  " << std::setw(3) << getScalingListDC(sizeIdc, listIdc) << "\n";
2728        }
2729        os << "\n";
2730      }
2731    }
2732  }
2733}
2734
[313]2735Bool TComScalingList::xParseScalingList(Char* pchFile)
2736{
[1029]2737  static const Int LINE_SIZE=1024;
2738  FILE *fp = NULL;
2739  Char line[LINE_SIZE];
[313]2740
[1029]2741  if (pchFile == NULL)
[313]2742  {
[1029]2743    fprintf(stderr, "Error: no scaling list file specified. Help on scaling lists being output\n");
2744    outputScalingListHelp(std::cout);
2745    std::cout << "\n\nExample scaling list file using default values:\n\n";
2746    outputScalingLists(std::cout);
2747    exit (1);
[313]2748    return true;
2749  }
[1029]2750  else if ((fp = fopen(pchFile,"r")) == (FILE*)NULL)
2751  {
2752    fprintf(stderr, "Error: cannot open scaling list file %s for reading\n",pchFile);
2753    return true;
2754  }
[313]2755
[1029]2756  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
[313]2757  {
[1029]2758    const UInt size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
2759
2760    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
[313]2761    {
[1029]2762      Int * const src = getScalingListAddress(sizeIdc, listIdc);
[313]2763
[1029]2764      if ((sizeIdc==SCALING_LIST_32x32) && (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) != 0)) // derive chroma32x32 from chroma16x16
[313]2765      {
[1029]2766        const Int *srcNextSmallerSize = getScalingListAddress(sizeIdc-1, listIdc);
2767        for(UInt i=0; i<size; i++)
[313]2768        {
[1029]2769          src[i] = srcNextSmallerSize[i];
[313]2770        }
[1029]2771        setScalingListDC(sizeIdc,listIdc,(sizeIdc > SCALING_LIST_8x8) ? getScalingListDC(sizeIdc-1, listIdc) : src[0]);
[313]2772      }
[1029]2773      else
[313]2774      {
2775        {
[1029]2776          fseek(fp, 0, SEEK_SET);
2777          Bool bFound=false;
2778          while ((!feof(fp)) && (!bFound))
2779          {
2780            Char *ret = fgets(line, LINE_SIZE, fp);
2781            Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
2782            // This could be a match against the DC string as well, so verify it isn't
2783            if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL || strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
2784            {
2785              bFound=true;
2786            }
2787          }
2788          if (!bFound)
2789          {
2790            fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], pchFile);
2791            return true;
2792          }
[313]2793        }
[1029]2794        for (UInt i=0; i<size; i++)
[313]2795        {
[1029]2796          Int data;
2797          if (fscanf(fp, "%d,", &data)!=1)
[313]2798          {
[1029]2799            fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
[313]2800            return true;
2801          }
[1029]2802          if (data<0 || data>255)
2803          {
2804            fprintf(stderr, "Error: QMatrix entry #%d of value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", i, data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
2805            return true;
2806          }
2807          src[i] = data;
[313]2808        }
[1029]2809
2810        //set DC value for default matrix check
2811        setScalingListDC(sizeIdc,listIdc,src[0]);
2812
2813        if(sizeIdc > SCALING_LIST_8x8)
[313]2814        {
[1029]2815          {
2816            fseek(fp, 0, SEEK_SET);
2817            Bool bFound=false;
2818            while ((!feof(fp)) && (!bFound))
2819            {
2820              Char *ret = fgets(line, LINE_SIZE, fp);
2821              Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
2822              if (findNamePosition!= NULL)
2823              {
2824                // This won't be a match against the non-DC string.
2825                bFound=true;
2826              }
2827            }
2828            if (!bFound)
2829            {
2830              fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], pchFile);
2831              return true;
2832            }
2833          }
2834          Int data;
2835          if (fscanf(fp, "%d,", &data)!=1)
2836          {
2837            fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], pchFile, ftell(fp));
2838            return true;
2839          }
2840          if (data<0 || data>255)
2841          {
2842            fprintf(stderr, "Error: DC value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
2843            return true;
2844          }
2845          //overwrite DC value when size of matrix is larger than 16x16
2846          setScalingListDC(sizeIdc,listIdc,data);
[313]2847        }
2848      }
2849    }
2850  }
[1029]2851//  std::cout << "\n\nRead scaling lists of:\n\n";
2852//  outputScalingLists(std::cout);
2853
[313]2854  fclose(fp);
2855  return false;
2856}
2857
2858/** initialization process of quantization matrix array
2859 */
2860Void TComScalingList::init()
2861{
2862  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2863  {
[1029]2864    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
[313]2865    {
2866      m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
2867    }
2868  }
2869}
2870
2871/** destroy quantization matrix array
2872 */
2873Void TComScalingList::destroy()
2874{
2875  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2876  {
[1029]2877    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
[313]2878    {
2879      if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
2880    }
2881  }
2882}
2883
[1029]2884/** get default address of quantization matrix
[313]2885 * \param sizeId size index
2886 * \param listId list index
2887 * \returns pointer of quantization matrix
2888 */
2889Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
2890{
2891  Int *src = 0;
2892  switch(sizeId)
2893  {
2894    case SCALING_LIST_4x4:
2895      src = g_quantTSDefault4x4;
2896      break;
2897    case SCALING_LIST_8x8:
2898    case SCALING_LIST_16x16:
2899    case SCALING_LIST_32x32:
[1029]2900      src = (listId < (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) ) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
[313]2901      break;
2902    default:
2903      assert(0);
2904      src = NULL;
2905      break;
2906  }
2907  return src;
2908}
2909
2910/** process of default matrix
2911 * \param sizeId size index
2912 * \param Index of input matrix
2913 */
[540]2914Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
[313]2915{
2916  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2917  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
2918}
2919
2920/** check DC value of matrix for default matrix signaling
2921 */
2922Void TComScalingList::checkDcOfMatrix()
2923{
2924  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2925  {
[1029]2926    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
[313]2927    {
2928      //check default matrix?
2929      if(getScalingListDC(sizeId,listId) == 0)
2930      {
[540]2931        processDefaultMatrix(sizeId, listId);
[313]2932      }
2933    }
2934  }
2935}
2936
2937ParameterSetManager::ParameterSetManager()
2938#if SVC_EXTENSION
[834]2939: m_activeSPSId(-1)
[313]2940, m_activePPSId(-1)
2941#else
2942: m_vpsMap(MAX_NUM_VPS)
2943, m_spsMap(MAX_NUM_SPS)
2944, m_ppsMap(MAX_NUM_PPS)
2945, m_activeVPSId(-1)
2946, m_activeSPSId(-1)
2947, m_activePPSId(-1)
2948#endif
2949{
2950}
2951
2952
2953ParameterSetManager::~ParameterSetManager()
2954{
2955}
2956
2957//! activate a SPS from a active parameter sets SEI message
2958//! \returns true, if activation is successful
2959Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
2960{
2961  TComSPS *sps = m_spsMap.getPS(spsId);
2962  if (sps)
2963  {
2964    Int vpsId = sps->getVPSId();
2965    if (m_vpsMap.getPS(vpsId))
2966    {
2967      m_activeVPSId = vpsId;
2968      m_activeSPSId = spsId;
2969      return true;
2970    }
2971    else
2972    {
2973      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
2974    }
2975  }
2976  else
2977  {
2978    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
2979  }
2980  return false;
2981}
2982
2983//! activate a PPS and depending on isIDR parameter also SPS and VPS
2984//! \returns true, if activation is successful
2985Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
2986{
2987  TComPPS *pps = m_ppsMap.getPS(ppsId);
2988  if (pps)
2989  {
2990    Int spsId = pps->getSPSId();
2991    if (!isIRAP && (spsId != m_activeSPSId))
2992    {
[1029]2993      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
[313]2994      return false;
2995    }
2996    TComSPS *sps = m_spsMap.getPS(spsId);
2997    if (sps)
2998    {
2999      Int vpsId = sps->getVPSId();
3000      if (!isIRAP && (vpsId != m_activeVPSId))
3001      {
[1029]3002        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
[313]3003        return false;
3004      }
3005      if (m_vpsMap.getPS(vpsId))
3006      {
3007        m_activePPSId = ppsId;
3008        m_activeVPSId = vpsId;
3009        m_activeSPSId = spsId;
3010        return true;
3011      }
3012      else
3013      {
3014        printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
3015      }
3016    }
3017    else
3018    {
3019      printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
3020    }
3021  }
3022  else
3023  {
3024    printf("Warning: tried to activate non-existing PPS.");
3025  }
3026  return false;
3027}
3028
3029ProfileTierLevel::ProfileTierLevel()
3030  : m_profileSpace    (0)
[1029]3031  , m_tierFlag        (Level::MAIN)
3032  , m_profileIdc      (Profile::NONE)
3033  , m_levelIdc        (Level::NONE)
3034  , m_progressiveSourceFlag  (false)
3035  , m_interlacedSourceFlag   (false)
3036  , m_nonPackedConstraintFlag(false)
3037  , m_frameOnlyConstraintFlag(false)
[313]3038{
3039  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
3040}
[1029]3041
3042TComPTL::TComPTL()
3043{
3044  ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3045  ::memset(m_subLayerLevelPresentFlag,   0, sizeof(m_subLayerLevelPresentFlag  ));
3046}
3047
[1147]3048#if SVC_EXTENSION
3049
[313]3050#if VPS_EXTN_PROFILE_INFO
3051Void ProfileTierLevel::copyProfileInfo(ProfileTierLevel *ptl)
3052{
3053  this->setProfileSpace          ( ptl->getProfileSpace()      );
3054  this->setTierFlag              ( ptl->getTierFlag()          );
3055  this->setProfileIdc            ( ptl->getProfileIdc()        );
3056  for(Int j = 0; j < 32; j++)
3057  {
3058    this->setProfileCompatibilityFlag(j, ptl->getProfileCompatibilityFlag(j));
3059  }
3060  this->setProgressiveSourceFlag  ( ptl->getProgressiveSourceFlag()  );
3061  this->setInterlacedSourceFlag   ( ptl->getInterlacedSourceFlag()   );
3062  this->setNonPackedConstraintFlag( ptl->getNonPackedConstraintFlag());
3063  this->setFrameOnlyConstraintFlag( ptl->getFrameOnlyConstraintFlag()); 
3064}
3065#endif
3066
[1029]3067Window& TComPPS::getScaledRefLayerWindowForLayer(Int layerId)
[313]3068{
[1029]3069  static Window win;
3070
[1036]3071  for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
[1029]3072  {
[1035]3073    if( layerId == m_refLocationOffsetLayerId[i] )
[1029]3074    {
3075      return m_scaledRefLayerWindow[i];
3076    }
3077  }
3078
3079  win.resetWindow();  // scaled reference layer offsets are inferred to be zero when not present
3080  return win;
[313]3081}
[1090]3082
[1029]3083Window& TComPPS::getRefLayerWindowForLayer(Int layerId)
3084{
3085  static Window win;
3086
[1036]3087  for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
[1029]3088  {
[1035]3089    if( layerId == m_refLocationOffsetLayerId[i] )
[1029]3090    {
3091      return m_refLayerWindow[i];
3092    }
3093  }
3094
3095  win.resetWindow();  // reference region offsets are inferred to be zero when not present
3096  return win;
3097}
3098
[1035]3099Bool TComPPS::hasZeroResamplingPhase(Int refLayerId)
[1029]3100{
[1035]3101  Bool phaseSetPresentFlag;
3102  Int phaseHorLuma, phaseVerLuma, phaseHorChroma, phaseVerChroma;
3103
3104  getResamplingPhase(refLayerId, phaseSetPresentFlag, phaseHorLuma, phaseVerLuma, phaseHorChroma, phaseVerChroma);
3105
[1029]3106  return ( phaseHorLuma == 0 && phaseHorChroma == 0 && phaseVerLuma == 0 && phaseVerChroma == 0);
3107}
[1035]3108
3109Void TComPPS::getResamplingPhase(Int refLayerId, Bool& phaseSetPresentFlag, Int& phaseHorLuma, Int& phaseVerLuma, Int& phaseHorChroma, Int& phaseVerChroma)
3110{
3111  phaseSetPresentFlag = false;
3112  phaseHorLuma = 0, phaseVerLuma = 0, phaseHorChroma = 0, phaseVerChroma = 0;
3113
[1036]3114  for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
[1035]3115  {
3116    if( refLayerId == m_refLocationOffsetLayerId[i] )
3117    {
3118      phaseSetPresentFlag = m_resamplePhaseSetPresentFlag[i];
3119      phaseHorLuma        = m_phaseHorLuma[i];
3120      phaseVerLuma        = m_phaseVerLuma[i];
3121      phaseHorChroma      = m_phaseHorChroma[i];
3122      phaseVerChroma      = m_phaseVerChroma[i];
3123
3124      return;
3125    }
3126  }
3127}
[1029]3128
3129Void TComVPS::deriveLayerIdListVariables()
3130{
3131  // For layer 0
3132  m_numLayerInIdList.push_back(1);
3133  m_layerSetLayerIdList.resize(m_vpsNumLayerSetsMinus1 + 1);
3134  m_layerSetLayerIdList[0].push_back(0);
3135 
3136  // For other layers
3137  for (Int i = 1; i <= m_vpsNumLayerSetsMinus1; i++)
3138  {
3139    for( Int m = 0; m <= m_maxLayerId; m++)
3140    {
3141      if( m_layerIdIncludedFlag[i][m] )
3142      {
3143        m_layerSetLayerIdList[i].push_back(m);
3144      }
3145    }
[1077]3146    m_numLayerInIdList.push_back((Int)m_layerSetLayerIdList[i].size());
[1029]3147  }
3148}
[1161]3149
[1029]3150#if VPS_DPB_SIZE_TABLE
3151Void TComVPS::deriveNumberOfSubDpbs()
3152{
3153  // Derive number of sub-DPBs
3154  // For layer set 0
[1057]3155  m_numSubDpbs[0] = 1;
[1029]3156  // For other layer sets
[1057]3157  for( Int i = 1; i < m_numLayerSets; i++)
[1029]3158  {
[1057]3159    m_numSubDpbs[i] = m_numLayerInIdList[i];
[1029]3160  }
3161}
3162#endif
3163#if VPS_VUI_TILES_NOT_IN_USE__FLAG
3164Void TComVPS::setTilesNotInUseFlag(Bool x)
3165{
3166  m_tilesNotInUseFlag = x;
3167  if (m_tilesNotInUseFlag)
3168  {
3169    for (int i = 0; i < getMaxLayers(); i++)
3170    {
3171      m_tilesInUseFlag[i] = m_loopFilterNotAcrossTilesFlag[i] = m_tilesNotInUseFlag;
3172    }
3173  }
3174
3175  if (m_tilesNotInUseFlag)
3176  {
3177    for (int i = 1; i < getMaxLayers(); i++)
3178    {
3179      for(int j = 0; j < getNumDirectRefLayers(getLayerIdInNuh(i)); j++)
3180      {
3181        setTileBoundariesAlignedFlag(i, j, m_tilesNotInUseFlag);
3182      }
3183    }
3184  }
3185}
3186#endif
3187
3188#if VPS_VUI_WPP_NOT_IN_USE__FLAG
3189Void TComVPS::setWppNotInUseFlag(Bool x)
3190{
3191  m_wppNotInUseFlag = x;
3192  if (m_wppNotInUseFlag)
3193  {
3194    for (int i = 0; i < getMaxLayers(); i++)
3195    {
3196      m_wppInUseFlag[i] = m_wppNotInUseFlag;
3197    }
3198  }
3199}
3200#endif
3201#if O0092_0094_DEPENDENCY_CONSTRAINT
3202Void TComVPS::setRefLayersFlags(Int currLayerId)
3203{
3204  for (Int i = 0; i < m_numDirectRefLayers[currLayerId]; i++)
3205  {
3206    UInt refLayerId = getRefLayerId(currLayerId, i);
3207    m_recursiveRefLayerFlag[currLayerId][refLayerId] = true;
3208    for (Int k = 0; k < MAX_NUM_LAYER_IDS; k++)
3209    {
3210      m_recursiveRefLayerFlag[currLayerId][k] = m_recursiveRefLayerFlag[currLayerId][k] | m_recursiveRefLayerFlag[refLayerId][k];
3211    }
3212  }
3213}
3214
3215Void TComVPS::setNumRefLayers()
3216{
3217  memset( m_numberRefLayers, 0, sizeof( m_numberRefLayers ) );
3218
3219  for (Int i = 0; i < m_uiMaxLayers; i++)
3220  {
3221    UInt iNuhLId = m_layerIdInNuh[i];
3222    setRefLayersFlags(iNuhLId);
3223    for (UInt j = 0; j < MAX_NUM_LAYER_IDS; j++)
3224    {
3225      m_numberRefLayers[iNuhLId] += (m_recursiveRefLayerFlag[iNuhLId][j] == true ? 1 : 0);
3226    }
3227  }
3228}
3229#endif
3230
3231#if Q0078_ADD_LAYER_SETS
3232Void TComVPS::setPredictedLayerIds()
3233{
3234  for (UInt i = 0; i < m_uiMaxLayers - 1; i++)
3235  {
3236    UInt iNuhLId = m_layerIdInNuh[i];
3237    UInt predIdx = 0;
3238    for (UInt j = iNuhLId + 1; j < MAX_NUM_LAYER_IDS; j++)
3239    {
3240      if( m_recursiveRefLayerFlag[j][iNuhLId] )
3241      {
3242        m_predictedLayerId[iNuhLId][predIdx] = j;
3243        predIdx++;
3244      }
3245    }
3246    m_numPredictedLayers[iNuhLId] = predIdx;
3247  }
3248  m_numPredictedLayers[m_layerIdInNuh[m_uiMaxLayers-1]] = 0;
3249}
3250
3251Void TComVPS::setTreePartitionLayerIdList()
3252{
3253  Bool countedLayerIdxFlag[MAX_NUM_LAYER_IDS];
3254  memset( countedLayerIdxFlag, 0, sizeof(countedLayerIdxFlag) );
3255
3256  Int numIndependentLayers = 0;
3257
3258  for (UInt i = 0; i < m_uiMaxLayers; i++)
3259  {
3260    UInt iNuhLId = m_layerIdInNuh[i];
3261    if( m_numDirectRefLayers[iNuhLId] == 0 )
3262    {
3263      m_treePartitionLayerIdList[numIndependentLayers][0] = iNuhLId;
3264      m_numLayersInTreePartition[numIndependentLayers] = 1;
3265      for( UInt j = 0; j < m_numPredictedLayers[iNuhLId]; j++ )
3266      {
[1043]3267        if( !countedLayerIdxFlag[m_layerIdxInVps[iNuhLId]] )
[1029]3268        {
3269          m_treePartitionLayerIdList[numIndependentLayers][m_numLayersInTreePartition[numIndependentLayers]] = m_predictedLayerId[iNuhLId][j];
3270          m_numLayersInTreePartition[numIndependentLayers] = m_numLayersInTreePartition[numIndependentLayers] + 1;
[1043]3271          countedLayerIdxFlag[m_layerIdxInVps[m_predictedLayerId[iNuhLId][j]]] = true;
[1029]3272        }
3273      }
3274      numIndependentLayers++;
3275    }
3276  }
3277
3278  m_numIndependentLayers = numIndependentLayers;
3279}
3280
[1132]3281Void TComVPS::deriveLayerIdListVariablesForAddLayerSets()
[1029]3282{
3283  m_layerSetLayerIdList.resize(m_vpsNumLayerSetsMinus1 + 1 + m_numAddLayerSets);
3284
3285  for (UInt i = 0; i < m_numAddLayerSets; i++)
3286  {
3287    Int layerNum = 0;
3288    Int lsIdx = m_vpsNumLayerSetsMinus1 + 1 + i;
3289    for (Int treeIdx = 1; treeIdx < m_numIndependentLayers; treeIdx++)
3290    {
3291      for (Int layerCnt = 0; layerCnt < m_highestLayerIdxPlus1[i][treeIdx]; layerCnt++)
3292      {
3293        m_layerSetLayerIdList[lsIdx].push_back(m_treePartitionLayerIdList[treeIdx][layerCnt]);
3294        layerNum++;
3295      }
3296    }
3297    m_numLayerInIdList.push_back(layerNum);
3298  }
3299}
3300#endif
3301
3302#if VIEW_ID_RELATED_SIGNALING
3303Int TComVPS::getNumViews()
3304{
3305  Int numViews = 1; 
3306  for( Int i = 0; i <= getMaxLayers() - 1; i++ )
3307  {
3308    Int lId = getLayerIdInNuh( i ); 
3309    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
3310    {
3311      numViews++; 
3312    }   
3313  }
3314
3315  return numViews;
3316}
3317Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
3318{
3319  return getScalabilityMask( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
3320} 
3321Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
3322{
3323  assert( scalType >= 0 && scalType <= MAX_VPS_NUM_SCALABILITY_TYPES ); 
3324  assert( scalType == MAX_VPS_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) );
3325  Int scalIdx = 0; 
3326  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
3327  {
3328    scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
3329
3330  }
3331
3332  return scalIdx; 
3333}
3334#endif
3335#if VPS_DPB_SIZE_TABLE
[1086]3336Int TComVPS::getLayerIdcForOls( Int olsIdx, Int layerId )
[1073]3337{
3338  Int layerIdc = -1;
[1086]3339  UInt lsIdx = m_outputLayerSetIdx[olsIdx];
[1073]3340
[1086]3341  std::vector<Int>::iterator it = std::find( m_layerSetLayerIdList[lsIdx].begin(), m_layerSetLayerIdList[lsIdx].end(), layerId );
[1073]3342
[1086]3343  if( it != m_layerSetLayerIdList[lsIdx].end() )
[1073]3344  {
[1086]3345    layerIdc = (Int)std::distance( m_layerSetLayerIdList[lsIdx].begin(), it );
[1073]3346  }
3347
3348  assert( layerIdc >= 0 );
3349
3350  return layerIdc;
3351}
3352
[1029]3353Void TComVPS::determineSubDpbInfoFlags()
3354{
3355  for(Int i = 1; i < getNumOutputLayerSets(); i++)
3356  {
3357    Int layerSetIdxForOutputLayerSet = getOutputLayerSetIdx( i );
3358    // For each output layer set, set the DPB size for each layer and the reorder/latency value the maximum for all layers
3359    Bool checkFlagOuter = false;      // Used to calculate sub_layer_flag_info_present_flag
3360    Bool checkFlagInner[MAX_TLAYER];  // Used to calculate sub_layer_dpb_info_present_flag
3361
3362    for(Int j = 0; j < getMaxTLayers(); j++)
3363    {
3364      // --------------------------------------------------------
3365      // To determine value of m_subLayerDpbInfoPresentFlag
3366      // --------------------------------------------------------
3367      if( j == 0 )  // checkFlagInner[0] is always 1
3368      {
3369        checkFlagInner[j] = true;     // Always signal sub-layer DPB information for the first sub-layer
3370      }
3371      else
3372      {
3373        checkFlagInner[j] = false;    // Initialize to be false. If the values of the current sub-layers matches with the earlier sub-layer,
3374                                      // then will be continue to be false - i.e. the j-th sub-layer DPB info is not signaled
3375        checkFlagInner[j] |= ( getMaxVpsNumReorderPics(i, j) != getMaxVpsNumReorderPics(i, j - 1) );
[1135]3376
[1029]3377        for(Int subDpbIdx = 0; subDpbIdx < getNumSubDpbs(layerSetIdxForOutputLayerSet) && !checkFlagInner[j]; subDpbIdx++)  // If checkFlagInner[j] is true, break and signal the values
3378        {
3379          checkFlagInner[j] |= ( getMaxVpsDecPicBufferingMinus1(i, subDpbIdx, j - 1) != getMaxVpsDecPicBufferingMinus1(i, subDpbIdx, j) );
3380        }
3381      }
3382      // If checkFlagInner[j] = true, then some value needs to be signalled for the j-th sub-layer
3383      setSubLayerDpbInfoPresentFlag( i, j, checkFlagInner[j] );
3384    }
3385
3386    // --------------------------------------------------------
3387    // To determine value of m_subLayerFlagInfoPresentFlag
3388    // --------------------------------------------------------
3389
3390    for(Int j = 1; j < getMaxTLayers(); j++) // Check if DPB info of any of non-zero sub-layers is signaled. If so set flag to one
3391    {
3392      if( getSubLayerDpbInfoPresentFlag(i, j) )
3393      {
3394        checkFlagOuter = true;
3395        break;
3396      }
3397    }
3398    setSubLayerFlagInfoPresentFlag( i, checkFlagOuter );
3399  }
3400}
3401#endif
3402
3403#if O0164_MULTI_LAYER_HRD
3404Void TComVPS::setBspHrdParameters( UInt hrdIdx, UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
3405{
3406  if( !getVpsVuiBspHrdPresentFlag() )
3407  {
3408    return;
3409  }
3410
3411  TComHRD *hrd = getBspHrd(hrdIdx);
3412
3413  Bool rateCnt = ( bitRate > 0 );
3414  hrd->setNalHrdParametersPresentFlag( rateCnt );
3415  hrd->setVclHrdParametersPresentFlag( rateCnt );
3416
3417  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
3418
3419  if( hrd->getSubPicCpbParamsPresentFlag() )
3420  {
3421    hrd->setTickDivisorMinus2( 100 - 2 );                          //
3422    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
3423    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
3424    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
3425  }
3426  else
3427  {
3428    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false ); 
3429  }
3430
3431  hrd->setBitRateScale( 4 );                                       // in units of 2~( 6 + 4 ) = 1,024 bps
3432  hrd->setCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
3433  hrd->setDuCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
3434
3435  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
3436  if( randomAccess )
3437  {
3438    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
3439    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
3440  }
3441  else
3442  {
3443    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
3444    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
3445  }
3446
3447  /*
3448  Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
3449  */
3450  Int i, j;
3451  UInt birateValue, cpbSizeValue;
3452  UInt ducpbSizeValue;
3453  UInt duBitRateValue = 0;
3454
3455  for( i = 0; i < MAX_TLAYER; i ++ )
3456  {
3457    hrd->setFixedPicRateFlag( i, 1 );
3458    hrd->setPicDurationInTcMinus1( i, 0 );
3459    hrd->setLowDelayHrdFlag( i, 0 );
3460    hrd->setCpbCntMinus1( i, 0 );
3461
3462    birateValue  = bitRate;
3463    cpbSizeValue = bitRate;                                     // 1 second
3464    ducpbSizeValue = bitRate/numDU;
3465    duBitRateValue = bitRate;
3466    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
3467    {
3468      hrd->setBitRateValueMinus1( i, j, 0, ( birateValue  - 1 ) );
3469      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
3470      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
3471      hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
3472
3473      hrd->setBitRateValueMinus1( i, j, 1, ( birateValue  - 1) );
3474      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
3475      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
3476      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
3477      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
3478    }
3479  }
3480}
3481#endif
[1151]3482
[1029]3483Void TComVPS::deriveNecessaryLayerFlag()
3484{
3485  m_necessaryLayerFlag.empty();
3486  m_numNecessaryLayers.empty();
3487  // Assumed that output layer sets and variables RecursiveRefLayer are already derived
[1057]3488  for( Int olsIdx = 0; olsIdx < m_numOutputLayerSets; olsIdx++)
[1029]3489  {
3490    deriveNecessaryLayerFlag(olsIdx);
3491  }
3492}
[1151]3493
[1029]3494Void TComVPS::deriveNecessaryLayerFlag(Int const olsIdx)
3495{
[1057]3496  Int lsIdx = m_outputLayerSetIdx[olsIdx];
3497  Int numLayersInLs = m_numLayerInIdList[lsIdx];
[1029]3498  assert( m_necessaryLayerFlag.size() == olsIdx );   // Function should be called in the correct order.
3499  m_necessaryLayerFlag.push_back( std::vector<Bool>( numLayersInLs, false ) ); // Initialize to false
3500  for( Int lsLayerIdx = 0; lsLayerIdx < numLayersInLs; lsLayerIdx++ )
3501  {
[1057]3502    if( m_outputLayerFlag[olsIdx][lsLayerIdx] )
[1029]3503    {
3504      m_necessaryLayerFlag[olsIdx][lsLayerIdx] = true;
[1057]3505      Int currNuhLayerId = m_layerSetLayerIdList[lsIdx][lsLayerIdx];
[1029]3506      for( Int rLsLayerIdx = 0; rLsLayerIdx < lsLayerIdx; rLsLayerIdx++ )
3507      {
[1057]3508        Int refNuhLayerId = m_layerSetLayerIdList[lsIdx][rLsLayerIdx];
3509        if( m_recursiveRefLayerFlag[currNuhLayerId][refNuhLayerId] )
[1029]3510        {
3511          m_necessaryLayerFlag[olsIdx][rLsLayerIdx] = true;
3512        }
3513      }
3514    }
3515  }
3516  m_numNecessaryLayers.push_back(std::accumulate(m_necessaryLayerFlag[olsIdx].begin(), m_necessaryLayerFlag[olsIdx].end(), 0));
3517}
[1151]3518
[1029]3519Void TComVPS::checkNecessaryLayerFlagCondition()
3520{
3521  /* It is a requirement of bitstream conformance that for each layer index layerIdx in the range of
3522  ( vps_base_layer_internal_flag ? 0 : 1 ) to MaxLayersMinus1, inclusive, there shall be at least one OLS with index olsIdx such that
3523  NecessaryLayerFlag[ olsIdx ][ lsLayerIdx ] is equal to 1 for the value of lsLayerIdx
3524  for which LayerSetLayerIdList[ OlsIdxToLsIdx[ olsIdx ] ][ lsLayerIdx ] is equal to layer_id_in_nuh[ layerIdx ]. */
[1057]3525  for(Int layerIdx = m_baseLayerInternalFlag ? 0 : 1; layerIdx < m_uiMaxLayers; layerIdx++)
[1029]3526  {
3527    Bool layerFoundNecessaryLayerFlag = false;
[1057]3528    for(Int olsIdx = 0; olsIdx < m_numOutputLayerSets; olsIdx++)
[1029]3529    {
[1057]3530      Int lsIdx = m_outputLayerSetIdx[olsIdx];
3531      Int currNuhLayerId = m_layerIdInNuh[layerIdx];
[1029]3532      std::vector<Int>::iterator iter = std::find( m_layerSetLayerIdList[lsIdx].begin(), m_layerSetLayerIdList[lsIdx].end(), currNuhLayerId );
3533      if( iter != m_layerSetLayerIdList[lsIdx].end() ) // Layer present in layer set
3534      {
3535        size_t positionLayer = iter - m_layerSetLayerIdList[lsIdx].begin();
3536        if( *(m_necessaryLayerFlag[olsIdx].begin() + positionLayer) == true )
3537        {
3538          layerFoundNecessaryLayerFlag = true;
3539          break;
3540        }
3541      }
3542    }
3543    assert( layerFoundNecessaryLayerFlag );
3544  }
3545}
[1151]3546
[1029]3547Int TComVPS::calculateLenOfSyntaxElement( Int const numVal )
3548{
3549  Int numBits = 1;
3550  while((1 << numBits) < numVal)
3551  {
3552    numBits++;
3553  }
3554  return numBits;
3555}
[1136]3556
[1029]3557Void TComVPS::calculateMaxSLInLayerSets()
3558{
3559  for(Int lsIdx = 0; lsIdx < getNumLayerSets(); lsIdx++)
3560  {
3561    UInt maxSLMinus1 = 0;
3562    for(Int k = 0; k < getNumLayersInIdList(lsIdx); k++ ) {
3563      Int  lId = getLayerSetLayerIdList(lsIdx, k);
[1043]3564      maxSLMinus1 = std::max(maxSLMinus1, getMaxTSLayersMinus1(getLayerIdxInVps(lId)));
[1029]3565    }
3566    setMaxSLayersInLayerSetMinus1(lsIdx,maxSLMinus1);
3567  }
3568}
3569
3570#if REPN_FORMAT_IN_VPS
3571UInt TComSlice::getPicWidthInLumaSamples()
3572{
3573  TComSPS *sps = getSPS();
3574  TComVPS *vps = getVPS();
3575  UInt retVal, layerId = getLayerId();
[1119]3576
[1029]3577  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3578  {
3579    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3580    {
3581      retVal = vps->getVpsRepFormat(layerId)->getPicWidthVpsInLumaSamples();
3582    }
3583    else
3584    {
3585      retVal = sps->getPicWidthInLumaSamples();
3586    }
3587  }
3588  else
3589  {
[1043]3590    retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getPicWidthVpsInLumaSamples();
[1029]3591  }
[1119]3592
[1029]3593  return retVal;
3594}
[1119]3595
[1029]3596UInt TComSlice::getPicHeightInLumaSamples()
3597{
3598  TComSPS *sps = getSPS();
3599  TComVPS *vps = getVPS();
3600  UInt retVal, layerId = getLayerId();
[1119]3601
[1029]3602  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3603  {
3604    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3605    {
3606      retVal = vps->getVpsRepFormat(layerId)->getPicHeightVpsInLumaSamples();
3607    }
3608    else
3609    {
3610      retVal = sps->getPicHeightInLumaSamples();
3611    }
3612  }
3613  else
3614  {
[1043]3615    retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getPicHeightVpsInLumaSamples();
[1029]3616  }
[1119]3617
[1029]3618  return retVal;
3619}
[1119]3620
[1029]3621#if AUXILIARY_PICTURES
3622ChromaFormat TComSlice::getChromaFormatIdc()
3623#else
3624UInt TComSlice::getChromaFormatIdc()
3625#endif
3626{
3627  TComSPS *sps = getSPS();
3628  TComVPS *vps = getVPS();
3629#if AUXILIARY_PICTURES
3630  ChromaFormat retVal;
3631  UInt layerId = getLayerId();
3632#else
3633  UInt retVal, layerId = getLayerId();
3634#endif
[1119]3635
[1029]3636  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3637  {
3638    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3639    {
3640      retVal = vps->getVpsRepFormat(layerId)->getChromaFormatVpsIdc();
3641    }
3642    else
3643    {
3644      retVal = sps->getChromaFormatIdc();
3645    }
3646  }
3647  else
3648  {
[1043]3649    retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getChromaFormatVpsIdc();
[1029]3650  }
[1119]3651
[1029]3652  return retVal;
3653}
[1119]3654
[1029]3655UInt TComSlice::getBitDepthY()
3656{
3657  TComSPS *sps = getSPS();
3658  TComVPS *vps = getVPS();
3659  UInt retVal, layerId = getLayerId();
[1119]3660
[1029]3661  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3662  {
3663    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3664    {
3665      retVal = vps->getVpsRepFormat(layerId)->getBitDepthVpsLuma();
3666    }
3667    else
3668    {
3669      retVal = sps->getBitDepth(CHANNEL_TYPE_LUMA);
3670    }
3671  }
3672  else
3673  {
[1043]3674    retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getBitDepthVpsLuma();
[1029]3675  }
[1119]3676
[1029]3677  return retVal;
3678}
[1119]3679
[1029]3680UInt TComSlice::getBitDepthC()
3681{
3682  TComSPS *sps = getSPS();
3683  TComVPS *vps = getVPS();
3684  UInt retVal, layerId = getLayerId();
[1119]3685
[1029]3686  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3687  {
3688    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3689    {
3690      retVal = vps->getVpsRepFormat(layerId)->getBitDepthVpsChroma();
3691    }
3692    else
3693    {
3694      retVal = sps->getBitDepth(CHANNEL_TYPE_CHROMA);
3695    }
3696  }
3697  else
3698  {
[1043]3699    retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getBitDepthVpsChroma();
[1029]3700  }
[1119]3701
[1029]3702  return retVal;
3703}
[1119]3704
[1029]3705Int TComSlice::getQpBDOffsetY()
3706{
3707  return (getBitDepthY() - 8) * 6;
3708}
[1119]3709
[1029]3710Int TComSlice::getQpBDOffsetC()
3711{
3712  return (getBitDepthC() - 8) * 6;
3713}
3714
3715Window& TComSlice::getConformanceWindow()
3716{
3717  TComSPS *sps = getSPS();
3718  TComVPS *vps = getVPS();
3719  UInt layerId = getLayerId();
[1119]3720
[1029]3721  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
3722  {
3723    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3724    {
3725      return vps->getVpsRepFormat(layerId)->getConformanceWindowVps();
3726    }
3727    else
3728    {
3729      return sps->getConformanceWindow();
3730    }
3731  }
3732  else
3733  {
[1043]3734    return vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getConformanceWindowVps();
[1029]3735  }
3736}
3737
3738RepFormat::RepFormat()
3739#if AUXILIARY_PICTURES
3740: m_chromaFormatVpsIdc          (CHROMA_420)
3741#else
3742: m_chromaFormatVpsIdc          (0)
3743#endif
3744, m_separateColourPlaneVpsFlag  (false)
3745, m_picWidthVpsInLumaSamples    (0)
3746, m_picHeightVpsInLumaSamples   (0)
3747, m_bitDepthVpsLuma             (0)
3748, m_bitDepthVpsChroma           (0)
3749{}
[1117]3750#endif //REPN_FORMAT_IN_VPS
[1029]3751
[313]3752#if VPS_EXTN_PROFILE_INFO
3753Void TComPTL::copyProfileInfo(TComPTL *ptl)
3754{
3755  // Copy all information related to general profile
3756  this->getGeneralPTL()->copyProfileInfo(ptl->getGeneralPTL());
3757}
3758#endif
3759
[1136]3760
[540]3761Bool TComSlice::setBaseColPic(  TComList<TComPic*>& rcListPic, UInt refLayerIdc )
[313]3762{ 
3763  if(m_layerId == 0)
3764  {
3765    memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
[540]3766    return false;
[313]3767  }       
[815]3768#if POC_RESET_IDC_DECODER
3769  TComPic* pic = xGetRefPic( rcListPic, getPOC() );
[540]3770
3771  if( pic )
[442]3772  {
[540]3773    setBaseColPic(refLayerIdc, pic );
[442]3774  }
3775  else
3776  {
[540]3777    return false;
[442]3778  }
[540]3779 
3780  return true;
[442]3781#else
[815]3782  setBaseColPic(refLayerIdc, xGetRefPic(rcListPic, getPOC()));
3783  return true;
[442]3784#endif
[313]3785}
3786
[494]3787#if MFM_ENCCONSTRAINT
3788TComPic* TComSlice::getBaseColPic(  TComList<TComPic*>& rcListPic )
3789{
3790  return xGetRefPic( rcListPic, m_iPOC );
3791}
3792#endif
3793
[821]3794Void TComSlice::setILRPic(TComPic **pcIlpPic)
[313]3795{
[821]3796  for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
[313]3797  {
[821]3798    Int refLayerIdc = m_interLayerPredLayerIdc[i];
[313]3799
[821]3800    if( pcIlpPic[refLayerIdc] )
3801    {
3802      TComPic* pcRefPicBL = m_pcBaseColPic[refLayerIdc];
[713]3803
[869]3804      // copy scalability ratio, it is needed to get the correct location for the motion field of the corresponding reference layer block
[827]3805      pcIlpPic[refLayerIdc]->setSpatialEnhLayerFlag( refLayerIdc, m_pcPic->isSpatialEnhLayer(refLayerIdc) );
3806
[821]3807      pcIlpPic[refLayerIdc]->copyUpsampledPictureYuv( m_pcPic->getFullPelBaseRec( refLayerIdc ), pcIlpPic[refLayerIdc]->getPicYuvRec() );     
3808      pcIlpPic[refLayerIdc]->getSlice(0)->setBaseColPic( refLayerIdc, pcRefPicBL );
[313]3809
[821]3810      //set reference picture POC of each ILP reference
3811      pcIlpPic[refLayerIdc]->getSlice(0)->setPOC( m_iPOC );
[313]3812
[821]3813      //set temporal Id
3814      pcIlpPic[refLayerIdc]->getSlice(0)->setTLayer( m_uiTLayer );
[313]3815
[821]3816      //copy layer id from the reference layer
3817      pcIlpPic[refLayerIdc]->setLayerId( pcRefPicBL->getLayerId() );
[1083]3818      pcIlpPic[refLayerIdc]->getSlice(0)->setLayerId(pcRefPicBL->getLayerId());
[713]3819
[821]3820      pcIlpPic[refLayerIdc]->getPicYuvRec()->setBorderExtension( false );
3821      pcIlpPic[refLayerIdc]->getPicYuvRec()->extendPicBorder();
[1029]3822      for (Int j=0; j<pcIlpPic[refLayerIdc]->getPicSym()->getNumberOfCtusInFrame(); j++)    // set reference CU layerId
[821]3823      {
[1029]3824        pcIlpPic[refLayerIdc]->getPicSym()->getCtu(j)->setLayerId( pcIlpPic[refLayerIdc]->getLayerId() );
[821]3825      }
3826      pcIlpPic[refLayerIdc]->setIsLongTerm(1);
[713]3827
[1057]3828      // assign PPS to ILRP to be used for reference location offsets
[1030]3829      pcIlpPic[refLayerIdc]->getSlice(0)->setPPS( m_pcPic->getSlice(0)->getPPS() );
3830
[1057]3831      // assing VPS to ILRP to be used for deriving layerIdx
3832      pcIlpPic[refLayerIdc]->getSlice(0)->setVPS( m_pcPic->getSlice(0)->getVPS() );
3833
[821]3834#if REF_IDX_MFM
3835      if( m_bMFMEnabledFlag && !(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) )
3836      {
3837        //set reference picture POC of each ILP reference
3838        assert( pcIlpPic[refLayerIdc]->getPOC() == pcRefPicBL->getPOC() );
[313]3839
[821]3840        //copy slice type from the reference layer
3841        pcIlpPic[refLayerIdc]->getSlice(0)->setSliceType( pcRefPicBL->getSlice(0)->getSliceType() );
[313]3842
[821]3843        //copy "used for reference"
3844        pcIlpPic[refLayerIdc]->getSlice(0)->setReferenced( pcRefPicBL->getSlice(0)->isReferenced() );
[313]3845
[821]3846        for( Int refList = 0; refList < 2; refList++ )
3847        {
3848          RefPicList refPicList = RefPicList( refList );
3849
3850          //set reference POC of ILP
3851          pcIlpPic[refLayerIdc]->getSlice(0)->setNumRefIdx(refPicList, pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList));
3852          assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) >= 0);
3853          assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) <= MAX_NUM_REF);
3854
3855          //initialize reference POC of ILP
3856          for(Int refIdx = 0; refIdx < pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx++)
3857          {
3858            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(pcRefPicBL->getSlice(0)->getRefPOC(refPicList, refIdx), refPicList, refIdx);
3859            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(pcRefPicBL->getSlice(0)->getRefPic(refPicList, refIdx), refPicList, refIdx);
3860          }
3861
3862          for(Int refIdx = pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx < MAX_NUM_REF; refIdx++) 
3863          { 
3864            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(0, refPicList, refIdx); 
3865            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(NULL, refPicList, refIdx); 
3866          }
3867
3868          //copy reference pictures' marking from the reference layer
3869          for(Int j = 0; j < MAX_NUM_REF + 1; j++)
3870          {
3871            pcIlpPic[refLayerIdc]->getSlice(0)->setIsUsedAsLongTerm(refList, j, pcRefPicBL->getSlice(0)->getIsUsedAsLongTerm(refList, j));
3872          }
3873        }
3874
3875        pcIlpPic[refLayerIdc]->copyUpsampledMvField( refLayerIdc, m_pcBaseColPic[refLayerIdc] );
[313]3876      }
[821]3877      else
[713]3878      {
[821]3879        pcIlpPic[refLayerIdc]->initUpsampledMvField();
[713]3880      }
[313]3881#endif
3882
[1085]3883      Int maxTidIlRefPicsPlus1 = m_pcVPS->getMaxTidIlRefPicsPlus1( pcIlpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx() );
[821]3884      assert( (Int)pcIlpPic[refLayerIdc]->getSlice(0)->getTLayer() < maxTidIlRefPicsPlus1 || ( !maxTidIlRefPicsPlus1 && pcIlpPic[refLayerIdc]->getSlice(0)->getRapPicFlag() ) );
[494]3885
3886    }
3887  }
3888}
[890]3889
3890Int TComSlice::getReferenceLayerIdc( UInt refLayerId )
3891{ 
3892  for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
3893  {
3894    if( m_pcVPS->getRefLayerId(m_layerId, m_interLayerPredLayerIdc[i]) == refLayerId )
3895    {
3896      return m_interLayerPredLayerIdc[i];
3897    }
3898  }
3899
3900  return -1;
3901}
[1029]3902
3903Bool TComSlice::getBlaPicFlag       ()
3904{
3905    return  getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
3906    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
3907    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP;
3908}
[1139]3909
[1029]3910Bool TComSlice::getCraPicFlag       ()
3911{
3912    return getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
3913}
[1139]3914
[1029]3915#if POC_RESET_IDC_DECODER
3916Bool TComSlice::getRaslPicFlag      ()
3917{
3918  return  getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R
3919  || getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N;
3920}
3921Bool TComSlice::getRadlPicFlag      ()
3922{
3923  return  getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
3924  || getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N;
3925}
3926#endif
3927#if POC_RESET_IDC_ENCODER
3928Void TComSlice::decrementRefPocValues(Int const decrementValue)
3929{
3930  for(Int listNum = 0; listNum < 2; listNum++)
3931  {
3932    RefPicList dpbPicSliceList = (listNum == 1) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
3933    for(Int listIdx = 0; listIdx < getNumRefIdx( dpbPicSliceList ); listIdx++)
3934    {
3935      setRefPOC( getRefPOC(dpbPicSliceList, listIdx) - decrementValue, 
3936                  dpbPicSliceList,
3937                  listIdx
3938                  );
3939    }
3940  }
3941}
3942
3943Int TComSlice::getCurrMsb( Int currLsb, Int prevLsb, Int prevMsb, Int maxLsbVal )
3944{
3945  if( prevLsb - currLsb >= (maxLsbVal >> 1) )
3946  {
3947    return prevMsb + maxLsbVal;
3948  }
3949  else if( currLsb - prevLsb > (maxLsbVal >> 1) )
3950  {
3951    return prevMsb - maxLsbVal;
3952  }
3953  else
3954  {
3955    return prevMsb;
3956  }
3957}
3958#endif
3959
3960Void TComSlice::setRefPicListModificationSvc()
3961{
3962  if( !m_pcPPS->getListsModificationPresentFlag()) 
3963  {
3964    return;
3965  }
3966
3967  if(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA)
3968  {
3969    return;
3970  }
3971
3972  TComRefPicListModification* refPicListModification = &m_RefPicListModification;
3973  Int numberOfRpsCurrTempList = this->getNumRpsCurrTempList();  // total number of ref pics in listTemp0 including inter-layer ref pics
3974#if RPL_INIT_N0316_N0082
3975  Int numberOfPocBeforeCurr = this->getNumNegativeRpsCurrTempList();  // number of negative temporal ref pics
3976#endif
3977
3978  assert(m_aiNumRefIdx[REF_PIC_LIST_0] > 0);
3979  assert(m_aiNumRefIdx[REF_PIC_LIST_1] > 0);
3980
3981  //set L0 inter-layer reference picture modification
3982#if RPL_INIT_N0316_N0082
3983  Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == (numberOfPocBeforeCurr + m_activeNumILRRefIdx)) ? false : true;
3984
3985  if( m_activeNumILRRefIdx > 1 )
3986  {
3987    hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] >= (numberOfPocBeforeCurr + m_activeNumILRRefIdx)) ? false : true;
3988  }
3989#else
3990  Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == numberOfRpsCurrTempList) ? false : true;
3991#endif
3992  hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_0] > 1 );
3993  refPicListModification->setRefPicListModificationFlagL0(hasModification);
3994  if(hasModification)
3995  { 
3996    for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_0], numberOfRpsCurrTempList); i++)
3997    {
3998      refPicListModification->setRefPicSetIdxL0(i, i);
3999    }
4000
4001    if(m_aiNumRefIdx[REF_PIC_LIST_0] > numberOfRpsCurrTempList)
4002    {
4003      // repeat last ref pic when the number of active ref idx are more than RPS entries
4004      for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_0]; i ++)
4005      {
4006        refPicListModification->setRefPicSetIdxL0(i, numberOfRpsCurrTempList - 1);
4007      }
4008    }
4009    else
4010    {
4011      // number of ILRPs included into the reference picture list with the list modification
4012      Int includeNumILRP = min( max(1, m_aiNumRefIdx[REF_PIC_LIST_0]-numberOfPocBeforeCurr), m_activeNumILRRefIdx);
4013
4014      for(Int i = includeNumILRP; i > 0; i-- )
4015      {
4016#if RPL_INIT_N0316_N0082
4017        if((numberOfPocBeforeCurr) >= m_aiNumRefIdx[REF_PIC_LIST_0])
4018        {
4019          refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr + includeNumILRP - i);
4020        }
4021        else
4022        {
4023          refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr + includeNumILRP - i);
4024          for (Int j = numberOfPocBeforeCurr; j < (m_aiNumRefIdx[REF_PIC_LIST_0] - i); j++)
4025          {
4026            assert( j + includeNumILRP < numberOfRpsCurrTempList );
4027            refPicListModification->setRefPicSetIdxL0(j, j + includeNumILRP);
4028          }
4029        }
4030#else
4031        refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfRpsCurrTempList - i);
4032#endif
4033      }
4034    }
4035  }
4036
4037  //set L1 inter-layer reference picture modification
4038  hasModification = (m_aiNumRefIdx[REF_PIC_LIST_1] >= numberOfRpsCurrTempList) ? false : true;
4039  hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_1] > 1 );
4040
4041  refPicListModification->setRefPicListModificationFlagL1(hasModification);
4042  if(hasModification)
4043  { 
4044    for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_1], numberOfRpsCurrTempList); i++)
4045    {
4046      refPicListModification->setRefPicSetIdxL1(i, i);
4047    }
4048    if(m_aiNumRefIdx[REF_PIC_LIST_1] > numberOfRpsCurrTempList)
4049    {
4050      for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_1]; i ++)
4051      {
4052        // repeat last ref pic when the number of active ref idx are more than RPS entries
4053        refPicListModification->setRefPicSetIdxL1(i, numberOfRpsCurrTempList - 1); 
4054      }
4055    }
4056    else
4057    {
4058      Int includeNumILRP = min(m_aiNumRefIdx[REF_PIC_LIST_1], m_activeNumILRRefIdx);
4059
4060      for(Int i = includeNumILRP; i > 0; i-- )
4061      {
4062        refPicListModification->setRefPicSetIdxL1(m_aiNumRefIdx[REF_PIC_LIST_1] - i, numberOfRpsCurrTempList - i);
4063      }
4064    }
4065  }
4066  return;
4067}
4068
4069#if RPL_INIT_N0316_N0082
4070Int TComSlice::getNumNegativeRpsCurrTempList()
4071{
4072  if( m_eSliceType == I_SLICE ) 
4073  {
4074    return 0;
4075  }
4076
4077  Int numPocBeforeCurr = 0;
4078  for( UInt i = 0; i < m_pcRPS->getNumberOfNegativePictures(); i++ )
4079  {
4080    if(m_pcRPS->getUsed(i))
4081    {
4082      numPocBeforeCurr++;
4083    }
4084  }
4085
4086  return numPocBeforeCurr;
4087}
4088#endif
[494]4089#endif //SVC_EXTENSION
4090
[313]4091//! \}
Note: See TracBrowser for help on using the repository browser.