source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComSlice.cpp @ 1405

Last change on this file since 1405 was 1405, checked in by tech, 8 years ago

Merged HTM-16.1-dev@1404.

  • Property svn:eol-style set to native
File size: 173.2 KB
Line 
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
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2016, ITU/ISO/IEC
7 * All rights reserved.
8
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions are met:
12 *
13 *  * Redistributions of source code must retain the above copyright notice,
14 *    this list of conditions and the following disclaimer.
15 *  * Redistributions in binary form must reproduce the above copyright notice,
16 *    this list of conditions and the following disclaimer in the documentation
17 *    and/or other materials provided with the distribution.
18 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
19 *    be used to endorse or promote products derived from this software without
20 *    specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32 * THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/** \file     TComSlice.cpp
36    \brief    slice header and SPS class
37*/
38
39#include "CommonDef.h"
40#include "TComSlice.h"
41#include "TComPic.h"
42#include "TLibEncoder/TEncSbac.h"
43#include "TLibDecoder/TDecSbac.h"
44
45
46//! \ingroup TLibCommon
47//! \{
48
49TComSlice::TComSlice()
50: m_iPPSId                        ( -1 )
51, m_PicOutputFlag                 ( true )
52#if NH_MV
53, m_slicePicOrderCntLsb           ( 0 )
54#endif
55, m_iPOC                          ( 0 )
56, m_iLastIDR                      ( 0 )
57, m_iAssociatedIRAP               ( 0 )
58, m_iAssociatedIRAPType           ( NAL_UNIT_INVALID )
59, m_pRPS                          ( 0 )
60, m_localRPS                      ( )
61, m_rpsIdx                        ( 0 )
62, m_RefPicListModification        ( )
63, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
64, m_eSliceType                    ( I_SLICE )
65, m_iSliceQp                      ( 0 )
66, m_dependentSliceSegmentFlag     ( false )
67#if ADAPTIVE_QP_SELECTION
68, m_iSliceQpBase                  ( 0 )
69#endif
70, m_ChromaQpAdjEnabled            ( false )
71, m_deblockingFilterDisable       ( false )
72, m_deblockingFilterOverrideFlag  ( false )
73, m_deblockingFilterBetaOffsetDiv2( 0 )
74, m_deblockingFilterTcOffsetDiv2  ( 0 )
75, m_bCheckLDC                     ( false )
76, m_iSliceQpDelta                 ( 0 )
77, m_iDepth                        ( 0 )
78, m_bRefenced                     ( false )
79, m_pcVPS                         ( NULL )
80, m_pcSPS                         ( NULL )
81, m_pcPPS                         ( NULL )
82, m_pcPic                         ( NULL )
83, m_colFromL0Flag                 ( true )
84, m_noOutputPriorPicsFlag         ( false )
85, m_noRaslOutputFlag              ( false )
86, m_handleCraAsBlaFlag            ( false )
87, m_colRefIdx                     ( 0 )
88, m_maxNumMergeCand               ( 0 )
89, m_uiTLayer                      ( 0 )
90, m_bTLayerSwitchingFlag          ( false )
91, m_sliceMode                     ( NO_SLICES )
92, m_sliceArgument                 ( 0 )
93, m_sliceCurStartCtuTsAddr        ( 0 )
94, m_sliceCurEndCtuTsAddr          ( 0 )
95, m_sliceIdx                      ( 0 )
96, m_sliceSegmentMode              ( NO_SLICES )
97, m_sliceSegmentArgument          ( 0 )
98, m_sliceSegmentCurStartCtuTsAddr ( 0 )
99, m_sliceSegmentCurEndCtuTsAddr   ( 0 )
100, m_nextSlice                     ( false )
101, m_nextSliceSegment              ( false )
102, m_sliceBits                     ( 0 )
103, m_sliceSegmentBits              ( 0 )
104, m_bFinalized                    ( false )
105, m_bTestWeightPred               ( false )
106, m_bTestWeightBiPred             ( false )
107, m_substreamSizes                ( )
108, m_cabacInitFlag                 ( false )
109, m_bLMvdL1Zero                   ( false )
110, m_temporalLayerNonReferenceFlag ( false )
111, m_LFCrossSliceBoundaryFlag      ( false )
112, m_enableTMVPFlag                ( true )
113, m_encCABACTableIdx              (I_SLICE)
114#if NH_MV
115, m_refPicSetInterLayer0          ( NULL )
116, m_refPicSetInterLayer1          ( NULL )
117, m_layerId                       (0)
118, m_viewId                        (0)
119, m_viewIndex                     (0)
120#if NH_3D_VSO || NH_3D
121, m_isDepth                       (false)
122#endif
123#if NH_MV
124, m_pocResetFlag                  (false)
125, m_crossLayerBlaFlag             (false)
126#endif
127, m_discardableFlag               (false)
128, m_interLayerPredEnabledFlag     (false)
129, m_numInterLayerRefPicsMinus1    (0)
130#if NH_MV
131, m_sliceSegmentHeaderExtensionLength (0)
132, m_pocResetIdc                   (0)
133, m_pocResetPeriodId              (0)
134, m_hasPocResetPeriodIdPresent    (false)
135, m_fullPocResetFlag              (false)
136, m_pocLsbVal                     (0)
137, m_pocMsbCycleValPresentFlag     (false)
138, m_pocMsbCycleVal                (0)
139, m_pocMsbValRequiredFlag         (false)
140#endif
141#if NH_3D_IC
142, m_bApplyIC                      (false)
143, m_icSkipParseFlag               (false)
144#endif
145#if NH_3D
146, m_inCmpPredFlag                 (false)
147, m_numViews                      (0)
148, m_depthToDisparityB             (NULL)
149, m_depthToDisparityF             (NULL)
150#endif
151#if NH_3D_DIS
152, m_bApplyDIS                     (false)
153#endif
154#endif
155{
156
157#if NH_MV
158  m_shortTermRefPicSetIdx = 0; 
159  m_numLongTermSps        = 0; 
160  m_numLongTermPics       = 0; 
161  for (Int i = 0; i < MAX_NUM_PICS_RPS; i++)
162  {
163    m_ltIdxSps          [i] = 0; 
164    m_deltaPocMsbCycleLt[i] = 0;
165  }
166  setSliceTemporalMvpEnabledFlag( false ); 
167#endif
168  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
169  {
170    m_aiNumRefIdx[i] = 0;
171  }
172
173  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
174  {
175    m_lambdas            [component] = 0.0;
176    m_iSliceChromaQpDelta[component] = 0;
177  }
178
179  initEqualRef();
180
181  for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
182  {
183    m_list1IdxToList0Idx[idx] = -1;
184  }
185
186  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
187  {
188    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
189    {
190      m_apcRefPicList [i][iNumCount] = NULL;
191      m_aiRefPOCList  [i][iNumCount] = 0;
192    }
193#if NH_MV
194    m_aiRefLayerIdList[0][iNumCount] = 0;
195    m_aiRefLayerIdList[1][iNumCount] = 0;
196#endif
197  }
198
199  resetWpScaling();
200  initWpAcDcParam();
201
202  for(Int ch=0; ch < MAX_NUM_CHANNEL_TYPE; ch++)
203  {
204    m_saoEnabledFlag[ch] = false;
205  }
206#if NH_MV
207  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
208  {
209    m_interLayerPredLayerIdc[ i ] = -1;
210  }
211#endif
212#if NH_3D
213  m_iDefaultRefViewIdx = -1;
214  m_bDefaultRefViewIdxAvailableFlag = false;
215  m_ivMvPredFlag           = false;
216  m_ivMvScalingFlag        = false;
217  m_ivResPredFlag          = false; 
218  m_depthRefinementFlag    = false;
219  m_viewSynthesisPredFlag  = false;
220  m_depthBasedBlkPartFlag  = false;
221  m_mpiFlag                = false;
222  m_intraContourFlag       = false;
223  m_intraSdcWedgeFlag      = false;
224  m_qtPredFlag             = false;
225  m_interSdcFlag           = false;
226  m_depthIntraSkipFlag     = false;
227  m_subPbSize              =  1 << 6;
228  m_mpiSubPbSize           =  1 << 6;
229
230  m_aaiCodedOffset.resize(2);
231  m_aaiCodedScale .resize(2);
232  for (Int i = 0; i < 2; i++)
233  {
234    m_aaiCodedOffset[i].resize(MAX_NUM_LAYERS);
235    m_aaiCodedScale [i].resize(MAX_NUM_LAYERS);
236  }
237 
238#endif
239
240}
241
242TComSlice::~TComSlice()
243{
244#if NH_3D
245  for( UInt i = 0; i < m_numViews; i++ )
246  {
247    if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
248    {
249      delete[] m_depthToDisparityB [ i ];
250    }
251
252    if ( m_depthToDisparityF && m_depthToDisparityF[ i ] ) 
253    {
254      delete[] m_depthToDisparityF [ i ];
255    }
256  }
257
258  if ( m_depthToDisparityF )
259  {
260    delete[] m_depthToDisparityF; 
261  }
262
263  m_depthToDisparityF = NULL;
264
265  if ( m_depthToDisparityB )
266    delete[] m_depthToDisparityB; 
267
268  m_depthToDisparityB = NULL;
269#endif
270
271}
272
273
274Void TComSlice::initSlice()
275{
276  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
277  {
278    m_aiNumRefIdx[i]      = 0;
279  }
280  m_colFromL0Flag = true;
281
282  m_colRefIdx = 0;
283  initEqualRef();
284
285  m_bCheckLDC = false;
286
287  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
288  {
289    m_iSliceChromaQpDelta[component] = 0;
290  }
291#if NH_3D_IV_MERGE
292  m_maxNumMergeCand = MRG_MAX_NUM_CANDS_MEM;
293#else
294  m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
295#endif
296
297  m_bFinalized=false;
298
299  m_substreamSizes.clear();
300  m_cabacInitFlag        = false;
301  m_enableTMVPFlag = true;
302#if NH_3D_TMVP
303  m_aiAlterRefIdx[0]                  = -1;
304  m_aiAlterRefIdx[1]                  = -1;
305#endif
306}
307
308Bool TComSlice::getRapPicFlag() const
309{
310  return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
311      || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
312      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
313      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
314      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
315      || getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
316}
317
318
319Void  TComSlice::sortPicList        (TComList<TComPic*>& rcListPic)
320{
321  TComPic*    pcPicExtract;
322  TComPic*    pcPicInsert;
323
324  TComList<TComPic*>::iterator    iterPicExtract;
325  TComList<TComPic*>::iterator    iterPicExtract_1;
326  TComList<TComPic*>::iterator    iterPicInsert;
327
328  for (Int i = 1; i < (Int)(rcListPic.size()); i++)
329  {
330    iterPicExtract = rcListPic.begin();
331    for (Int j = 0; j < i; j++)
332    {
333      iterPicExtract++;
334    }
335    pcPicExtract = *(iterPicExtract);
336    pcPicExtract->setCurrSliceIdx(0);
337
338    iterPicInsert = rcListPic.begin();
339    while (iterPicInsert != iterPicExtract)
340    {
341      pcPicInsert = *(iterPicInsert);
342      pcPicInsert->setCurrSliceIdx(0);
343      if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
344      {
345        break;
346      }
347
348      iterPicInsert++;
349    }
350
351    iterPicExtract_1 = iterPicExtract;    iterPicExtract_1++;
352
353    //  swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
354    rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
355    rcListPic.erase  (iterPicExtract);
356  }
357}
358
359TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic, Int poc)
360{
361  TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
362  TComPic*                      pcPic = *(iterPic);
363  while ( iterPic != rcListPic.end() )
364  {
365    if(pcPic->getPOC() == poc)
366    {
367      break;
368    }
369    iterPic++;
370    pcPic = *(iterPic);
371  }
372  return  pcPic;
373}
374
375
376TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
377{
378  TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
379  TComPic*                      pcPic = *(iterPic);
380  TComPic*                      pcStPic = pcPic;
381
382  Int pocCycle = 1 << getSPS()->getBitsForPOC();
383  if (!pocHasMsb)
384  {
385    poc = poc & (pocCycle - 1);
386  }
387
388  while ( iterPic != rcListPic.end() )
389  {
390    pcPic = *(iterPic);
391    if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
392    {
393      Int picPoc = pcPic->getPOC();
394      if (!pocHasMsb)
395      {
396        picPoc = picPoc & (pocCycle - 1);
397      }
398
399      if (poc == picPoc)
400      {
401        if(pcPic->getIsLongTerm())
402        {
403          return pcPic;
404        }
405        else
406        {
407          pcStPic = pcPic;
408        }
409        break;
410      }
411    }
412
413    iterPic++;
414  }
415
416  return  pcStPic;
417}
418
419Void TComSlice::setRefPOCList       ()
420{
421  for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
422  {
423    for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
424    {
425      m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
426#if NH_MV
427      m_aiRefLayerIdList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getLayerId();
428#endif
429    }
430  }
431
432}
433
434Void TComSlice::setList1IdxToList0Idx()
435{
436  Int idxL0, idxL1;
437  for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
438  {
439    m_list1IdxToList0Idx[idxL1] = -1;
440    for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
441    {
442      if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
443      {
444        m_list1IdxToList0Idx[idxL1] = idxL0;
445        break;
446      }
447    }
448  }
449}
450
451#if !NH_MV
452Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
453{
454    if (m_eSliceType == I_SLICE)
455    {
456      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
457      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
458
459    if (!checkNumPocTotalCurr)
460    {
461      return;
462    }
463  }
464
465  TComPic*  pcRefPic= NULL;
466  static const UInt MAX_NUM_NEGATIVE_PICTURES=16;
467  TComPic*  RefPicSetStCurr0[MAX_NUM_NEGATIVE_PICTURES];
468  TComPic*  RefPicSetStCurr1[MAX_NUM_NEGATIVE_PICTURES];
469  TComPic*  RefPicSetLtCurr[MAX_NUM_NEGATIVE_PICTURES];
470  UInt NumPicStCurr0 = 0;
471  UInt NumPicStCurr1 = 0;
472  UInt NumPicLtCurr = 0;
473  Int i;
474
475  for(i=0; i < m_pRPS->getNumberOfNegativePictures(); i++)
476  {
477    if(m_pRPS->getUsed(i))
478    {
479      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pRPS->getDeltaPOC(i));
480      pcRefPic->setIsLongTerm(0);
481      pcRefPic->getPicYuvRec()->extendPicBorder();
482      RefPicSetStCurr0[NumPicStCurr0] = pcRefPic;
483      NumPicStCurr0++;
484      pcRefPic->setCheckLTMSBPresent(false);
485    }
486  }
487
488  for(; i < m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures(); i++)
489  {
490    if(m_pRPS->getUsed(i))
491    {
492      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pRPS->getDeltaPOC(i));
493      pcRefPic->setIsLongTerm(0);
494      pcRefPic->getPicYuvRec()->extendPicBorder();
495      RefPicSetStCurr1[NumPicStCurr1] = pcRefPic;
496      NumPicStCurr1++;
497      pcRefPic->setCheckLTMSBPresent(false);
498    }
499  }
500
501  for(i = m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures()+m_pRPS->getNumberOfLongtermPictures()-1; i > m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures()-1 ; i--)
502  {
503    if(m_pRPS->getUsed(i))
504    {
505      pcRefPic = xGetLongTermRefPic(rcListPic, m_pRPS->getPOC(i), m_pRPS->getCheckLTMSBPresent(i));
506      pcRefPic->setIsLongTerm(1);
507      pcRefPic->getPicYuvRec()->extendPicBorder();
508      RefPicSetLtCurr[NumPicLtCurr] = pcRefPic;
509      NumPicLtCurr++;
510    }
511    if(pcRefPic==NULL)
512    {
513      pcRefPic = xGetLongTermRefPic(rcListPic, m_pRPS->getPOC(i), m_pRPS->getCheckLTMSBPresent(i));
514    }
515    pcRefPic->setCheckLTMSBPresent(m_pRPS->getCheckLTMSBPresent(i));
516  }
517
518  // ref_pic_list_init
519  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
520  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
521  Int numPicTotalCurr = NumPicStCurr0 + NumPicStCurr1 + NumPicLtCurr;
522
523  if (checkNumPocTotalCurr)
524  {
525    // 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:
526    // - If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
527    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
528    if (getRapPicFlag())
529    {
530      assert(numPicTotalCurr == 0);
531    }
532
533    if (m_eSliceType == I_SLICE)
534    {
535      return;
536    }
537
538    assert(numPicTotalCurr > 0);
539    // general tier and level limit:
540    assert(numPicTotalCurr <= 8);
541  }
542
543  Int cIdx = 0;
544  for ( i=0; i<NumPicStCurr0; i++, cIdx++)
545  {
546    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
547  }
548  for ( i=0; i<NumPicStCurr1; i++, cIdx++)
549  {
550    rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
551  }
552  for ( i=0; i<NumPicLtCurr;  i++, cIdx++)
553  {
554    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
555  }
556  assert(cIdx == numPicTotalCurr);
557
558  if (m_eSliceType==B_SLICE)
559  {
560    cIdx = 0;
561    for ( i=0; i<NumPicStCurr1; i++, cIdx++)
562    {
563      rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
564    }
565    for ( i=0; i<NumPicStCurr0; i++, cIdx++)
566    {
567      rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
568    }
569    for ( i=0; i<NumPicLtCurr;  i++, cIdx++)
570    {
571      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
572    }
573    assert(cIdx == numPicTotalCurr);
574  }
575
576  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
577
578  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_0]; rIdx ++)
579  {
580    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPicTotalCurr;
581    assert(cIdx >= 0 && cIdx < numPicTotalCurr);
582    m_apcRefPicList[REF_PIC_LIST_0][rIdx] = rpsCurrList0[ cIdx ];
583    m_bIsUsedAsLongTerm[REF_PIC_LIST_0][rIdx] = ( cIdx >= NumPicStCurr0 + NumPicStCurr1 );
584  }
585  if ( m_eSliceType != B_SLICE )
586  {
587    m_aiNumRefIdx[REF_PIC_LIST_1] = 0;
588    ::memset( m_apcRefPicList[REF_PIC_LIST_1], 0, sizeof(m_apcRefPicList[REF_PIC_LIST_1]));
589  }
590  else
591  {
592    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_1]; rIdx ++)
593    {
594      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPicTotalCurr;
595      assert(cIdx >= 0 && cIdx < numPicTotalCurr);
596      m_apcRefPicList[REF_PIC_LIST_1][rIdx] = rpsCurrList1[ cIdx ];
597      m_bIsUsedAsLongTerm[REF_PIC_LIST_1][rIdx] = ( cIdx >= NumPicStCurr0 + NumPicStCurr1 );
598    }
599  }
600}
601#else
602Void TComSlice::getTempRefPicLists( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
603                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr )
604{
605  if (!checkNumPocTotalCurr)
606  {
607    if (m_eSliceType == I_SLICE)
608    {     
609      return;
610    }   
611  }
612
613  TComPic*  pcRefPic= NULL;
614  TComPic*  RefPicSetStCurr0[16];
615  TComPic*  RefPicSetStCurr1[16];
616  TComPic*  RefPicSetLtCurr[16];
617  UInt NumPocStCurr0 = 0;
618  UInt NumPocStCurr1 = 0;
619  UInt NumPocLtCurr = 0;
620  Int i;
621#if NH_3D
622  m_pocsInCurrRPSs.clear();
623#endif
624  for(i=0; i < m_pRPS->getNumberOfNegativePictures(); i++)
625  {
626    if(m_pRPS->getUsed(i))
627    {
628      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pRPS->getDeltaPOC(i));
629      pcRefPic->setIsLongTerm(0);
630      pcRefPic->getPicYuvRec()->extendPicBorder();
631      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
632      NumPocStCurr0++;
633      pcRefPic->setCheckLTMSBPresent(false); 
634#if NH_3D
635      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() ); 
636#endif
637    }
638  }
639 
640  for(; i < m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures(); i++)
641  {
642    if(m_pRPS->getUsed(i))
643    {
644      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pRPS->getDeltaPOC(i));
645      pcRefPic->setIsLongTerm(0);
646      pcRefPic->getPicYuvRec()->extendPicBorder();
647      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
648      NumPocStCurr1++;
649      pcRefPic->setCheckLTMSBPresent(false); 
650#if NH_3D
651      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() ); 
652#endif
653    }
654  }
655 
656  for(i = m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures()+m_pRPS->getNumberOfLongtermPictures()-1; i > m_pRPS->getNumberOfNegativePictures()+m_pRPS->getNumberOfPositivePictures()-1 ; i--)
657  {
658    if(m_pRPS->getUsed(i))
659    {
660      pcRefPic = xGetLongTermRefPic(rcListPic, m_pRPS->getPOC(i), m_pRPS->getCheckLTMSBPresent(i));
661      pcRefPic->setIsLongTerm(1);
662      pcRefPic->getPicYuvRec()->extendPicBorder();
663      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
664      NumPocLtCurr++;
665#if NH_3D
666      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() ); 
667#endif
668    }
669    if(pcRefPic==NULL) 
670    {
671      pcRefPic = xGetLongTermRefPic(rcListPic, m_pRPS->getPOC(i), m_pRPS->getCheckLTMSBPresent(i));
672    }
673    pcRefPic->setCheckLTMSBPresent(m_pRPS->getCheckLTMSBPresent(i)); 
674  }
675
676  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr; 
677#if NH_3D
678  assert( numPocInterCurr == (Int) m_pocsInCurrRPSs.size() ); 
679#endif
680  numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
681  assert( numPocTotalCurr == getNumRpsCurrTempList() );
682
683  if (checkNumPocTotalCurr)
684  {
685    // 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:
686    // - If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
687    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
688    if ( getRapPicFlag() && m_layerId == 0 )
689    {
690      assert(numPocTotalCurr == 0);
691    }
692
693    if (m_eSliceType == I_SLICE)
694    {
695      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
696      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
697     
698      return;
699    }
700   
701    assert(numPocTotalCurr > 0);
702   
703    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
704    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
705  }
706
707  std::vector<TComPic*>* refPicSetInterLayer[2] = { &refPicSetInterLayer0, &refPicSetInterLayer1}; 
708  Int numPocInterLayer[2] = { getNumActiveRefLayerPics0( ), getNumActiveRefLayerPics1( ) }; 
709 
710  TComPic**             refPicSetStCurr    [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
711  Int numPocStCurr[2] = { (Int)NumPocStCurr0, (Int)NumPocStCurr1 }; 
712
713  for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
714  { 
715    rpsCurrList   [li].resize(MAX_NUM_REF+1,NULL ); 
716    usedAsLongTerm[li].resize(MAX_NUM_REF+1,false); 
717
718    Int cIdx = 0;
719    for ( i=0; i < numPocStCurr[li]; i++, cIdx++)
720    {
721      rpsCurrList[li][cIdx] = refPicSetStCurr[li][i];
722      usedAsLongTerm [li][cIdx] = false; 
723    }
724
725    for ( i=0; i < numPocInterLayer[li];  i++, cIdx++)
726    {   
727      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[li])[i];
728      usedAsLongTerm [li][cIdx] = true; 
729    }
730
731    for ( i=0; i < numPocStCurr[1-li]; i++, cIdx++)
732    {
733      rpsCurrList[li][cIdx] = refPicSetStCurr[1-li][i];
734      usedAsLongTerm [li][cIdx] = false; 
735    }
736
737    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
738    {
739      rpsCurrList[li][cIdx] = RefPicSetLtCurr[i];
740      usedAsLongTerm [li][cIdx] = true; 
741    }
742
743    for ( i=0; i < numPocInterLayer[1-li];  i++, cIdx++)
744    {   
745      assert( cIdx < MAX_NUM_REF );   
746      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[1-li])[i];
747      usedAsLongTerm [li][cIdx] = true; 
748    }
749
750    assert(cIdx == numPocTotalCurr);
751  }
752}
753
754Void TComSlice::setRefPicList( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr )
755
756{
757  if (!checkNumPocTotalCurr)
758  {
759    if (m_eSliceType == I_SLICE)
760    {
761      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
762      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
763
764      return;
765    }   
766  }
767
768  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
769
770  for (Int li = 0; li < 2; li++)
771  {
772    if ( m_eSliceType == P_SLICE && li == 1 )
773    {
774      m_aiNumRefIdx[1] = 0;
775      ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
776    } 
777    else
778    {
779      for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
780      { 
781        Bool listModified             =                m_RefPicListModification.getRefPicListModificationFlagL( li ); 
782        Int orgIdx                    = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr); 
783
784        assert( rpsCurrList[li][ orgIdx ] != NULL ); 
785        assert( rpsCurrList[li][ orgIdx ]->getSlice(0)->getDiscardableFlag() == 0 );    // Inter-layer RPS shall not contain picture with discardable_flag = 1.
786        m_apcRefPicList    [li][rIdx] = rpsCurrList    [li][ orgIdx ];
787        m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ; 
788      }
789    }
790  }
791}
792#endif
793
794
795Int TComSlice::getNumRpsCurrTempList() const
796{
797  Int numRpsCurrTempList = 0;
798
799  if (m_eSliceType == I_SLICE)
800  {
801    return 0;
802  }
803  for(UInt i=0; i < m_pRPS->getNumberOfNegativePictures()+ m_pRPS->getNumberOfPositivePictures() + m_pRPS->getNumberOfLongtermPictures(); i++)
804  {
805    if(m_pRPS->getUsed(i))
806    {
807      numRpsCurrTempList++;
808    }
809  }
810#if NH_MV
811    numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
812#endif
813  return numRpsCurrTempList;
814}
815
816Void TComSlice::initEqualRef()
817{
818  for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
819  {
820    for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
821    {
822      for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
823      {
824        m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
825      }
826    }
827  }
828}
829#if NH_3D
830#if NH_3D_TMVP
831Void TComSlice::generateAlterRefforTMVP()
832{
833  for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
834  {       
835    if ( this->getNumRefIdx( RefPicList( uiRefListIdx ) ) == 0)
836    {
837        continue;
838    }
839    Bool bZeroIdxLtFlag = this->getRefPic(RefPicList(uiRefListIdx), 0)->getIsLongTerm();
840    for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
841    {
842      if ( ( bZeroIdxLtFlag && !this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) ||
843           (!bZeroIdxLtFlag &&  this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) )
844      {
845        this->setAlterRefIdx(RefPicList(uiRefListIdx),i);
846        break;
847      }
848    }
849  }
850}
851#endif
852#endif
853
854#if NH_3D
855Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
856{ 
857  Int voiInVps      = m_pcVPS->getVoiInVps(getViewIndex() ); 
858  if( m_pcVPS->getNumCp( voiInVps ) > 0 )
859  {   
860    if( m_pcVPS->getCpInSliceSegmentHeaderFlag( voiInVps ) )
861    {
862      for( Int m = 0; m < m_pcVPS->getNumCp( voiInVps ); m++ )
863      {     
864        Int j      = m_pcVPS->getCpRefVoi( voiInVps, m );
865        Int jInVps = m_pcVPS->getVoiInVps( j ); 
866
867        setCpScale   ( jInVps , aaiScale [ jInVps   ][ voiInVps ]);
868        setCpInvScale( jInVps , aaiScale [ voiInVps ][ jInVps   ]);
869        setCpOff     ( jInVps , aaiOffset[ jInVps   ][ voiInVps ]);
870        setCpInvOff  ( jInVps , aaiOffset[ voiInVps ][ jInVps   ]);
871      }
872    }
873  } 
874}
875#endif
876
877Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
878{
879  Int i;
880  TComSlice* curSlice = pic->getSlice(curSliceIdx);
881  Int currColRefPOC =  curSlice->getRefPOC( RefPicList(1 - curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
882  TComSlice* preSlice;
883  Int preColRefPOC;
884  for(i=curSliceIdx-1; i>=0; i--)
885  {
886    preSlice = pic->getSlice(i);
887    if(preSlice->getSliceType() != I_SLICE)
888    {
889      preColRefPOC  = preSlice->getRefPOC( RefPicList(1 - preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
890      if(currColRefPOC != preColRefPOC)
891      {
892        printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
893        exit(EXIT_FAILURE);
894      }
895      else
896      {
897        break;
898      }
899    }
900  }
901}
902
903Void TComSlice::checkCRA(const TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic)
904{
905  for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
906  {
907    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
908    {
909      assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
910    }
911  }
912  for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
913  {
914    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
915    {
916      if (!pReferencePictureSet->getCheckLTMSBPresent(i))
917      {
918        assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
919      }
920      else
921      {
922        assert(pReferencePictureSet->getPOC(i) >= pocCRA);
923      }
924    }
925  }
926  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
927  {
928    pocCRA = getPOC();
929    associatedIRAPType = getNalUnitType();
930  }
931  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
932  {
933    pocCRA = getPOC();
934    associatedIRAPType = getNalUnitType();
935  }
936  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
937         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
938         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
939  {
940    pocCRA = getPOC();
941    associatedIRAPType = getNalUnitType();
942  }
943}
944
945/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
946 * \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
947 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
948 * \param rcListPic reference to the reference picture list
949 * This function marks the reference pictures as "unused for reference" in the following conditions.
950 * If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
951 * are marked as "unused for reference"
952 *    If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
953 * Otherwise
954 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
955 *    temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
956 *    mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
957 *    the bRefreshPending flag to false.
958 *    If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
959 *    reference of the current picture.
960 * Note that the current picture is already placed in the reference list and its marking is not changed.
961 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
962 */
963Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic, const bool bEfficientFieldIRAPEnabled)
964{
965  TComPic* rpcPic;
966  Int      pocCurr = getPOC();
967
968  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
969    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
970    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
971    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
972    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )  // IDR or BLA picture
973  {
974    // mark all pictures as not used for reference
975    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
976    while (iterPic != rcListPic.end())
977    {
978      rpcPic = *(iterPic);
979      rpcPic->setCurrSliceIdx(0);
980      if (rpcPic->getPOC() != pocCurr)
981      {
982        rpcPic->getSlice(0)->setReferenced(false);
983      }
984      iterPic++;
985    }
986    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
987      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
988      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
989    {
990      pocCRA = pocCurr;
991    }
992    if (bEfficientFieldIRAPEnabled)
993    {
994    bRefreshPending = true;
995    }
996  }
997  else // CRA or No DR
998  {
999    if(bEfficientFieldIRAPEnabled && (getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1000    {
1001      if (bRefreshPending==true && pocCurr > m_iLastIDR) // IDR reference marking pending
1002      {
1003        TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
1004        while (iterPic != rcListPic.end())
1005        {
1006          rpcPic = *(iterPic);
1007          if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != m_iLastIDR)
1008          {
1009            rpcPic->getSlice(0)->setReferenced(false);
1010          }
1011          iterPic++;
1012        }
1013        bRefreshPending = false; 
1014      }
1015    }
1016    else
1017    {
1018      if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
1019      {
1020        TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1021        while (iterPic != rcListPic.end())
1022        {
1023          rpcPic = *(iterPic);
1024          if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
1025          {
1026            rpcPic->getSlice(0)->setReferenced(false);
1027          }
1028          iterPic++;
1029        }
1030        bRefreshPending = false;
1031      }
1032    }
1033    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
1034    {
1035      bRefreshPending = true;
1036      pocCRA = pocCurr;
1037    }
1038  }
1039}
1040
1041Void TComSlice::copySliceInfo(TComSlice *pSrc)
1042{
1043  assert( pSrc != NULL );
1044
1045  Int i, j, k;
1046
1047  m_iPOC                 = pSrc->m_iPOC;
1048  m_eNalUnitType         = pSrc->m_eNalUnitType;
1049#if NH_MV
1050  m_layerId              = pSrc->m_layerId;
1051  // GT: Copying of several other values might be be missing here, or is above not necessary?
1052#endif
1053  m_eSliceType           = pSrc->m_eSliceType;
1054  m_iSliceQp             = pSrc->m_iSliceQp;
1055#if ADAPTIVE_QP_SELECTION
1056  m_iSliceQpBase         = pSrc->m_iSliceQpBase;
1057#endif
1058  m_ChromaQpAdjEnabled = pSrc->m_ChromaQpAdjEnabled;
1059  m_deblockingFilterDisable   = pSrc->m_deblockingFilterDisable;
1060  m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
1061  m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
1062  m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
1063
1064  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1065  {
1066    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
1067  }
1068
1069  for (i = 0; i < MAX_NUM_REF; i++)
1070  {
1071    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
1072  }
1073
1074  m_bCheckLDC             = pSrc->m_bCheckLDC;
1075  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
1076  for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
1077  {
1078    m_iSliceChromaQpDelta[component] = pSrc->m_iSliceChromaQpDelta[component];
1079  }
1080  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1081  {
1082    for (j = 0; j < MAX_NUM_REF; j++)
1083    {
1084      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
1085      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
1086      m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
1087#if NH_MV
1088      m_aiRefLayerIdList[i][j] = pSrc->m_aiRefLayerIdList[i][j];
1089#endif
1090    }
1091    m_bIsUsedAsLongTerm[i][MAX_NUM_REF] = pSrc->m_bIsUsedAsLongTerm[i][MAX_NUM_REF];
1092  }
1093  m_iDepth               = pSrc->m_iDepth;
1094
1095  // referenced slice
1096  m_bRefenced            = pSrc->m_bRefenced;
1097
1098  // access channel
1099#if NH_MV
1100  m_pcVPS                = pSrc->m_pcVPS;
1101#endif
1102  m_pRPS                = pSrc->m_pRPS;
1103  m_iLastIDR             = pSrc->m_iLastIDR;
1104
1105  m_pcPic                = pSrc->m_pcPic;
1106
1107  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
1108  m_colRefIdx            = pSrc->m_colRefIdx;
1109
1110  setLambdas(pSrc->getLambdas());
1111
1112  for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1113  {
1114    for (j = 0; j < MAX_NUM_REF; j++)
1115    {
1116      for (k =0; k < MAX_NUM_REF; k++)
1117      {
1118        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1119      }
1120    }
1121  }
1122
1123  m_uiTLayer                      = pSrc->m_uiTLayer;
1124  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
1125
1126  m_sliceMode                     = pSrc->m_sliceMode;
1127  m_sliceArgument                 = pSrc->m_sliceArgument;
1128  m_sliceCurStartCtuTsAddr        = pSrc->m_sliceCurStartCtuTsAddr;
1129  m_sliceCurEndCtuTsAddr          = pSrc->m_sliceCurEndCtuTsAddr;
1130  m_sliceIdx                      = pSrc->m_sliceIdx;
1131  m_sliceSegmentMode              = pSrc->m_sliceSegmentMode;
1132  m_sliceSegmentArgument          = pSrc->m_sliceSegmentArgument;
1133  m_sliceSegmentCurStartCtuTsAddr = pSrc->m_sliceSegmentCurStartCtuTsAddr;
1134  m_sliceSegmentCurEndCtuTsAddr   = pSrc->m_sliceSegmentCurEndCtuTsAddr;
1135  m_nextSlice                     = pSrc->m_nextSlice;
1136  m_nextSliceSegment              = pSrc->m_nextSliceSegment;
1137
1138  for ( UInt e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1139  {
1140    for ( UInt n=0 ; n<MAX_NUM_REF ; n++ )
1141    {
1142      memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(WPScalingParam)*MAX_NUM_COMPONENT );
1143    }
1144  }
1145
1146  for( UInt ch = 0 ; ch < MAX_NUM_CHANNEL_TYPE; ch++)
1147  {
1148    m_saoEnabledFlag[ch] = pSrc->m_saoEnabledFlag[ch];
1149  }
1150
1151  m_cabacInitFlag                 = pSrc->m_cabacInitFlag;
1152
1153  m_bLMvdL1Zero                   = pSrc->m_bLMvdL1Zero;
1154  m_LFCrossSliceBoundaryFlag      = pSrc->m_LFCrossSliceBoundaryFlag;
1155  m_enableTMVPFlag                = pSrc->m_enableTMVPFlag;
1156  m_maxNumMergeCand               = pSrc->m_maxNumMergeCand;
1157  m_encCABACTableIdx              = pSrc->m_encCABACTableIdx;
1158
1159#if NH_MV
1160  // Additional slice header syntax elements
1161  m_pocResetFlag               = pSrc->m_pocResetFlag; 
1162  m_discardableFlag            = pSrc->m_discardableFlag; 
1163  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag; 
1164  m_numInterLayerRefPicsMinus1 = pSrc->m_numInterLayerRefPicsMinus1;
1165
1166  for (Int layer = 0; layer < MAX_NUM_LAYERS; layer++ )
1167  {
1168    m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 
1169  }
1170#endif
1171#if NH_3D_DIS
1172  m_bApplyDIS = pSrc->m_bApplyDIS;
1173#endif
1174#if NH_3D_IC
1175  m_bApplyIC = pSrc->m_bApplyIC;
1176  m_icSkipParseFlag = pSrc->m_icSkipParseFlag;
1177#endif
1178
1179}
1180
1181
1182/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1183 * \param uiTLayer Temporal layer ID of the current slice
1184 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1185 * the SPS's temporal_id_nesting_flag and the parsed PPS.  Then, current slice's temporal layer ID and
1186 * temporal_layer_switching_point_flag is set accordingly.
1187 */
1188Void TComSlice::setTLayerInfo( UInt uiTLayer )
1189{
1190  m_uiTLayer = uiTLayer;
1191}
1192
1193/** Function for checking if this is a switching-point
1194*/
1195Bool TComSlice::isTemporalLayerSwitchingPoint(TComList<TComPic*>& rcListPic)
1196{
1197  TComPic* rpcPic;
1198  // loop through all pictures in the reference picture buffer
1199  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1200  while ( iterPic != rcListPic.end())
1201  {
1202    rpcPic = *(iterPic++);
1203    if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1204    {
1205      if(rpcPic->getTLayer() >= getTLayer())
1206      {
1207        return false;
1208      }
1209    }
1210  }
1211  return true;
1212}
1213
1214/** Function for checking if this is a STSA candidate
1215 */
1216Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate(TComList<TComPic*>& rcListPic)
1217{
1218  TComPic* rpcPic;
1219
1220  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1221  while ( iterPic != rcListPic.end())
1222  {
1223    rpcPic = *(iterPic++);
1224    if(rpcPic->getSlice(0)->isReferenced() &&  (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1225    {
1226      if(rpcPic->getTLayer() >= getTLayer())
1227      {
1228        return false;
1229      }
1230    }
1231  }
1232  return true;
1233}
1234
1235
1236Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1237{
1238  TComPic* rpcPic;
1239
1240  Int nalUnitType = this->getNalUnitType();
1241
1242  // When a picture is a leading picture, it shall be a RADL or RASL picture.
1243  if(this->getAssociatedIRAPPOC() > this->getPOC())
1244  {
1245    // Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1246    if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP ||
1247       nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1248    {
1249      assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1250             nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1251             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1252             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1253    }
1254  }
1255
1256  // When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1257  if(this->getAssociatedIRAPPOC() < this->getPOC())
1258  {
1259    assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1260           nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1261           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1262           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1263  }
1264
1265  // No RASL pictures shall be present in the bitstream that are associated
1266  // with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1267  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1268     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1269  {
1270    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1271           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1272  }
1273
1274  // No RASL pictures shall be present in the bitstream that are associated with
1275  // an IDR picture.
1276  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1277     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1278  {
1279    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP   &&
1280           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1281  }
1282
1283  // No RADL pictures shall be present in the bitstream that are associated with
1284  // a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1285  // with an IDR picture having nal_unit_type equal to IDR_N_LP.
1286  if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1287     nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1288  {
1289    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP   &&
1290           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1291  }
1292
1293  // loop through all pictures in the reference picture buffer
1294  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1295  while ( iterPic != rcListPic.end())
1296  {
1297    rpcPic = *(iterPic++);
1298    if(!rpcPic->getReconMark())
1299    {
1300      continue;
1301    }
1302    if (rpcPic->getPOC() == this->getPOC())
1303    {
1304      continue;
1305    }
1306
1307    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1308    // in decoding order shall precede the IRAP picture in output order.
1309    // (Note that any picture following in output order would be present in the DPB)
1310    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1 && !this->getNoOutputPriorPicsFlag())
1311    {
1312      if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP    ||
1313         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP    ||
1314         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL  ||
1315         nalUnitType == NAL_UNIT_CODED_SLICE_CRA         ||
1316         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP    ||
1317         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1318      {
1319        assert(rpcPic->getPOC() < this->getPOC());
1320      }
1321    }
1322
1323    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1324    // in decoding order shall precede any RADL picture associated with the IRAP
1325    // picture in output order.
1326    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1327    {
1328      if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1329          nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1330      {
1331        // rpcPic precedes the IRAP in decoding order
1332        if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1333        {
1334          // rpcPic must not be the IRAP picture
1335          if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1336          {
1337            assert(rpcPic->getPOC() < this->getPOC());
1338          }
1339        }
1340      }
1341    }
1342
1343    // When a picture is a leading picture, it shall precede, in decoding order,
1344    // all trailing pictures that are associated with the same IRAP picture.
1345      if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1346         nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1347         nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1348         nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1349      {
1350        if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1351        {
1352          // rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1353          // rpcPic would violate the constraint if it was a trailing picture
1354          assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1355        }
1356      }
1357
1358    // Any RASL picture associated with a CRA or BLA picture shall precede any
1359    // RADL picture associated with the CRA or BLA picture in output order
1360    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1361       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1362    {
1363      if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1364          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1365          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1366          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)       &&
1367          this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1368      {
1369        if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
1370           rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1371        {
1372          assert(rpcPic->getPOC() > this->getPOC());
1373        }
1374      }
1375    }
1376
1377    // Any RASL picture associated with a CRA picture shall follow, in output
1378    // order, any IRAP picture that precedes the CRA picture in decoding order.
1379    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1380       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1381    {
1382      if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1383      {
1384        if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1385           (rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1386            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1387            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1388            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP   ||
1389            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
1390            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1391        {
1392          assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1393        }
1394      }
1395    }
1396  }
1397}
1398
1399
1400
1401/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1402*/
1403Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet)
1404{
1405  TComPic* rpcPic;
1406  Int i, isReference;
1407
1408  checkLeadingPictureRestrictions(rcListPic);
1409
1410  // loop through all pictures in the reference picture buffer
1411  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1412  while ( iterPic != rcListPic.end())
1413  {
1414    rpcPic = *(iterPic++);
1415
1416    if(!rpcPic->getSlice( 0 )->isReferenced())
1417    {
1418      continue;
1419    }
1420
1421    isReference = 0;
1422    // loop through all pictures in the Reference Picture Set
1423    // to see if the picture should be kept as reference picture
1424    for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1425    {
1426      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1427      {
1428        isReference = 1;
1429        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1430        rpcPic->setIsLongTerm(0);
1431      }
1432    }
1433    for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1434    {
1435      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1436      {
1437        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1438        {
1439          isReference = 1;
1440          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1441        }
1442      }
1443      else
1444      {
1445        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1446        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1447        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1448        if(rpcPic->getIsLongTerm() && curPoc == refPoc)
1449        {
1450          isReference = 1;
1451          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1452        }
1453      }
1454
1455    }
1456#if NH_MV
1457    if( isReference ) // Current picture is in the temporal RPS
1458    {
1459      assert( rpcPic->getSlice(0)->getDiscardableFlag() == 0 ); // Temporal RPS shall not contain picture with discardable_flag equal to 1
1460    }
1461#endif
1462    // mark the picture as "unused for reference" if it is not in
1463    // the Reference Picture Set
1464    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
1465    {
1466      rpcPic->getSlice( 0 )->setReferenced( false );
1467      rpcPic->setUsedByCurr(0);
1468      rpcPic->setIsLongTerm(0);
1469    }
1470    //check that pictures of higher temporal layers are not used
1471    assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
1472    //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1473    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1474    {
1475      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
1476    }
1477    //check that pictures marked as temporal layer non-reference pictures are not used for reference
1478    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1479    {
1480      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1481    }
1482  }
1483}
1484
1485/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1486*/
1487Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess, Bool bUseRecoveryPoint)
1488{
1489  Int atLeastOneUnabledByRecoveryPoint = 0;
1490  Int atLeastOneFlushedByPreviousIDR = 0;
1491  TComPic* rpcPic;
1492  Int i, isAvailable;
1493  Int atLeastOneLost = 0;
1494  Int atLeastOneRemoved = 0;
1495  Int iPocLost = 0;
1496
1497  // loop through all long-term pictures in the Reference Picture Set
1498  // to see if the picture should be kept as reference picture
1499  for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1500  {
1501    isAvailable = 0;
1502    // loop through all pictures in the reference picture buffer
1503    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1504    while ( iterPic != rcListPic.end())
1505    {
1506      rpcPic = *(iterPic++);
1507      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1508      {
1509        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1510        {
1511          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1512          {
1513            isAvailable = 0;
1514          }
1515          else
1516          {
1517            isAvailable = 1;
1518          }
1519        }
1520      }
1521      else
1522      {
1523        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1524        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1525        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1526        if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
1527        {
1528          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1529          {
1530            isAvailable = 0;
1531          }
1532          else
1533          {
1534            isAvailable = 1;
1535          }
1536        }
1537      }
1538    }
1539    // if there was no such long-term check the short terms
1540    if(!isAvailable)
1541    {
1542      iterPic = rcListPic.begin();
1543      while ( iterPic != rcListPic.end())
1544      {
1545        rpcPic = *(iterPic++);
1546
1547        Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1548        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1549        Int refPoc = pReferencePictureSet->getPOC(i);
1550        if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1551        {
1552          curPoc = curPoc & (pocCycle - 1);
1553          refPoc = refPoc & (pocCycle - 1);
1554        }
1555
1556        if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1557        {
1558          if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1559          {
1560            isAvailable = 0;
1561          }
1562          else
1563          {
1564            isAvailable = 1;
1565            rpcPic->setIsLongTerm(1);
1566            break;
1567          }
1568        }
1569      }
1570    }
1571    // report that a picture is lost if it is in the Reference Picture Set
1572    // but not available as reference picture
1573    if(isAvailable == 0)
1574    {
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      }
1595      else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1596      {
1597        atLeastOneUnabledByRecoveryPoint = 1;
1598      }
1599      else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1600      {
1601        atLeastOneFlushedByPreviousIDR = 1;
1602      }
1603    }
1604  }
1605  // loop through all short-term pictures in the Reference Picture Set
1606  // to see if the picture should be kept as reference picture
1607  for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1608  {
1609    isAvailable = 0;
1610    // loop through all pictures in the reference picture buffer
1611    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1612    while ( iterPic != rcListPic.end())
1613    {
1614      rpcPic = *(iterPic++);
1615
1616      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1617      {
1618        if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1619        {
1620          isAvailable = 0;
1621        }
1622        else
1623        {
1624          isAvailable = 1;
1625        }
1626      }
1627    }
1628    // report that a picture is lost if it is in the Reference Picture Set
1629    // but not available as reference picture
1630    if(isAvailable == 0)
1631    {
1632      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1633      {
1634        if(!pReferencePictureSet->getUsed(i) )
1635        {
1636          if(printErrors)
1637          {
1638            printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1639          }
1640          atLeastOneRemoved = 1;
1641        }
1642        else
1643        {
1644          if(printErrors)
1645          {
1646            printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1647          }
1648          atLeastOneLost = 1;
1649          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1650        }
1651      }
1652      else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1653      {
1654        atLeastOneUnabledByRecoveryPoint = 1;
1655      }
1656      else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1657      {
1658        atLeastOneFlushedByPreviousIDR = 1;
1659      }
1660    }
1661  }
1662
1663  if(atLeastOneUnabledByRecoveryPoint || atLeastOneFlushedByPreviousIDR)
1664  {
1665    return -1;
1666  }   
1667  if(atLeastOneLost)
1668  {
1669    return iPocLost+1;
1670  }
1671  if(atLeastOneRemoved)
1672  {
1673    return -2;
1674  }
1675  else
1676  {
1677    return 0;
1678  }
1679}
1680
1681/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1682*/
1683Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool isRAP, Int pocRandomAccess, Bool bUseRecoveryPoint, const Bool bEfficientFieldIRAPEnabled)
1684{
1685  TComPic* rpcPic;
1686  Int i, j;
1687  Int k = 0;
1688  Int nrOfNegativePictures = 0;
1689  Int nrOfPositivePictures = 0;
1690  TComReferencePictureSet* pLocalRPS = this->getLocalRPS();
1691  (*pLocalRPS)=TComReferencePictureSet();
1692
1693  Bool irapIsInRPS = false; // Used when bEfficientFieldIRAPEnabled==true
1694
1695  // loop through all pictures in the Reference Picture Set
1696  for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1697  {
1698    j = 0;
1699    // loop through all pictures in the reference picture buffer
1700    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1701    while ( iterPic != rcListPic.end())
1702    {
1703      j++;
1704      rpcPic = *(iterPic++);
1705
1706      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1707      {
1708        // This picture exists as a reference picture
1709        // and should be added to the explicit Reference Picture Set
1710        pLocalRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1711        pLocalRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1712        if (bEfficientFieldIRAPEnabled)
1713        {
1714          pLocalRPS->setUsed(k, pLocalRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess) );
1715        }
1716
1717        if(pLocalRPS->getDeltaPOC(k) < 0)
1718        {
1719          nrOfNegativePictures++;
1720        }
1721        else
1722        {
1723          if(bEfficientFieldIRAPEnabled && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1724          {
1725            irapIsInRPS = true;
1726          }
1727          nrOfPositivePictures++;
1728        }
1729        k++;
1730      }
1731    }
1732  }
1733
1734  Bool useNewRPS = false;
1735  // if current picture is complimentary field associated to IRAP, add the IRAP to its RPS.
1736  if(bEfficientFieldIRAPEnabled && m_pcPic->isField() && !irapIsInRPS)
1737  {
1738    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1739    while ( iterPic != rcListPic.end())
1740    {
1741      rpcPic = *(iterPic++);
1742      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1743      {
1744        pLocalRPS->setDeltaPOC(k, 1);
1745        pLocalRPS->setUsed(k, true);
1746        nrOfPositivePictures++;
1747        k ++;
1748        useNewRPS = true;
1749      }
1750    }
1751  }
1752  pLocalRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1753  pLocalRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1754  pLocalRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1755  // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1756  // inter RPS prediction with.  Here we just use the reference used by pReferencePictureSet.
1757  // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1758  if (!pReferencePictureSet->getInterRPSPrediction() || useNewRPS )
1759  {
1760    pLocalRPS->setInterRPSPrediction(false);
1761    pLocalRPS->setNumRefIdc(0);
1762  }
1763  else
1764  {
1765    Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1766    Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1767    const TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1768    Int iRefPics = pcRefRPS->getNumberOfPictures();
1769    Int iNewIdc=0;
1770    for(i=0; i<= iRefPics; i++)
1771    {
1772      Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0);  // check if the reference abs POC is >= 0
1773      Int iRefIdc = 0;
1774      for (j=0; j < pLocalRPS->getNumberOfPictures(); j++) // loop through the  pictures in the new RPS
1775      {
1776        if ( (deltaPOC + deltaRPS) == pLocalRPS->getDeltaPOC(j))
1777        {
1778          if (pLocalRPS->getUsed(j))
1779          {
1780            iRefIdc = 1;
1781          }
1782          else
1783          {
1784            iRefIdc = 2;
1785          }
1786        }
1787      }
1788      pLocalRPS->setRefIdc(i, iRefIdc);
1789      iNewIdc++;
1790    }
1791    pLocalRPS->setInterRPSPrediction(true);
1792    pLocalRPS->setNumRefIdc(iNewIdc);
1793    pLocalRPS->setDeltaRPS(deltaRPS);
1794    pLocalRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1795  }
1796
1797  this->setRPS(pLocalRPS);
1798  this->setRPSidx(-1);
1799}
1800
1801//! get AC and DC values for weighted pred
1802Void  TComSlice::getWpAcDcParam(WPACDCParam *&wp)
1803{
1804  wp = m_weightACDCParam;
1805}
1806
1807//! init AC and DC values for weighted pred
1808Void  TComSlice::initWpAcDcParam()
1809{
1810  for(Int iComp = 0; iComp < MAX_NUM_COMPONENT; iComp++ )
1811  {
1812    m_weightACDCParam[iComp].iAC = 0;
1813    m_weightACDCParam[iComp].iDC = 0;
1814  }
1815}
1816
1817//! get tables for weighted prediction
1818Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp )
1819{
1820  assert (e<NUM_REF_PIC_LIST_01);
1821  wp = m_weightPredTable[e][iRefIdx];
1822}
1823
1824//! reset Default WP tables settings : no weight.
1825Void  TComSlice::resetWpScaling()
1826{
1827  for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1828  {
1829    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1830    {
1831      for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
1832      {
1833        WPScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1834        pwp->bPresentFlag      = false;
1835        pwp->uiLog2WeightDenom = 0;
1836        pwp->uiLog2WeightDenom = 0;
1837        pwp->iWeight           = 1;
1838        pwp->iOffset           = 0;
1839      }
1840    }
1841  }
1842}
1843
1844//! init WP table
1845Void  TComSlice::initWpScaling(const TComSPS *sps)
1846{
1847  const Bool bUseHighPrecisionPredictionWeighting = sps->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag();
1848  for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1849  {
1850    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1851    {
1852      for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
1853      {
1854        WPScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1855        if ( !pwp->bPresentFlag )
1856        {
1857          // Inferring values not present :
1858          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1859          pwp->iOffset = 0;
1860        }
1861
1862        const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (sps->getBitDepth(toChannelType(ComponentID(yuv)))-8));
1863
1864        pwp->w      = pwp->iWeight;
1865        pwp->o      = pwp->iOffset * offsetScalingFactor; //NOTE: This value of the ".o" variable is never used - .o is set immediately before it gets used
1866        pwp->shift  = pwp->uiLog2WeightDenom;
1867        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1868      }
1869    }
1870  }
1871}
1872
1873// ------------------------------------------------------------------------------------------------
1874// Video parameter set (VPS)
1875// ------------------------------------------------------------------------------------------------
1876TComVPS::TComVPS()
1877: m_VPSId                     (  0)
1878, m_uiMaxTLayers              (  1)
1879#if NH_MV
1880, m_uiMaxLayersMinus1         (  0)
1881#else
1882, m_uiMaxLayers               (  1)
1883#endif
1884, m_bTemporalIdNestingFlag    (false)
1885, m_numHrdParameters          (  0)
1886#if NH_MV
1887, m_maxLayerId             (  0)
1888#else
1889, m_maxNuhReservedZeroLayerId (  0)
1890#endif
1891, m_hrdParameters             ()
1892, m_hrdOpSetIdx               ()
1893, m_cprmsPresentFlag          ()
1894{
1895#if NH_MV
1896  m_vpsBaseLayerInternalFlag = true; 
1897  m_vpsBaseLayerAvailableFlag = true; 
1898
1899  m_numViews = 0; 
1900
1901#endif
1902
1903  for( Int i = 0; i < MAX_TLAYER; i++)
1904  {
1905    m_numReorderPics[i] = 0;
1906    m_uiMaxDecPicBuffering[i] = 1;
1907    m_uiMaxLatencyIncrease[i] = 0;
1908  }
1909#if NH_MV
1910  for (Int lsIdx = 0; lsIdx < MAX_VPS_OP_SETS_PLUS1; lsIdx++ )
1911  { 
1912    for( Int layerId = 0; layerId < MAX_VPS_NUH_LAYER_ID_PLUS1; layerId++ )
1913    {
1914      m_layerIdIncludedFlag[lsIdx][layerId] = (( lsIdx == 0 ) && ( layerId == 0 )) ; 
1915    }
1916  } 
1917  m_vpsNumProfileTierLevelMinus1 = -1; 
1918   
1919  m_numAddLayerSets              = 0;   
1920  m_numAddOlss                   = 0; 
1921  m_defaultOutputLayerIdc     = 0; 
1922 
1923  for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
1924  {
1925    for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
1926    {
1927      m_profileTierLevelIdx[i][j] = -1; 
1928      m_outputLayerFlag[i][j] = false; 
1929    }
1930    m_altOutputLayerFlag[ i ]       = false; 
1931  }
1932
1933  m_repFormatIdxPresentFlag = false; 
1934  m_maxOneActiveRefLayerFlag = false; 
1935  m_vpsPocLsbAlignedFlag  = false; 
1936  m_directDepTypeLenMinus2   = 0;         
1937 
1938
1939  m_vpsExtensionFlag = true; 
1940  m_vpsNonVuiExtensionLength = 0;
1941  m_splittingFlag    = false;
1942
1943 
1944  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
1945  {
1946    m_scalabilityMaskFlag[i] = false;
1947    m_dimensionIdLen [i]  = -1; 
1948  }
1949
1950  m_vpsNuhLayerIdPresentFlag = false;
1951
1952  for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
1953  {
1954    m_vpsProfilePresentFlag   [i] = false;
1955    m_layerSetIdxForOlsMinus1       [i] = 0;
1956    for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
1957    {
1958      m_outputLayerFlag[i][j] = false;
1959    }
1960  }
1961
1962  for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
1963  {
1964    m_layerIdInVps[i] =  (i == 0 ) ? 0 : -1;         
1965  }
1966
1967  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1968  {
1969    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1; 
1970    m_numDirectRefLayers[i] = 0; 
1971#if NH_3D
1972    m_numRefListLayers[i] = 0; 
1973#endif
1974    m_vpsRepFormatIdx    [i] = 0; 
1975    m_pocLsbNotPresentFlag[i] = 0;   
1976    m_viewIdVal          [i] = 0; 
1977
1978#if NH_3D
1979    m_viewIndex         [i] = -1; 
1980#endif
1981
1982    for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
1983    {
1984      m_directDependencyFlag[i][j] = false;
1985      m_directDependencyType[i][j] = -1; 
1986      m_dependencyFlag  [i][j]    = false; 
1987      m_idDirectRefLayer[i][j]    = -1; 
1988#if NH_3D
1989      m_idRefListLayer[i][j]    = -1; 
1990#endif
1991      m_idPredictedLayer[i][j]    = -1; 
1992      m_idRefLayer      [i][j]    = -1; 
1993      m_maxTidIlRefPicsPlus1[i][j]  = 7;
1994    }
1995
1996    for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
1997    {
1998      m_dimensionId[i][j] = 0;
1999    }
2000#if NH_3D_ARP
2001#endif
2002  } 
2003#endif
2004}
2005
2006TComVPS::~TComVPS()
2007{
2008}
2009
2010#if NH_MV
2011
2012Bool TComVPS::checkVPSExtensionSyntax()
2013{
2014  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
2015  {
2016    // check layer_id_in_nuh constraint
2017    assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
2018  }
2019
2020  //The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
2021  assert( getVpsNumRepFormatsMinus1() >= 0 ); 
2022  assert( getVpsNumRepFormatsMinus1() <= 255 ); 
2023
2024  // The value of num_add_layer_sets shall be in the range of 0 to 1023, inclusive.
2025  assert( getNumAddLayerSets() >= 0 && getNumAddLayerSets() <= 1023 ); 
2026  return true; 
2027}
2028
2029Int TComVPS::getNumScalabilityTypes() const
2030{
2031  return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
2032}
2033
2034Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType ) const
2035{
2036  assert( (Int)scalType >= 0 && (Int)scalType <= MAX_NUM_SCALABILITY_TYPES );
2037  assert( (Int)scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
2038  Int scalIdx = 0; 
2039  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
2040  {
2041    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
2042
2043  }
2044
2045  return scalIdx; 
2046}
2047Void TComVPS::setScalabilityMaskFlag( UInt val )
2048{
2049  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ ) 
2050  {
2051    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
2052  }
2053}
2054
2055Void TComVPS::setRefLayers()
2056{
2057
2058  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
2059  {
2060    for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
2061    {
2062      m_dependencyFlag[ i ][ j ] = getDirectDependencyFlag( i , j );
2063      for( Int k = 0; k < i; k++ )
2064      {
2065        if( getDirectDependencyFlag(i , k )  &&  m_dependencyFlag[k][j] )
2066        {
2067          m_dependencyFlag[ i ][ j ] = true;
2068        }
2069      }
2070    }
2071  }
2072
2073  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
2074  {
2075    Int iNuhLId = getLayerIdInNuh( i );
2076    Int d = 0;
2077#if NH_3D
2078    Int l = 0; 
2079#endif
2080    Int r = 0;
2081    Int p = 0;
2082
2083    for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
2084    {
2085      Int jNuhLid = getLayerIdInNuh( j );
2086      if( getDirectDependencyFlag( i , j ) )
2087      {
2088        m_idDirectRefLayer[iNuhLId][d++] = jNuhLid;
2089      }
2090#if NH_3D
2091      if( getDirectDependencyFlag( i , j ) && ( getDepthId( iNuhLId ) == getDepthId( jNuhLid ) ))
2092      {
2093        m_idRefListLayer [iNuhLId][l++] = jNuhLid;
2094      }
2095#endif
2096
2097      if( getDependencyFlag( i , j ) )
2098      {
2099        m_idRefLayer      [iNuhLId][r++] = jNuhLid;
2100      }
2101      if( getDependencyFlag( j , i ) )
2102      {
2103        m_idPredictedLayer[iNuhLId][p++] = jNuhLid;
2104      }
2105    }
2106    m_numDirectRefLayers[ iNuhLId ] = d;
2107#if NH_3D
2108    m_numRefListLayers[ iNuhLId ] = l; 
2109#endif
2110
2111    m_numRefLayers      [ iNuhLId ] = r;
2112    m_numPredictedLayers[ iNuhLId ] = p;
2113  }
2114 
2115  Bool layerIdInListFlag[ 64 ]; 
2116  for( Int i = 0; i  <=  63; i++ )
2117  {
2118    layerIdInListFlag[ i ] = 0;
2119  }
2120
2121  Int k = 0; 
2122  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
2123  {
2124    Int iNuhLId = getLayerIdInNuh( i );
2125    if( getNumDirectRefLayers( iNuhLId )  ==  0 )
2126    {
2127      m_treePartitionLayerIdList[ k ][ 0 ] = iNuhLId;
2128      Int h = 1; 
2129      for( Int j = 0; j < getNumPredictedLayers( iNuhLId ); j++ ) 
2130      {
2131        Int predLId = getIdPredictedLayer( iNuhLId, j );
2132        if ( !layerIdInListFlag[ predLId ] )
2133        {
2134          m_treePartitionLayerIdList[ k ][ h++ ] = predLId;
2135          layerIdInListFlag[ predLId ] = 1; 
2136        }         
2137      }
2138      m_numLayersInTreePartition[ k++ ] = h;
2139    }
2140  }
2141  m_numIndependentLayers = k;
2142}
2143
2144
2145Void     TComVPS::initNumViews( )
2146{
2147  m_numViews = 1; 
2148#if NH_3D
2149  AOF( m_viewOIdxList.size() == 0 );   
2150  m_viewOIdxList.push_back( 0 );       
2151#endif
2152
2153  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
2154  {
2155    Int lId = getLayerIdInNuh( i ); 
2156    if( i > 0 )
2157    {
2158      Bool newViewFlag = true; 
2159      for( Int j = 0; j < i; j++ )
2160      {
2161        if( getViewOrderIdx( lId )  ==  getViewOrderIdx( getLayerIdInNuh( j ) )  )
2162        {
2163          newViewFlag = false;
2164        }
2165      }
2166      if( newViewFlag )
2167      {
2168        m_numViews++;
2169#if NH_3D
2170        m_viewOIdxList.push_back( getViewOrderIdx( lId ) );       
2171#endif
2172      }
2173    }
2174  }
2175}
2176
2177
2178Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType ) const
2179{
2180  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
2181}
2182
2183#if NH_3D_VSO || NH_3D
2184Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag, Int auxId ) const
2185{
2186  Int foundLayerIdinNuh = -1; 
2187
2188  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
2189  {
2190    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps ); 
2191#if !NH_3D
2192    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getAuxId( layerIdInNuh ) == ( depthFlag ? 2 : 0 ) )  )
2193#else
2194    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
2195#endif
2196    {
2197      foundLayerIdinNuh = layerIdInNuh; 
2198      break; 
2199    }
2200  }
2201  return foundLayerIdinNuh;
2202}
2203#endif
2204#if NH_3D
2205Void TComVPS::createCamPars(Int iNumViews)
2206{
2207  m_numCp                     .resize( iNumViews );
2208  m_cpRefVoi                  .resize( iNumViews );
2209  m_cpInSliceSegmentHeaderFlag.resize( iNumViews );
2210  m_cpPresentFlag             .resize( iNumViews ); 
2211  m_aaaiCodedScale            .resize( iNumViews ); 
2212  m_aaaiCodedOffset           .resize( iNumViews ); 
2213
2214  for ( Int i = 0; i < iNumViews ; i++ )
2215  {
2216    m_numCp                     [i] = 0; 
2217    m_cpRefVoi                  [i].resize( iNumViews );
2218    m_cpInSliceSegmentHeaderFlag[i] = false;         
2219    m_aaaiCodedScale            [i].resize( 2 );
2220    m_aaaiCodedOffset           [i].resize( 2 );       
2221    m_cpPresentFlag             [i].resize( iNumViews ); 
2222
2223    for ( Int j = 0; j < iNumViews; j++)
2224    {
2225      m_cpRefVoi             [i][j] = 0; 
2226      m_cpPresentFlag        [i][j] = false; 
2227    }
2228
2229    for ( Int j = 0; j < 2; j++ )
2230    {
2231      m_aaaiCodedScale       [i][j].resize( MAX_NUM_LAYERS );
2232      m_aaaiCodedOffset      [i][j].resize( MAX_NUM_LAYERS );
2233
2234      for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
2235      {
2236        m_aaaiCodedScale [i][j][k] = 0;
2237        m_aaaiCodedOffset[i][j][k] = 0;
2238      }
2239    }
2240  }
2241}
2242#endif // NH_3D
2243
2244
2245Int TComVPS::xGetDimBitOffset( Int j ) const
2246{
2247  Int dimBitOffset = 0; 
2248  if ( getSplittingFlag() && j == getNumScalabilityTypes() )
2249  {
2250     dimBitOffset = 6; 
2251  }
2252  else
2253  {
2254    for (Int dimIdx = 0; dimIdx <= j-1; dimIdx++)
2255    {
2256      dimBitOffset += getDimensionIdLen( dimIdx ); 
2257    }
2258  }
2259  return dimBitOffset; 
2260}
2261
2262Int TComVPS::inferDimensionId( Int i, Int j ) const
2263{
2264    return ( ( getLayerIdInNuh( i ) & ( (1 << xGetDimBitOffset( j + 1 ) ) - 1) ) >> xGetDimBitOffset( j ) ); 
2265}
2266
2267Int TComVPS::inferLastDimsionIdLenMinus1() const
2268{
2269  return ( 5 - xGetDimBitOffset( getNumScalabilityTypes() - 1 ) ); 
2270}
2271
2272Int TComVPS::getNumLayersInIdList( Int lsIdx ) const
2273{
2274  assert( lsIdx >= 0 ); 
2275  assert( lsIdx <= getNumLayerSets() ); 
2276  return (Int) m_layerSetLayerIdList[ lsIdx ].size(); 
2277}
2278
2279Int    TComVPS::getNumOutputLayerSets() const
2280{
2281  return getNumAddOlss() + getNumLayerSets(); 
2282}
2283
2284
2285
2286Void TComVPS::deriveLayerSetLayerIdList()
2287{
2288  m_layerSetLayerIdList.resize( getVpsNumLayerSetsMinus1() + 1 ); 
2289  for (Int i = 0; i <= getVpsNumLayerSetsMinus1(); i++ )
2290  {
2291    for( Int m = 0; m  <= getVpsMaxLayerId(); m++ )
2292    {
2293      if( getLayerIdIncludedFlag( i, m) ) 
2294      {
2295        m_layerSetLayerIdList[ i ].push_back( m );       
2296      }
2297    }
2298  }
2299}
2300
2301Void TComVPS::initTargetLayerIdLists()
2302{
2303  m_targetDecLayerIdLists.resize( getNumOutputLayerSets() ); 
2304  m_targetOptLayerIdLists.resize( getNumOutputLayerSets() ); 
2305}
2306
2307Void TComVPS::deriveTargetLayerIdList( Int i )
2308{ 
2309  Int lsIdx = olsIdxToLsIdx( i );     
2310
2311  for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
2312  {
2313    if ( getNecessaryLayerFlag( i , j ))
2314    {
2315      m_targetDecLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] ); 
2316    }
2317
2318    if( getOutputLayerFlag( i, j  ))
2319    {
2320      m_targetOptLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2321    }
2322  } 
2323  assert( getNumOutputLayersInOutputLayerSet( i ) > 0 ); 
2324}
2325
2326Bool TComVPS::inferOutputLayerFlag( Int i, Int j ) const
2327{
2328  Bool outputLayerFlag; 
2329  switch ( getDefaultOutputLayerIdc( ) )
2330  {
2331  case 0:
2332    outputLayerFlag = true; 
2333    break; 
2334  case 1:
2335    outputLayerFlag = ( j == m_layerSetLayerIdList[ olsIdxToLsIdx( i ) ].size() - 1 ); 
2336    break;
2337  case 2:
2338    if ( i == 0 && j == 0)
2339    {     
2340      outputLayerFlag = true;  // This is a software only fix for a bug in the spec. In spec outputLayerFlag is neither present nor inferred.
2341    }
2342    else
2343    {
2344      assert( 0 ); 
2345    }
2346    break; 
2347  default:     
2348    assert( 0 );
2349    break; 
2350  }
2351  return outputLayerFlag;
2352}
2353
2354Int TComVPS::getMaxSubLayersInLayerSetMinus1( Int i ) const
2355{
2356  Int maxSLMinus1 = 0; 
2357  for( Int k = 0; k < getNumLayersInIdList( i ); k++ )
2358  {
2359    Int lId = m_layerSetLayerIdList[i][k];
2360    maxSLMinus1 = std::max( maxSLMinus1, getSubLayersVpsMaxMinus1( getLayerIdInVps( lId ) ));
2361  }
2362  return maxSLMinus1;
2363}
2364
2365Bool TComVPS::getAltOutputLayerFlagVar( Int i ) const
2366{
2367  // Semantics variable not syntax element !
2368
2369  Bool altOptLayerFlag = false;     
2370  if ( i > 0 && getNumOutputLayersInOutputLayerSet( i ) == 1 && 
2371    getNumDirectRefLayers( getOlsHighestOutputLayerId( i ) ) > 0 )
2372  {
2373    altOptLayerFlag = getAltOutputLayerFlag( i ); 
2374  }
2375  return altOptLayerFlag;
2376}
2377
2378
2379
2380Int TComVPS::inferProfileTierLevelIdx(Int i, Int j) const
2381{
2382  Bool inferZero        = ( i == 0 && j == 0 &&  getVpsBaseLayerInternalFlag() );
2383  Bool inferGreaterZero = getNecessaryLayerFlag(i,j) && ( getVpsNumProfileTierLevelMinus1() == 0 ); 
2384  assert( inferZero || inferGreaterZero );
2385
2386  Bool ptlIdx = 0; // inference for greaterZero
2387  if ( inferZero )
2388  {
2389    ptlIdx = getMaxLayersMinus1() > 0 ? 1 : 0; 
2390    if ( inferGreaterZero )
2391    {
2392      assert( ptlIdx == 0 ); 
2393      // This should never happen since :
2394      // When vps_max_layers_minus1 is greater than 0, the value of vps_num_profile_tier_level_minus1 shall be greater than or equal to 1.
2395    }
2396  }
2397  return ptlIdx;
2398}
2399
2400Void TComVPS::deriveAddLayerSetLayerIdList(Int i)
2401{
2402  assert( m_layerSetLayerIdList.size() ==  ( getVpsNumLayerSetsMinus1() + 1 + i ) ); 
2403  std::vector<Int> layerSetLayerIdList;
2404
2405  for( Int treeIdx = 1; treeIdx < getNumIndependentLayers(); treeIdx++ )
2406  { 
2407    // The value of highest_layer_idx_plus1[ i ][ j ] shall be in the range of 0 to NumLayersInTreePartition[ j ], inclusive.
2408    assert( getHighestLayerIdxPlus1( i, treeIdx ) >= 0 && getHighestLayerIdxPlus1( i, treeIdx ) <= getNumLayersInTreePartition( treeIdx ) );
2409
2410    for( Int layerCnt = 0; layerCnt < getHighestLayerIdxPlus1( i, treeIdx ); layerCnt++ )
2411    {
2412      layerSetLayerIdList.push_back( getTreePartitionLayerIdList( treeIdx, layerCnt ) );
2413    }
2414  }
2415  m_layerSetLayerIdList.push_back( layerSetLayerIdList ); 
2416
2417  //It is a requirement of bitstream conformance that
2418  //NumLayersInIdList[ vps_num_layer_sets_minus1 + 1 + i ] shall be greater than 0.
2419  assert( getNumLayersInIdList( getVpsNumLayerSetsMinus1() + 1 + i ) > 0 );
2420}
2421
2422
2423Void TComVPS::deriveNecessaryLayerFlags(Int olsIdx)
2424{
2425  AOF( olsIdx >= 0 && olsIdx < getNumOutputLayerSets() ); 
2426  Int lsIdx = olsIdxToLsIdx( olsIdx );
2427  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx) ; lsLayerIdx++ )
2428  {
2429    m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ] = 0;
2430  }
2431  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx ); lsLayerIdx++ )
2432  {
2433    if( getOutputLayerFlag( olsIdx, lsLayerIdx  ))
2434    {
2435      m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ] = 1;
2436      Int currLayerId = getLayerSetLayerIdList( lsIdx, lsLayerIdx );
2437      for( Int rLsLayerIdx = 0; rLsLayerIdx < lsLayerIdx; rLsLayerIdx++ )
2438      {
2439        Int refLayerId = getLayerSetLayerIdList( lsIdx, rLsLayerIdx );
2440        if( getDependencyFlag( getLayerIdInVps( currLayerId ), getLayerIdInVps( refLayerId ) ) )
2441        {
2442          m_necessaryLayerFlag[ olsIdx ][ rLsLayerIdx ] = 1;
2443        }
2444      }
2445    }
2446  }
2447  m_numNecessaryLayers[ olsIdx ] = 0;
2448  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx ); lsLayerIdx++ ) 
2449  {
2450    m_numNecessaryLayers[ olsIdx ]  +=  m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ];
2451  }
2452}
2453
2454Void TComVPS::printPTL() const
2455{
2456  std::vector<Int> idx; 
2457  std::vector<Int> num; 
2458  IntAry2d ptlInfo; 
2459
2460  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "PTLI" << std::endl; 
2461
2462  for ( Int i = 0; i <= getVpsNumProfileTierLevelMinus1(); i++ )
2463  {
2464    std::vector<Int> curPtlInfo;
2465    const ProfileTierLevel* ptl = getPTL( i )->getGeneralPTL(); 
2466    curPtlInfo.push_back( (Int) ptl->getProfileIdc()  );
2467    curPtlInfo.push_back( (Int) ptl->getTierFlag()    );
2468    curPtlInfo.push_back( (Int) ptl->getLevelIdc()    );
2469    curPtlInfo.push_back( (Int) ptl->getInbldFlag()   );
2470
2471    idx.push_back ( i );
2472    num.push_back ( 4 ); 
2473    ptlInfo.push_back( curPtlInfo );
2474  } 
2475
2476  xPrintArray( "VpsProfileTierLevel", getVpsNumProfileTierLevelMinus1() + 1, idx, num, ptlInfo, false  ); 
2477
2478  num.clear(); 
2479  idx.clear(); 
2480  for (Int i = 0; i < getNumOutputLayerSets(); i++)
2481  {
2482    num.push_back ( getNumLayersInIdList( olsIdxToLsIdx( i ))  ); 
2483    idx.push_back( i ); 
2484  }
2485
2486  xPrintArray( "profile_tier_level_idx", getNumOutputLayerSets(), idx, num, m_profileTierLevelIdx, true );
2487  std::cout << std::endl;
2488}
2489
2490Void TComVPS::printLayerDependencies() const
2491{
2492  vector<Int> fullArray;
2493  vector<Int> range; 
2494
2495#if NH_3D
2496  vector<Int> depthId; 
2497#endif
2498
2499  vector<Int> viewOrderIndex;
2500  vector<Int> auxId;
2501  vector<Int> dependencyId; 
2502  vector<Int> viewId; 
2503  for (Int i = 0; i <= getMaxLayersMinus1(); i++ )
2504  {
2505    fullArray.push_back( getMaxLayersMinus1() + 1 ); 
2506    range.push_back( i ); 
2507    viewOrderIndex.push_back( getViewIndex   ( i ) );
2508    dependencyId  .push_back( getDependencyId( i ) );
2509    auxId         .push_back( getAuxId       ( i ) );     
2510    viewId        .push_back( getViewId      ( getLayerIdInNuh( i ) ) );
2511#if NH_3D 
2512    depthId.push_back( getDepthId( i ) );
2513#endif
2514  }
2515  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Layer Dependencies" << std::endl; 
2516  xPrintArray( "direct_dependency_flag", getMaxLayersMinus1()+1, range, fullArray, m_directDependencyFlag, false ); 
2517  xPrintArray( "DependencyFlag", getMaxLayersMinus1()+1, range, fullArray, m_dependencyFlag, false ); 
2518  xPrintArray( "layer_id_in_nuh", getMaxLayersMinus1()+1, m_layerIdInNuh, true  );     
2519  xPrintArray( "IdPredictedLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numPredictedLayers, m_idPredictedLayer, true );
2520  xPrintArray( "IdRefLayer"      , getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numRefLayers, m_idRefLayer, true );
2521  xPrintArray( "IdDirectRefLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numDirectRefLayers, m_idDirectRefLayer, true );
2522#if NH_3D
2523  xPrintArray( "IdRefListLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numRefListLayers, m_idRefListLayer, true );
2524#endif
2525
2526  std::cout << std::endl;
2527}
2528
2529Void TComVPS::printScalabilityId() const
2530{
2531  vector<Int> layerIdxInVps; 
2532
2533
2534  vector<Int> depthId; 
2535  vector<Int> viewOrderIndex;
2536  vector<Int> auxId;
2537  vector<Int> dependencyId; 
2538  vector<Int> viewId; 
2539
2540  for (Int i = 0; i <= getMaxLayersMinus1(); i++ )
2541  {
2542    Int layerIdInNuh = getLayerIdInNuh( i );
2543    layerIdxInVps  .push_back( i ); 
2544    depthId       .push_back( getDepthId     ( layerIdInNuh ) );
2545    viewOrderIndex.push_back( getViewIndex   ( layerIdInNuh ) );
2546    dependencyId  .push_back( getDependencyId( layerIdInNuh ) );
2547    auxId         .push_back( getAuxId       ( layerIdInNuh ) );     
2548    viewId        .push_back( getViewId      ( layerIdInNuh ) );
2549
2550  }
2551
2552  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Scalability Ids" << std::endl; 
2553  xPrintArray( "layerIdxInVps"  , getMaxLayersMinus1()+1, layerIdxInVps,          false );
2554  xPrintArray( "layer_id_in_nuh", getMaxLayersMinus1()+1, m_layerIdInNuh, false );     
2555
2556  xPrintArray( "DepthLayerFlag", getMaxLayersMinus1()+1, depthId       , false );     
2557  xPrintArray( "ViewOrderIdx"  , getMaxLayersMinus1()+1, viewOrderIndex, false );     
2558  xPrintArray( "DependencyId"  , getMaxLayersMinus1()+1, dependencyId  , false );     
2559  xPrintArray( "AuxId"         , getMaxLayersMinus1()+1, auxId         , false );     
2560  xPrintArray( "ViewIdVal"     , getMaxLayersMinus1()+1, viewId        , false );     
2561
2562  std::cout << std::endl;
2563}
2564
2565Void TComVPS::printLayerSets() const
2566{
2567  vector<Int> fullArray;
2568  vector<Int> numLayersInIdList; 
2569  vector<Int> rangeLayerSets; 
2570
2571
2572  for (Int i = 0; i < getNumLayerSets(); i++ )
2573  {
2574    numLayersInIdList.push_back( getNumLayersInIdList( i ) );       
2575    rangeLayerSets.push_back( i ); 
2576  }
2577
2578  vector<Int> rangeOutputLayerSets; 
2579  vector<Int> numOutputLayersInOutputLayerSet; 
2580  vector<Int> numDecLayer; 
2581  vector<Int> numLayersInLayerSetForOutputLayerSet; 
2582  vector<Int> vOlsIdxToLsIdx;
2583  for (Int i = 0; i < getNumOutputLayerSets(); i++ )
2584  {
2585    vOlsIdxToLsIdx.push_back( olsIdxToLsIdx(i));
2586    numOutputLayersInOutputLayerSet.push_back( getNumOutputLayersInOutputLayerSet( i ) );       
2587    numDecLayer.push_back( (Int) m_targetDecLayerIdLists[ i ].size() );
2588    rangeOutputLayerSets.push_back( i ); 
2589    numLayersInLayerSetForOutputLayerSet.push_back( getNumLayersInIdList( olsIdxToLsIdx( i ) ) );
2590  }
2591
2592  vector<Int> rangeIndependentLayers;
2593  for(Int i = 0; i < getNumIndependentLayers(); i++ )
2594  {
2595    rangeIndependentLayers.push_back( i );   
2596  }
2597
2598  vector<Int> rangeAddLayerSets;
2599  vector<Int> numHighestLayerIdxPlus1; 
2600  for(Int i = 0; i < getNumAddLayerSets(); i++ )
2601  {
2602    rangeAddLayerSets.push_back( i );   
2603    numHighestLayerIdxPlus1.push_back( getNumIndependentLayers() );
2604  }
2605
2606  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Layer Sets" << std::endl;     
2607  xPrintArray( "TreePartitionLayerIdList", getNumIndependentLayers(), rangeIndependentLayers, m_numLayersInTreePartition, m_treePartitionLayerIdList, true );
2608  xPrintArray( "highest_layer_idx_plus1", getNumAddLayerSets(), rangeAddLayerSets, numHighestLayerIdxPlus1, m_highestLayerIdxPlus1, true ); 
2609  xPrintArray( "LayerSetLayerIdList" , (Int) getNumLayerSets()      , rangeLayerSets      , numLayersInIdList, m_layerSetLayerIdList, true );
2610  xPrintArray( "OlsIdxToLsIdx", (Int) vOlsIdxToLsIdx.size(), vOlsIdxToLsIdx, true ); 
2611  xPrintArray( "OutputLayerFlag"     , getNumOutputLayerSets(), rangeOutputLayerSets, numLayersInLayerSetForOutputLayerSet, m_outputLayerFlag, true );
2612  xPrintArray( "TargetOptLayerIdList", getNumOutputLayerSets(), rangeOutputLayerSets, numOutputLayersInOutputLayerSet, m_targetOptLayerIdLists, true );
2613  xPrintArray( "NecessaryLayerFlag"  , getNumOutputLayerSets(), rangeOutputLayerSets, numLayersInLayerSetForOutputLayerSet, m_necessaryLayerFlag   , true );
2614  xPrintArray( "TargetDecLayerIdList", getNumOutputLayerSets(), rangeOutputLayerSets, numDecLayer,                     m_targetDecLayerIdLists, true );
2615  std::cout << endl;
2616}
2617
2618#if NH_3D
2619Void TComVPS::initViewCompLayer()
2620{
2621  assert( m_viewCompLayerId.size() == 0 && m_viewCompLayerPresentFlag.size() == 0  );
2622  for( Int i = 0; i < getNumViews(); i++ )
2623  {
2624    m_viewCompLayerId         .push_back( std::vector<Int>(0)  );
2625    m_viewCompLayerPresentFlag.push_back( std::vector<Bool>(0) );     
2626
2627    for( Int depFlag = 0; depFlag  <=  1; depFlag++ )
2628    {
2629      Int iViewOIdx = getViewOIdxList( i );
2630      Int layerId = -1;
2631      for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ ) 
2632      {
2633        Int jNuhLId = getLayerIdInNuh( j );
2634        if( getVpsDepthFlag( jNuhLId ) == ( (Bool) depFlag )  &&  getViewOrderIdx( jNuhLId )  ==  iViewOIdx 
2635          &&  getDependencyId( jNuhLId )  ==  0  &&  getAuxId( jNuhLId )  ==  0 )
2636        {
2637          layerId = jNuhLId;
2638        }
2639      }
2640      m_viewCompLayerPresentFlag[ i ].push_back( layerId  !=  -1 );
2641      m_viewCompLayerId         [ i ].push_back( layerId );       
2642    }
2643  }
2644}
2645
2646Int TComVPS::getVoiInVps(Int viewOIdx) const
2647{
2648  for ( Int i = 0; i < m_viewOIdxList.size(); i++ )
2649  {
2650    if  ( m_viewOIdxList[ i ] == viewOIdx )
2651    {
2652      return i; 
2653    }
2654  }
2655  assert( 0 );   
2656  return -1;
2657}
2658
2659Void TComVPS::deriveCpPresentFlag()
2660{
2661  for( Int nInVps = 0; nInVps < getNumViews(); nInVps++  )
2662  {
2663    for( Int mInVps = 0; mInVps < getNumViews(); mInVps++ )
2664    {
2665      m_cpPresentFlag[nInVps][mInVps] = 0; 
2666    }
2667  }
2668
2669  for( Int n = 1; n < getNumViews(); n++ )
2670  {
2671    Int iInVps = getVoiInVps(  getViewOIdxList( n ) );     
2672    for( Int m = 0; m < getNumCp( iInVps ); m++ )
2673    {
2674      m_cpPresentFlag[ iInVps ][ getVoiInVps( getCpRefVoi( iInVps, m ) ) ] = 1;
2675    }
2676  }
2677}
2678
2679#endif
2680#endif // NH_MV
2681
2682// ------------------------------------------------------------------------------------------------
2683// Sequence parameter set (SPS)
2684// ------------------------------------------------------------------------------------------------
2685
2686TComSPSRExt::TComSPSRExt()
2687 : m_transformSkipRotationEnabledFlag   (false)
2688 , m_transformSkipContextEnabledFlag    (false)
2689// m_rdpcmEnabledFlag initialized below
2690 , m_extendedPrecisionProcessingFlag    (false)
2691 , m_intraSmoothingDisabledFlag         (false)
2692 , m_highPrecisionOffsetsEnabledFlag    (false)
2693 , m_persistentRiceAdaptationEnabledFlag(false)
2694 , m_cabacBypassAlignmentEnabledFlag    (false)
2695{
2696  for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
2697  {
2698    m_rdpcmEnabledFlag[signallingModeIndex] = false;
2699  }
2700}
2701
2702TComSPS::TComSPS()
2703: m_SPSId                     (  0)
2704, m_VPSId                     (  0)
2705, m_chromaFormatIdc           (CHROMA_420)
2706, m_uiMaxTLayers              (  1)
2707// Structure
2708, m_picWidthInLumaSamples     (352)
2709, m_picHeightInLumaSamples    (288)
2710, m_log2MinCodingBlockSize    (  0)
2711, m_log2DiffMaxMinCodingBlockSize(0)
2712, m_uiMaxCUWidth              ( 32)
2713, m_uiMaxCUHeight             ( 32)
2714, m_uiMaxTotalCUDepth         (  3)
2715, m_bLongTermRefsPresent      (false)
2716, m_uiQuadtreeTULog2MaxSize   (  0)
2717, m_uiQuadtreeTULog2MinSize   (  0)
2718, m_uiQuadtreeTUMaxDepthInter (  0)
2719, m_uiQuadtreeTUMaxDepthIntra (  0)
2720// Tool list
2721, m_usePCM                    (false)
2722, m_pcmLog2MaxSize            (  5)
2723, m_uiPCMLog2MinSize          (  7)
2724, m_bPCMFilterDisableFlag     (false)
2725, m_uiBitsForPOC              (  8)
2726, m_numLongTermRefPicSPS      (  0)
2727#if NH_MV
2728, m_numShortTermRefPicSets    (   0)
2729#endif
2730, m_uiMaxTrSize               ( 32)
2731, m_bUseSAO                   (false)
2732, m_bTemporalIdNestingFlag    (false)
2733, m_scalingListEnabledFlag    (false)
2734, m_useStrongIntraSmoothing   (false)
2735, m_vuiParametersPresentFlag  (false)
2736, m_vuiParameters             ()
2737#if NH_MV
2738, m_pcVPS                     ( NULL )
2739, m_spsInferScalingListFlag   ( false )
2740, m_spsScalingListRefLayerId  ( 0 )
2741
2742, m_updateRepFormatFlag       ( false ) 
2743, m_spsRepFormatIdx           ( 0 )
2744, m_interViewMvVertConstraintFlag (false)
2745#endif
2746
2747{
2748  for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2749  {
2750    m_bitDepths.recon[ch] = 8;
2751#if O0043_BEST_EFFORT_DECODING
2752    m_bitDepths.stream[ch] = 8;
2753#endif
2754    m_pcmBitDepths[ch] = 8;
2755    m_qpBDOffset   [ch] = 0;
2756  }
2757
2758
2759  for ( Int i = 0; i < MAX_TLAYER; i++ )
2760  {
2761#if NH_MV
2762    m_uiSpsMaxLatencyIncreasePlus1[i] = 0;
2763#else
2764    m_uiMaxLatencyIncreasePlus1[i] = 0;
2765#endif
2766    m_uiMaxDecPicBuffering[i] = 1;
2767    m_numReorderPics[i]       = 0;
2768  }
2769
2770  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2771  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2772#if NH_MV
2773  m_spsRangeExtensionsFlag     = false;
2774  m_spsMultilayerExtensionFlag = false;
2775  m_spsExtension5bits          = 0;
2776  m_sps3dExtensionFlag         = false; 
2777
2778#endif
2779
2780}
2781
2782TComSPS::~TComSPS()
2783{
2784  m_RPSList.destroy();
2785}
2786
2787Void  TComSPS::createRPSList( Int numRPS )
2788{
2789  m_RPSList.destroy();
2790  m_RPSList.create(numRPS);
2791}
2792
2793const Int TComSPS::m_winUnitX[]={1,2,2,1};
2794const Int TComSPS::m_winUnitY[]={1,2,1,1};
2795
2796TComPPSRExt::TComPPSRExt()
2797: m_log2MaxTransformSkipBlockSize      (2)
2798, m_crossComponentPredictionEnabledFlag(false)
2799, m_diffCuChromaQpOffsetDepth          (0)
2800, m_chromaQpOffsetListLen              (0)
2801// m_ChromaQpAdjTableIncludingNullEntry initialized below
2802// m_log2SaoOffsetScale initialized below
2803{
2804  m_ChromaQpAdjTableIncludingNullEntry[0].u.comp.CbOffset = 0; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0. This is initialised here and never subsequently changed.
2805  m_ChromaQpAdjTableIncludingNullEntry[0].u.comp.CrOffset = 0;
2806  for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2807  {
2808    m_log2SaoOffsetScale[ch] = 0;
2809  }
2810}
2811
2812TComPPS::TComPPS()
2813: m_PPSId                            (0)
2814, m_SPSId                            (0)
2815, m_picInitQPMinus26                 (0)
2816, m_useDQP                           (false)
2817, m_bConstrainedIntraPred            (false)
2818, m_bSliceChromaQpFlag               (false)
2819, m_uiMaxCuDQPDepth                  (0)
2820, m_chromaCbQpOffset                 (0)
2821, m_chromaCrQpOffset                 (0)
2822, m_numRefIdxL0DefaultActive         (1)
2823, m_numRefIdxL1DefaultActive         (1)
2824, m_TransquantBypassEnableFlag       (false)
2825, m_useTransformSkip                 (false)
2826, m_dependentSliceSegmentsEnabledFlag(false)
2827, m_tilesEnabledFlag                 (false)
2828, m_entropyCodingSyncEnabledFlag     (false)
2829, m_loopFilterAcrossTilesEnabledFlag (true)
2830, m_uniformSpacingFlag               (false)
2831, m_numTileColumnsMinus1             (0)
2832, m_numTileRowsMinus1                (0)
2833, m_signHideFlag                     (false)
2834, m_cabacInitPresentFlag             (false)
2835, m_sliceHeaderExtensionPresentFlag  (false)
2836, m_loopFilterAcrossSlicesEnabledFlag(false)
2837, m_listsModificationPresentFlag     (0)
2838, m_numExtraSliceHeaderBits          (0)
2839#if NH_MV
2840, m_ppsInferScalingListFlag          (false)
2841, m_ppsScalingListRefLayerId         (0)
2842, m_pocResetInfoPresentFlag          (false)
2843#endif
2844#if NH_3D_DLT
2845, m_cDLT                             ()
2846#endif
2847{
2848#if NH_MV
2849  m_ppsRangeExtensionsFlag     = false;
2850  m_ppsMultilayerExtensionFlag = false;
2851  m_pps3dExtensionFlag         = false;
2852  m_ppsExtension5bits          = 0;
2853#endif
2854
2855}
2856
2857TComPPS::~TComPPS()
2858{
2859}
2860
2861#if NH_3D_DLT
2862TComDLT::TComDLT()
2863: m_bDltPresentFlag(false)
2864, m_iNumDepthViews(0)
2865, m_uiDepthViewBitDepth(8)
2866{
2867  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2868  {
2869    m_bUseDLTFlag                 [i] = false;
2870    m_bInterViewDltPredEnableFlag [i] = false;
2871    m_bDltBitMapRepFlag           [i] = false;
2872
2873    // allocate some memory and initialize with default mapping
2874    m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
2875    m_iDepthValue2Idx[i]    = std::vector<Int>(m_iNumDepthmapValues[i]);
2876    m_iIdx2DepthValue[i]    = std::vector<Int>(m_iNumDepthmapValues[i]);
2877   
2878    m_iDepthIdxToLayerId[i] = i;
2879
2880    //default mapping
2881    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
2882    {
2883      m_iDepthValue2Idx[i][d] = d;
2884      m_iIdx2DepthValue[i][d] = d;
2885    }
2886  }
2887}
2888
2889TComDLT::~TComDLT()
2890{
2891 
2892}
2893
2894Void TComDLT::setDepthLUTs(Int layerIdInVps, std::vector<Int> idxToDepthValueTable, Int iNumDepthValues)
2895{
2896  if( iNumDepthValues == 0 ) // default mapping only
2897    return;
2898
2899  // copy idx2DepthValue to internal array
2900  m_iIdx2DepthValue[layerIdInVps] = idxToDepthValueTable;
2901
2902  UInt uiMaxDepthValue = ((1 << m_uiDepthViewBitDepth)-1);
2903  for(Int p=0; p<=uiMaxDepthValue; p++)
2904  {
2905    Int iIdxDown    = 0;
2906    Int iIdxUp      = iNumDepthValues-1;
2907    Bool bFound     = false;
2908
2909    // iterate over indices to find lower closest depth
2910    Int i = 1;
2911    while(!bFound && i<iNumDepthValues)
2912    {
2913      if( m_iIdx2DepthValue[layerIdInVps][i] > p )
2914      {
2915        iIdxDown  = i-1;
2916        bFound    = true;
2917      }
2918
2919      i++;
2920    }
2921    iIdxUp = bFound ?  iIdxDown + 1 : iNumDepthValues-1;
2922
2923    // assign closer depth value/idx
2924    if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
2925    {
2926      m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
2927    }
2928    else
2929    {
2930      m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
2931    }
2932
2933  }
2934
2935  // update DLT variables
2936  m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
2937}
2938
2939Void TComDLT::getDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int>& riDeltaDLTOut, UInt&ruiDeltaDLTOutNum ) const
2940{
2941  Bool abBM0[ 256 ];
2942  Bool abBM1[ 256 ];
2943 
2944  memset( abBM0, 0, sizeof( abBM0 ));
2945  memset( abBM1, 0, sizeof( abBM1 ));
2946 
2947  // convert reference DLT to bit string
2948  for( Int i = 0; i < uiDLTInRefNum; i++ )
2949  {
2950    abBM0[ piDLTInRef[ i ] ] = true;
2951  }
2952  // convert internal DLT to bit string
2953  for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
2954  {
2955    abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
2956  }
2957 
2958  ruiDeltaDLTOutNum = 0;
2959  for( Int i = 0; i < 256; i++ )
2960  {
2961    if( abBM0[ i ] ^ abBM1[ i ] )
2962    {
2963      riDeltaDLTOut[ ruiDeltaDLTOutNum++ ] = i;
2964    }
2965  }
2966}
2967
2968Void TComDLT::setDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int> piDeltaDLTIn, UInt uiDeltaDLTInNum )
2969{
2970  Bool abBM0[ 256 ];
2971  Bool abBM1[ 256 ];
2972 
2973  memset( abBM0, 0, sizeof( abBM0 ));
2974  memset( abBM1, 0, sizeof( abBM1 ));
2975 
2976  // convert reference DLT to bit string
2977  for( Int i = 0; i < uiDLTInRefNum; i++ )
2978  {
2979    abBM0[ piDLTInRef[ i ] ] = true;
2980  }
2981  // convert delta DLT to bit string
2982  for( Int i = 0; i < uiDeltaDLTInNum; i++ )
2983  {
2984    abBM1[ piDeltaDLTIn[ i ] ] = true;
2985  }
2986 
2987  std::vector<Int> aiIdx2DepthValue(256, 0);
2988  UInt uiNumDepthValues = 0;
2989  std::fill(aiIdx2DepthValue.begin(), aiIdx2DepthValue.end(), 0);
2990 
2991  for( Int i = 0; i < 256; i++ )
2992  {
2993    if( abBM0[ i ] ^ abBM1[ i ] )
2994    {
2995      aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
2996    }
2997  }
2998 
2999  // update internal tables
3000  setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
3001}
3002
3003#endif
3004
3005#if NH_MV
3006Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr, Bool encoder )
3007{
3008  if ( getMultiLayerExtSpsFlag() )
3009  {   
3010    Int            repFormatIdx = getUpdateRepFormatFlag() ?  getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
3011    const TComRepFormat* repFormat    = vps->getRepFormat( repFormatIdx ); 
3012
3013    if ( encoder )
3014    {
3015      assert( getChromaFormatIdc() ==  (ChromaFormat) repFormat->getChromaFormatVpsIdc() );         
3016      //// ToDo: add when supported:
3017      // assert( getSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
3018
3019      assert( getPicWidthInLumaSamples()  ==  repFormat->getPicWidthVpsInLumaSamples()  ); 
3020      assert( getPicHeightInLumaSamples() == repFormat->getPicHeightVpsInLumaSamples() ); 
3021
3022      assert( getBitDepth              ( CHANNEL_TYPE_LUMA ) == repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
3023      assert( getQpBDOffset            ( CHANNEL_TYPE_LUMA ) == (Int) (6*( getBitDepth( CHANNEL_TYPE_LUMA ) - 8 )) );
3024
3025      assert( getBitDepth              ( CHANNEL_TYPE_CHROMA ) == repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
3026      assert( getQpBDOffset            ( CHANNEL_TYPE_CHROMA ) == (Int) (6* ( getBitDepth( CHANNEL_TYPE_CHROMA ) -8 ) ) );
3027    }
3028    else
3029    {
3030      setChromaFormatIdc( (ChromaFormat) repFormat->getChromaFormatVpsIdc() );         
3031      //// ToDo: add when supported:
3032      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
3033
3034      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
3035      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
3036
3037      setBitDepth              ( CHANNEL_TYPE_LUMA, repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
3038      setQpBDOffset            ( CHANNEL_TYPE_LUMA, (Int) (6*( getBitDepth( CHANNEL_TYPE_LUMA ) - 8 )) );
3039
3040      setBitDepth              ( CHANNEL_TYPE_CHROMA, repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
3041      setQpBDOffset            ( CHANNEL_TYPE_CHROMA, (Int) (6* ( getBitDepth( CHANNEL_TYPE_CHROMA ) -8 ) ) );
3042      Window &spsConf    = getConformanceWindow();   
3043
3044      // Scaled later
3045      spsConf.setScaledFlag( false ); 
3046      spsConf.setWindowLeftOffset  ( repFormat->getConfWinVpsLeftOffset()    );
3047      spsConf.setWindowRightOffset ( repFormat->getConfWinVpsRightOffset()   );
3048      spsConf.setWindowTopOffset   ( repFormat->getConfWinVpsTopOffset()     );
3049      spsConf.setWindowBottomOffset( repFormat->getConfWinVpsBottomOffset()  );           
3050    }
3051
3052   if ( getMultiLayerExtSpsFlag() && getUpdateRepFormatFlag() )
3053    {
3054      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
3055      //// ToDo: add when supported:
3056      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ;
3057
3058      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    ); 
3059      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   ); 
3060
3061      assert( getBitDepth( CHANNEL_TYPE_LUMA   )  <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
3062      assert( getBitDepth( CHANNEL_TYPE_CHROMA )  <= repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
3063    }
3064  }
3065
3066  // Set conformance window
3067  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
3068  getConformanceWindow().scaleOffsets( scal );
3069  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
3070
3071  if (encoder && getMultiLayerExtSpsFlag() )
3072  { 
3073    Int            repFormatIdx = getUpdateRepFormatFlag() ?  getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
3074    const TComRepFormat* repFormat    = vps->getRepFormat( repFormatIdx ); 
3075
3076    Window &spsConf    = getConformanceWindow();   
3077    assert( spsConf.getWindowLeftOffset  () == repFormat->getConfWinVpsLeftOffset()    );
3078    assert( spsConf.getWindowRightOffset () == repFormat->getConfWinVpsRightOffset()   );
3079    assert( spsConf.getWindowTopOffset   () == repFormat->getConfWinVpsTopOffset()     );
3080    assert( spsConf.getWindowBottomOffset() == repFormat->getConfWinVpsBottomOffset()  );           
3081  }
3082}
3083
3084Void TComSPS::inferScalingList( const TComSPS* spsSrc )
3085{
3086  if ( getSpsInferScalingListFlag() ) 
3087  {
3088    assert( spsSrc != NULL ); 
3089    assert( !spsSrc->getSpsInferScalingListFlag() );             
3090    getScalingList().inferFrom( (spsSrc->getScalingList()) ); 
3091  }
3092}
3093
3094Void TComSPS::inferSpsMaxDecPicBufferingMinus1( TComVPS* vps, Int targetOptLayerSetIdx, Int currLayerId, Bool encoder )
3095{
3096  if ( getMultiLayerExtSpsFlag() )
3097  {
3098    const std::vector<Int>& targetDecLayerIdList = vps->getTargetDecLayerIdList( vps->olsIdxToLsIdx( targetOptLayerSetIdx )); 
3099    Int layerIdx = 0;         
3100    while (layerIdx < (Int) targetDecLayerIdList.size() )
3101    {
3102      if ( targetDecLayerIdList[layerIdx] == currLayerId )
3103      { 
3104        break; 
3105      }
3106      layerIdx++; 
3107    }
3108
3109    assert( layerIdx < (Int) targetDecLayerIdList.size() ); 
3110
3111    for (Int i = 0; i <= getSpsMaxSubLayersMinus1(); i++ ) 
3112    {
3113      Int maxDecPicBufferingMinus1 = vps->getDpbSize()->getMaxVpsDecPicBufferingMinus1( targetOptLayerSetIdx, layerIdx, i ) ; 
3114
3115      // This preliminary fix needs to be checked.
3116      Int maxNumReorderPics       = vps->getDpbSize()->getMaxVpsNumReorderPics( targetOptLayerSetIdx, i ); 
3117      Int maxLatencyIncreasePlus1 = vps->getDpbSize()->getMaxVpsLatencyIncreasePlus1( targetOptLayerSetIdx, i ); 
3118      if ( encoder )     
3119      {
3120        assert( getMaxDecPicBuffering( i ) - 1 == maxDecPicBufferingMinus1 ); 
3121        // This preliminary fix needs to be checked.
3122        assert( getNumReorderPics( i )     == maxNumReorderPics       ); 
3123        assert( getSpsMaxLatencyIncreasePlus1( i ) == maxLatencyIncreasePlus1 ); 
3124
3125      }
3126      else
3127      {
3128        // This preliminary fix needs to be checked.
3129        setMaxDecPicBuffering( maxDecPicBufferingMinus1 + 1 , i); 
3130        setNumReorderPics    ( maxNumReorderPics, i );
3131        setSpsMaxLatencyIncreasePlus1( maxLatencyIncreasePlus1 , i); 
3132      }
3133    }   
3134  }
3135}
3136
3137Void TComSPS::checkRpsMaxNumPics( const TComVPS* vps, Int currLayerId ) const
3138{
3139  for (Int i = 0; i < getRPSList()->getNumberOfReferencePictureSets(); i++ )
3140  {
3141    const TComReferencePictureSet* rps = getRPSList()->getReferencePictureSet( i ); 
3142    if ( !rps->getInterRPSPrediction() )
3143    {
3144      rps->checkMaxNumPics( vps->getVpsExtensionFlag(), MAX_INT, getLayerId(), getMaxDecPicBuffering( getSpsMaxSubLayersMinus1() ) - 1 );   // INT_MAX to be replaced by DpbSize
3145    }
3146  }
3147}
3148
3149Void TComSPS::inferSpsMaxSubLayersMinus1(Bool atPsActivation, TComVPS* vps)
3150{
3151  assert( getLayerId() != 0 ); 
3152  if ( !atPsActivation   )
3153  {
3154    assert( vps == NULL );
3155    if (getSpsExtOrMaxSubLayersMinus1() != 7)
3156    {
3157      setSpsMaxSubLayersMinus1( getSpsExtOrMaxSubLayersMinus1() );
3158    }
3159  }
3160  else
3161  {
3162    assert( vps != NULL );
3163    if (getSpsExtOrMaxSubLayersMinus1() == 7)
3164    {
3165      setSpsMaxSubLayersMinus1( vps->getMaxSubLayersMinus1() );
3166    }
3167  }
3168}
3169#endif
3170
3171
3172TComReferencePictureSet::TComReferencePictureSet()
3173: m_numberOfPictures (0)
3174, m_numberOfNegativePictures (0)
3175, m_numberOfPositivePictures (0)
3176, m_numberOfLongtermPictures (0)
3177, m_interRPSPrediction (0)
3178, m_deltaRIdxMinus1 (0)
3179, m_deltaRPS (0)
3180, m_numRefIdc (0)
3181{
3182  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
3183  ::memset( m_POC, 0, sizeof(m_POC) );
3184  ::memset( m_used, 0, sizeof(m_used) );
3185  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
3186  ::memset( m_bCheckLTMSB, 0, sizeof(m_bCheckLTMSB) );
3187  ::memset( m_pocLSBLT, 0, sizeof(m_pocLSBLT) );
3188  ::memset( m_deltaPOCMSBCycleLT, 0, sizeof(m_deltaPOCMSBCycleLT) );
3189  ::memset( m_deltaPocMSBPresentFlag, 0, sizeof(m_deltaPocMSBPresentFlag) );
3190}
3191
3192TComReferencePictureSet::~TComReferencePictureSet()
3193{
3194}
3195
3196Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
3197{
3198  m_used[bufferNum] = used;
3199}
3200
3201Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
3202{
3203  m_deltaPOC[bufferNum] = deltaPOC;
3204}
3205
3206Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
3207{
3208  m_numberOfPictures = numberOfPictures;
3209}
3210
3211Int TComReferencePictureSet::getUsed(Int bufferNum) const
3212{
3213  return m_used[bufferNum];
3214}
3215
3216Int TComReferencePictureSet::getDeltaPOC(Int bufferNum) const
3217{
3218  return m_deltaPOC[bufferNum];
3219}
3220
3221Int TComReferencePictureSet::getNumberOfPictures() const
3222{
3223  return m_numberOfPictures;
3224}
3225
3226Int TComReferencePictureSet::getPOC(Int bufferNum) const
3227{
3228  return m_POC[bufferNum];
3229}
3230
3231Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
3232{
3233  m_POC[bufferNum] = POC;
3234}
3235
3236Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum) const
3237{
3238  return m_bCheckLTMSB[bufferNum];
3239}
3240
3241Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
3242{
3243  m_bCheckLTMSB[bufferNum] = b;
3244}
3245
3246//! set the reference idc value at uiBufferNum entry to the value of iRefIdc
3247Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
3248{
3249  m_refIdc[bufferNum] = refIdc;
3250}
3251
3252//! get the reference idc value at uiBufferNum
3253Int  TComReferencePictureSet::getRefIdc(Int bufferNum) const
3254{
3255  return m_refIdc[bufferNum];
3256}
3257
3258/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
3259 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
3260 *  +ve values are in increasing order.
3261 * \returns Void
3262 */
3263Void TComReferencePictureSet::sortDeltaPOC()
3264{
3265  // sort in increasing order (smallest first)
3266  for(Int j=1; j < getNumberOfPictures(); j++)
3267  {
3268    Int deltaPOC = getDeltaPOC(j);
3269    Bool used = getUsed(j);
3270    for (Int k=j-1; k >= 0; k--)
3271    {
3272      Int temp = getDeltaPOC(k);
3273      if (deltaPOC < temp)
3274      {
3275        setDeltaPOC(k+1, temp);
3276        setUsed(k+1, getUsed(k));
3277        setDeltaPOC(k, deltaPOC);
3278        setUsed(k, used);
3279      }
3280    }
3281  }
3282  // flip the negative values to largest first
3283  Int numNegPics = getNumberOfNegativePictures();
3284  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
3285  {
3286    Int deltaPOC = getDeltaPOC(j);
3287    Bool used = getUsed(j);
3288    setDeltaPOC(j, getDeltaPOC(k));
3289    setUsed(j, getUsed(k));
3290    setDeltaPOC(k, deltaPOC);
3291    setUsed(k, used);
3292  }
3293}
3294
3295/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
3296 *  A "*" is added to the deltaPOC value if it is Used bu current.
3297 * \returns Void
3298 */
3299Void TComReferencePictureSet::printDeltaPOC() const
3300{
3301  printf("DeltaPOC = { ");
3302  for(Int j=0; j < getNumberOfPictures(); j++)
3303  {
3304    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
3305  }
3306  if (getInterRPSPrediction())
3307  {
3308    printf("}, RefIdc = { ");
3309    for(Int j=0; j < getNumRefIdc(); j++)
3310    {
3311      printf("%d ", getRefIdc(j));
3312    }
3313  }
3314  printf("}\n");
3315}
3316
3317#if NH_MV
3318Void TComReferencePictureSet::checkMaxNumPics( Bool vpsExtensionFlag, Int maxNumPics, Int nuhLayerId, Int spsMaxDecPicBufferingMinus1 ) const
3319{
3320  assert( getNumberOfPictures() >= 0 ); 
3321  if ( nuhLayerId == 0 )
3322  {
3323    assert( getNumberOfPictures() <= spsMaxDecPicBufferingMinus1 ); 
3324  }
3325
3326  if ( vpsExtensionFlag )
3327  {
3328    assert( getNumberOfPictures() <= maxNumPics );
3329  }
3330}
3331#endif
3332
3333
3334
3335
3336TComRefPicListModification::TComRefPicListModification()
3337: m_refPicListModificationFlagL0 (false)
3338, m_refPicListModificationFlagL1 (false)
3339{
3340  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
3341  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
3342}
3343
3344TComRefPicListModification::~TComRefPicListModification()
3345{
3346}
3347
3348TComScalingList::TComScalingList()
3349{
3350  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3351  {
3352    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
3353    {
3354      m_scalingListCoef[sizeId][listId].resize(min<Int>(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3355    }
3356  }
3357}
3358
3359/** set default quantization matrix to array
3360*/
3361Void TComScalingList::setDefaultScalingList()
3362{
3363  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3364  {
3365    for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
3366    {
3367      processDefaultMatrix(sizeId, listId);
3368    }
3369  }
3370}
3371/** check if use default quantization matrix
3372 * \returns true if use default quantization matrix in all size
3373*/
3374Bool TComScalingList::checkDefaultScalingList()
3375{
3376  UInt defaultCounter=0;
3377
3378  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3379  {
3380    for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
3381    {
3382      if( !memcmp(getScalingListAddress(sizeId,listId), getScalingListDefaultAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
3383     && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == 16))) // check DC value
3384      {
3385        defaultCounter++;
3386      }
3387    }
3388  }
3389
3390  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM )) ? false : true;
3391}
3392
3393#if NH_MV
3394Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
3395{
3396  refPicSetInterLayer0.clear(); 
3397  refPicSetInterLayer1.clear(); 
3398
3399  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
3400  {
3401    Int layerIdRef = getRefPicLayerId( i ); 
3402    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ; 
3403    assert ( picRef != 0 ); // There shall be no entry equal to "no reference picture" in RefPicSetInterLayer0 or RefPicSetInterLayer1.
3404
3405    picRef->getPicYuvRec()->extendPicBorder(); 
3406    picRef->setIsLongTerm( true );       
3407    picRef->getSlice(0)->setReferenced( true );       
3408
3409    Int viewIdCur  = getVPS()->getViewId( getLayerId() ); 
3410    Int viewIdZero = getVPS()->getViewId( 0 );
3411    Int viewIdRef  = getVPS()->getViewId( layerIdRef ); 
3412
3413    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
3414    {
3415      refPicSetInterLayer0.push_back( picRef ); 
3416    }
3417    else
3418    {
3419      refPicSetInterLayer1.push_back( picRef ); 
3420    }
3421    // Consider to check here:
3422    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "   
3423    assert( picRef->getSlice(0)->getDiscardableFlag() == false ); // "There shall be no picture that has discardable_flag equal to 1 in RefPicSetInterLayer0 or RefPicSetInterLayer1".       
3424  }
3425}
3426Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
3427{
3428  // Mark as short-term
3429  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ ) 
3430  {
3431    refPicSetInterLayer0[i]->setIsLongTerm( false ); 
3432  }
3433
3434  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ ) 
3435  {
3436    refPicSetInterLayer1[i]->setIsLongTerm( false ); 
3437  }
3438
3439}
3440
3441Void TComSlice::printRefPicList()
3442{ 
3443  for ( Int li = 0; li < 2; li++)
3444  {   
3445    std::cout << std::endl << "RefPicListL" <<  li << ":" << std::endl; 
3446    for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
3447    {     
3448      if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( 1 );
3449      m_apcRefPicList[li][rIdx]->print( 0 );     
3450       
3451    }
3452  }
3453}
3454
3455Void TComSlice::markCurrPic( TComPic* currPic )
3456{
3457  currPic->getSlice(0)->setReferenced( true ) ; 
3458  currPic->setIsLongTerm( false ); 
3459
3460  currPic->setReconMark( true );
3461  currPic->setPicOutputFlag( currPic->getSlice(0)->getPicOutputFlag() );
3462}
3463
3464Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
3465{
3466  m_refPicSetInterLayer0 = refPicSetInterLayer0; 
3467  m_refPicSetInterLayer1 = refPicSetInterLayer1; 
3468}
3469
3470TComPic* TComSlice::getRefPicSetInterLayer( Int setIdc, Int i ) const
3471{
3472  TComPic* pic = NULL; 
3473  if (setIdc == 0 )
3474  {
3475    pic = (*m_refPicSetInterLayer0)[ i ]; 
3476  }
3477  else if (setIdc == 1 )
3478  {
3479    pic = (*m_refPicSetInterLayer1)[ i ]; 
3480  }
3481
3482  assert( pic != NULL );   
3483
3484  return pic; 
3485}
3486
3487
3488TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId ) const
3489{
3490  assert ( setIdc == 0 || setIdc == 1);   
3491  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
3492  assert( refPicSetInterLayer != 0 ); 
3493 
3494  TComPic* pcPic = NULL; 
3495  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
3496  {
3497    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
3498    {
3499      pcPic = (*refPicSetInterLayer)[ i ]; 
3500    }
3501  }
3502
3503  assert(pcPic != NULL); 
3504  return pcPic;
3505}
3506
3507
3508Int  TComSlice::getRefLayerPicFlag( Int i ) const
3509{
3510  const TComVPS* vps = getVPS(); 
3511#if NH_3D
3512  Int refLayerIdx = vps->getLayerIdInVps( vps->getIdRefListLayer( getLayerId(), i ) ); 
3513#else
3514  Int refLayerIdx = vps->getLayerIdInVps( vps->getIdDirectRefLayer( getLayerId(), i ) ); 
3515#endif
3516
3517  Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer()  && ( getTLayer() == 0   ||
3518    vps->getMaxTidIlRefPicsPlus1( refLayerIdx, vps->getLayerIdInVps( getLayerId() )) > getTLayer() )); 
3519  return refLayerPicFlag;       
3520}   
3521
3522Int TComSlice::getRefLayerPicIdc( Int j ) const
3523{ 
3524  Int refLayerPicIdc = -1; 
3525  Int curj = 0; 
3526#if NH_3D
3527  for( Int i = 0;  i < getVPS()->getNumRefListLayers( getLayerId()) ; i++ )
3528#else
3529  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3530#endif
3531  {
3532    if( getRefLayerPicFlag( i ) )
3533    {
3534      if ( curj == j ) 
3535      {
3536        refLayerPicIdc = i;         
3537        break;
3538      }
3539      curj++; 
3540    }
3541  }
3542
3543  assert( curj == j ); 
3544  assert( refLayerPicIdc != -1 ); 
3545  return refLayerPicIdc; 
3546}
3547
3548Int  TComSlice::getNumRefLayerPics( ) const
3549{ 
3550  Int numRefLayerPics = 0; 
3551#if NH_3D
3552  for( Int i = 0;  i < getVPS()->getNumRefListLayers( getLayerId()) ; i++ )
3553#else
3554  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3555#endif
3556  {
3557    numRefLayerPics += getRefLayerPicFlag( i ); 
3558  }
3559  return numRefLayerPics; 
3560}
3561
3562
3563
3564Int TComSlice::getNumActiveRefLayerPics() const
3565{
3566  Int numActiveRefLayerPics; 
3567
3568  if( getLayerId() == 0 || getNumRefLayerPics() ==  0 )
3569  {
3570    numActiveRefLayerPics = 0; 
3571  }
3572  else if (getVPS()->getAllRefLayersActiveFlag() )
3573  {
3574    numActiveRefLayerPics = getNumRefLayerPics(); 
3575  }
3576  else if ( !getInterLayerPredEnabledFlag() )
3577  {
3578    numActiveRefLayerPics = 0; 
3579  }
3580#if NH_3D
3581  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumRefListLayers( getLayerId() ) == 1 )
3582#else
3583  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
3584#endif
3585  {
3586    numActiveRefLayerPics = 1; 
3587  }
3588  else
3589  {
3590    numActiveRefLayerPics = getNumInterLayerRefPicsMinus1() + 1; 
3591  }
3592  return numActiveRefLayerPics;
3593}
3594
3595Int TComSlice::getRefPicLayerId( Int i ) const
3596{
3597#if NH_3D
3598  return getVPS()->getIdRefListLayer( getLayerId(), getInterLayerPredLayerIdc( i ) );
3599#else
3600  return getVPS()->getIdDirectRefLayer( getLayerId(), getInterLayerPredLayerIdc( i ) );
3601#endif
3602}
3603#endif
3604#if NH_3D_NBDV
3605Void TComSlice::setDefaultRefView()
3606{
3607  setDefaultRefViewIdx(-1);
3608  setDefaultRefViewIdxAvailableFlag(false); 
3609
3610  Int valid = 0;
3611  Int DefaultRefViewIdx = -1;
3612
3613  for(UInt curViewIdx = 0; curViewIdx < getViewIndex() && valid == 0; curViewIdx++)
3614  {
3615    for(Int iRefListId = 0; (iRefListId < (isInterB() ? 2 : 1)) && !isIntra() && valid == 0; iRefListId++)
3616    {
3617      RefPicList eRefPicList = RefPicList(iRefListId);
3618      Int        iNumRefPics = getNumRefIdx(eRefPicList);
3619
3620      for(Int i = 0; i < iNumRefPics; i++)
3621      { 
3622        if(getPOC() == getRefPic(eRefPicList, i)->getPOC() && curViewIdx == getRefPic(eRefPicList, i)->getViewIndex())
3623        {
3624          valid = 1;
3625          DefaultRefViewIdx = curViewIdx;
3626          break;
3627        }
3628      }
3629    }
3630  }
3631
3632  if(valid)
3633  {
3634    setDefaultRefViewIdx(DefaultRefViewIdx);
3635    setDefaultRefViewIdxAvailableFlag(true);
3636  }
3637}
3638#endif
3639
3640#if NH_3D_ARP
3641Void TComSlice::setARPStepNum( TComPicLists*ivPicLists )
3642{
3643  Bool tempRefPicInListsFlag = false;
3644  if( !getIvResPredFlag() || this->isIRAP())
3645  {
3646    m_nARPStepNum = 0;
3647  }
3648  else
3649  {
3650    setFirstTRefIdx (REF_PIC_LIST_0, -1);
3651    setFirstTRefIdx (REF_PIC_LIST_1, -1);
3652    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3653    {
3654      Int diffPOC=MAX_INT;
3655      Int idx=-1;
3656      for(Int i = 0; i < getNumRefIdx(RefPicList(refListIdx)); i++ )
3657      {
3658        if ( getRefPic(RefPicList(refListIdx), i)->getPOC() != getPOC() )
3659        {
3660          if( abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC()) < diffPOC)
3661          {
3662            diffPOC=abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC());
3663            idx=i;
3664          }
3665        }
3666        if(idx>=0)
3667        {
3668          setFirstTRefIdx (RefPicList(refListIdx), idx);
3669        }
3670      }
3671    }
3672    tempRefPicInListsFlag = (getFirstTRefIdx(REF_PIC_LIST_0) >= 0 || getFirstTRefIdx(REF_PIC_LIST_1) >= 0) && getDefaultRefViewIdxAvailableFlag();
3673    m_nARPStepNum = tempRefPicInListsFlag ? 3 : 0;
3674  }
3675
3676  if (tempRefPicInListsFlag)
3677  {
3678    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3679    {
3680      RefPicList eRefPicList = RefPicList( refListIdx );
3681      Int prevPOC = getRefPic(eRefPicList, getFirstTRefIdx(eRefPicList) )->getPOC();
3682      for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
3683      {
3684        Int layerIdInNuh = getRefPicLayerId( i );
3685
3686        TComPic* picV = getIvPic( getIsDepth(), getVPS()->getViewIndex( layerIdInNuh ) );
3687        assert( picV != NULL ); 
3688        IntAry1d pocsInCurrRPSsPicV = picV->getSlice(0)->getPocsInCurrRPSs(); 
3689        Bool refRpRefAvailFlag = false; 
3690        for (Int idx = 0; idx < pocsInCurrRPSsPicV.size(); idx++)
3691        {
3692          if ( pocsInCurrRPSsPicV[idx] == prevPOC )
3693          {
3694            refRpRefAvailFlag = true; 
3695            break; 
3696          }
3697        }
3698
3699        if (getFirstTRefIdx(eRefPicList) >= 0 && refRpRefAvailFlag )
3700        {
3701          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
3702        }
3703        else
3704        {
3705          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = false;
3706        }
3707      }
3708    }
3709  }
3710  if( m_nARPStepNum > 1)
3711  {
3712    for(Int i = 0; i < getNumActiveRefLayerPics(); i ++ )
3713    {
3714      Int  iLayerId = getRefPicLayerId( i );
3715      Int  iViewIdx =   getVPS()->getViewIndex(iLayerId);
3716      Bool bIsDepth = ( getVPS()->getDepthId  ( iLayerId ) == 1 );
3717      if( iViewIdx<getViewIndex() && !bIsDepth )
3718      {
3719        setBaseViewRefPicList( ivPicLists->getSubDpb( iLayerId, false ), iViewIdx );
3720      }
3721    }
3722  }
3723}
3724#endif
3725
3726#if NH_3D_IC
3727// This is an encoder only function and should be moved to TEncSlice or TEncSearch!!
3728Void TComSlice::xSetApplyIC(Bool bUseLowLatencyICEnc)
3729{
3730  if(bUseLowLatencyICEnc)
3731  {
3732    Bool existInterViewRef=false;
3733    TComPic* pcCurrPic = getPic();
3734    TComPic* pcRefPic = NULL;
3735    for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_0 )) && !existInterViewRef; i++ )
3736    {
3737      pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3738      if ( pcRefPic != NULL )
3739      {
3740        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3741        {
3742          existInterViewRef = true;
3743        }
3744      }
3745    }
3746
3747    for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_1 )) && !existInterViewRef; i++ )
3748    {
3749      pcRefPic = getRefPic( REF_PIC_LIST_1, i );
3750      if ( pcRefPic != NULL )
3751      {
3752        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3753        {
3754          existInterViewRef = true;       
3755        }
3756      }
3757    }
3758
3759    if(!existInterViewRef)
3760    {
3761      m_bApplyIC = false;
3762    }
3763    else
3764    {
3765      Int curLayer=getDepth();
3766      if( curLayer>9) curLayer=9; // Max layer is 10
3767
3768      m_bApplyIC = true;
3769      Int refLayer = curLayer-1;
3770
3771      Int ICEnableCandidate = getICEnableCandidate(refLayer);
3772      Int ICEnableNum = getICEnableNum(refLayer);
3773      if( (refLayer>=0) && (ICEnableCandidate>0) )
3774      {   
3775        Double ratio=Double(ICEnableNum/Double(ICEnableCandidate));
3776
3777        if( ratio > IC_LOW_LATENCY_ENCODING_THRESHOLD)
3778        {
3779          m_bApplyIC=true;
3780        }
3781        else
3782        {
3783          m_bApplyIC=false;
3784        }
3785      }
3786      setICEnableCandidate(curLayer, 0);
3787      setICEnableNum(curLayer, 0);
3788    }
3789  }
3790  else
3791  {       
3792    TComPic*    pcCurrPic = getPic();
3793    TComPicYuv* pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
3794   
3795    // Get InterView Reference picture
3796    // !!!!! Assume only one Interview Reference Picture in L0
3797    // GT: Is this assumption correct?
3798
3799    TComPicYuv* pcRefPicYuvOrg = NULL;
3800    for ( Int i = 0; i < getNumRefIdx( REF_PIC_LIST_0 ); i++ )
3801    {
3802      TComPic* pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3803      if ( pcRefPic != NULL )
3804      {
3805        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3806        {
3807          pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
3808        }
3809      }
3810    }
3811
3812    if ( pcRefPicYuvOrg != NULL )
3813    {
3814      // Histogram building - luminance
3815      Int iMaxPelValue = ( 1 << getSPS()->getBitDepth(CHANNEL_TYPE_LUMA) ); 
3816      Int *aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
3817      Int *aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
3818      memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
3819      memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
3820
3821      Int iWidth   = pcCurrPicYuv->getWidth(COMPONENT_Y);
3822      Int iHeight  = pcCurrPicYuv->getHeight(COMPONENT_Y);
3823      Pel* pCurrY   = pcCurrPicYuv->getAddr(COMPONENT_Y);
3824      Pel* pRefOrgY = pcRefPicYuvOrg->getAddr(COMPONENT_Y);
3825      Int iCurrStride = pcCurrPicYuv->getStride(COMPONENT_Y);
3826      Int iRefStride = pcRefPicYuvOrg->getStride(COMPONENT_Y);
3827      for ( Int y = 0; y < iHeight; y++ )
3828      {
3829        for ( Int x = 0; x < iWidth; x++ )
3830        {
3831          aiCurrHist[pCurrY[x]]++;
3832          aiRefOrgHist[pRefOrgY[x]]++;
3833        }
3834        pCurrY += iCurrStride;
3835        pRefOrgY += iRefStride;
3836      }
3837
3838      // Histogram SAD
3839      Int iSumOrgSAD = 0;
3840      for ( Int i = 0; i < iMaxPelValue; i++ )
3841      {
3842        iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
3843      }
3844
3845      // Setting
3846      Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
3847
3848      if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
3849      {
3850        m_bApplyIC = true;
3851      }
3852      else
3853      {
3854        m_bApplyIC = false;
3855      }
3856
3857      xFree( aiCurrHist   );
3858      xFree( aiRefOrgHist );
3859    }
3860  }//if(bUseLowLatencyICEnc)
3861}
3862#endif
3863#if NH_3D_QTL
3864Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
3865{ 
3866  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3867  { 
3868    for ( Int depthId = 0; depthId < 2; depthId++ )
3869    {
3870      m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , 0, getPOC() ) : NULL;
3871    }       
3872  } 
3873}
3874#endif
3875#if NH_3D
3876Void TComSlice::setDepthToDisparityLUTs()
3877{ 
3878  Bool setupLUT = false; 
3879 
3880  setupLUT = setupLUT || getViewSynthesisPredFlag( ); 
3881
3882#if NH_3D_NBDV_REF
3883  setupLUT = setupLUT || getDepthRefinementFlag( );
3884#endif 
3885
3886#if NH_3D_IV_MERGE
3887  setupLUT = setupLUT || ( getIvMvPredFlag() && getIsDepth() );
3888#endif
3889
3890  Int bitDepthY = getSPS()->getBitDepth(CHANNEL_TYPE_LUMA);
3891
3892  if( !setupLUT )
3893  {
3894    return; 
3895  }
3896
3897  m_numViews = getVPS()->getNumViews(); 
3898  /// GT: Allocation should be moved to a better place later;
3899  if ( m_depthToDisparityB == NULL )
3900  {
3901    m_depthToDisparityB = new Int*[ m_numViews ];
3902    for ( Int i = 0; i < getVPS()->getNumViews(); i++ )
3903    {
3904      m_depthToDisparityB[ i ] = new Int[ Int(1 << bitDepthY) ]; 
3905    }
3906  }
3907
3908 
3909  if ( m_depthToDisparityF == NULL )
3910  {
3911    m_depthToDisparityF = new Int*[ m_numViews ];
3912    for ( Int i = 0; i < m_numViews; i++ )
3913    {
3914      m_depthToDisparityF[ i ] = new Int[ Int(1 << bitDepthY) ]; 
3915    }
3916  }
3917
3918  assert( m_depthToDisparityB != NULL ); 
3919  assert( m_depthToDisparityF != NULL ); 
3920
3921  const TComVPS* vps = getVPS(); 
3922
3923  Int log2Div = bitDepthY - 1 + vps->getCpPrecision();
3924  Int voiInVps = vps->getVoiInVps( getViewIndex() ); 
3925  Bool camParaSH = vps->getCpInSliceSegmentHeaderFlag( voiInVps ); 
3926
3927  const IntAry1d codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( voiInVps ); 
3928  const IntAry1d codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( voiInVps ); 
3929  const IntAry1d invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( voiInVps ); 
3930  const IntAry1d invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( voiInVps ); 
3931
3932
3933  for (Int i = 0; i < voiInVps; i++)
3934  {
3935    Int iInVoi = vps->getVoiInVps( i ); 
3936#if ENC_DEC_TRACE && NH_MV_ENC_DEC_TRAC
3937    if ( g_traceCameraParameters )
3938    {
3939      std::cout << "Cp: " << codScale   [ iInVoi ] << " " <<    codOffset[ iInVoi ] << " "
3940                << invCodScale[ iInVoi ] << " " << invCodOffset[ iInVoi ] << " " << log2Div << std::endl ; 
3941    }
3942#endif
3943    for ( Int d = 0; d <= ( ( 1 << bitDepthY ) - 1 ); d++ )
3944    {     
3945      Int offset =    ( codOffset  [ iInVoi ] << bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3946      m_depthToDisparityB[ iInVoi ][ d ] = ( codScale [ iInVoi ] * d + offset ) >> log2Div; 
3947
3948      Int invOffset = ( invCodOffset[ iInVoi ] << bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3949      m_depthToDisparityF[ iInVoi ][ d ] = ( invCodScale[ iInVoi ] * d + invOffset ) >> log2Div; 
3950    }
3951  }
3952}
3953#endif
3954
3955
3956
3957#if NH_MV
3958Void TComSlice::checkCrossLayerBlaFlag() const
3959{
3960  // cross_layer_bla_flag shall be equal to 0 for pictures with nal_unit_type not equal to IDR_W_RADL or IDR_N_LP or with nuh_layer_id not equal to 0.
3961  if ( getLayerId() != 0 || getNalUnitType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
3962  {
3963    assert( m_crossLayerBlaFlag == 0 ); 
3964  }
3965}
3966
3967Bool TComSlice::inferPocMsbCycleValPresentFlag()
3968{
3969  Bool pocMsbValPresentFlag; 
3970  if( getSliceSegmentHeaderExtensionLength() == 0 ) 
3971  {
3972    pocMsbValPresentFlag = false; 
3973  }
3974  else if ( getPocMsbValRequiredFlag() )
3975  {
3976    pocMsbValPresentFlag = true; 
3977  }
3978  else
3979  {
3980    pocMsbValPresentFlag = false; 
3981  }
3982
3983  return pocMsbValPresentFlag;
3984}
3985
3986
3987Void TComSlice::f834decProcForRefPicListConst()
3988{
3989  // This process is invoked at the beginning of the decoding process for each P or B slice.
3990  assert( getSliceType() == B_SLICE || getSliceType() == P_SLICE );
3991
3992  // Reference pictures are addressed through reference indices as specified in clause 8.5.3.3.2. A reference index is an index into
3993  // a reference picture list. When decoding a P slice, there is a single reference picture list RefPicList0. When decoding a B
3994  // slice, there is a second independent reference picture list RefPicList1 in addition to RefPicList0.
3995
3996  // At the beginning of the decoding process for each slice, the reference picture lists RefPicList0 and, for B slices, RefPicList1
3997  // are derived as follows:
3998
3999  // The variable NumRpsCurrTempList0 is set equal to Max( num_ref_idx_l0_active_minus1 + 1, NumPicTotalCurr )
4000  Int numRpsCurrTempList0 = std::max( getNumRefIdxL0ActiveMinus1() + 1, getNumPicTotalCurr() );
4001
4002  // and the list RefPicListTemp0 is constructed as follows:
4003  std::vector<TComPic*> refPicListTemp0;
4004  refPicListTemp0.resize((MAX_NUM_REF+1),NULL);
4005
4006  const TComDecodedRps* decRps = getPic()->getDecodedRps(); 
4007
4008  const std::vector<TComPic*>& refPicSetStCurrBefore  = decRps->m_refPicSetStCurrBefore; 
4009  const std::vector<TComPic*>& refPicSetStCurrAfter   = decRps->m_refPicSetStCurrAfter;
4010  const std::vector<TComPic*>& refPicSetLtCurr        = decRps->m_refPicSetLtCurr; 
4011
4012  const Int                    numPocStCurrBefore     = decRps->m_numPocStCurrBefore; 
4013  const Int                    numPocStCurrAfter      = decRps->m_numPocStCurrAfter;
4014  const Int                    numPocLtCurr           = decRps->m_numPocLtCurr;
4015
4016  const Int                    numActiveRefLayerPics0 = decRps->m_numActiveRefLayerPics0;
4017  const Int                    numActiveRefLayerPics1 = decRps->m_numActiveRefLayerPics1;
4018
4019  const std::vector<TComPic*>& refPicSetInterLayer0   = decRps->m_refPicSetInterLayer0;
4020  const std::vector<TComPic*>& refPicSetInterLayer1   = decRps->m_refPicSetInterLayer1;
4021
4022  Int rIdx = 0;
4023  while( rIdx < numRpsCurrTempList0 )
4024  {
4025    for(Int  i = 0; i < numPocStCurrBefore  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )
4026    {
4027      refPicListTemp0[ rIdx ] = refPicSetStCurrBefore[ i ];
4028    }   
4029
4030    for(Int  i = 0; i < numActiveRefLayerPics0; rIdx++, i++ )
4031    {
4032      refPicListTemp0[ rIdx ] = refPicSetInterLayer0[ i ];
4033    }
4034
4035    for(Int  i = 0;  i < numPocStCurrAfter  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )  // (F 65)
4036    {
4037      refPicListTemp0[ rIdx ] = refPicSetStCurrAfter[ i ];
4038    }
4039
4040    for(Int  i = 0; i < numPocLtCurr  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )
4041    {
4042      refPicListTemp0[ rIdx ] = refPicSetLtCurr[ i ]; 
4043    }
4044
4045    for(Int  i = 0; i < numActiveRefLayerPics1; rIdx++, i++ )
4046    {
4047      refPicListTemp0[ rIdx ] = refPicSetInterLayer1[ i ];
4048    }
4049  }
4050
4051  // The list RefPicList0 is constructed as follows:
4052  TComRefPicListModification* rplm  = getRefPicListModification(); 
4053  for( rIdx = 0; rIdx  <=  getNumRefIdxL0ActiveMinus1(); rIdx++ )      //  (F 66)
4054  {
4055    m_apcRefPicList[ 0 ][ rIdx ] = rplm->getRefPicListModificationFlagL0( ) ? refPicListTemp0[ rplm->getListEntryL0( rIdx )] : refPicListTemp0[ rIdx ];
4056    // The decoding process below slice level requires the status
4057    // of the reference pictures, when decoding the RPS. So store it here.
4058    m_bIsUsedAsLongTerm[ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getIsLongTerm();
4059    m_aiRefPOCList     [ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getPOC();
4060    m_aiRefLayerIdList [ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getLayerId();
4061  } 
4062
4063  std::vector<TComPic*> refPicListTemp1;
4064  refPicListTemp1.resize((MAX_NUM_REF+1),NULL);
4065
4066  if (getSliceType() == B_SLICE )
4067  {
4068    // When the slice is a B slice, the variable NumRpsCurrTempList1 is set equal to
4069    // Max( num_ref_idx_l1_active_minus1 + 1, NumPicTotalCurr ) and the list RefPicListTemp1 is constructed as follows:       
4070    Int numRpsCurrTempList1 = std::max( getNumRefIdxL1ActiveMinus1() + 1, getNumPicTotalCurr() );
4071
4072    rIdx = 0; 
4073    while( rIdx < numRpsCurrTempList1 )
4074    {
4075      for( Int i = 0; i < numPocStCurrAfter  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )
4076      {
4077        refPicListTemp1[ rIdx ] = refPicSetStCurrAfter[ i ]; 
4078      }
4079      for( Int i = 0; i< numActiveRefLayerPics1; rIdx++, i++ )
4080      {
4081        refPicListTemp1[ rIdx ] = refPicSetInterLayer1[ i ]; 
4082      }
4083      for( Int i = 0;  i < numPocStCurrBefore  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )  // (F 67)
4084      {
4085        refPicListTemp1[ rIdx ] = refPicSetStCurrBefore[ i ];
4086      }         
4087      for( Int i = 0; i < numPocLtCurr  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )
4088      {
4089        refPicListTemp1[ rIdx ] = refPicSetLtCurr[ i ];
4090      }
4091      for( Int i = 0; i< numActiveRefLayerPics0; rIdx++, i++ )
4092      {
4093        refPicListTemp1[ rIdx ] = refPicSetInterLayer0[ i ]; 
4094      }
4095    }
4096  }
4097
4098  if (getSliceType() == B_SLICE )
4099  {
4100    //   When the slice is a B slice, the list RefPicList1 is constructed as follows:
4101    for( rIdx = 0; rIdx  <=  getNumRefIdxL1ActiveMinus1(); rIdx++ )      // (F 68)
4102    {
4103      m_apcRefPicList[ 1 ][ rIdx ] = rplm->getRefPicListModificationFlagL1() ? refPicListTemp1[ rplm->getListEntryL1( rIdx ) ] : refPicListTemp1[ rIdx ]; 
4104
4105      // The decoding process below slice level requires the marking status
4106      // of the reference pictures, when decoding the RPS. So store it here.
4107      m_bIsUsedAsLongTerm[ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getIsLongTerm();
4108      m_aiRefPOCList     [ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getPOC();
4109      m_aiRefLayerIdList [ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getLayerId();
4110    }   
4111  }
4112}
4113
4114
4115Void TComSlice::cl834DecProcForRefPicListConst()
4116{
4117  // This process is invoked at the beginning of the decoding process for each P or B slice.
4118  assert( getSliceType() == B_SLICE || getSliceType() == P_SLICE );
4119
4120  // Reference pictures are addressed through reference indices as specified in clause 8.5.3.3.2. A reference index is an index into
4121  // a reference picture list. When decoding a P slice, there is a single reference picture list RefPicList0. When decoding a B
4122  // slice, there is a second independent reference picture list RefPicList1 in addition to RefPicList0.
4123
4124  // At the beginning of the decoding process for each slice, the reference picture lists RefPicList0 and, for B slices, RefPicList1
4125  // are derived as follows:
4126
4127  // The variable NumRpsCurrTempList0 is set equal to Max( num_ref_idx_l0_active_minus1 + 1, NumPicTotalCurr )
4128  Int numRpsCurrTempList0 = std::max( getNumRefIdxL0ActiveMinus1() + 1, getNumPicTotalCurr() );
4129
4130  // and the list RefPicListTemp0 is constructed as follows:
4131  std::vector<TComPic*> refPicListTemp0; 
4132  refPicListTemp0.resize((MAX_NUM_REF+1),NULL);
4133
4134  const TComDecodedRps* decRps = getPic()->getDecodedRps(); 
4135
4136  const std::vector<TComPic*>& refPicSetStCurrBefore = decRps->m_refPicSetStCurrBefore; 
4137  const std::vector<TComPic*>& refPicSetStCurrAfter  = decRps->m_refPicSetStCurrAfter;
4138  const std::vector<TComPic*>& refPicSetLtCurr       = decRps->m_refPicSetLtCurr; 
4139   
4140  const Int                    numPocStCurrBefore    = decRps->m_numPocStCurrBefore; 
4141  const Int                    numPocStCurrAfter     = decRps->m_numPocStCurrAfter;
4142  const Int                    numPocLtCurr          = decRps->m_numPocLtCurr;
4143
4144  Int rIdx = 0;
4145  while( rIdx < numRpsCurrTempList0 )
4146  {
4147    for(Int  i = 0; i < numPocStCurrBefore  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )
4148    {
4149      refPicListTemp0[ rIdx ] = refPicSetStCurrBefore[ i ];
4150    }   
4151
4152    for(Int  i = 0;  i < numPocStCurrAfter  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )  // (8 8)
4153    {
4154      refPicListTemp0[ rIdx ] = refPicSetStCurrAfter[ i ];
4155    }
4156
4157    for(Int  i = 0; i < numPocLtCurr  &&  rIdx < numRpsCurrTempList0; rIdx++, i++ )
4158    {
4159      refPicListTemp0[ rIdx ] = refPicSetLtCurr[ i ]; 
4160    }
4161  }
4162
4163  // The list RefPicList0 is constructed as follows:
4164
4165  TComRefPicListModification* rplm = getRefPicListModification(); 
4166  for( rIdx = 0; rIdx  <=  getNumRefIdxL0ActiveMinus1(); rIdx++ )      //   (8-9)
4167  {
4168    m_apcRefPicList[0][ rIdx ] = rplm->getRefPicListModificationFlagL0( ) ? refPicListTemp0[ rplm->getListEntryL0( rIdx )] : refPicListTemp0[ rIdx ];
4169
4170    // The decoding process below slice level requires the marking status
4171    // of the reference pictures, when decoding the RPS. So store it here.
4172    m_bIsUsedAsLongTerm[ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getIsLongTerm();
4173    m_aiRefPOCList     [ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getPOC();
4174    m_aiRefLayerIdList [ 0 ][ rIdx ] = m_apcRefPicList[ 0 ][ rIdx ]->getLayerId();
4175  }
4176
4177  std::vector<TComPic*> refPicListTemp1;
4178  refPicListTemp1.resize((MAX_NUM_REF+1),NULL);
4179
4180  if (getSliceType() == B_SLICE )
4181  {
4182    // When the slice is a B slice, the variable NumRpsCurrTempList1 is set equal to
4183    // Max( num_ref_idx_l1_active_minus1 + 1, NumPicTotalCurr ) and the list RefPicListTemp1 is constructed as follows:
4184    Int numRpsCurrTempList1 = std::max( getNumRefIdxL1ActiveMinus1() + 1, getNumPicTotalCurr() );
4185
4186    rIdx = 0; 
4187    while( rIdx < numRpsCurrTempList1 )
4188    {
4189      for( Int i = 0; i < numPocStCurrAfter  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )
4190      {
4191        refPicListTemp1[ rIdx ] = refPicSetStCurrAfter[ i ]; 
4192      }
4193      for( Int i = 0;  i < numPocStCurrBefore  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )  // (8-10)
4194      {
4195        refPicListTemp1[ rIdx ] = refPicSetStCurrBefore[ i ];
4196      }         
4197      for( Int i = 0; i < numPocLtCurr  &&  rIdx < numRpsCurrTempList1; rIdx++, i++ )
4198      {
4199        refPicListTemp1[ rIdx ] = refPicSetLtCurr[ i ];
4200      }
4201    }
4202  }
4203
4204  if (getSliceType() == B_SLICE )
4205  {
4206    //   When the slice is a B slice, the list RefPicList1 is constructed as follows:
4207    for( rIdx = 0; rIdx  <=  getNumRefIdxL1ActiveMinus1(); rIdx++ )      // (F 68)
4208    {
4209      m_apcRefPicList[ 1 ][ rIdx ] = rplm->getRefPicListModificationFlagL1() ? refPicListTemp1[ rplm->getListEntryL1( rIdx ) ] : refPicListTemp1[ rIdx ]; 
4210
4211      // The decoding process below slice level requires the marking status
4212      // of the reference pictures, when decoding the RPS. So store it here.
4213      m_bIsUsedAsLongTerm[ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getIsLongTerm();
4214      m_aiRefPOCList     [ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getPOC();
4215      m_aiRefLayerIdList [ 1 ][ rIdx ] = m_apcRefPicList[ 1 ][ rIdx ]->getLayerId();
4216    }
4217  }
4218}
4219
4220Int TComSlice::getNumPicTotalCurr() const
4221{
4222  Int numPicTotalCurr = 0;
4223#if NH_MV_FIX_NUM_POC_TOTAL_CUR
4224  if ( !isIdr()  )
4225  {
4226    const TComStRefPicSet* stRps = getStRps( getCurrRpsIdx() ); 
4227#endif
4228    for( Int i = 0; i < stRps->getNumNegativePicsVar(); i++ )
4229    {
4230      if( stRps->getUsedByCurrPicS0Var( i ) )
4231      {
4232        numPicTotalCurr++;
4233      }
4234    }
4235    for( Int i = 0; i < stRps->getNumPositivePicsVar(); i++)  //(7 55)
4236    {
4237      if( stRps->getUsedByCurrPicS1Var(i) )
4238      {
4239        numPicTotalCurr++;
4240      }
4241    }
4242    for( Int i = 0; i < getNumLongTermSps() + getNumLongTermPics(); i++ )
4243    {
4244      if( getUsedByCurrPicLtVar( i ) )
4245      {
4246        numPicTotalCurr++;
4247      }
4248    }
4249#if NH_MV_FIX_NUM_POC_TOTAL_CUR
4250  }
4251#endif
4252
4253  if ( decProcAnnexF() )
4254  {
4255    numPicTotalCurr += getNumActiveRefLayerPics(); 
4256  }
4257  return numPicTotalCurr;
4258}
4259
4260
4261
4262Int TComSlice::getPocLsbLtVar( Int i )
4263{
4264  Int pocLsbLtVar; 
4265  if (i < getNumLongTermSps() )
4266  {
4267
4268    pocLsbLtVar = getSPS()->getLtRefPicPocLsbSps( getLtIdxSps( i ) ); 
4269  }
4270  else
4271  {
4272    pocLsbLtVar = getPocLsbLt( i ); 
4273  }
4274  return pocLsbLtVar;
4275}
4276
4277
4278Bool TComSlice::getUsedByCurrPicLtVar( Int i ) const
4279{
4280  Bool usedByCurrPicLtVar; 
4281  if (i < getNumLongTermSps() )
4282  {
4283    usedByCurrPicLtVar = getSPS()->getUsedByCurrPicLtSPSFlag( getLtIdxSps( i ) ); 
4284  }
4285  else
4286  {
4287    usedByCurrPicLtVar = getUsedByCurrPicLtFlag( i ); 
4288  }
4289  return usedByCurrPicLtVar;
4290}
4291
4292
4293Int TComSlice::getDeltaPocMsbCycleLtVar( Int i ) const
4294{
4295  Int deltaPocMsbCycleVar; 
4296  if (i == 0 || i == getNumLongTermSps() )
4297  {
4298    deltaPocMsbCycleVar = getDeltaPocMsbCycleLt( i ); 
4299  }
4300  else
4301  {
4302    deltaPocMsbCycleVar = getDeltaPocMsbCycleLt( i ) + getDeltaPocMsbCycleLtVar( i - 1 ); 
4303  }
4304  return deltaPocMsbCycleVar;
4305}
4306
4307#endif
4308
4309
4310#if NH_3D
4311Void TComSlice::init3dToolParameters()
4312{
4313  Bool depthFlag = getIsDepth();
4314
4315  Bool nRLLG0 =  ( getVPS()->getNumRefListLayers( getLayerId() ) > 0 );     
4316
4317  const TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
4318
4319  m_ivMvPredFlag           = sps3dExt->getIvDiMcEnabledFlag          ( depthFlag ) && nRLLG0                       ;                             
4320  m_ivMvScalingFlag        = sps3dExt->getIvMvScalEnabledFlag        ( depthFlag )                                 ;                             
4321  m_ivResPredFlag          = sps3dExt->getIvResPredEnabledFlag       ( depthFlag ) && nRLLG0                       ;                               
4322  m_depthRefinementFlag    = sps3dExt->getDepthRefEnabledFlag        ( depthFlag )           && getInCompPredFlag() && m_cpAvailableFlag;
4323  m_viewSynthesisPredFlag  = sps3dExt->getVspMcEnabledFlag           ( depthFlag ) && nRLLG0 && getInCompPredFlag() && m_cpAvailableFlag;
4324  m_depthBasedBlkPartFlag  = sps3dExt->getDbbpEnabledFlag            ( depthFlag )           && getInCompPredFlag();                         
4325  m_mpiFlag                = sps3dExt->getTexMcEnabledFlag           ( depthFlag )           && getInCompPredFlag();
4326  m_intraContourFlag       = sps3dExt->getIntraContourEnabledFlag    ( depthFlag )           && getInCompPredFlag();
4327  m_intraSdcWedgeFlag      = sps3dExt->getIntraDcOnlyWedgeEnabledFlag( depthFlag )                                 ;                         
4328  m_qtPredFlag             = sps3dExt->getCqtCuPartPredEnabledFlag   ( depthFlag )           && getInCompPredFlag();
4329  m_interSdcFlag           = sps3dExt->getInterDcOnlyEnabledFlag     ( depthFlag )                                 ; 
4330  m_depthIntraSkipFlag     = sps3dExt->getSkipIntraEnabledFlag       ( depthFlag )                                 ;                         
4331
4332  m_subPbSize              =  1 << ( sps3dExt->getLog2IvmcSubPbSizeMinus3 ( depthFlag ) + 3 ); 
4333  m_mpiSubPbSize           =  1 << ( sps3dExt->getLog2TexmcSubPbSizeMinus3( depthFlag ) + 3 );
4334
4335
4336#if NH_3D_OUTPUT_ACTIVE_TOOLS
4337  std::cout << "Layer:                  :" << getLayerId()             << std::endl;
4338  std::cout << "DepthFlag:              :" << getIsDepth()             << std::endl;
4339  std::cout << "ViewOrderIdx:           :" << getViewIndex()           << std::endl;
4340  std::cout << "InterCmpPredAvailableFlag:" << getInCmpPredAvailFlag() << std::endl;
4341  std::cout << "InterCompPredFlag       :"  << getInCompPredFlag()     << std::endl;
4342 
4343  std::cout << "ivMvPredFlag            :" << m_ivMvPredFlag           << std::endl;
4344  std::cout << "ivMvScalingFlag         :" << m_ivMvScalingFlag        << std::endl;
4345  std::cout << "ivResPredFlag           :" << m_ivResPredFlag          << std::endl;
4346  std::cout << "depthRefinementFlag     :" << m_depthRefinementFlag    << std::endl;
4347  std::cout << "viewSynthesisPredFlag   :" << m_viewSynthesisPredFlag  << std::endl;
4348  std::cout << "depthBasedBlkPartFlag   :" << m_depthBasedBlkPartFlag  << std::endl;
4349  std::cout << "mpiFlag                 :" << m_mpiFlag                << std::endl;
4350  std::cout << "intraContourFlag        :" << m_intraContourFlag       << std::endl;
4351  std::cout << "intraSdcWedgeFlag       :" << m_intraSdcWedgeFlag      << std::endl;
4352  std::cout << "qtPredFlag              :" << m_qtPredFlag             << std::endl;
4353  std::cout << "interSdcFlag            :" << m_interSdcFlag           << std::endl;
4354  std::cout << "depthIntraSkipFlag      :" << m_depthIntraSkipFlag     << std::endl;   
4355  std::cout << "subPbSize               :" << m_subPbSize              << std::endl;
4356  std::cout << "mpiSubPbSize            :" << m_mpiSubPbSize           << std::endl;
4357#endif
4358}
4359
4360Void TComSlice::deriveInCmpPredAndCpAvailFlag( )
4361{
4362  Int numCurCmpLIds = getIsDepth() ? 1 : getNumActiveRefLayerPics(); 
4363  std::vector<Int> curCmpLIds;
4364  if ( getIsDepth() )
4365  {
4366    curCmpLIds.push_back( getLayerId() );
4367  }
4368  else
4369  {
4370    for (Int i = 0; i < numCurCmpLIds; i++)
4371    {
4372      curCmpLIds.push_back( getRefPicLayerId( i ) );
4373    }
4374  }
4375
4376  m_cpAvailableFlag = true;
4377  m_inCmpRefViewIdcs.clear();
4378  Bool allRefCmpLayersAvailFlag = true;
4379
4380  for( Int i = 0; i <= numCurCmpLIds - 1; i++ )
4381  {     
4382    m_inCmpRefViewIdcs.push_back( getVPS()->getViewOrderIdx( curCmpLIds[ i ] ));
4383    if( !getVPS()->getCpPresentFlag( getVPS()->getVoiInVps( getViewIndex() ),  getVPS()->getVoiInVps( m_inCmpRefViewIdcs[ i ] ) ) )
4384    {
4385      m_cpAvailableFlag = false;
4386    }
4387    Bool refCmpCurLIdAvailFlag = false;
4388    if( getVPS()->getViewCompLayerPresentFlag( m_inCmpRefViewIdcs[ i ], !getIsDepth() ) )
4389    {
4390      Int j = getVPS()->getLayerIdInVps( getVPS()->getViewCompLayerId( m_inCmpRefViewIdcs[ i ],  !getIsDepth() ) );
4391      if  ( getVPS()->getDirectDependencyFlag( getVPS()->getLayerIdInVps( getLayerId() ) ,  j ) &&
4392        getVPS()->getSubLayersVpsMaxMinus1( j ) >= getTemporalId()   &&
4393        ( getTemporalId() == 0 || getVPS()->getMaxTidIlRefPicsPlus1( j , getVPS()->getLayerIdInVps( getLayerId() ) ) > getTemporalId() )       
4394        )
4395      {
4396        refCmpCurLIdAvailFlag = true;
4397      }
4398    }
4399    if( !refCmpCurLIdAvailFlag )
4400    {
4401      allRefCmpLayersAvailFlag = false;
4402    }
4403  }
4404
4405  if( !allRefCmpLayersAvailFlag )
4406  {
4407    m_inCmpPredAvailFlag = false;
4408  } 
4409  else 
4410  {
4411    const TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
4412    if( !getIsDepth() )
4413    {
4414      m_inCmpPredAvailFlag = sps3dExt->getVspMcEnabledFlag( getIsDepth() ) || 
4415        sps3dExt->getDbbpEnabledFlag( getIsDepth() ) || 
4416        sps3dExt->getDepthRefEnabledFlag  ( getIsDepth() );                           
4417    }
4418    else
4419    {
4420      m_inCmpPredAvailFlag = sps3dExt->getIntraContourEnabledFlag( getIsDepth() ) || 
4421        sps3dExt->getCqtCuPartPredEnabledFlag( getIsDepth() ) || 
4422        sps3dExt->getTexMcEnabledFlag( getIsDepth() );                                 
4423    }
4424  }
4425}
4426
4427Void TComSlice::checkInCompPredRefLayers()
4428{ 
4429  if ( getInCompPredFlag() )
4430  {
4431    for (Int i = 0; i < getNumCurCmpLIds(); i++ )
4432    {     
4433      assert( getIvPic(!getIsDepth(), getInCmpRefViewIdcs( i ) ) != NULL );       
4434      //  It is a requirement of bitstream conformance that there
4435      //  is a picture in the DPB with PicOrderCntVal equal to the PicOrderCntVal of the current picture,
4436      //  and a nuh_layer_id value equal to ViewCompLayerId[ inCmpRefViewIdcs[ i ] ][ !DepthFlag ].
4437    }
4438  } 
4439}
4440
4441Void TComSlice::setPocsInCurrRPSs()
4442{
4443  // Currently only needed at decoder side;
4444  m_pocsInCurrRPSs.clear();   
4445  std::vector<TComPic*>** rpsCurr = getPic()->getDecodedRps()->m_refPicSetsCurr;
4446  for (Int i = 0 ; i < 3; i++ )
4447  {
4448    for( Int j = 0; j < rpsCurr[i]->size(); j++ )
4449    {
4450      m_pocsInCurrRPSs.push_back( (*rpsCurr[i])[j]->getPOC() ); 
4451    }
4452  }
4453}
4454
4455#endif
4456
4457/** get scaling matrix from RefMatrixID
4458 * \param sizeId    size index
4459 * \param listId    index of input matrix
4460 * \param refListId index of reference matrix
4461 */
4462Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
4463{
4464  ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
4465}
4466
4467Void TComScalingList::checkPredMode(UInt sizeId, UInt listId)
4468{
4469  Int predListStep = (sizeId == SCALING_LIST_32x32? (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) : 1); // if 32x32, skip over chroma entries.
4470
4471  for(Int predListIdx = (Int)listId ; predListIdx >= 0; predListIdx-=predListStep)
4472  {
4473    if( !memcmp(getScalingListAddress(sizeId,listId),((listId == predListIdx) ?
4474      getScalingListDefaultAddress(sizeId, predListIdx): getScalingListAddress(sizeId, predListIdx)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
4475     && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
4476    {
4477      setRefMatrixId(sizeId, listId, predListIdx);
4478      setScalingListPredModeFlag(sizeId, listId, false);
4479      return;
4480    }
4481  }
4482  setScalingListPredModeFlag(sizeId, listId, true);
4483}
4484
4485static Void outputScalingListHelp(std::ostream &os)
4486{
4487  os << "The scaling list file specifies all matrices and their DC values; none can be missing,\n"
4488         "but their order is arbitrary.\n\n"
4489         "The matrices are specified by:\n"
4490         "<matrix name><unchecked data>\n"
4491         "  <value>,<value>,<value>,....\n\n"
4492         "  Line-feeds can be added arbitrarily between values, and the number of values needs to be\n"
4493         "  at least the number of entries for the matrix (superfluous entries are ignored).\n"
4494         "  The <unchecked data> is text on the same line as the matrix that is not checked\n"
4495         "  except to ensure that the matrix name token is unique. It is recommended that it is ' ='\n"
4496         "  The values in the matrices are the absolute values (0-255), not the delta values as\n"
4497         "  exchanged between the encoder and decoder\n\n"
4498         "The DC values (for matrix sizes larger than 8x8) are specified by:\n"
4499         "<matrix name>_DC<unchecked data>\n"
4500         "  <value>\n";
4501
4502  os << "The permitted matrix names are:\n";
4503  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
4504  {
4505    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
4506    {
4507      if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
4508      {
4509        os << "  " << MatrixType[sizeIdc][listIdc] << '\n';
4510      }
4511    }
4512  }
4513}
4514
4515Void TComScalingList::outputScalingLists(std::ostream &os) const
4516{
4517  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
4518  {
4519    const UInt size = min(8,4<<(sizeIdc));
4520    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
4521    {
4522      if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
4523      {
4524        const Int *src = getScalingListAddress(sizeIdc, listIdc);
4525        os << (MatrixType[sizeIdc][listIdc]) << " =\n  ";
4526        for(UInt y=0; y<size; y++)
4527        {
4528          for(UInt x=0; x<size; x++, src++)
4529          {
4530            os << std::setw(3) << (*src) << ", ";
4531          }
4532          os << (y+1<size?"\n  ":"\n");
4533        }
4534        if(sizeIdc > SCALING_LIST_8x8)
4535        {
4536          os << MatrixType_DC[sizeIdc][listIdc] << " = \n  " << std::setw(3) << getScalingListDC(sizeIdc, listIdc) << "\n";
4537        }
4538        os << "\n";
4539      }
4540    }
4541  }
4542}
4543
4544Bool TComScalingList::xParseScalingList(const std::string &fileName)
4545{
4546  static const Int LINE_SIZE=1024;
4547  FILE *fp = NULL;
4548  TChar line[LINE_SIZE];
4549
4550  if (fileName.empty())
4551  {
4552    fprintf(stderr, "Error: no scaling list file specified. Help on scaling lists being output\n");
4553    outputScalingListHelp(std::cout);
4554    std::cout << "\n\nExample scaling list file using default values:\n\n";
4555    outputScalingLists(std::cout);
4556    exit (1);
4557    return true;
4558  }
4559  else if ((fp = fopen(fileName.c_str(),"r")) == (FILE*)NULL)
4560  {
4561    fprintf(stderr, "Error: cannot open scaling list file %s for reading\n", fileName.c_str());
4562    return true;
4563  }
4564
4565  for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
4566  {
4567    const UInt size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
4568
4569    for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
4570    {
4571      Int * const src = getScalingListAddress(sizeIdc, listIdc);
4572
4573      if ((sizeIdc==SCALING_LIST_32x32) && (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) != 0)) // derive chroma32x32 from chroma16x16
4574      {
4575        const Int *srcNextSmallerSize = getScalingListAddress(sizeIdc-1, listIdc);
4576        for(UInt i=0; i<size; i++)
4577        {
4578          src[i] = srcNextSmallerSize[i];
4579        }
4580        setScalingListDC(sizeIdc,listIdc,(sizeIdc > SCALING_LIST_8x8) ? getScalingListDC(sizeIdc-1, listIdc) : src[0]);
4581      }
4582      else
4583      {
4584        {
4585          fseek(fp, 0, SEEK_SET);
4586          Bool bFound=false;
4587          while ((!feof(fp)) && (!bFound))
4588          {
4589            TChar *ret = fgets(line, LINE_SIZE, fp);
4590            TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
4591            // This could be a match against the DC string as well, so verify it isn't
4592            if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL || strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
4593            {
4594              bFound=true;
4595            }
4596          }
4597          if (!bFound)
4598          {
4599            fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], fileName.c_str());
4600            return true;
4601          }
4602        }
4603        for (UInt i=0; i<size; i++)
4604        {
4605          Int data;
4606          if (fscanf(fp, "%d,", &data)!=1)
4607          {
4608            fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
4609            return true;
4610          }
4611          if (data<0 || data>255)
4612          {
4613            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], fileName.c_str(), ftell(fp));
4614            return true;
4615          }
4616          src[i] = data;
4617        }
4618
4619        //set DC value for default matrix check
4620        setScalingListDC(sizeIdc,listIdc,src[0]);
4621
4622        if(sizeIdc > SCALING_LIST_8x8)
4623        {
4624          {
4625            fseek(fp, 0, SEEK_SET);
4626            Bool bFound=false;
4627            while ((!feof(fp)) && (!bFound))
4628            {
4629              TChar *ret = fgets(line, LINE_SIZE, fp);
4630              TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
4631              if (findNamePosition!= NULL)
4632              {
4633                // This won't be a match against the non-DC string.
4634                bFound=true;
4635              }
4636            }
4637            if (!bFound)
4638            {
4639              fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], fileName.c_str());
4640              return true;
4641            }
4642          }
4643          Int data;
4644          if (fscanf(fp, "%d,", &data)!=1)
4645          {
4646            fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
4647            return true;
4648          }
4649          if (data<0 || data>255)
4650          {
4651            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], fileName.c_str(), ftell(fp));
4652            return true;
4653          }
4654          //overwrite DC value when size of matrix is larger than 16x16
4655          setScalingListDC(sizeIdc,listIdc,data);
4656        }
4657      }
4658    }
4659  }
4660//  std::cout << "\n\nRead scaling lists of:\n\n";
4661//  outputScalingLists(std::cout);
4662
4663  fclose(fp);
4664  return false;
4665}
4666
4667#if NH_MV
4668Void TComScalingList::inferFrom( const TComScalingList& srcScLi )
4669{
4670  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
4671  {
4672    for(Int listId = 0; listId <  SCALING_LIST_NUM; listId++)
4673    {
4674      setRefMatrixId  (sizeId,listId, srcScLi.getRefMatrixId  (sizeId,listId));
4675      setScalingListDC(sizeId,listId, srcScLi.getScalingListDC(sizeId,listId));         
4676      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi.getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
4677    }
4678  }
4679}
4680#endif
4681
4682
4683/** get default address of quantization matrix
4684 * \param sizeId size index
4685 * \param listId list index
4686 * \returns pointer of quantization matrix
4687 */
4688const Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
4689{
4690  const Int *src = 0;
4691  switch(sizeId)
4692  {
4693    case SCALING_LIST_4x4:
4694      src = g_quantTSDefault4x4;
4695      break;
4696    case SCALING_LIST_8x8:
4697    case SCALING_LIST_16x16:
4698    case SCALING_LIST_32x32:
4699      src = (listId < (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) ) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
4700      break;
4701    default:
4702      assert(0);
4703      src = NULL;
4704      break;
4705  }
4706  return src;
4707}
4708
4709/** process of default matrix
4710 * \param sizeId size index
4711 * \param listId index of input matrix
4712 */
4713Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
4714{
4715  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
4716  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
4717}
4718
4719/** check DC value of matrix for default matrix signaling
4720 */
4721Void TComScalingList::checkDcOfMatrix()
4722{
4723  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
4724  {
4725    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
4726    {
4727      //check default matrix?
4728      if(getScalingListDC(sizeId,listId) == 0)
4729      {
4730        processDefaultMatrix(sizeId, listId);
4731      }
4732    }
4733  }
4734}
4735
4736ParameterSetManager::ParameterSetManager()
4737: m_vpsMap(MAX_NUM_VPS)
4738, m_spsMap(MAX_NUM_SPS)
4739, m_ppsMap(MAX_NUM_PPS)
4740, m_activeVPSId(-1)
4741#if !NH_MV
4742, m_activeSPSId(-1)
4743#endif
4744{
4745#if NH_MV 
4746  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
4747  {   
4748    m_activeSPSId[i] = -1; 
4749  }
4750#endif
4751}
4752
4753
4754ParameterSetManager::~ParameterSetManager()
4755{
4756}
4757
4758//! activate a SPS from a active parameter sets SEI message
4759//! \returns true, if activation is successful
4760#if NH_MV
4761//Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
4762#else
4763//Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
4764#endif
4765//{
4766//TComSPS *sps = m_spsMap.getPS(spsId);
4767//  if (sps)
4768//  {
4769//    Int vpsId = sps->getVPSId();
4770//    TComVPS *vps = m_vpsMap.getPS(vpsId);
4771//    if (vps)
4772//    {
4773#if NH_MV
4774//      m_activeVPS = *(vps);
4775//      m_activeSPS[ layerId ] = *(sps);
4776#else
4777//      m_activeVPS = *(vps);
4778//      m_activeSPS = *(sps);
4779#endif
4780//      return true;
4781//    }
4782//    else
4783//    {
4784//      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
4785//    }
4786//  }
4787//  else
4788//  {
4789//    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
4790//  }
4791//  return false;
4792//}
4793
4794//! activate a PPS and depending on isIDR parameter also SPS and VPS
4795//! \returns true, if activation is successful
4796#if NH_MV
4797Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
4798#else
4799Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
4800#endif
4801{
4802  TComPPS *pps = m_ppsMap.getPS(ppsId);
4803  if (pps)
4804  {
4805    Int spsId = pps->getSPSId();
4806#if NH_MV
4807    if (!isIRAP && (spsId != m_activeSPSId[ layerId ] ))
4808#else
4809    if (!isIRAP && (spsId != m_activeSPSId ))
4810#endif
4811    {
4812      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
4813    }
4814    else
4815    {
4816      TComSPS *sps = m_spsMap.getPS(spsId);
4817      if (sps)
4818      {
4819        Int vpsId = sps->getVPSId();
4820        if (!isIRAP && (vpsId != m_activeVPSId ))
4821        {
4822          printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
4823        }
4824        else
4825        {
4826          TComVPS *vps =m_vpsMap.getPS(vpsId);
4827          if (vps)
4828          {
4829            m_activeVPSId = vpsId;
4830#if NH_MV
4831            m_activeSPSId[layerId] = spsId;
4832#else
4833            m_activeSPSId = spsId;
4834#endif
4835            return true;
4836          }
4837          else
4838          {
4839            printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
4840          }
4841        }
4842      }
4843      else
4844      {
4845       printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
4846      }
4847    }
4848  }
4849  else
4850  {
4851    printf("Warning: tried to activate non-existing PPS.");
4852  }
4853
4854  // Failed to activate if reach here.
4855#if NH_MV
4856  m_activeSPSId[layerId]=-1;
4857#else
4858  m_activeSPSId=-1;
4859#endif
4860  m_activeVPSId=-1;
4861
4862  return false;
4863}
4864
4865ProfileTierLevel::ProfileTierLevel()
4866  : m_profileSpace    (0)
4867  , m_tierFlag        (Level::MAIN)
4868  , m_profileIdc      (Profile::NONE)
4869  , m_levelIdc        (Level::NONE)
4870  , m_progressiveSourceFlag  (false)
4871  , m_interlacedSourceFlag   (false)
4872  , m_nonPackedConstraintFlag(false)
4873  , m_frameOnlyConstraintFlag(false)
4874#if NH_MV
4875  , m_intraConstraintFlag         ( false )
4876  , m_onePictureOnlyConstraintFlag( false )
4877  , m_lowerBitRateConstraintFlag  ( false )
4878  , m_max12bitConstraintFlag      ( false )
4879  , m_max10bitConstraintFlag      ( false )
4880  , m_max8bitConstraintFlag       ( false )
4881  , m_max422chromaConstraintFlag  ( false )
4882  , m_max420chromaConstraintFlag  ( false )
4883  , m_maxMonochromeConstraintFlag ( false ) 
4884  , m_inbldFlag                   ( false )
4885#endif
4886{
4887  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
4888}
4889
4890#if NH_MV
4891Bool ProfileTierLevel::getV2ConstraintsPresentFlag() const
4892{
4893  return ( 
4894    getProfileIdc( ) ==  4 || getProfileCompatibilityFlag( 4 ) || getProfileIdc( ) ==  5 || getProfileCompatibilityFlag( 5 )  ||
4895    getProfileIdc( ) ==  6 || getProfileCompatibilityFlag( 6 ) || getProfileIdc( ) ==  7 || getProfileCompatibilityFlag( 7 ) 
4896    );
4897}
4898
4899Bool ProfileTierLevel::getInbldPresentFlag() const
4900{
4901  return ( 
4902    ( getProfileIdc() >= 1 && getProfileIdc() <= 5 )  || getProfileCompatibilityFlag( 1 ) || getProfileCompatibilityFlag( 2 ) || 
4903    getProfileCompatibilityFlag( 3 ) || getProfileCompatibilityFlag( 4 )  ||   getProfileCompatibilityFlag( 5 ) 
4904    );
4905}
4906
4907Void ProfileTierLevel::copyV2ConstraintFlags(ProfileTierLevel* ptlRef)
4908{
4909  setMax12bitConstraintFlag         ( ptlRef->getMax12bitConstraintFlag       ( ) );
4910  setMax10bitConstraintFlag         ( ptlRef->getMax10bitConstraintFlag       ( ) );
4911  setMax8bitConstraintFlag          ( ptlRef->getMax8bitConstraintFlag        ( ) );
4912  setMax422chromaConstraintFlag     ( ptlRef->getMax422chromaConstraintFlag   ( ) );
4913  setMax420chromaConstraintFlag     ( ptlRef->getMax420chromaConstraintFlag   ( ) );
4914  setMaxMonochromeConstraintFlag    ( ptlRef->getMaxMonochromeConstraintFlag  ( ) );
4915  setIntraConstraintFlag            ( ptlRef->getIntraConstraintFlag          ( ) );
4916  setOnePictureOnlyConstraintFlag   ( ptlRef->getOnePictureOnlyConstraintFlag ( ) );
4917  setLowerBitRateConstraintFlag     ( ptlRef->getLowerBitRateConstraintFlag   ( ) );
4918}
4919
4920Void ProfileTierLevel::copyProfile(ProfileTierLevel* ptlRef)
4921{
4922  setProfileSpace            ( ptlRef->getProfileSpace              ( ) );
4923  setTierFlag                ( ptlRef->getTierFlag                  ( ) );
4924  setProfileIdc              ( ptlRef->getProfileIdc                ( ) );
4925  for (Int j = 0; j < 32; j++)
4926  {     
4927    setProfileCompatibilityFlag(j, ptlRef->getProfileCompatibilityFlag  ( j ) );           
4928  }
4929  setProgressiveSourceFlag   ( ptlRef->getProgressiveSourceFlag     ( ) );
4930  setInterlacedSourceFlag    ( ptlRef->getInterlacedSourceFlag      ( ) );
4931  setNonPackedConstraintFlag ( ptlRef->getNonPackedConstraintFlag   ( ) );
4932  setFrameOnlyConstraintFlag ( ptlRef->getFrameOnlyConstraintFlag   ( ) );
4933  copyV2ConstraintFlags      ( ptlRef );
4934}
4935#endif
4936
4937TComPTL::TComPTL()
4938{
4939  ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
4940  ::memset(m_subLayerLevelPresentFlag,   0, sizeof(m_subLayerLevelPresentFlag  ));
4941}
4942
4943Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> &newData)
4944{
4945  if (!bChanged)
4946  {
4947    if ((pOldData==0 && pOldData!=0) || (pOldData!=0 && pOldData==0))
4948    {
4949      bChanged=true;
4950    }
4951    else if (pOldData!=0 && pOldData!=0)
4952    {
4953      // compare the two
4954      if (pOldData->size() != pOldData->size())
4955      {
4956        bChanged=true;
4957      }
4958      else
4959      {
4960        const UChar *pNewDataArray=&(newData)[0];
4961        const UChar *pOldDataArray=&(*pOldData)[0];
4962        if (memcmp(pOldDataArray, pNewDataArray, pOldData->size()))
4963        {
4964          bChanged=true;
4965        }
4966      }
4967    }
4968  }
4969}
4970#if NH_MV
4971Void TComPTL::inferGeneralValues(Bool profilePresentFlag, Int k, TComPTL* refPTL)
4972{
4973  ProfileTierLevel* refProfileTierLevel = NULL; 
4974  if ( k > 0 )
4975  {   
4976    assert( refPTL != NULL);
4977    refProfileTierLevel = refPTL->getGeneralPTL(); 
4978  }
4979
4980  ProfileTierLevel* curProfileTierLevel = getGeneralPTL( ); 
4981  assert( curProfileTierLevel != NULL ); 
4982
4983  if( !profilePresentFlag )
4984  {
4985    assert( k > 0 ); 
4986    assert( refProfileTierLevel != NULL ); 
4987    curProfileTierLevel->copyProfile( refProfileTierLevel);
4988  }
4989  else
4990  {
4991    if ( !curProfileTierLevel->getV2ConstraintsPresentFlag() )
4992    {
4993      curProfileTierLevel->setMax12bitConstraintFlag         ( false );
4994      curProfileTierLevel->setMax10bitConstraintFlag         ( false );
4995      curProfileTierLevel->setMax8bitConstraintFlag          ( false );
4996      curProfileTierLevel->setMax422chromaConstraintFlag     ( false );
4997      curProfileTierLevel->setMax420chromaConstraintFlag     ( false );
4998      curProfileTierLevel->setMaxMonochromeConstraintFlag    ( false );
4999      curProfileTierLevel->setIntraConstraintFlag            ( false );
5000      curProfileTierLevel->setOnePictureOnlyConstraintFlag   ( false );
5001      curProfileTierLevel->setLowerBitRateConstraintFlag     ( false );   
5002    }
5003
5004    if ( !curProfileTierLevel->getInbldPresentFlag() )
5005    {
5006      curProfileTierLevel->setInbldFlag( false ); 
5007    }     
5008  }
5009}
5010
5011Void TComPTL::inferSubLayerValues(Int maxNumSubLayersMinus1, Int k, TComPTL* refPTL)
5012{
5013  assert( k == 0 || refPTL != NULL );   
5014  for (Int i = maxNumSubLayersMinus1; i >= 0; i--)
5015  {
5016    ProfileTierLevel* refProfileTierLevel;
5017    if ( k != 0 )
5018    {
5019      refProfileTierLevel = refPTL->getSubLayerPTL( i );
5020    }
5021    else
5022    {
5023      if ( i == maxNumSubLayersMinus1)     
5024      {
5025        refProfileTierLevel = getGeneralPTL();
5026      }
5027      else
5028      {
5029        refProfileTierLevel = getSubLayerPTL( i + 1 );
5030      }
5031    }   
5032
5033    assert( refProfileTierLevel != NULL ); 
5034    ProfileTierLevel* curProfileTierLevel = getSubLayerPTL( i ); 
5035    assert( curProfileTierLevel != NULL ); 
5036    if( !getSubLayerLevelPresentFlag( i ) )
5037    {
5038      curProfileTierLevel->setLevelIdc( refProfileTierLevel->getLevelIdc() ); 
5039    }
5040
5041    if( !getSubLayerProfilePresentFlag( i ) )
5042    {
5043      curProfileTierLevel->copyProfile( refProfileTierLevel);
5044    }
5045    else
5046    {
5047      if ( !curProfileTierLevel->getV2ConstraintsPresentFlag() )
5048      {
5049        curProfileTierLevel->copyV2ConstraintFlags( refProfileTierLevel ); 
5050      }
5051
5052      if ( !curProfileTierLevel->getInbldPresentFlag() )
5053      {
5054        curProfileTierLevel->setInbldFlag( refProfileTierLevel->getInbldFlag() ); 
5055      }     
5056    }     
5057  }
5058}
5059
5060#endif
5061
5062//! \}
5063
5064#if NH_MV
5065Void TComVPSVUI::init( Int numLayerSets, Int maxNumSubLayers, Int maxNumLayers )
5066{
5067  m_crossLayerIrapAlignedFlag = true; 
5068  m_allLayersIdrAlignedFlag   = false; 
5069  m_bitRatePresentVpsFlag     = false;
5070  m_picRatePresentVpsFlag     = false;
5071
5072  m_bitRatePresentFlag          .resize(numLayerSets); 
5073  m_picRatePresentFlag          .resize(numLayerSets); 
5074  m_avgBitRate                  .resize(numLayerSets); 
5075  m_maxBitRate                  .resize(numLayerSets); 
5076  m_constantPicRateIdc          .resize(numLayerSets); 
5077  m_avgPicRate                  .resize(numLayerSets); 
5078
5079  for ( Int i = 0; i < numLayerSets; i++)
5080  { 
5081    m_bitRatePresentFlag          [i].resize( maxNumSubLayers); 
5082    m_picRatePresentFlag          [i].resize( maxNumSubLayers); 
5083    m_avgBitRate                  [i].resize( maxNumSubLayers); 
5084    m_maxBitRate                  [i].resize( maxNumSubLayers); 
5085    m_constantPicRateIdc          [i].resize( maxNumSubLayers); 
5086    m_avgPicRate                  [i].resize( maxNumSubLayers); 
5087    for ( Int j = 0; j < maxNumSubLayers; j++)
5088    {   
5089      m_bitRatePresentFlag          [i][j] = false;
5090      m_picRatePresentFlag          [i][j] = false;
5091      m_avgBitRate                  [i][j] = -1;
5092      m_maxBitRate                  [i][j] = -1;
5093      m_constantPicRateIdc          [i][j] = -1;
5094      m_avgPicRate                  [i][j] = -1;
5095    }
5096  }
5097
5098  m_ilpRestrictedRefLayersFlag = false;
5099
5100  m_tileBoundariesAlignedFlag             .resize( maxNumLayers );
5101  m_minSpatialSegmentOffsetPlus1          .resize( maxNumLayers );
5102  m_ctuBasedOffsetEnabledFlag             .resize( maxNumLayers );
5103  m_minHorizontalCtuOffsetPlus1           .resize( maxNumLayers );
5104  m_baseLayerParameterSetCompatibilityFlag.resize( maxNumLayers );
5105
5106  for ( Int i = 0; i < maxNumLayers; i++)
5107  {         
5108    m_tileBoundariesAlignedFlag   [i].resize( maxNumLayers );
5109    m_minSpatialSegmentOffsetPlus1[i].resize( maxNumLayers );
5110    m_ctuBasedOffsetEnabledFlag   [i].resize( maxNumLayers );
5111    m_minHorizontalCtuOffsetPlus1 [i].resize( maxNumLayers );
5112    for ( Int j = 0; j < maxNumLayers; j++)
5113    {   
5114      m_tileBoundariesAlignedFlag   [i][j] = false;
5115      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
5116      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
5117      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
5118    }
5119    m_baseLayerParameterSetCompatibilityFlag[i] = false;
5120  }
5121  m_vpsVuiBspHrdPresentFlag = false; 
5122}
5123
5124Void TComRepFormat::inferChromaAndBitDepth( const TComRepFormat* prevRepFormat )
5125{
5126    setChromaAndBitDepthVpsPresentFlag( prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
5127    setSeparateColourPlaneVpsFlag     ( prevRepFormat->getSeparateColourPlaneVpsFlag     () );
5128    setBitDepthVpsLumaMinus8          ( prevRepFormat->getBitDepthVpsLumaMinus8          () );
5129    setBitDepthVpsChromaMinus8        ( prevRepFormat->getBitDepthVpsChromaMinus8        () );
5130}
5131
5132Void TComRepFormat::checkInferChromaAndBitDepth( const TComRepFormat* prevRepFormat ) const 
5133{
5134    assert( getChromaAndBitDepthVpsPresentFlag() == prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
5135    assert( getSeparateColourPlaneVpsFlag     () == prevRepFormat->getSeparateColourPlaneVpsFlag     () );
5136    assert( getBitDepthVpsLumaMinus8          () == prevRepFormat->getBitDepthVpsLumaMinus8          () );
5137    assert( getBitDepthVpsChromaMinus8        () == prevRepFormat->getBitDepthVpsChromaMinus8        () );
5138}
5139
5140Int TComVpsVuiBspHrdParameters::getBspHrdIdxLen( const TComVPS* vps) const
5141{
5142  return gCeilLog2( vps->getNumHrdParameters() + getVpsNumAddHrdParams() );
5143}
5144
5145Void TComVpsVuiBspHrdParameters::createAfterVpsNumAddHrdParams( const TComVPS* vps )
5146{
5147  m_offsetHrdParamIdx = vps->getNumHrdParameters(); 
5148  m_numHrdParam       = vps->getNumHrdParameters() + getVpsNumAddHrdParams() - m_offsetHrdParamIdx;
5149  m_numOls            = vps->getNumOutputLayerSets(); 
5150
5151  m_cprmsAddPresentFlag .resize( m_numHrdParam );
5152  m_numSubLayerHrdMinus1.resize( m_numHrdParam );
5153  m_hrdParameters       .resize( m_numHrdParam );
5154
5155  m_numSignalledPartitioningSchemes .resize( m_numOls ); 
5156  m_numPartitionsInSchemeMinus1     .resize( m_numOls );
5157  m_numBspSchedulesMinus1           .resize( m_numOls ); 
5158  m_bspHrdIdx                       .resize( m_numOls );
5159  m_bspSchedIdx                     .resize( m_numOls );
5160}
5161
5162Void TComVpsVuiBspHrdParameters::createAfterNumSignalledPartitioningSchemes( const TComVPS* vps, Int h )
5163{
5164  m_numPartitionsInSchemeMinus1 [h].resize( getNumSignalledPartitioningSchemes(h) );
5165  m_layerIncludedInPartitionFlag[h].resize( getNumSignalledPartitioningSchemes(h) );   
5166
5167  m_numBspSchedulesMinus1       [h].resize( getNumSignalledPartitioningSchemes(h) + 1 );
5168  for (Int i = 0; i < getNumSignalledPartitioningSchemes(h) + 1; i++)
5169  {
5170    Int tMax = vps->getMaxSubLayersInLayerSetMinus1( m_vps->olsIdxToLsIdx(h) ) + 1;
5171    m_numBspSchedulesMinus1[h][i].resize( tMax );
5172    m_bspHrdIdx            [h][i].resize( tMax );
5173    m_bspSchedIdx          [h][i].resize( tMax );
5174  }
5175}
5176
5177Void TComVpsVuiBspHrdParameters::createAfterNumPartitionsInSchemeMinus1( const TComVPS* vps, Int h, Int j )
5178{
5179  m_layerIncludedInPartitionFlag[h][j].resize( getNumPartitionsInSchemeMinus1(h,j));
5180  for( Int k = 0; k < getNumPartitionsInSchemeMinus1(h,j); k++ )
5181  {
5182    m_layerIncludedInPartitionFlag[h][j][k].resize( m_vps->getNumLayersInIdList( vps->olsIdxToLsIdx(h)));
5183  }
5184}
5185
5186Void TComVpsVuiBspHrdParameters::createAfterNumBspSchedulesMinus1( const TComVPS* vps, Int h, Int i, Int t )
5187{
5188  m_bspSchedIdx[h][i][t].resize( getNumBspSchedulesMinus1( h, i, t ) + 1 );
5189  m_bspHrdIdx  [h][i][t].resize( getNumBspSchedulesMinus1( h, i, t ) + 1 );
5190  for( Int j = 0; j < getNumBspSchedulesMinus1( h, i, t ) + 1; j++ )
5191  {
5192    m_bspSchedIdx[h][i][t][j].resize( getNumPartitionsInSchemeMinus1( h, i ) );
5193    m_bspHrdIdx  [h][i][t][j].resize( getNumPartitionsInSchemeMinus1( h, i ) );
5194  }
5195}
5196
5197
5198Void TComVUI::inferVideoSignalInfo( const TComVPS* vps, Int layerIdCurr )
5199{
5200  if ( layerIdCurr == 0 || !vps->getVpsVuiPresentFlag() ) 
5201  {
5202    return; 
5203  }
5204
5205  const TComVPSVUI* vpsVui = vps->getVPSVUI(); 
5206  assert( vpsVui != NULL ); 
5207
5208  const TComVideoSignalInfo* videoSignalInfo = vpsVui->getVideoSignalInfo( vpsVui->getVpsVideoSignalInfoIdx( vps->getLayerIdInVps( layerIdCurr ) ) ); 
5209  assert( videoSignalInfo != NULL );
5210
5211  setVideoFormat            ( videoSignalInfo->getVideoVpsFormat            () ); 
5212  setVideoFullRangeFlag     ( videoSignalInfo->getVideoFullRangeVpsFlag     () );
5213  setColourPrimaries        ( videoSignalInfo->getColourPrimariesVps        () );
5214  setTransferCharacteristics( videoSignalInfo->getTransferCharacteristicsVps() );
5215  setMatrixCoefficients     ( videoSignalInfo->getMatrixCoeffsVps           () );
5216}
5217
5218Void TComDpbSize::init( Int numOutputLayerSets, Int maxNumLayerIds, Int maxNumSubLayers ) 
5219{
5220  m_subLayerFlagInfoPresentFlag.resize( numOutputLayerSets );
5221  m_subLayerDpbInfoPresentFlag .resize( numOutputLayerSets );
5222  m_maxVpsDecPicBufferingMinus1.resize( numOutputLayerSets ); 
5223  m_maxVpsNumReorderPics       .resize( numOutputLayerSets );
5224  m_maxVpsLatencyIncreasePlus1 .resize( numOutputLayerSets );
5225
5226  for (Int i = 0; i < numOutputLayerSets; i++ )
5227  {     
5228    m_subLayerFlagInfoPresentFlag[i]  = false;
5229
5230    m_subLayerDpbInfoPresentFlag [i].resize( maxNumSubLayers );
5231    m_maxVpsDecPicBufferingMinus1[i].resize( maxNumLayerIds ); 
5232    m_maxVpsNumReorderPics       [i].resize( maxNumSubLayers );
5233    m_maxVpsLatencyIncreasePlus1 [i].resize( maxNumSubLayers );   
5234
5235    for (Int j = 0; j < maxNumSubLayers; j++  )
5236    {       
5237      m_subLayerDpbInfoPresentFlag [i][j] = ( j == 0) ;
5238      m_maxVpsNumReorderPics       [i][j] = 0;
5239      m_maxVpsLatencyIncreasePlus1 [i][j] = 0;
5240    }
5241
5242    for (Int k = 0; k < maxNumLayerIds; k++ )
5243    {
5244      m_maxVpsDecPicBufferingMinus1[i][k].resize( maxNumSubLayers );
5245      for (Int j = 0; j < maxNumSubLayers; j++  )
5246      {       
5247        m_maxVpsDecPicBufferingMinus1[i][k][j] = MIN_INT; 
5248      }
5249    }
5250  }
5251}
5252
5253
5254Int TComDpbSize::getVpsMaxLatencyPictures( Int i, Int j ) const
5255{
5256  return getMaxVpsNumReorderPics( i, j ) + getMaxVpsLatencyIncreasePlus1(i, j) - 1; 
5257}
5258
5259Void Window::scaleOffsets( Int scal )
5260{
5261  if (! m_scaledFlag )
5262  {
5263    m_scaledFlag         = true; 
5264    m_winLeftOffset     *= scal; 
5265    m_winRightOffset    *= scal; 
5266    m_winTopOffset      *= scal; 
5267    m_winBottomOffset   *= scal; 
5268  }
5269}
5270
5271Void TComStRefPicSet::inferRps( Int stRpsIdx, TComSPS* sps, Bool encoder )
5272{
5273  if ( getInterRefPicSetPredictionFlag() )
5274  {
5275    // When inter_ref_pic_set_prediction_flag is equal to 1, the variables DeltaPocS0[ stRpsIdx ][ i ], UsedByCurrPicS0[ stRpsIdx ][ i ],
5276    // NumNegativePics[ stRpsIdx ], DeltaPocS1[ stRpsIdx ][ i ], UsedByCurrPicS1[ stRpsIdx ][ i ] and NumPositivePics[ stRpsIdx ] are
5277    // derived as follows:
5278
5279    Int i = 0;
5280    Int refRpsIdx = getRefRpsIdx( stRpsIdx );
5281    TComStRefPicSet* refRps = sps->getStRefPicSet( refRpsIdx ); 
5282
5283    for( Int j = refRps->getNumPositivePicsVar( ) - 1; j >= 0; j-- ) 
5284    {
5285      Int dPoc = refRps->getDeltaPocS1Var( j ) + getDeltaRps();
5286      if( dPoc < 0  &&  getUseDeltaFlag( refRps->getNumNegativePicsVar( ) + j ) ) 
5287      {
5288        setDeltaPocS0Var     ( i, dPoc );
5289        setUsedByCurrPicS0Var( i++ , getUsedByCurrPicFlag( refRps->getNumNegativePicsVar( ) + j ) );
5290      }
5291    }
5292    if( getDeltaRps() < 0  && getUseDeltaFlag( refRps->getNumDeltaPocs() ) )   //   (7 59)
5293    {
5294      setDeltaPocS0Var( i,  getDeltaRps() ); 
5295      setUsedByCurrPicS0Var( i++ , getUsedByCurrPicFlag( refRps->getNumDeltaPocs() ) );
5296    }
5297    for( Int j = 0; j < refRps->getNumNegativePicsVar(); j++ )
5298    {
5299      Int dPoc = refRps->getDeltaPocS0Var( j ) + getDeltaRps(); 
5300      if( dPoc < 0  &&  getUseDeltaFlag( j ) ) 
5301      {
5302        setDeltaPocS0Var( i , dPoc);
5303        setUsedByCurrPicS0Var( i++ , getUsedByCurrPicFlag( j )) ;
5304      }
5305    }
5306
5307    setNumNegativePicsVar( i );
5308
5309    i = 0;
5310    for( Int j = refRps->getNumNegativePicsVar() - 1; j  >=  0; j-- )
5311    {
5312      Int dPoc = refRps->getDeltaPocS0Var( j ) + getDeltaRps(); 
5313      if( dPoc > 0  &&  getUseDeltaFlag( j ) )
5314      {
5315        setDeltaPocS1Var( i, dPoc );
5316        setUsedByCurrPicS1Var(  i++, getUsedByCurrPicFlag( j ) ) ;
5317      }
5318    }
5319
5320    if( getDeltaRps() > 0  &&  getUseDeltaFlag( refRps->getNumDeltaPocs() ) ) //  (7 60)
5321    { 
5322      setDeltaPocS1Var( i , getDeltaRps() );
5323      setUsedByCurrPicS1Var( i++ , getUsedByCurrPicFlag( refRps->getNumDeltaPocs() ));
5324    }
5325
5326    for( Int j = 0; j < refRps->getNumPositivePicsVar( ); j++) 
5327    {
5328      Int dPoc = refRps->getDeltaPocS1Var( j ) + getDeltaRps(); 
5329      if( dPoc > 0  &&  getUseDeltaFlag( refRps->getNumNegativePicsVar() + j ) ) 
5330      {
5331        setDeltaPocS1Var( i, dPoc);
5332        setUsedByCurrPicS1Var( i++, getUsedByCurrPicFlag( refRps->getNumNegativePicsVar() + j ));
5333      }
5334    }
5335    setNumPositivePicsVar(  i );
5336  }
5337  else
5338  {
5339    // When inter_ref_pic_set_prediction_flag is equal to 0, the variables NumNegativePics[ stRpsIdx ], NumPositivePics[ stRpsIdx ],
5340    // UsedByCurrPicS0[ stRpsIdx ][ i ], UsedByCurrPicS1[ stRpsIdx ][ i ], DeltaPocS0[ stRpsIdx ][ i ] and DeltaPocS1[ stRpsIdx ][ i ]
5341    // are derived as follows:
5342
5343    setNumNegativePicsVar( getNumNegativePics( ) );        //  (7 61)
5344    setNumPositivePicsVar( getNumPositivePics( ) );         //  (7 62)
5345
5346    for (Int i = 0 ; i < getNumNegativePics(); i++ )
5347    {     
5348      setUsedByCurrPicS0Var( i,  getUsedByCurrPicS0Flag( i ) ); //  (7 63)
5349      if (i == 0 )
5350      {
5351        setDeltaPocS0Var( i , -( getDeltaPocS0Minus1( i ) + 1 )); // (7 65)
5352      }
5353      else
5354      {
5355        setDeltaPocS0Var( i , getDeltaPocS0Var( i - 1 ) - ( getDeltaPocS0Minus1( i ) + 1 )); //  (7 67)
5356      }
5357    }
5358
5359    for (Int i = 0 ; i < getNumPositivePics(); i++ )
5360    {     
5361      setUsedByCurrPicS1Var( i,  getUsedByCurrPicS1Flag( i ) ); //  (7 64)
5362
5363      if (i == 0 )
5364      {
5365        setDeltaPocS1Var( i , getDeltaPocS1Minus1( i ) + 1    );      // (7 66)
5366      }
5367      else
5368      {
5369        setDeltaPocS1Var( i , getDeltaPocS1Var( i - 1 ) + ( getDeltaPocS1Minus1( i ) + 1 )); //  (7 68)
5370      }
5371    }
5372  }
5373}
5374
5375#endif
Note: See TracBrowser for help on using the repository browser.