source: 3DVCSoftware/branches/HTM-8.2-dev1-Qualcomm/source/Lib/TLibCommon/TComSlice.cpp @ 666

Last change on this file since 666 was 666, checked in by zhang, 11 years ago

JCT3V-F0123, JCT3V-F0108

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