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

Last change on this file since 1179 was 1179, checked in by tech, 9 years ago

Merged branch 13.1-dev0@1178.

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