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

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

Cleanup part 3

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