source: 3DVCSoftware/branches/HTM-9.2-dev0/source/Lib/TLibCommon/TComSlice.cpp @ 765

Last change on this file since 765 was 765, checked in by tech, 10 years ago

Cleanup part 2

  • Property svn:eol-style set to native
File size: 118.7 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-2013, 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
47TComSlice::TComSlice()
48: m_iPPSId                        ( -1 )
49, m_iPOC                          ( 0 )
50, m_iLastIDR                      ( 0 )
51, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
52, m_eSliceType                    ( I_SLICE )
53, m_iSliceQp                      ( 0 )
54, m_dependentSliceSegmentFlag            ( false )
55#if ADAPTIVE_QP_SELECTION
56, m_iSliceQpBase                  ( 0 )
57#endif
58, m_deblockingFilterDisable        ( false )
59, m_deblockingFilterOverrideFlag   ( false )
60, m_deblockingFilterBetaOffsetDiv2 ( 0 )
61, m_deblockingFilterTcOffsetDiv2   ( 0 )
62, m_bCheckLDC                     ( false )
63, m_iSliceQpDelta                 ( 0 )
64, m_iSliceQpDeltaCb               ( 0 )
65, m_iSliceQpDeltaCr               ( 0 )
66, m_iDepth                        ( 0 )
67, m_bRefenced                     ( false )
68, m_pcSPS                         ( NULL )
69, m_pcPPS                         ( NULL )
70, m_pcPic                         ( NULL )
71, m_colFromL0Flag                 ( 1 )
72, m_colRefIdx                     ( 0 )
73#if SAO_CHROMA_LAMBDA
74, m_dLambdaLuma( 0.0 )
75, m_dLambdaChroma( 0.0 )
76#else
77, m_dLambda                       ( 0.0 )
78#endif
79, m_uiTLayer                      ( 0 )
80, m_bTLayerSwitchingFlag          ( false )
81, m_sliceMode                   ( 0 )
82, m_sliceArgument               ( 0 )
83, m_sliceCurStartCUAddr         ( 0 )
84, m_sliceCurEndCUAddr           ( 0 )
85, m_sliceIdx                    ( 0 )
86, m_sliceSegmentMode            ( 0 )
87, m_sliceSegmentArgument        ( 0 )
88, m_sliceSegmentCurStartCUAddr  ( 0 )
89, m_sliceSegmentCurEndCUAddr    ( 0 )
90, m_nextSlice                    ( false )
91, m_nextSliceSegment             ( false )
92, m_sliceBits                   ( 0 )
93, m_sliceSegmentBits         ( 0 )
94, m_bFinalized                    ( false )
95, m_uiTileOffstForMultES          ( 0 )
96, m_puiSubstreamSizes             ( NULL )
97, m_cabacInitFlag                 ( false )
98, m_bLMvdL1Zero                   ( false )
99, m_numEntryPointOffsets          ( 0 )
100, m_temporalLayerNonReferenceFlag ( false )
101, m_enableTMVPFlag                ( true )
102#if H_MV
103, m_refPicSetInterLayer0           ( NULL )
104, m_refPicSetInterLayer1           ( NULL )
105, m_layerId                       (0)
106, m_viewId                        (0)
107, m_viewIndex                     (0)
108#if H_3D
109, m_isDepth                       (false)
110#endif
111, m_pocResetFlag                  (false)
112#if H_MV_6_RALS_O0149_11
113, m_crossLayerBlaFlag             (false)
114#endif
115, m_discardableFlag               (false)
116, m_interLayerPredEnabledFlag     (false)
117, m_numInterLayerRefPicsMinus1    (0)
118#if H_3D_IC
119, m_bApplyIC                      ( false )
120, m_icSkipParseFlag               ( false )
121#endif
122#if H_3D
123, m_depthToDisparityB             ( NULL )
124, m_depthToDisparityF             ( NULL )
125#endif
126#endif
127{
128  m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = 0;
129 
130  initEqualRef();
131 
132  for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
133  {
134    m_list1IdxToList0Idx[idx] = -1;
135  }
136  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
137  {
138    m_apcRefPicList [0][iNumCount] = NULL;
139    m_apcRefPicList [1][iNumCount] = NULL;
140    m_aiRefPOCList  [0][iNumCount] = 0;
141    m_aiRefPOCList  [1][iNumCount] = 0;
142#if H_MV
143    m_aiRefLayerIdList[0][iNumCount] = 0;
144    m_aiRefLayerIdList[1][iNumCount] = 0;
145#endif
146  }
147  resetWpScaling();
148  initWpAcDcParam();
149  m_saoEnabledFlag = false;
150#if H_MV
151  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
152  {
153    m_interLayerPredLayerIdc[ i ] = -1;
154  }
155#endif
156}
157
158TComSlice::~TComSlice()
159{
160  delete[] m_puiSubstreamSizes;
161  m_puiSubstreamSizes = NULL;
162#if H_3D
163  for( UInt i = 0; i < getViewIndex(); i++ )
164  {
165    if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
166    {
167      delete[] m_depthToDisparityB [ i ];
168    }
169
170    if ( m_depthToDisparityF && m_depthToDisparityF[ i ] ) 
171    {
172      delete[] m_depthToDisparityF [ i ];
173  }
174  }
175
176  if ( m_depthToDisparityF )
177  {
178    delete[] m_depthToDisparityF; 
179  }
180
181  m_depthToDisparityF = NULL;
182
183  if ( m_depthToDisparityB )
184    delete[] m_depthToDisparityB; 
185
186  m_depthToDisparityB = NULL;
187#endif
188}
189
190
191Void TComSlice::initSlice()
192{
193  m_aiNumRefIdx[0]      = 0;
194  m_aiNumRefIdx[1]      = 0;
195 
196  m_colFromL0Flag = 1;
197 
198  m_colRefIdx = 0;
199  initEqualRef();
200  m_bCheckLDC = false;
201  m_iSliceQpDeltaCb = 0;
202  m_iSliceQpDeltaCr = 0;
203
204#if H_3D_IV_MERGE
205  m_maxNumMergeCand = MRG_MAX_NUM_CANDS_MEM;
206#else
207  m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
208#endif
209
210  m_bFinalized=false;
211
212  m_tileByteLocation.clear();
213  m_cabacInitFlag        = false;
214  m_numEntryPointOffsets = 0;
215  m_enableTMVPFlag = true;
216#if H_3D_TMVP
217  m_aiAlterRefIdx[0]                  = -1;
218  m_aiAlterRefIdx[1]                  = -1;
219#endif
220}
221
222Bool TComSlice::getRapPicFlag()
223{
224  return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
225      || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
226      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
227      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
228      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
229      || getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
230}
231
232/**
233 - allocate table to contain substream sizes to be written to the slice header.
234 .
235 \param uiNumSubstreams Number of substreams -- the allocation will be this value - 1.
236 */
237Void  TComSlice::allocSubstreamSizes(UInt uiNumSubstreams)
238{
239  delete[] m_puiSubstreamSizes;
240  m_puiSubstreamSizes = new UInt[uiNumSubstreams > 0 ? uiNumSubstreams-1 : 0];
241}
242
243Void  TComSlice::sortPicList        (TComList<TComPic*>& rcListPic)
244{
245  TComPic*    pcPicExtract;
246  TComPic*    pcPicInsert;
247 
248  TComList<TComPic*>::iterator    iterPicExtract;
249  TComList<TComPic*>::iterator    iterPicExtract_1;
250  TComList<TComPic*>::iterator    iterPicInsert;
251 
252  for (Int i = 1; i < (Int)(rcListPic.size()); i++)
253  {
254    iterPicExtract = rcListPic.begin();
255    for (Int j = 0; j < i; j++) iterPicExtract++;
256    pcPicExtract = *(iterPicExtract);
257    pcPicExtract->setCurrSliceIdx(0);
258   
259    iterPicInsert = rcListPic.begin();
260    while (iterPicInsert != iterPicExtract)
261    {
262      pcPicInsert = *(iterPicInsert);
263      pcPicInsert->setCurrSliceIdx(0);
264      if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
265      {
266        break;
267      }
268     
269      iterPicInsert++;
270    }
271   
272    iterPicExtract_1 = iterPicExtract;    iterPicExtract_1++;
273   
274    //  swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
275    rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
276    rcListPic.erase  (iterPicExtract);
277  }
278}
279
280TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic,
281                                Int                 poc)
282{
283  TComList<TComPic*>::iterator  iterPic = rcListPic.begin(); 
284  TComPic*                      pcPic = *(iterPic);
285  while ( iterPic != rcListPic.end() )
286  {
287    if(pcPic->getPOC() == poc)
288    {
289      break;
290    }
291    iterPic++;
292    pcPic = *(iterPic);
293  }
294  return  pcPic;
295}
296
297
298TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
299{
300  TComList<TComPic*>::iterator  iterPic = rcListPic.begin(); 
301  TComPic*                      pcPic = *(iterPic);
302  TComPic*                      pcStPic = pcPic;
303 
304  Int pocCycle = 1 << getSPS()->getBitsForPOC();
305  if (!pocHasMsb)
306  {
307    poc = poc & (pocCycle - 1);
308  }
309 
310  while ( iterPic != rcListPic.end() )
311  {
312    pcPic = *(iterPic);
313    if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
314    {
315      Int picPoc = pcPic->getPOC();
316      if (!pocHasMsb)
317      {
318        picPoc = picPoc & (pocCycle - 1);
319      }
320     
321      if (poc == picPoc)
322    {
323      if(pcPic->getIsLongTerm())
324      {
325        return pcPic;
326      }
327      else
328      {
329        pcStPic = pcPic;
330      }
331      break;
332    }
333    }
334
335    iterPic++;
336  }
337 
338  return  pcStPic;
339}
340
341Void TComSlice::setRefPOCList       ()
342{
343  for (Int iDir = 0; iDir < 2; iDir++)
344  {
345    for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
346    {
347      m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
348#if H_MV
349      m_aiRefLayerIdList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getLayerId();
350#endif
351    }
352  }
353
354}
355
356Void TComSlice::setList1IdxToList0Idx()
357{
358  Int idxL0, idxL1;
359  for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
360  {
361    m_list1IdxToList0Idx[idxL1] = -1;
362    for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
363    {
364      if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
365      {
366        m_list1IdxToList0Idx[idxL1] = idxL0;
367        break;
368      }
369    }
370  }
371}
372#if !H_MV
373#if FIX1071
374Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
375#else
376Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
377#endif
378{
379#if FIX1071
380  if (!checkNumPocTotalCurr)
381#endif
382  {
383    if (m_eSliceType == I_SLICE)
384    {
385      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
386      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
387
388      return;
389    }
390
391    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
392    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
393  }
394
395  TComPic*  pcRefPic= NULL;
396  TComPic*  RefPicSetStCurr0[16];
397  TComPic*  RefPicSetStCurr1[16];
398  TComPic*  RefPicSetLtCurr[16];
399  UInt NumPocStCurr0 = 0;
400  UInt NumPocStCurr1 = 0;
401  UInt NumPocLtCurr = 0;
402  Int i;
403
404  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
405  {
406    if(m_pcRPS->getUsed(i))
407    {
408      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
409      pcRefPic->setIsLongTerm(0);
410      pcRefPic->getPicYuvRec()->extendPicBorder();
411      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
412      NumPocStCurr0++;
413      pcRefPic->setCheckLTMSBPresent(false); 
414    }
415  }
416
417  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
418  {
419    if(m_pcRPS->getUsed(i))
420    {
421      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
422      pcRefPic->setIsLongTerm(0);
423      pcRefPic->getPicYuvRec()->extendPicBorder();
424      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
425      NumPocStCurr1++;
426      pcRefPic->setCheckLTMSBPresent(false); 
427    }
428  }
429
430  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
431  {
432    if(m_pcRPS->getUsed(i))
433    {
434      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
435      pcRefPic->setIsLongTerm(1);
436      pcRefPic->getPicYuvRec()->extendPicBorder();
437      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
438      NumPocLtCurr++;
439    }
440    if(pcRefPic==NULL) 
441    {
442      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
443    }
444    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); 
445  }
446
447  // ref_pic_list_init
448  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
449  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
450  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
451
452#if FIX1071
453  if (checkNumPocTotalCurr)
454  {
455    // 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:
456    // ?If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
457    // ?Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
458    if (getRapPicFlag())
459    {
460      assert(numPocTotalCurr == 0);
461    }
462
463    if (m_eSliceType == I_SLICE)
464    {
465      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
466      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
467
468      return;
469    }
470
471    assert(numPocTotalCurr > 0);
472
473    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
474    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
475  }
476#endif
477
478  Int cIdx = 0;
479  for ( i=0; i<NumPocStCurr0; i++, cIdx++)
480  {
481    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
482  }
483  for ( i=0; i<NumPocStCurr1; i++, cIdx++)
484  {
485    rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
486  }
487  for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
488  {
489    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
490  }
491  assert(cIdx == numPocTotalCurr);
492
493  if (m_eSliceType==B_SLICE)
494  {
495    cIdx = 0;
496    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
497    {
498      rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
499    }
500    for ( i=0; i<NumPocStCurr0; i++, cIdx++)
501    {
502      rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
503    }
504    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
505    {
506      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
507    }
508    assert(cIdx == numPocTotalCurr);
509  }
510
511  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
512
513  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
514  {
515    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
516    assert(cIdx >= 0 && cIdx < numPocTotalCurr);
517    m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
518    m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
519  }
520  if ( m_eSliceType != B_SLICE )
521  {
522    m_aiNumRefIdx[1] = 0;
523    ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
524  }
525  else
526  {
527    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
528    {
529      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
530      assert(cIdx >= 0 && cIdx < numPocTotalCurr);
531      m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
532      m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
533    }
534  }
535}
536
537#else
538Void TComSlice::getTempRefPicLists( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
539                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr )
540{
541  if (!checkNumPocTotalCurr)
542  {
543    if (m_eSliceType == I_SLICE)
544    {     
545      return;
546    }   
547  }
548
549  TComPic*  pcRefPic= NULL;
550  TComPic*  RefPicSetStCurr0[16];
551  TComPic*  RefPicSetStCurr1[16];
552  TComPic*  RefPicSetLtCurr[16];
553  UInt NumPocStCurr0 = 0;
554  UInt NumPocStCurr1 = 0;
555  UInt NumPocLtCurr = 0;
556  Int i;
557
558  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
559  {
560    if(m_pcRPS->getUsed(i))
561    {
562      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
563      pcRefPic->setIsLongTerm(0);
564      pcRefPic->getPicYuvRec()->extendPicBorder();
565      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
566      NumPocStCurr0++;
567      pcRefPic->setCheckLTMSBPresent(false); 
568    }
569  }
570 
571  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
572  {
573    if(m_pcRPS->getUsed(i))
574    {
575      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
576      pcRefPic->setIsLongTerm(0);
577      pcRefPic->getPicYuvRec()->extendPicBorder();
578      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
579      NumPocStCurr1++;
580      pcRefPic->setCheckLTMSBPresent(false); 
581    }
582  }
583 
584  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
585  {
586    if(m_pcRPS->getUsed(i))
587    {
588      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
589      pcRefPic->setIsLongTerm(1);
590      pcRefPic->getPicYuvRec()->extendPicBorder();
591      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
592      NumPocLtCurr++;
593    }
594    if(pcRefPic==NULL) 
595    {
596      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
597    }
598    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); 
599  }
600
601  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr; 
602  numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
603  assert( numPocTotalCurr == getNumRpsCurrTempList() );
604
605  if (checkNumPocTotalCurr)
606  {
607    // 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:
608    // - 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.
609    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
610    if ( getRapPicFlag() && m_layerId == 0 )
611    {
612      assert(numPocTotalCurr == 0);
613    }
614
615    if (m_eSliceType == I_SLICE)
616    {
617      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
618      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
619     
620      return;
621    }
622   
623    assert(numPocTotalCurr > 0);
624   
625    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
626    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
627  }
628
629  std::vector<TComPic*>* refPicSetInterLayer[2] = { &refPicSetInterLayer0, &refPicSetInterLayer1}; 
630  Int numPocInterLayer[2] = { getNumActiveRefLayerPics0( ), getNumActiveRefLayerPics1( ) }; 
631 
632  TComPic**             refPicSetStCurr    [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
633  Int numPocStCurr[2] = { NumPocStCurr0, NumPocStCurr1 }; 
634
635  for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
636  { 
637    rpsCurrList   [li].resize(MAX_NUM_REF+1,NULL ); 
638    usedAsLongTerm[li].resize(MAX_NUM_REF+1,false); 
639
640    Int cIdx = 0;
641    for ( i=0; i < numPocStCurr[li]; i++, cIdx++)
642    {
643      rpsCurrList[li][cIdx] = refPicSetStCurr[li][i];
644      usedAsLongTerm [li][cIdx] = false; 
645    }
646
647    for ( i=0; i < numPocInterLayer[li];  i++, cIdx++)
648    {   
649      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[li])[i];
650      usedAsLongTerm [li][cIdx] = true; 
651    }
652
653    for ( i=0; i < numPocStCurr[1-li]; i++, cIdx++)
654    {
655      rpsCurrList[li][cIdx] = refPicSetStCurr[1-li][i];
656      usedAsLongTerm [li][cIdx] = false; 
657    }
658
659    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
660    {
661      rpsCurrList[li][cIdx] = RefPicSetLtCurr[i];
662      usedAsLongTerm [li][cIdx] = true; 
663    }
664
665    for ( i=0; i < numPocInterLayer[1-li];  i++, cIdx++)
666    {   
667      assert( cIdx < MAX_NUM_REF );   
668      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[1-li])[i];
669      usedAsLongTerm [li][cIdx] = true; 
670    }
671
672    assert(cIdx == numPocTotalCurr);
673  }
674}
675
676Void TComSlice::setRefPicList( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr )
677
678{
679  if (!checkNumPocTotalCurr)
680  {
681    if (m_eSliceType == I_SLICE)
682    {
683      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
684      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
685
686      return;
687    }   
688  }
689
690  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
691
692  for (Int li = 0; li < 2; li++)
693  {
694    if ( m_eSliceType == P_SLICE && li == 1 )
695    {
696      m_aiNumRefIdx[1] = 0;
697      ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
698    } 
699    else
700    {
701      for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
702      { 
703        Bool listModified             =                m_RefPicListModification.getRefPicListModificationFlagL( li ); 
704        Int orgIdx                    = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr); 
705
706        assert( rpsCurrList[li][ orgIdx ] != NULL ); 
707        m_apcRefPicList    [li][rIdx] = rpsCurrList    [li][ orgIdx ];
708        m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ; 
709      }
710    }
711  }
712}
713#endif
714Int TComSlice::getNumRpsCurrTempList()
715{
716  Int numRpsCurrTempList = 0;
717
718  if (m_eSliceType == I_SLICE) 
719  {
720    return 0;
721  }
722  for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
723  {
724    if(m_pcRPS->getUsed(i))
725    {
726      numRpsCurrTempList++;
727    }
728  }
729#if H_MV
730  numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
731#endif
732  return numRpsCurrTempList;
733}
734
735Void TComSlice::initEqualRef()
736{
737  for (Int iDir = 0; iDir < 2; iDir++)
738  {
739    for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
740    {
741      for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
742      {
743        m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
744      }
745    }
746  }
747}
748#if H_3D
749#if H_3D_TMVP
750Void TComSlice::generateAlterRefforTMVP()
751{
752  for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
753  {       
754    if ( this->getNumRefIdx( RefPicList( uiRefListIdx ) ) == 0)
755    {
756        continue;
757    }
758    Bool bZeroIdxLtFlag = this->getRefPic(RefPicList(uiRefListIdx), 0)->getIsLongTerm();
759    for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
760    {
761      if ( ( bZeroIdxLtFlag && !this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) ||
762           (!bZeroIdxLtFlag &&  this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) )
763      {
764        this->setAlterRefIdx(RefPicList(uiRefListIdx),i);
765        break;
766      }
767    }
768  }
769}
770#endif
771Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
772{ 
773#if CAM_HLS_F0136_F0045_F0082
774  if( m_pcVPS->hasCamParInSliceHeader( m_viewIndex ) )
775#else
776  if( m_pcSPS->hasCamParInSliceHeader() )
777#endif
778  {   
779    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
780    {
781      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     m_viewIndex ];
782      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     m_viewIndex ][ uiBaseViewIndex ];
783      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     m_viewIndex ];
784      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     m_viewIndex ][ uiBaseViewIndex ];
785    }
786  } 
787}
788#endif
789
790Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
791{
792  Int i;
793  TComSlice* curSlice = pic->getSlice(curSliceIdx);
794  Int currColRefPOC =  curSlice->getRefPOC( RefPicList(1-curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
795  TComSlice* preSlice;
796  Int preColRefPOC;
797  for(i=curSliceIdx-1; i>=0; i--)
798  {
799    preSlice = pic->getSlice(i);
800    if(preSlice->getSliceType() != I_SLICE)
801    {
802      preColRefPOC  = preSlice->getRefPOC( RefPicList(1-preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
803      if(currColRefPOC != preColRefPOC)
804      {
805        printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
806        exit(EXIT_FAILURE);
807      }
808      else
809      {
810        break;
811      }
812    }
813  }
814}
815
816Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic)
817{
818  for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
819  {
820    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
821    {
822      assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
823    }
824  }
825  for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
826  {
827    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
828    {
829      if (!pReferencePictureSet->getCheckLTMSBPresent(i))
830      {
831        assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
832      }
833      else
834      {
835      assert(pReferencePictureSet->getPOC(i) >= pocCRA);
836    }
837  }
838  }
839  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
840  {
841    pocCRA = getPOC();
842    associatedIRAPType = getNalUnitType();
843  }
844  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
845  {
846    pocCRA = getPOC();
847    associatedIRAPType = getNalUnitType();
848  }
849  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
850         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
851         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
852  {
853    pocCRA = getPOC();
854    associatedIRAPType = getNalUnitType();
855  }
856}
857
858/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
859 * \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
860 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
861 * \param rcListPic reference to the reference picture list
862 * This function marks the reference pictures as "unused for reference" in the following conditions.
863 * If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list 
864 * are marked as "unused for reference"
865 *    If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
866 * Otherwise
867 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
868 *    temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
869 *    mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
870 *    the bRefreshPending flag to false.
871 *    If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
872 *    reference of the current picture.
873 * Note that the current picture is already placed in the reference list and its marking is not changed.
874 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
875 */
876Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
877{
878  TComPic*                 rpcPic;
879  setAssociatedIRAPPOC(pocCRA);
880  Int pocCurr = getPOC(); 
881
882  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
883    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
884    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
885    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
886    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )  // IDR or BLA picture
887  {
888    // mark all pictures as not used for reference
889    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
890    while (iterPic != rcListPic.end())
891    {
892      rpcPic = *(iterPic);
893      rpcPic->setCurrSliceIdx(0);
894      if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
895      iterPic++;
896    }
897    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
898      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
899      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
900    {
901      pocCRA = pocCurr;
902    }
903  }
904  else // CRA or No DR
905  {
906    if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
907    {
908      TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
909      while (iterPic != rcListPic.end())
910      {
911        rpcPic = *(iterPic);
912        if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
913        {
914          rpcPic->getSlice(0)->setReferenced(false);
915        }
916        iterPic++;
917      }
918      bRefreshPending = false; 
919    }
920    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
921    {
922      bRefreshPending = true; 
923      pocCRA = pocCurr;
924    }
925  }
926}
927
928Void TComSlice::copySliceInfo(TComSlice *pSrc)
929{
930  assert( pSrc != NULL );
931
932  Int i, j, k;
933
934  m_iPOC                 = pSrc->m_iPOC;
935  m_eNalUnitType         = pSrc->m_eNalUnitType;
936#if H_MV
937  m_layerId              = pSrc->m_layerId;
938  // GT: Copying of several other values might be be missing here, or is above not necessary?
939#endif
940  m_eSliceType           = pSrc->m_eSliceType;
941  m_iSliceQp             = pSrc->m_iSliceQp;
942#if ADAPTIVE_QP_SELECTION
943  m_iSliceQpBase         = pSrc->m_iSliceQpBase;
944#endif
945  m_deblockingFilterDisable   = pSrc->m_deblockingFilterDisable;
946  m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
947  m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
948  m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
949 
950  for (i = 0; i < 2; i++)
951  {
952    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
953  }
954
955  for (i = 0; i < MAX_NUM_REF; i++)
956  {
957    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
958  } 
959  m_bCheckLDC             = pSrc->m_bCheckLDC;
960  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
961  m_iSliceQpDeltaCb      = pSrc->m_iSliceQpDeltaCb;
962  m_iSliceQpDeltaCr      = pSrc->m_iSliceQpDeltaCr;
963  for (i = 0; i < 2; i++)
964  {
965    for (j = 0; j < MAX_NUM_REF; j++)
966    {
967      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
968      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
969#if H_MV
970      m_aiRefLayerIdList[i][j] = pSrc->m_aiRefLayerIdList[i][j];
971#endif
972    }
973  }
974  for (i = 0; i < 2; i++)
975  {
976    for (j = 0; j < MAX_NUM_REF + 1; j++)
977    {
978      m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
979    }
980  }
981  m_iDepth               = pSrc->m_iDepth;
982
983  // referenced slice
984  m_bRefenced            = pSrc->m_bRefenced;
985
986  // access channel
987#if H_MV
988  m_pcVPS                = pSrc->m_pcVPS;
989#endif
990  m_pcSPS                = pSrc->m_pcSPS;
991  m_pcPPS                = pSrc->m_pcPPS;
992  m_pcRPS                = pSrc->m_pcRPS;
993  m_iLastIDR             = pSrc->m_iLastIDR;
994
995  m_pcPic                = pSrc->m_pcPic;
996
997  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
998  m_colRefIdx            = pSrc->m_colRefIdx;
999#if SAO_CHROMA_LAMBDA
1000  m_dLambdaLuma          = pSrc->m_dLambdaLuma;
1001  m_dLambdaChroma        = pSrc->m_dLambdaChroma;
1002#else
1003  m_dLambda              = pSrc->m_dLambda;
1004#endif
1005  for (i = 0; i < 2; i++)
1006  {
1007    for (j = 0; j < MAX_NUM_REF; j++)
1008    {
1009      for (k =0; k < MAX_NUM_REF; k++)
1010      {
1011        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1012      }
1013    }
1014  }
1015
1016  m_uiTLayer                      = pSrc->m_uiTLayer;
1017  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
1018
1019  m_sliceMode                   = pSrc->m_sliceMode;
1020  m_sliceArgument               = pSrc->m_sliceArgument;
1021  m_sliceCurStartCUAddr         = pSrc->m_sliceCurStartCUAddr;
1022  m_sliceCurEndCUAddr           = pSrc->m_sliceCurEndCUAddr;
1023  m_sliceIdx                    = pSrc->m_sliceIdx;
1024  m_sliceSegmentMode            = pSrc->m_sliceSegmentMode;
1025  m_sliceSegmentArgument        = pSrc->m_sliceSegmentArgument; 
1026  m_sliceSegmentCurStartCUAddr  = pSrc->m_sliceSegmentCurStartCUAddr;
1027  m_sliceSegmentCurEndCUAddr    = pSrc->m_sliceSegmentCurEndCUAddr;
1028  m_nextSlice                    = pSrc->m_nextSlice;
1029  m_nextSliceSegment             = pSrc->m_nextSliceSegment;
1030  for ( Int e=0 ; e<2 ; e++ )
1031  {
1032    for ( Int n=0 ; n<MAX_NUM_REF ; n++ )
1033    {
1034      memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
1035    }
1036  }
1037  m_saoEnabledFlag = pSrc->m_saoEnabledFlag; 
1038  m_saoEnabledFlagChroma = pSrc->m_saoEnabledFlagChroma;
1039  m_cabacInitFlag                = pSrc->m_cabacInitFlag;
1040  m_numEntryPointOffsets  = pSrc->m_numEntryPointOffsets;
1041
1042  m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1043  m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1044  m_enableTMVPFlag                = pSrc->m_enableTMVPFlag;
1045  m_maxNumMergeCand               = pSrc->m_maxNumMergeCand;
1046
1047#if H_MV
1048  // Additional slice header syntax elements
1049  m_pocResetFlag               = pSrc->m_pocResetFlag; 
1050  m_discardableFlag            = pSrc->m_discardableFlag; 
1051  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag; 
1052  m_numInterLayerRefPicsMinus1 = pSrc->m_numInterLayerRefPicsMinus1;
1053
1054  for (Int layer = 0; layer < MAX_NUM_LAYERS; layer++ )
1055  {
1056    m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 
1057  }
1058#endif
1059#if H_3D_IC
1060  m_bApplyIC = pSrc->m_bApplyIC;
1061  m_icSkipParseFlag = pSrc->m_icSkipParseFlag;
1062#endif
1063}
1064
1065Int TComSlice::m_prevTid0POC = 0;
1066
1067/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1068 * \param uiTLayer Temporal layer ID of the current slice
1069 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1070 * the SPS's temporal_id_nesting_flag and the parsed PPS.  Then, current slice's temporal layer ID and
1071 * temporal_layer_switching_point_flag is set accordingly.
1072 */
1073Void TComSlice::setTLayerInfo( UInt uiTLayer )
1074{
1075  m_uiTLayer = uiTLayer;
1076}
1077
1078/** Function for checking if this is a switching-point
1079*/
1080Bool TComSlice::isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic )
1081{
1082  TComPic* rpcPic;
1083  // loop through all pictures in the reference picture buffer
1084  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1085  while ( iterPic != rcListPic.end())
1086  {
1087    rpcPic = *(iterPic++);
1088    if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1089    {
1090      if(rpcPic->getTLayer() >= getTLayer())
1091      {
1092        return false;
1093      }
1094    }
1095  }
1096  return true;
1097}
1098
1099/** Function for checking if this is a STSA candidate
1100 */
1101Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic )
1102{
1103    TComPic* rpcPic;
1104   
1105    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1106    while ( iterPic != rcListPic.end())
1107    {
1108        rpcPic = *(iterPic++);
1109        if(rpcPic->getSlice(0)->isReferenced() &&  (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1110        {
1111            if(rpcPic->getTLayer() >= getTLayer())
1112            {
1113                return false;
1114            }
1115        }
1116    }
1117    return true;
1118}
1119
1120
1121Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1122{
1123  TComPic* rpcPic;
1124
1125  Int nalUnitType = this->getNalUnitType();
1126
1127  // When a picture is a leading picture, it shall be a RADL or RASL picture.
1128  if(this->getAssociatedIRAPPOC() > this->getPOC())
1129  {
1130    // Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1131    if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP ||
1132       nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1133    {
1134      assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1135             nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1136             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1137             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1138    }
1139  }
1140
1141  // When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1142  if(this->getAssociatedIRAPPOC() < this->getPOC())
1143  {
1144    assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1145           nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1146           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1147           nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1148  }
1149
1150  // No RASL pictures shall be present in the bitstream that are associated
1151  // with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1152  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1153     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1154  {
1155    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1156           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1157  }
1158
1159  // No RASL pictures shall be present in the bitstream that are associated with
1160  // an IDR picture.
1161  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1162     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1163  {
1164    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP   &&
1165           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1166  }
1167
1168  // No RADL pictures shall be present in the bitstream that are associated with
1169  // a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1170  // with an IDR picture having nal_unit_type equal to IDR_N_LP.
1171  if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1172     nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1173  {
1174    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP   &&
1175           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1176  }
1177
1178  // loop through all pictures in the reference picture buffer
1179  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1180  while ( iterPic != rcListPic.end())
1181  {
1182    rpcPic = *(iterPic++);
1183    if (rpcPic->getPOC() == this->getPOC())
1184    {
1185      continue;
1186    }
1187
1188    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1189    // in decoding order shall precede the IRAP picture in output order.
1190    // (Note that any picture following in output order would be present in the DPB)
1191    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1192    {
1193      if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP    ||
1194         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP    ||
1195         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL  ||
1196         nalUnitType == NAL_UNIT_CODED_SLICE_CRA         ||
1197         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP    ||
1198         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1199      {
1200        assert(rpcPic->getPOC() < this->getPOC());
1201      }
1202    }
1203
1204    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1205    // in decoding order shall precede any RADL picture associated with the IRAP
1206    // picture in output order.
1207    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1208    {
1209      if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1210          nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1211      {
1212        // rpcPic precedes the IRAP in decoding order
1213        if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1214        {
1215          // rpcPic must not be the IRAP picture
1216          if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1217          {
1218            assert(rpcPic->getPOC() < this->getPOC());
1219          }
1220        }
1221      }
1222    }
1223
1224    // When a picture is a leading picture, it shall precede, in decoding order,
1225    // all trailing pictures that are associated with the same IRAP picture.
1226    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1227       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1228       nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1229       nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1230    {
1231      if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1232      {
1233        // rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1234        // rpcPic would violate the constraint if it was a trailing picture
1235        assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1236      }
1237    }
1238
1239    // Any RASL picture associated with a CRA or BLA picture shall precede any
1240    // RADL picture associated with the CRA or BLA picture in output order
1241    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1242       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1243    { 
1244      if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1245          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1246          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1247          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)       &&
1248          this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1249      {
1250        if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
1251           rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1252        {
1253          assert(rpcPic->getPOC() > this->getPOC());
1254        }
1255      }
1256    }
1257
1258    // Any RASL picture associated with a CRA picture shall follow, in output
1259    // order, any IRAP picture that precedes the CRA picture in decoding order.
1260    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1261       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1262    {
1263      if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1264      {
1265        if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1266           (rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1267            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1268            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1269            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP   ||
1270            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
1271            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1272        {
1273          assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1274        }
1275      }
1276    }
1277  }
1278}
1279
1280
1281
1282/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1283*/
1284Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1285{
1286  TComPic* rpcPic;
1287  Int i, isReference;
1288
1289  checkLeadingPictureRestrictions(rcListPic);
1290
1291  // loop through all pictures in the reference picture buffer
1292  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1293  while ( iterPic != rcListPic.end())
1294  {
1295    rpcPic = *(iterPic++);
1296
1297    if(!rpcPic->getSlice( 0 )->isReferenced())
1298    {
1299      continue;
1300    }
1301
1302    isReference = 0;
1303    // loop through all pictures in the Reference Picture Set
1304    // to see if the picture should be kept as reference picture
1305    for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1306    {
1307      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1308      {
1309        isReference = 1;
1310        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1311        rpcPic->setIsLongTerm(0);
1312      }
1313    }
1314    for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1315    {
1316      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1317      {
1318        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1319        {
1320          isReference = 1;
1321          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1322        }
1323      }
1324      else 
1325      {
1326        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1327        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1328        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1329        if(rpcPic->getIsLongTerm() && curPoc == refPoc)
1330        {
1331          isReference = 1;
1332          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1333        }
1334      }
1335
1336    }
1337    // mark the picture as "unused for reference" if it is not in
1338    // the Reference Picture Set
1339    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)   
1340    {           
1341      rpcPic->getSlice( 0 )->setReferenced( false );   
1342      rpcPic->setUsedByCurr(0);
1343      rpcPic->setIsLongTerm(0);
1344    }
1345    //check that pictures of higher temporal layers are not used
1346    assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
1347    //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1348    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1349    {
1350      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
1351    }
1352    //check that pictures marked as temporal layer non-reference pictures are not used for reference
1353    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1354    {
1355      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1356    }
1357  }
1358}
1359
1360/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1361*/
1362Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
1363{
1364  TComPic* rpcPic;
1365  Int i, isAvailable;
1366  Int atLeastOneLost = 0;
1367  Int atLeastOneRemoved = 0;
1368  Int iPocLost = 0;
1369
1370  // loop through all long-term pictures in the Reference Picture Set
1371  // to see if the picture should be kept as reference picture
1372  for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1373  {
1374    isAvailable = 0;
1375    // loop through all pictures in the reference picture buffer
1376    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1377    while ( iterPic != rcListPic.end())
1378    {
1379      rpcPic = *(iterPic++);
1380      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1381      {
1382        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1383        {
1384          isAvailable = 1;
1385        }
1386      }
1387      else 
1388      {
1389        Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1390        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1391        Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1392        if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
1393        {
1394          isAvailable = 1;
1395        }
1396      }
1397    }
1398    // if there was no such long-term check the short terms
1399    if(!isAvailable)
1400    {
1401      iterPic = rcListPic.begin();
1402      while ( iterPic != rcListPic.end())
1403      {
1404        rpcPic = *(iterPic++);
1405
1406        Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1407        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1408        Int refPoc = pReferencePictureSet->getPOC(i);
1409        if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1410        {
1411          curPoc = curPoc & (pocCycle - 1);
1412          refPoc = refPoc & (pocCycle - 1);
1413        }
1414       
1415        if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1416        {
1417          isAvailable = 1;
1418          rpcPic->setIsLongTerm(1);
1419          break;
1420        }
1421      }
1422    }
1423    // report that a picture is lost if it is in the Reference Picture Set
1424    // but not available as reference picture
1425    if(isAvailable == 0)   
1426    {           
1427      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1428      {
1429        if(!pReferencePictureSet->getUsed(i) )
1430        {
1431          if(printErrors)
1432          {
1433            printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1434          }
1435          atLeastOneRemoved = 1;
1436        }
1437        else
1438        {
1439          if(printErrors)
1440          {
1441            printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1442          }
1443          atLeastOneLost = 1;
1444          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1445        }
1446      }
1447    }
1448  } 
1449  // loop through all short-term pictures in the Reference Picture Set
1450  // to see if the picture should be kept as reference picture
1451  for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1452  {
1453    isAvailable = 0;
1454    // loop through all pictures in the reference picture buffer
1455    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1456    while ( iterPic != rcListPic.end())
1457    {
1458      rpcPic = *(iterPic++);
1459
1460      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1461      {
1462        isAvailable = 1;
1463      }
1464    }
1465    // report that a picture is lost if it is in the Reference Picture Set
1466    // but not available as reference picture
1467    if(isAvailable == 0)   
1468    {           
1469      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1470      {
1471        if(!pReferencePictureSet->getUsed(i) )
1472        {
1473          if(printErrors)
1474          {
1475            printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1476          }
1477          atLeastOneRemoved = 1;
1478        }
1479        else
1480        {
1481          if(printErrors)
1482          {
1483            printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1484          }
1485          atLeastOneLost = 1;
1486          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1487        }
1488      }
1489    }
1490  }   
1491  if(atLeastOneLost)
1492  {
1493    return iPocLost+1;
1494  }
1495  if(atLeastOneRemoved)
1496  {
1497    return -2;
1498  }
1499  else
1500  {
1501    return 0;
1502  }
1503}
1504
1505/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1506*/
1507#if FIX1071
1508Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
1509#else
1510Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1511#endif
1512{
1513  TComPic* rpcPic;
1514  Int i, j;
1515  Int k = 0;
1516  Int nrOfNegativePictures = 0;
1517  Int nrOfPositivePictures = 0;
1518  TComReferencePictureSet* pcRPS = this->getLocalRPS();
1519
1520  // loop through all pictures in the Reference Picture Set
1521  for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1522  {
1523    j = 0;
1524    // loop through all pictures in the reference picture buffer
1525    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1526    while ( iterPic != rcListPic.end())
1527    {
1528      j++;
1529      rpcPic = *(iterPic++);
1530
1531      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1532      {
1533        // This picture exists as a reference picture
1534        // and should be added to the explicit Reference Picture Set
1535        pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1536#if FIX1071
1537        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1538#else
1539        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i));
1540#endif
1541        if(pcRPS->getDeltaPOC(k) < 0)
1542        {
1543          nrOfNegativePictures++;
1544        }
1545        else
1546        {
1547          nrOfPositivePictures++;
1548        }
1549        k++;
1550      }
1551    }
1552  }
1553  pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1554  pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1555  pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1556  // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1557  // inter RPS prediction with.  Here we just use the reference used by pReferencePictureSet.
1558  // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1559  if (!pReferencePictureSet->getInterRPSPrediction())
1560  {
1561    pcRPS->setInterRPSPrediction(false);
1562    pcRPS->setNumRefIdc(0);
1563  }
1564  else
1565  {
1566    Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1567    Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1568    TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1569    Int iRefPics = pcRefRPS->getNumberOfPictures();
1570    Int iNewIdc=0;
1571    for(i=0; i<= iRefPics; i++) 
1572    {
1573      Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0);  // check if the reference abs POC is >= 0
1574      Int iRefIdc = 0;
1575      for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the  pictures in the new RPS
1576      {
1577        if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1578        {
1579          if (pcRPS->getUsed(j))
1580          {
1581            iRefIdc = 1;
1582          }
1583          else
1584          {
1585            iRefIdc = 2;
1586          }
1587        }
1588      }
1589      pcRPS->setRefIdc(i, iRefIdc);
1590      iNewIdc++;
1591    }
1592    pcRPS->setInterRPSPrediction(true);
1593    pcRPS->setNumRefIdc(iNewIdc);
1594    pcRPS->setDeltaRPS(deltaRPS); 
1595    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1596  }
1597
1598  this->setRPS(pcRPS);
1599  this->setRPSidx(-1);
1600}
1601
1602/** get AC and DC values for weighted pred
1603 * \param *wp
1604 * \returns Void
1605 */
1606Void  TComSlice::getWpAcDcParam(wpACDCParam *&wp)
1607{
1608  wp = m_weightACDCParam;
1609}
1610
1611/** init AC and DC values for weighted pred
1612 * \returns Void
1613 */
1614Void  TComSlice::initWpAcDcParam()
1615{
1616  for(Int iComp = 0; iComp < 3; iComp++ )
1617  {
1618    m_weightACDCParam[iComp].iAC = 0;
1619    m_weightACDCParam[iComp].iDC = 0;
1620  }
1621}
1622
1623/** get WP tables for weighted pred
1624 * \param RefPicList
1625 * \param iRefIdx
1626 * \param *&wpScalingParam
1627 * \returns Void
1628 */
1629Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
1630{
1631  wp = m_weightPredTable[e][iRefIdx];
1632}
1633
1634/** reset Default WP tables settings : no weight.
1635 * \param wpScalingParam
1636 * \returns Void
1637 */
1638Void  TComSlice::resetWpScaling()
1639{
1640  for ( Int e=0 ; e<2 ; e++ )
1641  {
1642    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1643    {
1644      for ( Int yuv=0 ; yuv<3 ; yuv++ )
1645      {
1646        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1647        pwp->bPresentFlag      = false;
1648        pwp->uiLog2WeightDenom = 0;
1649        pwp->uiLog2WeightDenom = 0;
1650        pwp->iWeight           = 1;
1651        pwp->iOffset           = 0;
1652      }
1653    }
1654  }
1655}
1656
1657/** init WP table
1658 * \returns Void
1659 */
1660Void  TComSlice::initWpScaling()
1661{
1662  for ( Int e=0 ; e<2 ; e++ )
1663  {
1664    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1665    {
1666      for ( Int yuv=0 ; yuv<3 ; yuv++ )
1667      {
1668        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1669        if ( !pwp->bPresentFlag ) 
1670        {
1671          // Inferring values not present :
1672          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1673          pwp->iOffset = 0;
1674        }
1675
1676        pwp->w      = pwp->iWeight;
1677        Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
1678        pwp->o      = pwp->iOffset << (bitDepth-8);
1679        pwp->shift  = pwp->uiLog2WeightDenom;
1680        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1681      }
1682    }
1683  }
1684}
1685
1686// ------------------------------------------------------------------------------------------------
1687// Video parameter set (VPS)
1688// ------------------------------------------------------------------------------------------------
1689TComVPS::TComVPS()
1690: m_VPSId                     (  0)
1691, m_uiMaxTLayers              (  1)
1692#if H_MV
1693, m_uiMaxLayersMinus1         (  0)
1694#else
1695, m_uiMaxLayers               (  1)
1696#endif
1697, m_bTemporalIdNestingFlag    (false)
1698, m_numHrdParameters          (  0)
1699#if H_MV
1700, m_maxLayerId             (  0)
1701#else
1702, m_maxNuhReservedZeroLayerId (  0)
1703#endif
1704, m_hrdParameters             (NULL)
1705, m_hrdOpSetIdx               (NULL)
1706, m_cprmsPresentFlag          (NULL)
1707#if H_MV_6_HRD_O0217_13
1708, m_dpbSize                   (NULL)
1709#endif
1710#if H_MV
1711, m_vpsVUI                 (  NULL )
1712#endif
1713{
1714  for( Int i = 0; i < MAX_TLAYER; i++)
1715  {
1716    m_numReorderPics[i] = 0;
1717    m_uiMaxDecPicBuffering[i] = 1; 
1718    m_uiMaxLatencyIncrease[i] = 0;
1719  }
1720#if H_MV
1721  for (Int lsIdx = 0; lsIdx < MAX_VPS_OP_SETS_PLUS1; lsIdx++ )
1722  { 
1723    for( Int layerId = 0; layerId < MAX_VPS_NUH_LAYER_ID_PLUS1; layerId++ )
1724    {
1725#if H_MV_6_HRD_O0217_13
1726      m_layerIdIncludedFlag[lsIdx][layerId] = (( lsIdx == 0 ) && ( layerId == 0 )) ; 
1727#else
1728      m_layerIdIncludedFlag[lsIdx][layerId] = false; 
1729#endif
1730    }
1731  } 
1732
1733  m_vpsNumberLayerSetsMinus1     = -1; 
1734  m_vpsNumProfileTierLevelMinus1 = -1; 
1735   
1736  for ( Int i = 0; i < MAX_VPS_PROFILE_TIER_LEVEL; i++)
1737  {
1738    m_profileRefMinus1[ i ] = -1; 
1739  }
1740   
1741  m_moreOutputLayerSetsThanDefaultFlag = false;   
1742  m_numAddOutputLayerSetsMinus1        = -1;   
1743#if H_MV_6_PS_0109_25
1744  m_defaultOneTargetOutputLayerIdc     = 0; 
1745#else
1746  m_defaultOneTargetOutputLayerFlag    = false; 
1747#endif
1748 
1749  for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
1750  {
1751    m_outputLayerSetIdxMinus1[i]  = -1; 
1752    m_profileLevelTierIdx[i]      = 0; 
1753    for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
1754    {
1755      m_outputLayerFlag[i][j] = false; 
1756    }
1757  }
1758#if H_MV_6_GEN_0153_28
1759  m_altOutputLayerFlag       = false; 
1760#endif
1761  m_maxOneActiveRefLayerFlag = false; 
1762  m_directDepTypeLenMinus2   = 0;         
1763 
1764
1765  m_avcBaseLayerFlag = false;
1766  m_vpsVuiOffset     = 0; 
1767  m_splittingFlag    = false;
1768 
1769  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
1770  {
1771    m_scalabilityMaskFlag[i] = false;
1772    m_dimensionIdLen [i]  = -1; 
1773  }
1774
1775  m_vpsNuhLayerIdPresentFlag = false;
1776
1777  for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
1778  {
1779    m_vpsProfilePresentFlag   [i] = false;
1780    m_profileRefMinus1[i] = 0;
1781    m_outputLayerSetIdxMinus1       [i] = 0;
1782    for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
1783    {
1784      m_outputLayerFlag[i][j] = false;
1785    }
1786  }
1787
1788  for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
1789  {
1790    m_layerIdInVps[i] =  (i == 0 ) ? 0 : -1;         
1791  }
1792
1793  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1794  {
1795    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1; 
1796    m_numDirectRefLayers[i] = 0; 
1797#if !H_MV_6_ILDDS_O0225_30
1798    m_maxTidIlRefPicPlus1[i] = 7;
1799#endif
1800    m_vpsRepFormatIdx    [i] = 0; 
1801#if H_MV_6_MISC_O0062_31
1802    m_pocLsbNotPresentFlag[i] = 0;
1803#endif
1804    m_repFormat          [i] = NULL; 
1805    m_viewIdVal          [i] = 0; 
1806
1807#if H_3D
1808    m_viewIndex         [i] = -1; 
1809    m_vpsDepthModesFlag [i] = false;
1810#if H_3D_DIM_DLT
1811#if !DLT_DIFF_CODING_IN_PPS
1812    m_bUseDLTFlag         [i] = false;
1813   
1814    // allocate some memory and initialize with default mapping
1815    m_iNumDepthmapValues[i] = ((1 << g_bitDepthY)-1)+1;
1816    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
1817   
1818    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
1819    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
1820   
1821    //default mapping
1822    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
1823    {
1824      m_iDepthValue2Idx[i][d] = d;
1825      m_iIdx2DepthValue[i][d] = d;
1826    }
1827#endif
1828#endif
1829#if H_3D
1830    m_ivMvScalingFlag = true; 
1831#endif
1832#endif
1833
1834    for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
1835    {
1836      m_directDependencyFlag[i][j] = false;
1837      m_directDependencyType[i][j] = -1; 
1838      m_refLayerId[i][j]           = -1; 
1839#if H_MV_6_ILDDS_O0225_30     
1840      m_maxTidIlRefPicsPlus1[i][j]  = 7;
1841#endif
1842    }
1843
1844    for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
1845    {
1846      m_dimensionId[i][j] = 0;
1847    }
1848#if H_3D_ARP
1849    m_uiUseAdvResPred[i]  = 0;
1850    m_uiARPStepNum[i]     = 1;
1851#endif
1852  }
1853  m_vpsVUI = new TComVPSVUI; 
1854#if H_MV_6_HRD_O0217_13
1855  m_dpbSize = new TComDpbSize; 
1856#endif
1857#
1858#if H_3D
1859  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1860  {
1861#if H_3D_IV_MERGE
1862    m_ivMvPredFlag         [ i ] = false;
1863#if H_3D_SPIVMP
1864    m_iSubPULog2Size       [ i ] = 0;
1865#endif
1866#endif
1867#if H_3D_VSP
1868    m_viewSynthesisPredFlag[ i ] = false;
1869#endif
1870#if H_3D_NBDV_REF
1871    m_depthRefinementFlag  [ i ] = false;
1872#endif
1873#if H_3D_INTER_SDC
1874    m_bInterSDCFlag        [ i ] = false;
1875#endif
1876#if H_3D_IV_MERGE
1877    m_bMPIFlag             [ i ] = false;
1878#endif
1879  } 
1880#endif
1881#endif
1882}
1883
1884TComVPS::~TComVPS()
1885{
1886if( m_hrdParameters    != NULL )     delete[] m_hrdParameters;
1887  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
1888  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
1889#if H_MV
1890  if ( m_vpsVUI          != NULL )     delete m_vpsVUI; 
1891#if H_MV_6_HRD_O0217_13
1892  if ( m_dpbSize         != NULL )     delete m_dpbSize; 
1893#endif
1894
1895  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1896  {
1897    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];   
1898#if H_3D_DIM_DLT
1899#if !DLT_DIFF_CODING_IN_PPS
1900    if ( m_iDepthValue2Idx[i] != 0 ) 
1901    {
1902       xFree( m_iDepthValue2Idx[i] );
1903       m_iDepthValue2Idx[i] = 0; 
1904    }
1905
1906    if ( m_iIdx2DepthValue[i] != 0 ) 
1907    {
1908      xFree( m_iIdx2DepthValue[i] );
1909      m_iIdx2DepthValue[i] = 0; 
1910    }
1911#endif
1912#endif
1913  }
1914#endif
1915#if CAM_HLS_F0136_F0045_F0082
1916  deleteCamPars();
1917#endif
1918}
1919
1920#if H_3D_DIM_DLT
1921#if !DLT_DIFF_CODING_IN_PPS
1922  Void TComVPS::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
1923  {
1924    if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
1925      return;
1926   
1927    // copy idx2DepthValue to internal array
1928    memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
1929   
1930    UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
1931    for(Int p=0; p<=uiMaxDepthValue; p++)
1932    {
1933      Int iIdxDown    = 0;
1934      Int iIdxUp      = iNumDepthValues-1;
1935      Bool bFound     = false;
1936     
1937      // iterate over indices to find lower closest depth
1938      Int i = 1;
1939      while(!bFound && i<iNumDepthValues)
1940      {
1941        if( m_iIdx2DepthValue[layerIdInVps][i] > p )
1942        {
1943          iIdxDown  = i-1;
1944          bFound    = true;
1945        }
1946       
1947        i++;
1948      }
1949      // iterate over indices to find upper closest depth
1950      i = iNumDepthValues-2;
1951      bFound = false;
1952      while(!bFound && i>=0)
1953      {
1954        if( m_iIdx2DepthValue[layerIdInVps][i] < p )
1955        {
1956          iIdxUp  = i+1;
1957          bFound    = true;
1958        }
1959       
1960        i--;
1961      }
1962     
1963      // assert monotony
1964      assert(iIdxDown<=iIdxUp);
1965     
1966      // assign closer depth value/idx
1967      if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
1968      {
1969        m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
1970      }
1971      else
1972      {
1973        m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
1974      }
1975     
1976    }
1977   
1978    // update DLT variables
1979    m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
1980    m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
1981  }
1982#endif
1983#endif
1984
1985#if H_MV
1986
1987Bool TComVPS::checkVPSExtensionSyntax()
1988{
1989  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
1990  {
1991    // check layer_id_in_nuh constraint
1992    assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
1993  }
1994  return true; 
1995}
1996
1997Int TComVPS::getNumScalabilityTypes()
1998{
1999  return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
2000}
2001
2002Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
2003{
2004  assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES ); 
2005  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
2006  Int scalIdx = 0; 
2007  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
2008  {
2009    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
2010
2011  }
2012
2013  return scalIdx; 
2014}
2015Void TComVPS::setScalabilityMaskFlag( UInt val )
2016{
2017  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ ) 
2018  {
2019    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
2020  }
2021}
2022
2023Void TComVPS::setRefLayers()
2024{
2025  for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
2026  {
2027    Int iNuhLId = getLayerIdInNuh( i ); 
2028    m_numDirectRefLayers[ iNuhLId ] = 0; 
2029    for( Int j = 0; j < i; j++ )
2030    {
2031      if( getDirectDependencyFlag(i , j) )
2032      {
2033        m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
2034      }
2035    }
2036  }
2037}
2038
2039Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
2040{
2041  assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );     
2042  Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];   
2043  assert ( refLayerIdInNuh >= 0 ); 
2044  return refLayerIdInNuh;
2045}
2046
2047Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
2048{
2049  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
2050}
2051
2052#if H_3D
2053Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
2054{
2055  Int foundLayerIdinNuh = -1; 
2056
2057  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
2058  {
2059    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps ); 
2060    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
2061    {
2062      foundLayerIdinNuh = layerIdInNuh; 
2063      break; 
2064    }
2065  }
2066  assert( foundLayerIdinNuh != -1 ); 
2067
2068  return foundLayerIdinNuh;
2069}
2070#if CAM_HLS_F0136_F0045_F0082
2071Void TComVPS::createCamPars(Int iNumViews)
2072{
2073  Int i = 0, j = 0;
2074
2075  m_bCamParPresent = new Bool[ iNumViews ];
2076  m_bCamParInSliceHeader = new Bool[ iNumViews ];
2077
2078  m_aaaiCodedScale = new Int**[ iNumViews ];
2079  m_aaaiCodedOffset = new Int**[ iNumViews ];
2080  for ( i = 0; i < iNumViews ; i++ )
2081  {
2082    m_aaaiCodedScale[i] = new Int*[ 2 ];
2083    m_aaaiCodedOffset[i] = new Int*[ 2 ];
2084    for ( j = 0; j < 2; j++ )
2085    {
2086      m_aaaiCodedScale[i][j] = new Int[ MAX_NUM_LAYERS ];
2087      m_aaaiCodedOffset[i][j] = new Int[ MAX_NUM_LAYERS ];
2088      for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
2089      {
2090        m_aaaiCodedScale[i][j][k] = 0;
2091        m_aaaiCodedOffset[i][j][k] = 0;
2092      }
2093    }
2094  }
2095}
2096
2097Void TComVPS::deleteCamPars()
2098{
2099  Int iNumViews = getNumViews();
2100  Int i = 0, j = 0;
2101
2102  if ( m_bCamParPresent != NULL )
2103  {
2104    delete [] m_bCamParPresent;
2105  }
2106  if ( m_bCamParInSliceHeader != NULL )
2107  {
2108    delete [] m_bCamParInSliceHeader;
2109  }
2110
2111  if ( m_aaaiCodedScale != NULL )
2112  {
2113    for ( i = 0; i < iNumViews ; i++ )
2114    {
2115      for ( j = 0; j < 2; j++ )
2116      {
2117        delete [] m_aaaiCodedScale[i][j];
2118      }
2119      delete [] m_aaaiCodedScale[i];
2120    }
2121    delete [] m_aaaiCodedScale;
2122  }
2123
2124  if ( m_aaaiCodedOffset != NULL )
2125  {
2126    for ( i = 0; i < iNumViews ; i++ )
2127    {
2128      for ( j = 0; j < 2; j++ )
2129      {
2130        delete [] m_aaaiCodedOffset[i][j];
2131      }
2132      delete [] m_aaaiCodedOffset[i];
2133    }
2134    delete [] m_aaaiCodedOffset;
2135  }
2136}
2137
2138
2139Void
2140  TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
2141{
2142  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
2143
2144  m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
2145  m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent  : false );
2146  m_bCamParInSliceHeader[ uiViewIndex ]  = ( (uiViewIndex != 0)? bCamParSlice  : false );
2147
2148  if( !m_bCamParInSliceHeader[ uiViewIndex ] )
2149  {
2150    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
2151    {
2152      m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
2153      m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
2154      m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
2155      m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
2156    }
2157  }
2158}
2159#endif // CAM_HLS_F0136_F0045_F0082
2160
2161#endif // H_3D
2162
2163
2164Int TComVPS::xGetDimBitOffset( Int j )
2165{
2166  Int dimBitOffset = 0; 
2167  if ( getSplittingFlag() && j == getNumScalabilityTypes() )
2168  {
2169     dimBitOffset = 6; 
2170  }
2171  else
2172  {
2173    for (Int dimIdx = 0; dimIdx <= j-1; dimIdx++)
2174    {
2175      dimBitOffset += getDimensionIdLen( dimIdx ); 
2176    }
2177  }
2178  return dimBitOffset; 
2179}
2180
2181Int TComVPS::inferDimensionId( Int i, Int j )
2182{
2183    return ( ( getLayerIdInNuh( i ) & ( (1 << xGetDimBitOffset( j + 1 ) ) - 1) ) >> xGetDimBitOffset( j ) ); 
2184}
2185
2186Int TComVPS::inferLastDimsionIdLenMinus1()
2187{
2188  return ( 5 - xGetDimBitOffset( getNumScalabilityTypes() - 1 ) ); 
2189}
2190
2191Int TComVPS::getNumLayersInIdList( Int lsIdx )
2192{
2193  assert( lsIdx >= 0 ); 
2194  assert( lsIdx <= getVpsNumLayerSetsMinus1() ); 
2195#if H_MV_6_HRD_O0217_13
2196  return (Int) m_layerSetLayerIdList[ lsIdx ].size(); 
2197#else
2198  Int numLayersInIdList = 0; 
2199  for (Int layerId = 0; layerId < getVpsMaxLayerId(); layerId++ )
2200  {
2201    numLayersInIdList += ( getLayerIdIncludedFlag( lsIdx, layerId ) ); 
2202  }
2203  return numLayersInIdList;
2204#endif
2205}
2206
2207#if H_MV_6_HRD_O0217_13
2208Int    TComVPS::getNumOutputLayerSets() 
2209{
2210  Int numOutputLayerSets = getVpsNumberLayerSetsMinus1( ) + 1; 
2211  if ( getMoreOutputLayerSetsThanDefaultFlag( ) )
2212  {     
2213    numOutputLayerSets += (getNumAddOutputLayerSetsMinus1( ) + 1); 
2214}
2215  return numOutputLayerSets; 
2216}
2217#endif
2218
2219Int TComVPS::getNumViews()
2220{
2221  Int numViews = 1; 
2222  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
2223  {
2224    Int lId = getLayerIdInNuh( i ); 
2225    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
2226    {
2227      numViews++; 
2228    }   
2229  }
2230
2231  return numViews;
2232}
2233
2234Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
2235{
2236  assert( depth < 65 ); 
2237  Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps ); 
2238
2239  for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
2240  {
2241    if ( getDirectDependencyFlag( depLayeridInVps, i ) )
2242    {
2243      dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ ); 
2244    }
2245  }
2246  return dependentFlag;
2247}
2248
2249#if H_MV_6_HRD_O0217_13
2250Void TComVPS::deriveLayerSetLayerIdList()
2251{
2252  m_layerSetLayerIdList.resize( getVpsNumLayerSetsMinus1() + 1 ); 
2253  for (Int i = 0; i <= getVpsNumLayerSetsMinus1(); i++ )
2254  {
2255    for( Int m = 0; m  <= getVpsMaxLayerId(); m++ )
2256    {
2257      if( getLayerIdIncludedFlag( i, m) ) 
2258      {
2259        m_layerSetLayerIdList[ i ].push_back( m );       
2260      }
2261    }
2262  }
2263}
2264
2265Void TComVPS::deriveTargetLayerIdLists()
2266{
2267  m_targetDecLayerIdLists.resize( getNumOutputLayerSets() ); 
2268  m_targetOptLayerIdLists.resize( getNumOutputLayerSets() ); 
2269
2270  for (Int targetOptLayerSetIdx = 0; targetOptLayerSetIdx < getNumOutputLayerSets(); targetOptLayerSetIdx++ )
2271  {
2272    Int targetDecLayerSetIdx = getOutputLayerSetIdxMinus1( targetOptLayerSetIdx ) + 1;     
2273    Int lsIdx                = targetDecLayerSetIdx;
2274
2275    for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
2276    {
2277      m_targetDecLayerIdLists[targetOptLayerSetIdx].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] ); 
2278      if( getOutputLayerFlag( targetOptLayerSetIdx, j  )) // This seems to be wrong in draft text
2279      {
2280        m_targetOptLayerIdLists[targetOptLayerSetIdx].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2281      }
2282    } 
2283  }
2284}
2285#endif
2286#endif // H_MV
2287
2288// ------------------------------------------------------------------------------------------------
2289// Sequence parameter set (SPS)
2290// ------------------------------------------------------------------------------------------------
2291
2292TComSPS::TComSPS()
2293: m_SPSId                     (  0)
2294, m_VPSId                     (  0)
2295, m_chromaFormatIdc           (CHROMA_420)
2296, m_uiMaxTLayers              (  1)
2297// Structure
2298, m_picWidthInLumaSamples     (352)
2299, m_picHeightInLumaSamples    (288)
2300, m_log2MinCodingBlockSize    (  0)
2301, m_log2DiffMaxMinCodingBlockSize (0)
2302, m_uiMaxCUWidth              ( 32)
2303, m_uiMaxCUHeight             ( 32)
2304, m_uiMaxCUDepth              (  3)
2305, m_bLongTermRefsPresent      (false)
2306, m_uiQuadtreeTULog2MaxSize   (  0)
2307, m_uiQuadtreeTULog2MinSize   (  0)
2308, m_uiQuadtreeTUMaxDepthInter (  0)
2309, m_uiQuadtreeTUMaxDepthIntra (  0)
2310// Tool list
2311, m_usePCM                   (false)
2312, m_pcmLog2MaxSize            (  5)
2313, m_uiPCMLog2MinSize          (  7)
2314#if H_3D_QTLPC
2315, m_bUseQTL                   (false)
2316, m_bUsePC                    (false)
2317#endif
2318, m_bitDepthY                 (  8)
2319, m_bitDepthC                 (  8)
2320, m_qpBDOffsetY               (  0)
2321, m_qpBDOffsetC               (  0)
2322, m_useLossless               (false)
2323, m_uiPCMBitDepthLuma         (  8)
2324, m_uiPCMBitDepthChroma       (  8)
2325, m_bPCMFilterDisableFlag     (false)
2326, m_uiBitsForPOC              (  8)
2327, m_numLongTermRefPicSPS    (  0) 
2328, m_uiMaxTrSize               ( 32)
2329, m_bUseSAO                   (false) 
2330, m_bTemporalIdNestingFlag    (false)
2331, m_scalingListEnabledFlag    (false)
2332, m_useStrongIntraSmoothing   (false)
2333, m_vuiParametersPresentFlag  (false)
2334, m_vuiParameters             ()
2335#if H_MV
2336, m_pcVPS                     ( NULL )
2337, m_spsInferScalingListFlag   ( false )
2338, m_spsScalingListRefLayerId  ( 0 )
2339
2340#if !H_MV_6_PS_REP_FORM_18_19_20
2341, m_updateRepFormatFlag       ( true ) 
2342#else
2343, m_updateRepFormatFlag       ( false ) 
2344, m_spsRepFormatIdx           ( 0 )
2345#endif
2346, m_interViewMvVertConstraintFlag (false)
2347#endif
2348#if H_3D
2349, m_bCamParInSliceHeader      (false)
2350#endif
2351{
2352  for ( Int i = 0; i < MAX_TLAYER; i++ )
2353  {
2354    m_uiMaxLatencyIncrease[i] = 0;
2355    m_uiMaxDecPicBuffering[i] = 1;
2356    m_numReorderPics[i]       = 0;
2357  }
2358  m_scalingList = new TComScalingList;
2359  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2360  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2361#if H_MV_6_PSEM_O0142_3
2362  m_spsExtensionFlag = false; 
2363  for( Int i = 0; i < PS_EX_T_MAX_NUM; i++ ) 
2364  {
2365    m_spsExtensionTypeFlag[ i ] = false;
2366  }
2367#endif
2368#if H_MV_6_SHVC_O0098_36
2369  m_numScaledRefLayerOffsets = 0; 
2370
2371  for (Int i = 0; i < MAX_NUM_SCALED_REF_LAYERS; i++ )
2372  {
2373    m_scaledRefLayerId             [i] = -1;
2374  }
2375
2376  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
2377  {
2378    m_scaledRefLayerLeftOffset     [i] = 0;
2379    m_scaledRefLayerTopOffset      [i] = 0;
2380    m_scaledRefLayerRightOffset    [i] = 0;
2381    m_scaledRefLayerBottomOffset   [i] = 0;
2382  }
2383#endif
2384}
2385
2386TComSPS::~TComSPS()
2387{
2388  delete m_scalingList;
2389  m_RPSList.destroy();
2390}
2391
2392Void  TComSPS::createRPSList( Int numRPS )
2393{ 
2394  m_RPSList.destroy();
2395  m_RPSList.create(numRPS);
2396}
2397
2398Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2399{
2400  if( !getVuiParametersPresentFlag() )
2401  {
2402    return;
2403  }
2404
2405  TComVUI *vui = getVuiParameters();
2406  TComHRD *hrd = vui->getHrdParameters();
2407
2408  TimingInfo *timingInfo = vui->getTimingInfo();
2409  timingInfo->setTimingInfoPresentFlag( true );
2410  switch( frameRate )
2411  {
2412  case 24:
2413    timingInfo->setNumUnitsInTick( 1125000 );    timingInfo->setTimeScale    ( 27000000 );
2414    break;
2415  case 25:
2416    timingInfo->setNumUnitsInTick( 1080000 );    timingInfo->setTimeScale    ( 27000000 );
2417    break;
2418  case 30:
2419    timingInfo->setNumUnitsInTick( 900900 );     timingInfo->setTimeScale    ( 27000000 );
2420    break;
2421  case 50:
2422    timingInfo->setNumUnitsInTick( 540000 );     timingInfo->setTimeScale    ( 27000000 );
2423    break;
2424  case 60:
2425    timingInfo->setNumUnitsInTick( 450450 );     timingInfo->setTimeScale    ( 27000000 );
2426    break;
2427  default:
2428    timingInfo->setNumUnitsInTick( 1001 );       timingInfo->setTimeScale    ( 60000 );
2429    break;
2430  }
2431
2432  Bool rateCnt = ( bitRate > 0 );
2433  hrd->setNalHrdParametersPresentFlag( rateCnt );
2434  hrd->setVclHrdParametersPresentFlag( rateCnt );
2435
2436  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2437
2438  if( hrd->getSubPicCpbParamsPresentFlag() )
2439  {
2440    hrd->setTickDivisorMinus2( 100 - 2 );                          //
2441    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
2442    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2443    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2444  }
2445  else
2446  {
2447    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false ); 
2448  }
2449
2450  hrd->setBitRateScale( 4 );                                       // in units of 2~( 6 + 4 ) = 1,024 bps
2451  hrd->setCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2452  hrd->setDuCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2453 
2454  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2455  if( randomAccess )
2456  {
2457    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
2458    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
2459  }
2460  else
2461  {
2462    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
2463    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
2464  }
2465
2466/*
2467   Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2468*/
2469  Int i, j;
2470  UInt birateValue, cpbSizeValue;
2471  UInt ducpbSizeValue;
2472  UInt duBitRateValue = 0;
2473
2474  for( i = 0; i < MAX_TLAYER; i ++ )
2475  {
2476    hrd->setFixedPicRateFlag( i, 1 );
2477    hrd->setPicDurationInTcMinus1( i, 0 );
2478    hrd->setLowDelayHrdFlag( i, 0 );
2479    hrd->setCpbCntMinus1( i, 0 );
2480
2481    birateValue  = bitRate;
2482    cpbSizeValue = bitRate;                                     // 1 second
2483    ducpbSizeValue = bitRate/numDU;
2484    duBitRateValue = bitRate;
2485    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2486    {
2487      hrd->setBitRateValueMinus1( i, j, 0, ( birateValue  - 1 ) );
2488      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2489      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
2490      hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2491
2492      hrd->setBitRateValueMinus1( i, j, 1, ( birateValue  - 1) );
2493      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2494      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
2495      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2496      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2497    }
2498  }
2499}
2500const Int TComSPS::m_winUnitX[]={1,2,2,1};
2501const Int TComSPS::m_winUnitY[]={1,2,1,1};
2502
2503TComPPS::TComPPS()
2504: m_PPSId                       (0)
2505, m_SPSId                       (0)
2506, m_picInitQPMinus26            (0)
2507, m_useDQP                      (false)
2508, m_bConstrainedIntraPred       (false)
2509, m_bSliceChromaQpFlag          (false)
2510, m_pcSPS                       (NULL)
2511, m_uiMaxCuDQPDepth             (0)
2512, m_uiMinCuDQPSize              (0)
2513, m_chromaCbQpOffset            (0)
2514, m_chromaCrQpOffset            (0)
2515, m_numRefIdxL0DefaultActive    (1)
2516, m_numRefIdxL1DefaultActive    (1)
2517, m_TransquantBypassEnableFlag  (false)
2518, m_useTransformSkip             (false)
2519, m_dependentSliceSegmentsEnabledFlag    (false)
2520, m_tilesEnabledFlag               (false)
2521, m_entropyCodingSyncEnabledFlag   (false)
2522, m_loopFilterAcrossTilesEnabledFlag  (true)
2523, m_uniformSpacingFlag           (0)
2524, m_iNumColumnsMinus1            (0)
2525, m_puiColumnWidth               (NULL)
2526, m_iNumRowsMinus1               (0)
2527, m_puiRowHeight                 (NULL)
2528, m_iNumSubstreams             (1)
2529, m_signHideFlag(0)
2530, m_cabacInitPresentFlag        (false)
2531, m_encCABACTableIdx            (I_SLICE)
2532, m_sliceHeaderExtensionPresentFlag    (false)
2533, m_loopFilterAcrossSlicesEnabledFlag (false)
2534, m_listsModificationPresentFlag(  0)
2535, m_numExtraSliceHeaderBits(0)
2536#if H_MV
2537, m_ppsInferScalingListFlag(false)
2538, m_ppsScalingListRefLayerId(0)
2539#if DLT_DIFF_CODING_IN_PPS
2540, m_pcDLT(NULL)
2541#endif
2542#endif
2543{
2544  m_scalingList = new TComScalingList;
2545}
2546
2547TComPPS::~TComPPS()
2548{
2549  if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2550  {
2551    if (m_puiColumnWidth) delete [] m_puiColumnWidth; 
2552    m_puiColumnWidth = NULL;
2553  }
2554  if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2555  {
2556    if (m_puiRowHeight) delete [] m_puiRowHeight;
2557    m_puiRowHeight = NULL;
2558  }
2559  delete m_scalingList;
2560}
2561
2562#if DLT_DIFF_CODING_IN_PPS
2563TComDLT::TComDLT()
2564: m_bDltPresentFlag(false)
2565, m_iNumDepthViews(0)
2566, m_uiDepthViewBitDepth(8)
2567{
2568  m_uiDepthViewBitDepth = g_bitDepthY; 
2569
2570  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2571  {
2572    m_bUseDLTFlag                 [i] = false;
2573    m_bInterViewDltPredEnableFlag [i] = false;
2574
2575    // allocate some memory and initialize with default mapping
2576    m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
2577    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
2578
2579    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2580    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2581
2582    //default mapping
2583    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
2584    {
2585      m_iDepthValue2Idx[i][d] = d;
2586      m_iIdx2DepthValue[i][d] = d;
2587    }
2588  }
2589}
2590
2591TComDLT::~TComDLT()
2592{
2593  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2594  {
2595    if ( m_iDepthValue2Idx[i] != NULL ) 
2596    {
2597      xFree( m_iDepthValue2Idx[i] );
2598      m_iDepthValue2Idx[i] = NULL; 
2599    }
2600
2601    if ( m_iIdx2DepthValue[i] != NULL ) 
2602    {
2603      xFree( m_iIdx2DepthValue[i] );
2604      m_iIdx2DepthValue[i] = NULL; 
2605    }
2606  }
2607}
2608
2609Void TComDLT::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
2610{
2611  if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
2612    return;
2613
2614  // copy idx2DepthValue to internal array
2615  memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
2616
2617  UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
2618  for(Int p=0; p<=uiMaxDepthValue; p++)
2619  {
2620    Int iIdxDown    = 0;
2621    Int iIdxUp      = iNumDepthValues-1;
2622    Bool bFound     = false;
2623
2624    // iterate over indices to find lower closest depth
2625    Int i = 1;
2626    while(!bFound && i<iNumDepthValues)
2627    {
2628      if( m_iIdx2DepthValue[layerIdInVps][i] > p )
2629      {
2630        iIdxDown  = i-1;
2631        bFound    = true;
2632      }
2633
2634      i++;
2635    }
2636    // iterate over indices to find upper closest depth
2637    i = iNumDepthValues-2;
2638    bFound = false;
2639    while(!bFound && i>=0)
2640    {
2641      if( m_iIdx2DepthValue[layerIdInVps][i] < p )
2642      {
2643        iIdxUp  = i+1;
2644        bFound    = true;
2645      }
2646
2647      i--;
2648    }
2649
2650    // assert monotony
2651    assert(iIdxDown<=iIdxUp);
2652
2653    // assign closer depth value/idx
2654    if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
2655    {
2656      m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
2657    }
2658    else
2659    {
2660      m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
2661    }
2662
2663  }
2664
2665  // update DLT variables
2666  m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
2667  m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
2668}
2669
2670#if H_3D_DELTA_DLT
2671Void TComDLT::getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum )
2672{
2673  Bool abBM0[ 256 ];
2674  Bool abBM1[ 256 ];
2675 
2676  memset( abBM0, 0, sizeof( abBM0 ));
2677  memset( abBM1, 0, sizeof( abBM1 ));
2678 
2679  // convert reference DLT to bit string
2680  for( Int i = 0; i < uiDLTInRefNum; i++ )
2681  {
2682    abBM0[ piDLTInRef[ i ] ] = true;
2683  }
2684  // convert internal DLT to bit string
2685  for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
2686  {
2687    abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
2688  }
2689 
2690  *puiDeltaDLTOutNum = 0;
2691  for( Int i = 0; i < 256; i++ )
2692  {
2693    if( abBM0[ i ] ^ abBM1[ i ] )
2694    {
2695      piDeltaDLTOut[ *puiDeltaDLTOutNum ] = i;
2696      *puiDeltaDLTOutNum = *puiDeltaDLTOutNum + 1;
2697    }
2698  }
2699}
2700
2701Void TComDLT::setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum )
2702{
2703  Bool abBM0[ 256 ];
2704  Bool abBM1[ 256 ];
2705 
2706  memset( abBM0, 0, sizeof( abBM0 ));
2707  memset( abBM1, 0, sizeof( abBM1 ));
2708 
2709  // convert reference DLT to bit string
2710  for( Int i = 0; i < uiDLTInRefNum; i++ )
2711  {
2712    abBM0[ piDLTInRef[ i ] ] = true;
2713  }
2714  // convert delta DLT to bit string
2715  for( Int i = 0; i < uiDeltaDLTInNum; i++ )
2716  {
2717    abBM1[ piDeltaDLTIn[ i ] ] = true;
2718  }
2719 
2720  Int aiIdx2DepthValue[256];
2721  UInt uiNumDepthValues = 0;
2722  memset( aiIdx2DepthValue, 0, sizeof( aiIdx2DepthValue ));
2723 
2724  for( Int i = 0; i < 256; i++ )
2725  {
2726    if( abBM0[ i ] ^ abBM1[ i ] )
2727    {
2728      aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
2729    }
2730  }
2731 
2732  // update internal tables
2733  setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
2734}
2735#endif
2736
2737#endif
2738
2739#if H_MV
2740Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
2741{
2742  if ( layerIdCurr > 0 )
2743  { 
2744#if H_MV_6_PS_REP_FORM_18_19_20
2745    Int            repFormatIdx = getUpdateRepFormatFlag() ?  getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
2746    TComRepFormat* repFormat    = vps->getRepFormat( repFormatIdx ); 
2747#else
2748    TComRepFormat* repFormat = vps->getRepFormat( vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ); 
2749    if ( !getUpdateRepFormatFlag() )
2750    {       
2751#endif
2752      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
2753      //// ToDo: add when supported:
2754      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
2755
2756      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
2757      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
2758
2759      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
2760      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
2761
2762      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2763      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
2764#if !H_MV_6_PS_REP_FORM_18_19_20
2765    }
2766    else
2767#else
2768    if ( getLayerId() > 0 && getUpdateRepFormatFlag() )
2769#endif
2770    {
2771      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
2772      //// ToDo: add when supported:
2773      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ;
2774
2775      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    ); 
2776      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   ); 
2777
2778      assert( getBitDepthY()              <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
2779      assert( getBitDepthC()              <= repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2780    }
2781  }
2782
2783  // Set conformance window
2784  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
2785  getConformanceWindow().scaleOffsets( scal );
2786  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
2787}
2788
2789Void TComSPS::inferScalingList( TComSPS* spsSrc )
2790{
2791  if ( getSpsInferScalingListFlag() ) 
2792  {
2793    assert( spsSrc != NULL ); 
2794    assert( !spsSrc->getSpsInferScalingListFlag() );             
2795    getScalingList()->inferFrom( spsSrc->getScalingList() ); 
2796  }
2797}
2798#endif
2799#if H_3D
2800#if !CAM_HLS_F0136_F0045_F0082
2801Void
2802TComSPS::initCamParaSPS( UInt uiViewIndex, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
2803{
2804  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
2805 
2806  m_uiCamParPrecision     = ( uiViewIndex ? uiCamParPrecision : 0 );
2807  m_bCamParInSliceHeader  = ( uiViewIndex ? bCamParSlice  : false );
2808  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
2809  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
2810
2811  if( !m_bCamParInSliceHeader )
2812  {
2813    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
2814    {
2815      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
2816      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
2817      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
2818      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
2819    }
2820  }
2821}
2822#endif
2823#endif
2824TComReferencePictureSet::TComReferencePictureSet()
2825: m_numberOfPictures (0)
2826, m_numberOfNegativePictures (0)
2827, m_numberOfPositivePictures (0)
2828, m_numberOfLongtermPictures (0)
2829, m_interRPSPrediction (0) 
2830, m_deltaRIdxMinus1 (0)   
2831, m_deltaRPS (0) 
2832, m_numRefIdc (0) 
2833{
2834  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2835  ::memset( m_POC, 0, sizeof(m_POC) );
2836  ::memset( m_used, 0, sizeof(m_used) );
2837  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
2838}
2839
2840TComReferencePictureSet::~TComReferencePictureSet()
2841{
2842}
2843
2844Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2845{
2846  m_used[bufferNum] = used;
2847}
2848
2849Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2850{
2851  m_deltaPOC[bufferNum] = deltaPOC;
2852}
2853
2854Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2855{
2856  m_numberOfPictures = numberOfPictures;
2857}
2858
2859Int TComReferencePictureSet::getUsed(Int bufferNum)
2860{
2861  return m_used[bufferNum];
2862}
2863
2864Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2865{
2866  return m_deltaPOC[bufferNum];
2867}
2868
2869Int TComReferencePictureSet::getNumberOfPictures()
2870{
2871  return m_numberOfPictures;
2872}
2873
2874Int TComReferencePictureSet::getPOC(Int bufferNum)
2875{
2876  return m_POC[bufferNum];
2877}
2878
2879Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2880{
2881  m_POC[bufferNum] = POC;
2882}
2883
2884Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2885{
2886  return m_bCheckLTMSB[bufferNum];
2887}
2888
2889Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2890{
2891  m_bCheckLTMSB[bufferNum] = b;
2892}
2893
2894/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2895 * \param uiBufferNum
2896 * \param iRefIdc
2897 * \returns Void
2898 */
2899Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2900{
2901  m_refIdc[bufferNum] = refIdc;
2902}
2903
2904/** get the reference idc value at uiBufferNum
2905 * \param uiBufferNum
2906 * \returns Int
2907 */
2908Int  TComReferencePictureSet::getRefIdc(Int bufferNum)
2909{
2910  return m_refIdc[bufferNum];
2911}
2912
2913/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2914 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
2915 *  +ve values are in increasing order.
2916 * \returns Void
2917 */
2918Void TComReferencePictureSet::sortDeltaPOC()
2919{
2920  // sort in increasing order (smallest first)
2921  for(Int j=1; j < getNumberOfPictures(); j++)
2922  { 
2923    Int deltaPOC = getDeltaPOC(j);
2924    Bool used = getUsed(j);
2925    for (Int k=j-1; k >= 0; k--)
2926    {
2927      Int temp = getDeltaPOC(k);
2928      if (deltaPOC < temp)
2929      {
2930        setDeltaPOC(k+1, temp);
2931        setUsed(k+1, getUsed(k));
2932        setDeltaPOC(k, deltaPOC);
2933        setUsed(k, used);
2934      }
2935    }
2936  }
2937  // flip the negative values to largest first
2938  Int numNegPics = getNumberOfNegativePictures();
2939  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2940  { 
2941    Int deltaPOC = getDeltaPOC(j);
2942    Bool used = getUsed(j);
2943    setDeltaPOC(j, getDeltaPOC(k));
2944    setUsed(j, getUsed(k));
2945    setDeltaPOC(k, deltaPOC);
2946    setUsed(k, used);
2947  }
2948}
2949
2950/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2951 *  A "*" is added to the deltaPOC value if it is Used bu current.
2952 * \returns Void
2953 */
2954Void TComReferencePictureSet::printDeltaPOC()
2955{
2956  printf("DeltaPOC = { ");
2957  for(Int j=0; j < getNumberOfPictures(); j++)
2958  {
2959    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2960  } 
2961  if (getInterRPSPrediction()) 
2962  {
2963    printf("}, RefIdc = { ");
2964    for(Int j=0; j < getNumRefIdc(); j++)
2965    {
2966      printf("%d ", getRefIdc(j));
2967    } 
2968  }
2969  printf("}\n");
2970}
2971
2972TComRPSList::TComRPSList()
2973:m_referencePictureSets (NULL)
2974{
2975}
2976
2977TComRPSList::~TComRPSList()
2978{
2979}
2980
2981Void TComRPSList::create( Int numberOfReferencePictureSets)
2982{
2983  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2984  m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2985}
2986
2987Void TComRPSList::destroy()
2988{
2989  if (m_referencePictureSets)
2990  {
2991    delete [] m_referencePictureSets;
2992  }
2993  m_numberOfReferencePictureSets = 0;
2994  m_referencePictureSets = NULL;
2995}
2996
2997
2998
2999TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
3000{
3001  return &m_referencePictureSets[referencePictureSetNum];
3002}
3003
3004Int TComRPSList::getNumberOfReferencePictureSets()
3005{
3006  return m_numberOfReferencePictureSets;
3007}
3008
3009Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
3010{
3011  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
3012}
3013
3014TComRefPicListModification::TComRefPicListModification()
3015: m_bRefPicListModificationFlagL0 (false)
3016, m_bRefPicListModificationFlagL1 (false)
3017{
3018  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
3019  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
3020}
3021
3022TComRefPicListModification::~TComRefPicListModification()
3023{
3024}
3025
3026TComScalingList::TComScalingList()
3027{
3028  init();
3029}
3030TComScalingList::~TComScalingList()
3031{
3032  destroy();
3033}
3034
3035/** set default quantization matrix to array
3036*/
3037Void TComSlice::setDefaultScalingList()
3038{
3039  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3040  {
3041    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
3042    {
3043      getScalingList()->processDefaultMarix(sizeId, listId);
3044    }
3045  }
3046}
3047/** check if use default quantization matrix
3048 * \returns true if use default quantization matrix in all size
3049*/
3050Bool TComSlice::checkDefaultScalingList()
3051{
3052  UInt defaultCounter=0;
3053
3054  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3055  {
3056    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
3057    {
3058      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
3059     && ((sizeId < SCALING_LIST_16x16) || (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
3060      {
3061        defaultCounter++;
3062      }
3063    }
3064  }
3065  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32
3066}
3067
3068#if H_MV
3069Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
3070{
3071  refPicSetInterLayer0.clear(); 
3072  refPicSetInterLayer1.clear(); 
3073
3074  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
3075  {
3076    Int layerIdRef = getRefPicLayerId( i ); 
3077    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ; 
3078    assert ( picRef != 0 ); 
3079
3080    picRef->getPicYuvRec()->extendPicBorder(); 
3081    picRef->setIsLongTerm( true );       
3082    picRef->getSlice(0)->setReferenced( true );       
3083
3084    Int viewIdCur  = getVPS()->getViewId( getLayerId() ); 
3085    Int viewIdZero = getVPS()->getViewId( 0 );
3086    Int viewIdRef  = getVPS()->getViewId( layerIdRef ); 
3087
3088    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
3089    {
3090      refPicSetInterLayer0.push_back( picRef ); 
3091    }
3092    else
3093    {
3094      refPicSetInterLayer1.push_back( picRef ); 
3095    }
3096    // Consider to check here:
3097    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "   
3098  }
3099}
3100
3101Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
3102{
3103  // Mark as shortterm
3104  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ ) 
3105  {
3106    refPicSetInterLayer0[i]->setIsLongTerm( false ); 
3107  }
3108
3109  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ ) 
3110  {
3111    refPicSetInterLayer1[i]->setIsLongTerm( false ); 
3112  }
3113
3114}
3115Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
3116{
3117  // Fill targetDecLayerIdSet with all layers if empty (at encoder side)
3118  if (targetDecLayerIdSet.size() == 0 )   
3119  {
3120    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
3121    {
3122      targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) ); 
3123    }
3124  }     
3125
3126  Int numTargetDecLayers = (Int) targetDecLayerIdSet.size(); 
3127  Int latestDecIdx; 
3128  for ( latestDecIdx = 0; latestDecIdx < numTargetDecLayers; latestDecIdx++)
3129  {
3130    if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
3131    {
3132      break; 
3133  }       
3134  }       
3135
3136  for( Int i = 0; i <= latestDecIdx; i++ ) 
3137  {
3138    if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ i ] ) )
3139    {
3140      TComPic* pcPic = ivPicLists->getPic( targetDecLayerIdSet[ i ], curPoc ); 
3141#if H_MV_LAYER_WISE_STARTUP
3142      if ( pcPic )
3143      {
3144#endif
3145      if( pcPic->getSlice(0)->isReferenced() && pcPic->getSlice(0)->getTemporalLayerNonReferenceFlag() ) 
3146      { 
3147        Bool remainingInterLayerReferencesFlag = false; 
3148        for( Int j = latestDecIdx + 1; j < numTargetDecLayers; j++ )
3149        { 
3150          TComVPS* vpsSlice = pcPic->getSlice(0)->getVPS(); 
3151          if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
3152          {
3153            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
3154            {
3155              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
3156              {
3157                remainingInterLayerReferencesFlag = true;
3158          }
3159        }
3160          }
3161        }
3162        if( !remainingInterLayerReferencesFlag )
3163        {
3164          pcPic->getSlice(0)->setReferenced( false );                   
3165      }
3166    }
3167#if H_MV_LAYER_WISE_STARTUP
3168      }
3169#endif
3170  }
3171}
3172}
3173
3174Void TComSlice::printRefPicList()
3175{ 
3176  for ( Int li = 0; li < 2; li++)
3177  {   
3178    std::cout << std::endl << "RefPicListL" <<  li << ":" << std::endl; 
3179    for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
3180    {     
3181      if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( true );
3182       
3183      m_apcRefPicList[li][rIdx]->print( false );
3184    }
3185  }
3186}
3187
3188Void TComSlice::markCurrPic( TComPic* currPic )
3189{
3190  if ( !currPic->getSlice(0)->getDiscardableFlag() )
3191  {
3192    currPic->getSlice(0)->setReferenced( true ) ; 
3193    currPic->setIsLongTerm( false ); 
3194  }
3195  else
3196  {
3197    currPic->getSlice(0)->setReferenced( false ) ; 
3198  }
3199}
3200
3201Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
3202{
3203  m_refPicSetInterLayer0 = refPicSetInterLayer0; 
3204  m_refPicSetInterLayer1 = refPicSetInterLayer1; 
3205}
3206
3207TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
3208{
3209  assert ( setIdc == 0 || setIdc == 1);   
3210  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
3211  assert( refPicSetInterLayer != 0 ); 
3212 
3213  TComPic* pcPic = NULL; 
3214  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
3215  {
3216    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
3217    {
3218      pcPic = (*refPicSetInterLayer)[ i ]; 
3219    }
3220  }
3221
3222  assert(pcPic != NULL); 
3223  return pcPic;
3224}
3225
3226
3227#if H_MV_6_ILDDS_ILREFPICS_27_34
3228Int  TComSlice::getRefLayerPicFlag( Int i ) 
3229{
3230  TComVPS* vps = getVPS(); 
3231  Int refLayerIdx = vps->getLayerIdInVps( vps->getRefLayerId( getLayerId(), i ) ); 
3232
3233  Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer() )  && 
3234    ( vps->getMaxTidIlRefPicsPlus1( refLayerIdx, vps->getLayerIdInVps( getLayerId() )) > getTLayer() ); 
3235
3236  return refLayerPicFlag;       
3237}   
3238
3239Int TComSlice::getRefLayerPicIdc( Int j ) 
3240{ 
3241  Int refLayerPicIdc = -1; 
3242  Int curj = 0; 
3243  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3244  {
3245    if( getRefLayerPicFlag( i ) )
3246    {
3247      if ( curj == j ) 
3248      {
3249        refLayerPicIdc = i;         
3250        break;
3251      }
3252      curj++; 
3253    }
3254  }
3255
3256  assert( curj == j ); 
3257  assert( refLayerPicIdc != -1 ); 
3258  return refLayerPicIdc; 
3259}
3260
3261Int  TComSlice::getNumRefLayerPics( )
3262{ 
3263  Int numRefLayerPics = 0; 
3264  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3265  {
3266    numRefLayerPics += getRefLayerPicFlag( i ); 
3267  }
3268  return numRefLayerPics; 
3269}
3270#endif
3271
3272
3273
3274Int TComSlice::getNumActiveRefLayerPics()
3275{
3276  Int numActiveRefLayerPics; 
3277
3278  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerId() ) ==  0 )
3279  {
3280    numActiveRefLayerPics = 0; 
3281  }
3282  else if (getVPS()->getAllRefLayersActiveFlag() )
3283  {
3284#if H_MV_6_ILDDS_ILREFPICS_27_34
3285    numActiveRefLayerPics = getNumRefLayerPics(); 
3286#else
3287    numActiveRefLayerPics = getVPS()->getNumDirectRefLayers( getLayerId() );
3288#endif
3289  }
3290  else if ( !getInterLayerPredEnabledFlag() )
3291  {
3292    numActiveRefLayerPics = 0; 
3293  }
3294  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
3295  {
3296#if H_MV_6_ILDDS_ILREFPICS_27_34
3297    numActiveRefLayerPics = getRefLayerPicFlag( 0 ) ? 1 : 0; 
3298#else
3299    numActiveRefLayerPics = 1; 
3300#endif
3301  }
3302  else
3303  {
3304    numActiveRefLayerPics = getNumInterLayerRefPicsMinus1() + 1; 
3305  }
3306  return numActiveRefLayerPics;
3307}
3308
3309Int TComSlice::getRefPicLayerId( Int i )
3310{
3311  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
3312}
3313
3314#if H_3D_ARP
3315Void TComSlice::setARPStepNum( TComPicLists*ivPicLists )
3316{
3317  Bool tempRefPicInListsFlag = false;
3318  if(!getVPS()->getUseAdvRP(getLayerId()) || this->isIRAP())
3319  {
3320    m_nARPStepNum = 0;
3321  }
3322  else
3323  {
3324    setFirstTRefIdx (REF_PIC_LIST_0, -1);
3325    setFirstTRefIdx (REF_PIC_LIST_1, -1);
3326    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3327    {
3328      for(Int i = 0; i < getNumRefIdx(RefPicList(refListIdx)); i++ )
3329      {
3330        if ( getRefPic(RefPicList(refListIdx), i)->getPOC() != getPOC() )
3331        {
3332          setFirstTRefIdx (RefPicList(refListIdx), i);
3333          break;
3334        }
3335      }
3336    }
3337    tempRefPicInListsFlag = getFirstTRefIdx(REF_PIC_LIST_0) >= 0 || getFirstTRefIdx(REF_PIC_LIST_1) >= 0;
3338    m_nARPStepNum = tempRefPicInListsFlag ? getVPS()->getARPStepNum(getLayerId()) : 0;
3339  }
3340
3341  if (tempRefPicInListsFlag)
3342  {
3343    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3344    {
3345      RefPicList eRefPicList = RefPicList( refListIdx );
3346      Int prevPOC = getRefPic(eRefPicList, getFirstTRefIdx(eRefPicList) )->getPOC();
3347      for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
3348      {
3349        Int layerIdInNuh = getRefPicLayerId( i );
3350        Int viewIdx = getVPS()->getViewId( layerIdInNuh );
3351        TComPic*pcPicPrev = ivPicLists->getPic(viewIdx, 0, prevPOC);
3352        if (getFirstTRefIdx(eRefPicList) >= 0 && pcPicPrev && pcPicPrev->getSlice( 0 )->isReferenced())
3353        {
3354          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
3355        }
3356        else
3357        {
3358          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = false;
3359        }
3360      }
3361    }
3362  }
3363}
3364#endif
3365#if H_3D_IC
3366Void TComSlice::xSetApplyIC()
3367{
3368  Int iMaxPelValue = ( 1 << g_bitDepthY ); 
3369  Int *aiRefOrgHist;
3370  Int *aiCurrHist;
3371  aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
3372  aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
3373  memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
3374  memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
3375  // Reference Idx Number
3376  Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
3377  TComPic* pcCurrPic = NULL;
3378  TComPic* pcRefPic = NULL;
3379  TComPicYuv* pcCurrPicYuv = NULL;
3380  TComPicYuv* pcRefPicYuvOrg = NULL;
3381  pcCurrPic = getPic();
3382  pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
3383  Int iWidth = pcCurrPicYuv->getWidth();
3384  Int iHeight = pcCurrPicYuv->getHeight();
3385
3386
3387  // Get InterView Reference picture
3388  // !!!!! Assume only one Interview Reference Picture in L0
3389  for ( Int i = 0; i < iNumRefIdx; i++ )
3390  {
3391    pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3392    if ( pcRefPic != NULL )
3393    {
3394      if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3395      {
3396        pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
3397      }
3398    }
3399  }
3400
3401  if ( pcRefPicYuvOrg != NULL )
3402  {
3403    Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
3404    Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
3405    Int iCurrStride = pcCurrPicYuv->getStride();
3406    Int iRefStride = pcRefPicYuvOrg->getStride();
3407    Int iSumOrgSAD = 0;
3408    Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
3409
3410    // Histogram building - luminance
3411    for ( Int y = 0; y < iHeight; y++ )
3412    {
3413      for ( Int x = 0; x < iWidth; x++ )
3414      {
3415        aiCurrHist[pCurrY[x]]++;
3416        aiRefOrgHist[pRefOrgY[x]]++;
3417      }
3418      pCurrY += iCurrStride;
3419      pRefOrgY += iRefStride;
3420    }
3421    // Histogram SAD
3422    for ( Int i = 0; i < iMaxPelValue; i++ )
3423    {
3424      iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
3425    }
3426    // Setting
3427    if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
3428    {
3429      m_bApplyIC = true;
3430    }
3431    else
3432    {
3433      m_bApplyIC = false;
3434    }
3435  }
3436
3437  xFree( aiCurrHist   );
3438  xFree( aiRefOrgHist );
3439  aiCurrHist = NULL;
3440  aiRefOrgHist = NULL;
3441}
3442#endif
3443#if H_3D
3444Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
3445{
3446  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3447  {     
3448    for ( Int depthId = 0; depthId < 2; depthId++ )
3449    {
3450      m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , getPOC() ) : NULL;
3451    }       
3452  } 
3453}
3454Void TComSlice::setDepthToDisparityLUTs()
3455{ 
3456  Bool setupLUT = false; 
3457  Int layerIdInVPS = getVPS()->getLayerIdInNuh( m_layerId ); 
3458
3459#if H_3D_VSP
3460  setupLUT = setupLUT || getVPS()->getViewSynthesisPredFlag( layerIdInVPS); 
3461#endif
3462
3463#if H_3D_NBDV_REF
3464  setupLUT = setupLUT || getVPS()->getDepthRefinementFlag( layerIdInVPS );
3465#endif
3466
3467#if H_3D_IV_MERGE
3468  setupLUT = setupLUT || ( getVPS()->getIvMvPredFlag(layerIdInVPS ) && getIsDepth() );
3469#endif
3470
3471  if( !setupLUT )
3472    return; 
3473
3474  /// GT: Allocation should be moved to a better place later;
3475  if ( m_depthToDisparityB == NULL )
3476  {
3477    m_depthToDisparityB = new Int*[ getViewIndex() ];
3478    for ( Int i = 0; i < getViewIndex(); i++ )
3479    {
3480      m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
3481    }
3482  }
3483
3484  if ( m_depthToDisparityF == NULL )
3485  {
3486    m_depthToDisparityF= new Int*[ getViewIndex() ];
3487    for ( Int i = 0; i < getViewIndex(); i++ )
3488    {
3489      m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
3490    }
3491  }
3492
3493  assert( m_depthToDisparityB != NULL ); 
3494  assert( m_depthToDisparityF != NULL ); 
3495
3496#if CAM_HLS_F0136_F0045_F0082
3497  TComVPS* vps = getVPS(); 
3498#else
3499  TComSPS* sps = getSPS(); 
3500#endif
3501
3502#if CAM_HLS_F0136_F0045_F0082
3503  Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
3504  Int viewIndex = getViewIndex();
3505
3506  Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
3507
3508  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( viewIndex ); 
3509  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( viewIndex ); 
3510  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex ); 
3511  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex ); 
3512#else
3513  Int log2Div = g_bitDepthY - 1 + sps->getCamParPrecision();
3514
3515  Bool camParaSH = m_pcSPS->hasCamParInSliceHeader();
3516
3517  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : sps->getCodedScale    (); 
3518  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : sps->getCodedOffset   (); 
3519  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : sps->getInvCodedScale (); 
3520  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : sps->getInvCodedOffset(); 
3521#endif
3522
3523  for (Int i = 0; i <= ( getViewIndex() - 1); i++)
3524  {
3525    for ( Int d = 0; d <= ( ( 1 << g_bitDepthY ) - 1 ); d++ )
3526    {
3527      Int offset =    ( codOffset  [ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3528      m_depthToDisparityB[ i ][ d ] = ( codScale [ i ] * d + offset ) >> log2Div; 
3529
3530      Int invOffset = ( invCodOffset[ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3531      m_depthToDisparityF[ i ][ d ] = ( invCodScale[ i ] * d + invOffset ) >> log2Div; 
3532    }
3533  }
3534}
3535#endif
3536#endif
3537/** get scaling matrix from RefMatrixID
3538 * \param sizeId size index
3539 * \param Index of input matrix
3540 * \param Index of reference matrix
3541 */
3542Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
3543{
3544  ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3545}
3546
3547/** parse syntax infomation
3548 *  \param pchFile syntax infomation
3549 *  \returns false if successful
3550 */
3551Bool TComScalingList::xParseScalingList(Char* pchFile)
3552{
3553  FILE *fp;
3554  Char line[1024];
3555  UInt sizeIdc,listIdc;
3556  UInt i,size = 0;
3557  Int *src=0,data;
3558  Char *ret;
3559  UInt  retval;
3560
3561  if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
3562  {
3563    printf("can't open file %s :: set Default Matrix\n",pchFile);
3564    return true;
3565  }
3566
3567  for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
3568  {
3569    size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
3570    for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
3571    {
3572      src = getScalingListAddress(sizeIdc, listIdc);
3573
3574      fseek(fp,0,0);
3575      do 
3576      {
3577        ret = fgets(line, 1024, fp);
3578        if ((ret==NULL)||(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
3579        {
3580          printf("Error: can't read Matrix :: set Default Matrix\n");
3581          return true;
3582        }
3583      }
3584      while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
3585      for (i=0; i<size; i++)
3586      {
3587        retval = fscanf(fp, "%d,", &data);
3588        if (retval!=1)
3589        {
3590          printf("Error: can't read Matrix :: set Default Matrix\n");
3591          return true;
3592        }
3593        src[i] = data;
3594      }
3595      //set DC value for default matrix check
3596      setScalingListDC(sizeIdc,listIdc,src[0]);
3597
3598      if(sizeIdc > SCALING_LIST_8x8)
3599      {
3600        fseek(fp,0,0);
3601        do 
3602        {
3603          ret = fgets(line, 1024, fp);
3604          if ((ret==NULL)||(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
3605          {
3606            printf("Error: can't read DC :: set Default Matrix\n");
3607            return true;
3608          }
3609        }
3610        while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
3611        retval = fscanf(fp, "%d,", &data);
3612        if (retval!=1)
3613        {
3614          printf("Error: can't read Matrix :: set Default Matrix\n");
3615          return true;
3616        }
3617        //overwrite DC value when size of matrix is larger than 16x16
3618        setScalingListDC(sizeIdc,listIdc,data);
3619      }
3620    }
3621  }
3622  fclose(fp);
3623  return false;
3624}
3625
3626#if H_MV
3627Void TComScalingList::inferFrom( TComScalingList* srcScLi )
3628{
3629  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3630  {
3631    for(Int listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
3632    {
3633      setRefMatrixId  (sizeId,listId, srcScLi->getRefMatrixId  (sizeId,listId));
3634      setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));         
3635      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3636    }
3637  }
3638}
3639#endif
3640/** initialization process of quantization matrix array
3641 */
3642Void TComScalingList::init()
3643{
3644  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3645  {
3646    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3647    {
3648      m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
3649    }
3650  }
3651  m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
3652}
3653
3654/** destroy quantization matrix array
3655 */
3656Void TComScalingList::destroy()
3657{
3658  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3659  {
3660    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3661    {
3662      if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
3663    }
3664  }
3665}
3666
3667/** get default address of quantization matrix
3668 * \param sizeId size index
3669 * \param listId list index
3670 * \returns pointer of quantization matrix
3671 */
3672Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
3673{
3674  Int *src = 0;
3675  switch(sizeId)
3676  {
3677    case SCALING_LIST_4x4:
3678      src = g_quantTSDefault4x4;
3679      break;
3680    case SCALING_LIST_8x8:
3681      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3682      break;
3683    case SCALING_LIST_16x16:
3684      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3685      break;
3686    case SCALING_LIST_32x32:
3687      src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3688      break;
3689    default:
3690      assert(0);
3691      src = NULL;
3692      break;
3693  }
3694  return src;
3695}
3696
3697/** process of default matrix
3698 * \param sizeId size index
3699 * \param Index of input matrix
3700 */
3701Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
3702{
3703  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3704  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
3705}
3706
3707/** check DC value of matrix for default matrix signaling
3708 */
3709Void TComScalingList::checkDcOfMatrix()
3710{
3711  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3712  {
3713    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3714    {
3715      //check default matrix?
3716      if(getScalingListDC(sizeId,listId) == 0)
3717      {
3718        processDefaultMarix(sizeId, listId);
3719      }
3720    }
3721  }
3722}
3723
3724ParameterSetManager::ParameterSetManager()
3725: m_vpsMap(MAX_NUM_VPS)
3726, m_spsMap(MAX_NUM_SPS)
3727, m_ppsMap(MAX_NUM_PPS)
3728, m_activeVPSId(-1)
3729#if !H_MV
3730, m_activeSPSId(-1)
3731, m_activePPSId(-1)
3732{
3733#else
3734{
3735  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3736  {
3737    m_activeSPSId[ i ] = -1; 
3738    m_activePPSId[ i ] = -1; 
3739  }
3740#endif
3741}
3742
3743
3744ParameterSetManager::~ParameterSetManager()
3745{
3746}
3747
3748//! activate a SPS from a active parameter sets SEI message
3749//! \returns true, if activation is successful
3750#if H_MV
3751Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
3752#else
3753Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
3754#endif
3755{
3756  TComSPS *sps = m_spsMap.getPS(spsId);
3757  if (sps)
3758  {
3759    Int vpsId = sps->getVPSId();
3760    if (m_vpsMap.getPS(vpsId))
3761    {
3762      m_activeVPSId = vpsId;
3763#if H_MV
3764      m_activeSPSId[ layerId ] = spsId;
3765#else
3766      m_activeSPSId = spsId;
3767#endif
3768      return true;
3769    }
3770    else
3771    {
3772      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
3773    }
3774  }
3775  else
3776  {
3777    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
3778  }
3779  return false;
3780}
3781
3782//! activate a PPS and depending on isIDR parameter also SPS and VPS
3783//! \returns true, if activation is successful
3784#if H_MV
3785Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
3786#else
3787Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
3788#endif
3789{
3790  TComPPS *pps = m_ppsMap.getPS(ppsId);
3791  if (pps)
3792  {
3793    Int spsId = pps->getSPSId();
3794#if H_MV
3795    if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
3796#else
3797    if (!isIRAP && (spsId != m_activeSPSId))
3798#endif
3799    {
3800      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
3801      return false;
3802    }
3803
3804    TComSPS *sps = m_spsMap.getPS(spsId);
3805    if (sps)
3806    {
3807      Int vpsId = sps->getVPSId();
3808      if (!isIRAP && (vpsId != m_activeVPSId))
3809      {
3810        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
3811        return false;
3812      }
3813      if (m_vpsMap.getPS(vpsId))
3814      {
3815#if H_MV
3816        m_activePPSId[ layerId ] = ppsId;
3817        m_activeVPSId = vpsId;
3818        m_activeSPSId[ layerId ] = spsId;
3819#else
3820        m_activePPSId = ppsId;
3821        m_activeVPSId = vpsId;
3822        m_activeSPSId = spsId;
3823#endif
3824        return true;
3825      }
3826      else
3827      {
3828        printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
3829      }
3830    }
3831    else
3832    {
3833      printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
3834    }
3835  }
3836  else
3837  {
3838    printf("Warning: tried to activate non-existing PPS.");
3839  }
3840  return false;
3841}
3842
3843ProfileTierLevel::ProfileTierLevel()
3844  : m_profileSpace    (0)
3845  , m_tierFlag        (false)
3846  , m_profileIdc      (0)
3847  , m_levelIdc        (0)
3848, m_progressiveSourceFlag  (false)
3849, m_interlacedSourceFlag   (false)
3850, m_nonPackedConstraintFlag(false)
3851, m_frameOnlyConstraintFlag(false)
3852{
3853  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
3854}
3855
3856TComPTL::TComPTL()
3857{
3858  ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3859  ::memset(m_subLayerLevelPresentFlag,   0, sizeof(m_subLayerLevelPresentFlag  ));
3860}
3861
3862#if H_MV
3863Void TComPTL::copyLevelFrom( TComPTL* source )
3864{
3865  getGeneralPTL()->setLevelIdc( source->getGeneralPTL()->getLevelIdc() );
3866  for( Int subLayer = 0; subLayer < 6; subLayer++ )
3867  {
3868    setSubLayerLevelPresentFlag( subLayer, source->getSubLayerLevelPresentFlag( subLayer ) );
3869    getSubLayerPTL( subLayer )->setLevelIdc( source->getSubLayerPTL( subLayer )->getLevelIdc() );
3870  }
3871}
3872#endif
3873//! \}
3874
3875#if H_MV
3876TComVPSVUI::TComVPSVUI()
3877{
3878#if H_MV_6_PS_O0223_29
3879  m_crossLayerIrapAlignedFlag = true; 
3880#endif
3881  m_bitRatePresentVpsFlag = false;
3882  m_picRatePresentVpsFlag = false;
3883  for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
3884  {   
3885    for ( Int j = 0; j < MAX_TLAYER; j++)
3886    {   
3887      m_bitRatePresentFlag          [i][j] = false;
3888      m_picRatePresentFlag          [i][j] = false;
3889      m_avgBitRate                  [i][j] = -1;
3890      m_maxBitRate                  [i][j] = -1;
3891      m_constantPicRateIdc          [i][j] = -1;
3892      m_avgPicRate                  [i][j] = -1;
3893    }
3894  }
3895
3896  m_ilpRestrictedRefLayersFlag = false;
3897
3898  for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
3899  {         
3900    for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
3901    {   
3902      m_tileBoundariesAlignedFlag   [i][j] = false;
3903      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
3904      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
3905      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
3906    }
3907  }
3908#if H_MV_6_PS_O0118_33 
3909  for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
3910  {
3911    m_videoSignalInfo          [i] = NULL;     
3912  }
3913#endif
3914
3915#if H_MV_6_HRD_O0164_15
3916  m_vpsVuiBspHrdPresentFlag = false; 
3917  m_vpsVuiBspHrdParameters  = new TComVpsVuiBspHrdParameters();
3918#endif
3919}
3920
3921#if H_MV_6_PS_O0118_33
3922TComVPSVUI::~TComVPSVUI()
3923{
3924  for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
3925  {
3926    if (m_videoSignalInfo[ i ] != NULL )      delete m_videoSignalInfo[ i ];   
3927    m_videoSignalInfo    [ i ] = NULL; 
3928  }
3929
3930#if H_MV_6_HRD_O0164_15
3931  if ( m_vpsVuiBspHrdParameters ) delete m_vpsVuiBspHrdParameters;
3932  m_vpsVuiBspHrdParameters = NULL; 
3933#endif
3934}
3935#endif
3936
3937#if H_MV_6_PS_REP_FORM_18_19_20
3938Void TComRepFormat::inferChromaAndBitDepth( TComRepFormat* prevRepFormat, Bool encoderFlag )
3939{
3940  if ( !encoderFlag )
3941  {
3942    setChromaAndBitDepthVpsPresentFlag( prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
3943    setSeparateColourPlaneVpsFlag     ( prevRepFormat->getSeparateColourPlaneVpsFlag     () );
3944    setBitDepthVpsLumaMinus8          ( prevRepFormat->getBitDepthVpsLumaMinus8          () );
3945    setBitDepthVpsChromaMinus8        ( prevRepFormat->getBitDepthVpsChromaMinus8        () );
3946  }
3947  else
3948  {
3949    assert( getChromaAndBitDepthVpsPresentFlag() == prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
3950    assert( getSeparateColourPlaneVpsFlag     () == prevRepFormat->getSeparateColourPlaneVpsFlag     () );
3951    assert( getBitDepthVpsLumaMinus8          () == prevRepFormat->getBitDepthVpsLumaMinus8          () );
3952    assert( getBitDepthVpsChromaMinus8        () == prevRepFormat->getBitDepthVpsChromaMinus8        () );
3953}
3954}
3955#endif
3956
3957#if H_MV_6_HRD_O0164_15
3958Void TComVpsVuiBspHrdParameters::checkLayerInBspFlag( TComVPS* vps, Int h )
3959{
3960  // It is a requirement of bitstream conformance that bitstream partition with index j shall not include
3961  // direct or indirect reference layers of any layers in bitstream partition i for any values of i and j
3962  // in the range of 0 to num_bitstream_partitions[ h ] ?1, inclusive, such that i is less than j.
3963
3964  for ( Int partJ = 0; partJ < getNumBitstreamPartitions( h ); partJ++ )
3965  {       
3966    for ( Int partI = 0; partI < partJ; partI++ )
3967    {
3968      for ( Int layerJ = 0; layerJ < vps->getMaxLayersMinus1(); layerJ++ )
3969      {
3970        if ( m_layerInBspFlag[ h ][partJ][layerJ ] )
3971        {
3972          for ( Int layerI = 0; layerI < vps->getMaxLayersMinus1(); layerI++ )
3973          {
3974            if ( m_layerInBspFlag[ h ][partI][layerI] )
3975            {
3976              assert( !vps->getInDirectDependencyFlag( layerI, layerJ ) ); 
3977            }
3978          }
3979        }
3980      }
3981    }
3982  }
3983}
3984#endif
3985#endif
Note: See TracBrowser for help on using the repository browser.