source: 3DVCSoftware/branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/TComSlice.cpp @ 651

Last change on this file since 651 was 651, checked in by tech, 11 years ago

Update to HM 12.0.

  • Property svn:eol-style set to native
File size: 101.7 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2013, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TComSlice.cpp
35    \brief    slice header and SPS class
36*/
37
38#include "CommonDef.h"
39#include "TComSlice.h"
40#include "TComPic.h"
41#include "TLibEncoder/TEncSbac.h"
42#include "TLibDecoder/TDecSbac.h"
43
44//! \ingroup TLibCommon
45//! \{
46
47TComSlice::TComSlice()
48: m_iPPSId                        ( -1 )
49, m_iPOC                          ( 0 )
50, m_iLastIDR                      ( 0 )
51, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
52, m_eSliceType                    ( I_SLICE )
53, m_iSliceQp                      ( 0 )
54, m_dependentSliceSegmentFlag            ( false )
55#if ADAPTIVE_QP_SELECTION
56, m_iSliceQpBase                  ( 0 )
57#endif
58, m_deblockingFilterDisable        ( false )
59, m_deblockingFilterOverrideFlag   ( false )
60, m_deblockingFilterBetaOffsetDiv2 ( 0 )
61, m_deblockingFilterTcOffsetDiv2   ( 0 )
62, m_bCheckLDC                     ( false )
63, m_iSliceQpDelta                 ( 0 )
64, m_iSliceQpDeltaCb               ( 0 )
65, m_iSliceQpDeltaCr               ( 0 )
66, m_iDepth                        ( 0 )
67, m_bRefenced                     ( false )
68, m_pcSPS                         ( NULL )
69, m_pcPPS                         ( NULL )
70, m_pcPic                         ( NULL )
71, m_colFromL0Flag                 ( 1 )
72, m_colRefIdx                     ( 0 )
73#if SAO_CHROMA_LAMBDA
74, m_dLambdaLuma( 0.0 )
75, m_dLambdaChroma( 0.0 )
76#else
77, m_dLambda                       ( 0.0 )
78#endif
79, m_uiTLayer                      ( 0 )
80, m_bTLayerSwitchingFlag          ( false )
81, m_sliceMode                   ( 0 )
82, m_sliceArgument               ( 0 )
83, m_sliceCurStartCUAddr         ( 0 )
84, m_sliceCurEndCUAddr           ( 0 )
85, m_sliceIdx                    ( 0 )
86, m_sliceSegmentMode            ( 0 )
87, m_sliceSegmentArgument        ( 0 )
88, m_sliceSegmentCurStartCUAddr  ( 0 )
89, m_sliceSegmentCurEndCUAddr    ( 0 )
90, m_nextSlice                    ( false )
91, m_nextSliceSegment             ( false )
92, m_sliceBits                   ( 0 )
93, m_sliceSegmentBits         ( 0 )
94, m_bFinalized                    ( false )
95, m_uiTileOffstForMultES          ( 0 )
96, m_puiSubstreamSizes             ( NULL )
97, m_cabacInitFlag                 ( false )
98, m_bLMvdL1Zero                   ( false )
99, m_numEntryPointOffsets          ( 0 )
100, m_temporalLayerNonReferenceFlag ( false )
101, m_enableTMVPFlag                ( true )
102#if H_MV
103, m_refPicSetInterLayer0           ( NULL )
104, m_refPicSetInterLayer1           ( NULL )
105, m_layerId                       (0)
106, m_viewId                        (0)
107, m_viewIndex                     (0)
108#if H_3D
109, m_isDepth                       (false)
110#endif
111, m_pocResetFlag                  (false)
112, 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
754    Bool bZeroIdxLtFlag = this->getRefPic(RefPicList(uiRefListIdx), 0)->getIsLongTerm();
755    for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
756    {
757      if ( ( bZeroIdxLtFlag && !this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) ||
758           (!bZeroIdxLtFlag &&  this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) )
759      {
760        this->setAlterRefIdx(RefPicList(uiRefListIdx),i);
761        break;
762      }
763    }
764  }
765}
766#endif
767Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
768{ 
769  if( m_pcSPS->hasCamParInSliceHeader() )
770  {   
771    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
772    {
773      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     m_viewIndex ];
774      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     m_viewIndex ][ uiBaseViewIndex ];
775      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     m_viewIndex ];
776      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     m_viewIndex ][ uiBaseViewIndex ];
777    }
778  } 
779}
780#endif
781
782Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
783{
784  Int i;
785  TComSlice* curSlice = pic->getSlice(curSliceIdx);
786  Int currColRefPOC =  curSlice->getRefPOC( RefPicList(1-curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
787  TComSlice* preSlice;
788  Int preColRefPOC;
789  for(i=curSliceIdx-1; i>=0; i--)
790  {
791    preSlice = pic->getSlice(i);
792    if(preSlice->getSliceType() != I_SLICE)
793    {
794      preColRefPOC  = preSlice->getRefPOC( RefPicList(1-preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
795      if(currColRefPOC != preColRefPOC)
796      {
797        printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
798        exit(EXIT_FAILURE);
799      }
800      else
801      {
802        break;
803      }
804    }
805  }
806}
807
808Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic)
809{
810  for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
811  {
812    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
813    {
814      assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
815    }
816  }
817  for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
818  {
819    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
820    {
821      if (!pReferencePictureSet->getCheckLTMSBPresent(i))
822      {
823        assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
824      }
825      else
826      {
827      assert(pReferencePictureSet->getPOC(i) >= pocCRA);
828    }
829  }
830  }
831  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
832  {
833    pocCRA = getPOC();
834  }
835  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
836  {
837    pocCRA = getPOC();
838    associatedIRAPType = getNalUnitType();
839  }
840  else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
841         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
842         || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
843  {
844    pocCRA = getPOC();
845    associatedIRAPType = getNalUnitType();
846  }
847}
848
849/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
850 * \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
851 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
852 * \param rcListPic reference to the reference picture list
853 * This function marks the reference pictures as "unused for reference" in the following conditions.
854 * If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list 
855 * are marked as "unused for reference"
856 *    If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
857 * Otherwise
858 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
859 *    temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
860 *    mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
861 *    the bRefreshPending flag to false.
862 *    If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
863 *    reference of the current picture.
864 * Note that the current picture is already placed in the reference list and its marking is not changed.
865 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
866 */
867Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
868{
869  TComPic*                 rpcPic;
870  setAssociatedIRAPPOC(pocCRA);
871  Int pocCurr = getPOC(); 
872
873  if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
874    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
875    || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
876    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
877    || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )  // IDR or BLA picture
878  {
879    // mark all pictures as not used for reference
880    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
881    while (iterPic != rcListPic.end())
882    {
883      rpcPic = *(iterPic);
884      rpcPic->setCurrSliceIdx(0);
885      if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
886      iterPic++;
887    }
888    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
889      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
890      || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
891    {
892      pocCRA = pocCurr;
893    }
894  }
895  else // CRA or No DR
896  {
897    if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
898    {
899      TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
900      while (iterPic != rcListPic.end())
901      {
902        rpcPic = *(iterPic);
903        if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
904        {
905          rpcPic->getSlice(0)->setReferenced(false);
906        }
907        iterPic++;
908      }
909      bRefreshPending = false; 
910    }
911    if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
912    {
913      bRefreshPending = true; 
914      pocCRA = pocCurr;
915    }
916  }
917}
918
919Void TComSlice::copySliceInfo(TComSlice *pSrc)
920{
921  assert( pSrc != NULL );
922
923  Int i, j, k;
924
925  m_iPOC                 = pSrc->m_iPOC;
926  m_eNalUnitType         = pSrc->m_eNalUnitType;
927#if H_MV
928  m_layerId              = pSrc->m_layerId;
929  // GT: Copying of several other values might be be missing here, or is above not necessary?
930#endif
931  m_eSliceType           = pSrc->m_eSliceType;
932  m_iSliceQp             = pSrc->m_iSliceQp;
933#if ADAPTIVE_QP_SELECTION
934  m_iSliceQpBase         = pSrc->m_iSliceQpBase;
935#endif
936  m_deblockingFilterDisable   = pSrc->m_deblockingFilterDisable;
937  m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
938  m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
939  m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
940 
941  for (i = 0; i < 2; i++)
942  {
943    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
944  }
945
946  for (i = 0; i < MAX_NUM_REF; i++)
947  {
948    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
949  } 
950  m_bCheckLDC             = pSrc->m_bCheckLDC;
951  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
952  m_iSliceQpDeltaCb      = pSrc->m_iSliceQpDeltaCb;
953  m_iSliceQpDeltaCr      = pSrc->m_iSliceQpDeltaCr;
954  for (i = 0; i < 2; i++)
955  {
956    for (j = 0; j < MAX_NUM_REF; j++)
957    {
958      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
959      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
960#if H_MV
961      m_aiRefLayerIdList[i][j] = pSrc->m_aiRefLayerIdList[i][j];
962#endif
963    }
964  }
965  for (i = 0; i < 2; i++)
966  {
967    for (j = 0; j < MAX_NUM_REF + 1; j++)
968    {
969      m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
970    }
971  }
972  m_iDepth               = pSrc->m_iDepth;
973
974  // referenced slice
975  m_bRefenced            = pSrc->m_bRefenced;
976
977  // access channel
978#if H_MV
979  m_pcVPS                = pSrc->m_pcVPS;
980#endif
981  m_pcSPS                = pSrc->m_pcSPS;
982  m_pcPPS                = pSrc->m_pcPPS;
983  m_pcRPS                = pSrc->m_pcRPS;
984  m_iLastIDR             = pSrc->m_iLastIDR;
985
986  m_pcPic                = pSrc->m_pcPic;
987
988  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
989  m_colRefIdx            = pSrc->m_colRefIdx;
990#if SAO_CHROMA_LAMBDA
991  m_dLambdaLuma          = pSrc->m_dLambdaLuma;
992  m_dLambdaChroma        = pSrc->m_dLambdaChroma;
993#else
994  m_dLambda              = pSrc->m_dLambda;
995#endif
996  for (i = 0; i < 2; i++)
997  {
998    for (j = 0; j < MAX_NUM_REF; j++)
999    {
1000      for (k =0; k < MAX_NUM_REF; k++)
1001      {
1002        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1003      }
1004    }
1005  }
1006
1007  m_uiTLayer                      = pSrc->m_uiTLayer;
1008  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
1009
1010  m_sliceMode                   = pSrc->m_sliceMode;
1011  m_sliceArgument               = pSrc->m_sliceArgument;
1012  m_sliceCurStartCUAddr         = pSrc->m_sliceCurStartCUAddr;
1013  m_sliceCurEndCUAddr           = pSrc->m_sliceCurEndCUAddr;
1014  m_sliceIdx                    = pSrc->m_sliceIdx;
1015  m_sliceSegmentMode            = pSrc->m_sliceSegmentMode;
1016  m_sliceSegmentArgument        = pSrc->m_sliceSegmentArgument; 
1017  m_sliceSegmentCurStartCUAddr  = pSrc->m_sliceSegmentCurStartCUAddr;
1018  m_sliceSegmentCurEndCUAddr    = pSrc->m_sliceSegmentCurEndCUAddr;
1019  m_nextSlice                    = pSrc->m_nextSlice;
1020  m_nextSliceSegment             = pSrc->m_nextSliceSegment;
1021  for ( Int e=0 ; e<2 ; e++ )
1022  {
1023    for ( Int n=0 ; n<MAX_NUM_REF ; n++ )
1024    {
1025      memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
1026    }
1027  }
1028  m_saoEnabledFlag = pSrc->m_saoEnabledFlag; 
1029  m_saoEnabledFlagChroma = pSrc->m_saoEnabledFlagChroma;
1030  m_cabacInitFlag                = pSrc->m_cabacInitFlag;
1031  m_numEntryPointOffsets  = pSrc->m_numEntryPointOffsets;
1032
1033  m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1034  m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1035  m_enableTMVPFlag                = pSrc->m_enableTMVPFlag;
1036  m_maxNumMergeCand               = pSrc->m_maxNumMergeCand;
1037
1038#if H_MV
1039  // Additional slice header syntax elements
1040  m_pocResetFlag               = pSrc->m_pocResetFlag; 
1041  m_discardableFlag            = pSrc->m_discardableFlag; 
1042  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag; 
1043  m_numInterLayerRefPicsMinus1 = pSrc->m_numInterLayerRefPicsMinus1;
1044
1045  for (Int layer = 0; layer < MAX_NUM_LAYERS; layer++ )
1046  {
1047    m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 
1048  }
1049#endif
1050#if H_3D_IC
1051  m_bApplyIC = pSrc->m_bApplyIC;
1052  m_icSkipParseFlag = pSrc->m_icSkipParseFlag;
1053#endif
1054}
1055
1056Int TComSlice::m_prevTid0POC = 0;
1057
1058/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1059 * \param uiTLayer Temporal layer ID of the current slice
1060 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1061 * the SPS's temporal_id_nesting_flag and the parsed PPS.  Then, current slice's temporal layer ID and
1062 * temporal_layer_switching_point_flag is set accordingly.
1063 */
1064Void TComSlice::setTLayerInfo( UInt uiTLayer )
1065{
1066  m_uiTLayer = uiTLayer;
1067}
1068
1069/** Function for checking if this is a switching-point
1070*/
1071Bool TComSlice::isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic )
1072{
1073  TComPic* rpcPic;
1074  // loop through all pictures in the reference picture buffer
1075  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1076  while ( iterPic != rcListPic.end())
1077  {
1078    rpcPic = *(iterPic++);
1079    if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1080    {
1081      if(rpcPic->getTLayer() >= getTLayer())
1082      {
1083        return false;
1084      }
1085    }
1086  }
1087  return true;
1088}
1089
1090/** Function for checking if this is a STSA candidate
1091 */
1092Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic )
1093{
1094    TComPic* rpcPic;
1095   
1096    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1097    while ( iterPic != rcListPic.end())
1098    {
1099        rpcPic = *(iterPic++);
1100        if(rpcPic->getSlice(0)->isReferenced() &&  (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1101        {
1102            if(rpcPic->getTLayer() >= getTLayer())
1103            {
1104                return false;
1105            }
1106        }
1107    }
1108    return true;
1109}
1110
1111
1112Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1113{
1114  TComPic* rpcPic;
1115
1116  Int nalUnitType = this->getNalUnitType();
1117
1118  // When a picture is a leading picture, it shall be a RADL or RASL picture.
1119  if(this->getAssociatedIRAPPOC() > this->getPOC())
1120  {
1121    // Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1122    if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP ||
1123       nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1124    {
1125      assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1126             nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1127             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1128             nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1129    }
1130  }
1131
1132  // When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1133  if(this->getAssociatedIRAPPOC() < this->getPOC())
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  // No RASL pictures shall be present in the bitstream that are associated
1142  // with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1143  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1144     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1145  {
1146    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1147           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1148  }
1149
1150  // No RASL pictures shall be present in the bitstream that are associated with
1151  // an IDR picture.
1152  if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1153     nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1154  {
1155    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP   &&
1156           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1157  }
1158
1159  // No RADL pictures shall be present in the bitstream that are associated with
1160  // a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1161  // with an IDR picture having nal_unit_type equal to IDR_N_LP.
1162  if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1163     nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1164  {
1165    assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP   &&
1166           this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1167  }
1168
1169  // loop through all pictures in the reference picture buffer
1170  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1171  while ( iterPic != rcListPic.end())
1172  {
1173    rpcPic = *(iterPic++);
1174    if (rpcPic->getPOC() == this->getPOC())
1175    {
1176      continue;
1177    }
1178
1179    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1180    // in decoding order shall precede the IRAP picture in output order.
1181    // (Note that any picture following in output order would be present in the DPB)
1182    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1183    {
1184      if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP    ||
1185         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP    ||
1186         nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL  ||
1187         nalUnitType == NAL_UNIT_CODED_SLICE_CRA         ||
1188         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP    ||
1189         nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1190      {
1191        assert(rpcPic->getPOC() < this->getPOC());
1192      }
1193    }
1194
1195    // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1196    // in decoding order shall precede any RADL picture associated with the IRAP
1197    // picture in output order.
1198    if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1199    {
1200      if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1201          nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1202      {
1203        // rpcPic precedes the IRAP in decoding order
1204        if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1205        {
1206          // rpcPic must not be the IRAP picture
1207          if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1208          {
1209            assert(rpcPic->getPOC() < this->getPOC());
1210          }
1211        }
1212      }
1213    }
1214
1215    // When a picture is a leading picture, it shall precede, in decoding order,
1216    // all trailing pictures that are associated with the same IRAP picture.
1217    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1218       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
1219       nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
1220       nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1221    {
1222      if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1223      {
1224        // rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1225        // rpcPic would violate the constraint if it was a trailing picture
1226        assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1227      }
1228    }
1229
1230    // Any RASL picture associated with a CRA or BLA picture shall precede any
1231    // RADL picture associated with the CRA or BLA picture in output order
1232    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1233       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1234    { 
1235      if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1236          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1237          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1238          this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)       &&
1239          this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1240      {
1241        if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
1242           rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1243        {
1244          assert(rpcPic->getPOC() > this->getPOC());
1245        }
1246      }
1247    }
1248
1249    // Any RASL picture associated with a CRA picture shall follow, in output
1250    // order, any IRAP picture that precedes the CRA picture in decoding order.
1251    if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
1252       nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1253    {
1254      if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1255      {
1256        if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1257           (rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ||
1258            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ||
1259            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
1260            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP   ||
1261            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
1262            rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1263        {
1264          assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1265        }
1266      }
1267    }
1268  }
1269}
1270
1271
1272
1273/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1274*/
1275Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1276{
1277  TComPic* rpcPic;
1278  Int i, isReference;
1279
1280  checkLeadingPictureRestrictions(rcListPic);
1281
1282  // loop through all pictures in the reference picture buffer
1283  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1284  while ( iterPic != rcListPic.end())
1285  {
1286    rpcPic = *(iterPic++);
1287
1288    if(!rpcPic->getSlice( 0 )->isReferenced())
1289    {
1290      continue;
1291    }
1292
1293    isReference = 0;
1294    // loop through all pictures in the Reference Picture Set
1295    // to see if the picture should be kept as reference picture
1296    for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1297    {
1298      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1299      {
1300        isReference = 1;
1301        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1302        rpcPic->setIsLongTerm(0);
1303      }
1304    }
1305    for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1306    {
1307      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1308      {
1309        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1310        {
1311          isReference = 1;
1312          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1313        }
1314      }
1315      else 
1316      {
1317        {
1318          isReference = 1;
1319          rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1320        }
1321      }
1322
1323    }
1324    // mark the picture as "unused for reference" if it is not in
1325    // the Reference Picture Set
1326    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)   
1327    {           
1328      rpcPic->getSlice( 0 )->setReferenced( false );   
1329      rpcPic->setUsedByCurr(0);
1330      rpcPic->setIsLongTerm(0);
1331    }
1332    //check that pictures of higher temporal layers are not used
1333    assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
1334    //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1335    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1336    {
1337      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
1338    }
1339    //check that pictures marked as temporal layer non-reference pictures are not used for reference
1340    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1341    {
1342      assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1343    }
1344  }
1345}
1346
1347/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1348*/
1349Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
1350{
1351  TComPic* rpcPic;
1352  Int i, isAvailable;
1353  Int atLeastOneLost = 0;
1354  Int atLeastOneRemoved = 0;
1355  Int iPocLost = 0;
1356
1357  // loop through all long-term pictures in the Reference Picture Set
1358  // to see if the picture should be kept as reference picture
1359  for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1360  {
1361    isAvailable = 0;
1362    // loop through all pictures in the reference picture buffer
1363    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1364    while ( iterPic != rcListPic.end())
1365    {
1366      rpcPic = *(iterPic++);
1367      if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1368      {
1369        if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1370        {
1371          isAvailable = 1;
1372        }
1373      }
1374      else 
1375      {
1376        {
1377          isAvailable = 1;
1378        }
1379      }
1380    }
1381    // if there was no such long-term check the short terms
1382    if(!isAvailable)
1383    {
1384      iterPic = rcListPic.begin();
1385      while ( iterPic != rcListPic.end())
1386      {
1387        rpcPic = *(iterPic++);
1388
1389        Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1390        Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1391        Int refPoc = pReferencePictureSet->getPOC(i);
1392        if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1393        {
1394          curPoc = curPoc & (pocCycle - 1);
1395          refPoc = refPoc & (pocCycle - 1);
1396        }
1397       
1398        if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1399        {
1400          isAvailable = 1;
1401          rpcPic->setIsLongTerm(1);
1402          break;
1403        }
1404      }
1405    }
1406    // report that a picture is lost if it is in the Reference Picture Set
1407    // but not available as reference picture
1408    if(isAvailable == 0)   
1409    {           
1410      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1411      {
1412        if(!pReferencePictureSet->getUsed(i) )
1413        {
1414          if(printErrors)
1415          {
1416            printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1417          }
1418          atLeastOneRemoved = 1;
1419        }
1420        else
1421        {
1422          if(printErrors)
1423          {
1424            printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1425          }
1426          atLeastOneLost = 1;
1427          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1428        }
1429      }
1430    }
1431  } 
1432  // loop through all short-term pictures in the Reference Picture Set
1433  // to see if the picture should be kept as reference picture
1434  for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1435  {
1436    isAvailable = 0;
1437    // loop through all pictures in the reference picture buffer
1438    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1439    while ( iterPic != rcListPic.end())
1440    {
1441      rpcPic = *(iterPic++);
1442
1443      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1444      {
1445        isAvailable = 1;
1446      }
1447    }
1448    // report that a picture is lost if it is in the Reference Picture Set
1449    // but not available as reference picture
1450    if(isAvailable == 0)   
1451    {           
1452      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1453      {
1454        if(!pReferencePictureSet->getUsed(i) )
1455        {
1456          if(printErrors)
1457          {
1458            printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1459          }
1460          atLeastOneRemoved = 1;
1461        }
1462        else
1463        {
1464          if(printErrors)
1465          {
1466            printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1467          }
1468          atLeastOneLost = 1;
1469          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1470        }
1471      }
1472    }
1473  }   
1474  if(atLeastOneLost)
1475  {
1476    return iPocLost+1;
1477  }
1478  if(atLeastOneRemoved)
1479  {
1480    return -2;
1481  }
1482  else
1483  {
1484    return 0;
1485  }
1486}
1487
1488/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1489*/
1490#if FIX1071
1491Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
1492#else
1493Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1494#endif
1495{
1496  TComPic* rpcPic;
1497  Int i, j;
1498  Int k = 0;
1499  Int nrOfNegativePictures = 0;
1500  Int nrOfPositivePictures = 0;
1501  TComReferencePictureSet* pcRPS = this->getLocalRPS();
1502
1503  // loop through all pictures in the Reference Picture Set
1504  for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1505  {
1506    j = 0;
1507    // loop through all pictures in the reference picture buffer
1508    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1509    while ( iterPic != rcListPic.end())
1510    {
1511      j++;
1512      rpcPic = *(iterPic++);
1513
1514      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1515      {
1516        // This picture exists as a reference picture
1517        // and should be added to the explicit Reference Picture Set
1518        pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1519#if FIX1071
1520        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1521#else
1522        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i));
1523#endif
1524        if(pcRPS->getDeltaPOC(k) < 0)
1525        {
1526          nrOfNegativePictures++;
1527        }
1528        else
1529        {
1530          nrOfPositivePictures++;
1531        }
1532        k++;
1533      }
1534    }
1535  }
1536  pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1537  pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1538  pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1539  // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1540  // inter RPS prediction with.  Here we just use the reference used by pReferencePictureSet.
1541  // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1542  if (!pReferencePictureSet->getInterRPSPrediction())
1543  {
1544    pcRPS->setInterRPSPrediction(false);
1545    pcRPS->setNumRefIdc(0);
1546  }
1547  else
1548  {
1549    Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1550    Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1551    TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1552    Int iRefPics = pcRefRPS->getNumberOfPictures();
1553    Int iNewIdc=0;
1554    for(i=0; i<= iRefPics; i++) 
1555    {
1556      Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0);  // check if the reference abs POC is >= 0
1557      Int iRefIdc = 0;
1558      for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the  pictures in the new RPS
1559      {
1560        if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1561        {
1562          if (pcRPS->getUsed(j))
1563          {
1564            iRefIdc = 1;
1565          }
1566          else
1567          {
1568            iRefIdc = 2;
1569          }
1570        }
1571      }
1572      pcRPS->setRefIdc(i, iRefIdc);
1573      iNewIdc++;
1574    }
1575    pcRPS->setInterRPSPrediction(true);
1576    pcRPS->setNumRefIdc(iNewIdc);
1577    pcRPS->setDeltaRPS(deltaRPS); 
1578    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1579  }
1580
1581  this->setRPS(pcRPS);
1582  this->setRPSidx(-1);
1583}
1584
1585/** get AC and DC values for weighted pred
1586 * \param *wp
1587 * \returns Void
1588 */
1589Void  TComSlice::getWpAcDcParam(wpACDCParam *&wp)
1590{
1591  wp = m_weightACDCParam;
1592}
1593
1594/** init AC and DC values for weighted pred
1595 * \returns Void
1596 */
1597Void  TComSlice::initWpAcDcParam()
1598{
1599  for(Int iComp = 0; iComp < 3; iComp++ )
1600  {
1601    m_weightACDCParam[iComp].iAC = 0;
1602    m_weightACDCParam[iComp].iDC = 0;
1603  }
1604}
1605
1606/** get WP tables for weighted pred
1607 * \param RefPicList
1608 * \param iRefIdx
1609 * \param *&wpScalingParam
1610 * \returns Void
1611 */
1612Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
1613{
1614  wp = m_weightPredTable[e][iRefIdx];
1615}
1616
1617/** reset Default WP tables settings : no weight.
1618 * \param wpScalingParam
1619 * \returns Void
1620 */
1621Void  TComSlice::resetWpScaling()
1622{
1623  for ( Int e=0 ; e<2 ; e++ )
1624  {
1625    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1626    {
1627      for ( Int yuv=0 ; yuv<3 ; yuv++ )
1628      {
1629        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1630        pwp->bPresentFlag      = false;
1631        pwp->uiLog2WeightDenom = 0;
1632        pwp->uiLog2WeightDenom = 0;
1633        pwp->iWeight           = 1;
1634        pwp->iOffset           = 0;
1635      }
1636    }
1637  }
1638}
1639
1640/** init WP table
1641 * \returns Void
1642 */
1643Void  TComSlice::initWpScaling()
1644{
1645  for ( Int e=0 ; e<2 ; e++ )
1646  {
1647    for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1648    {
1649      for ( Int yuv=0 ; yuv<3 ; yuv++ )
1650      {
1651        wpScalingParam  *pwp = &(m_weightPredTable[e][i][yuv]);
1652        if ( !pwp->bPresentFlag ) 
1653        {
1654          // Inferring values not present :
1655          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1656          pwp->iOffset = 0;
1657        }
1658
1659        pwp->w      = pwp->iWeight;
1660        Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
1661        pwp->o      = pwp->iOffset << (bitDepth-8);
1662        pwp->shift  = pwp->uiLog2WeightDenom;
1663        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1664      }
1665    }
1666  }
1667}
1668
1669// ------------------------------------------------------------------------------------------------
1670// Video parameter set (VPS)
1671// ------------------------------------------------------------------------------------------------
1672TComVPS::TComVPS()
1673: m_VPSId                     (  0)
1674, m_uiMaxTLayers              (  1)
1675#if H_MV
1676, m_uiMaxLayersMinus1         (  0)
1677#else
1678, m_uiMaxLayers               (  1)
1679#endif
1680, m_bTemporalIdNestingFlag    (false)
1681, m_numHrdParameters          (  0)
1682#if H_MV
1683, m_maxLayerId             (  0)
1684#else
1685, m_maxNuhReservedZeroLayerId (  0)
1686#endif
1687, m_hrdParameters             (NULL)
1688, m_hrdOpSetIdx               (NULL)
1689, m_cprmsPresentFlag          (NULL)
1690#if H_MV
1691, m_vpsVUI                 (  NULL )
1692#endif
1693{
1694  for( Int i = 0; i < MAX_TLAYER; i++)
1695  {
1696    m_numReorderPics[i] = 0;
1697    m_uiMaxDecPicBuffering[i] = 1; 
1698    m_uiMaxLatencyIncrease[i] = 0;
1699  }
1700#if H_MV
1701  for (Int lsIdx = 0; lsIdx < MAX_VPS_OP_SETS_PLUS1; lsIdx++ )
1702  { 
1703    for( Int layerId = 0; layerId < MAX_VPS_NUH_LAYER_ID_PLUS1; layerId++ )
1704    {
1705      m_layerIdIncludedFlag[lsIdx][layerId] = false; 
1706    }
1707  } 
1708
1709  m_vpsNumberLayerSetsMinus1     = -1; 
1710  m_vpsNumProfileTierLevelMinus1 = -1; 
1711   
1712  for ( Int i = 0; i < MAX_VPS_PROFILE_TIER_LEVEL; i++)
1713  {
1714    m_profileRefMinus1[ i ] = -1; 
1715  }
1716   
1717  m_moreOutputLayerSetsThanDefaultFlag = false;   
1718  m_numAddOutputLayerSetsMinus1        = -1;   
1719  m_defaultOneTargetOutputLayerFlag    = false; 
1720 
1721  for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
1722  {
1723    m_outputLayerSetIdxMinus1[i]  = -1; 
1724    m_profileLevelTierIdx[i]      = 0; 
1725    for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
1726    {
1727      m_outputLayerFlag[i][j] = false; 
1728    }
1729  }
1730 
1731  m_maxOneActiveRefLayerFlag = false; 
1732  m_directDepTypeLenMinus2   = 0;         
1733 
1734
1735  m_avcBaseLayerFlag = false;
1736  m_vpsVuiOffset     = 0; 
1737  m_splittingFlag    = false;
1738 
1739  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
1740  {
1741    m_scalabilityMaskFlag[i] = false;
1742    m_dimensionIdLen [i]  = -1; 
1743  }
1744
1745  m_vpsNuhLayerIdPresentFlag = false;
1746
1747  for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
1748  {
1749    m_vpsProfilePresentFlag   [i] = false;
1750    m_profileRefMinus1[i] = 0;
1751    m_outputLayerSetIdxMinus1       [i] = 0;
1752    for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
1753    {
1754      m_outputLayerFlag[i][j] = false;
1755    }
1756  }
1757
1758  for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
1759  {
1760    m_layerIdInVps[i] =  (i == 0 ) ? 0 : -1;         
1761  }
1762
1763  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1764  {
1765    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1; 
1766    m_numDirectRefLayers[i] = 0; 
1767    m_maxTidIlRefPicPlus1[i] = 7;
1768    m_vpsRepFormatIdx    [i] = 0; 
1769    m_repFormat          [i] = NULL; 
1770    m_viewIdVal          [i] = 0; 
1771
1772#if H_3D
1773    m_viewIndex         [i] = -1; 
1774    m_vpsDepthModesFlag [i] = false;
1775#if H_3D_DIM_DLT
1776    m_bUseDLTFlag         [i] = false;
1777   
1778    // allocate some memory and initialize with default mapping
1779    m_iNumDepthmapValues[i] = ((1 << g_bitDepthY)-1)+1;
1780    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
1781   
1782    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
1783    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
1784   
1785    //default mapping
1786    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
1787    {
1788      m_iDepthValue2Idx[i][d] = d;
1789      m_iIdx2DepthValue[i][d] = d;
1790    }
1791#endif
1792#if H_3D
1793    m_ivMvScalingFlag = true; 
1794#endif
1795#endif
1796
1797    for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
1798    {
1799      m_directDependencyFlag[i][j] = false;
1800      m_directDependencyType[i][j] = -1; 
1801      m_refLayerId[i][j]           = -1; 
1802    }
1803
1804    for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
1805    {
1806      m_dimensionId[i][j] = 0;
1807    }
1808#if H_3D_ARP
1809    m_uiUseAdvResPred[i]  = 0;
1810    m_uiARPStepNum[i]     = 1;
1811#endif
1812  }
1813  m_vpsVUI = new TComVPSVUI; 
1814#if H_3D
1815  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1816  {
1817#if H_3D_IV_MERGE
1818    m_ivMvPredFlag         [ i ] = false;
1819#endif
1820#if H_3D_VSP
1821    m_viewSynthesisPredFlag[ i ] = false;
1822#endif
1823#if H_3D_NBDV_REF
1824    m_depthRefinementFlag  [ i ] = false;
1825#endif
1826#if H_3D_INTER_SDC
1827    m_bInterSDCFlag        [ i ] = false;
1828#endif
1829  } 
1830#endif
1831#endif
1832}
1833
1834TComVPS::~TComVPS()
1835{
1836if( m_hrdParameters    != NULL )     delete[] m_hrdParameters;
1837  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
1838  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
1839#if H_MV
1840  if ( m_vpsVUI          != NULL )     delete m_vpsVUI; 
1841  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1842  {
1843    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];   
1844#if H_3D_DIM_DLT
1845    if ( m_iDepthValue2Idx[i] != 0 ) 
1846    {
1847       xFree( m_iDepthValue2Idx[i] );
1848       m_iDepthValue2Idx[i] = 0; 
1849    }
1850
1851    if ( m_iIdx2DepthValue[i] != 0 ) 
1852    {
1853      xFree( m_iIdx2DepthValue[i] );
1854      m_iIdx2DepthValue[i] = 0; 
1855    }
1856#endif
1857  }
1858#endif
1859}
1860
1861#if H_3D_DIM_DLT
1862  Void TComVPS::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
1863  {
1864    if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
1865      return;
1866   
1867    // copy idx2DepthValue to internal array
1868    memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
1869   
1870    UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
1871    for(Int p=0; p<=uiMaxDepthValue; p++)
1872    {
1873      Int iIdxDown    = 0;
1874      Int iIdxUp      = iNumDepthValues-1;
1875      Bool bFound     = false;
1876     
1877      // iterate over indices to find lower closest depth
1878      Int i = 1;
1879      while(!bFound && i<iNumDepthValues)
1880      {
1881        if( m_iIdx2DepthValue[layerIdInVps][i] > p )
1882        {
1883          iIdxDown  = i-1;
1884          bFound    = true;
1885        }
1886       
1887        i++;
1888      }
1889      // iterate over indices to find upper closest depth
1890      i = iNumDepthValues-2;
1891      bFound = false;
1892      while(!bFound && i>=0)
1893      {
1894        if( m_iIdx2DepthValue[layerIdInVps][i] < p )
1895        {
1896          iIdxUp  = i+1;
1897          bFound    = true;
1898        }
1899       
1900        i--;
1901      }
1902     
1903      // assert monotony
1904      assert(iIdxDown<=iIdxUp);
1905     
1906      // assign closer depth value/idx
1907      if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
1908      {
1909        m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
1910      }
1911      else
1912      {
1913        m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
1914      }
1915     
1916    }
1917   
1918    // update DLT variables
1919    m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
1920    m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
1921  }
1922#endif
1923
1924#if H_MV
1925
1926Bool TComVPS::checkVPSExtensionSyntax()
1927{
1928  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
1929  {
1930    // check layer_id_in_nuh constraint
1931    assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
1932  }
1933  return true; 
1934}
1935
1936Int TComVPS::getNumScalabilityTypes()
1937{
1938  return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
1939}
1940
1941Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
1942{
1943  assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES ); 
1944  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
1945  Int scalIdx = 0; 
1946  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
1947  {
1948    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
1949
1950  }
1951
1952  return scalIdx; 
1953}
1954Void TComVPS::setScalabilityMaskFlag( UInt val )
1955{
1956  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ ) 
1957  {
1958    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
1959  }
1960}
1961
1962Void TComVPS::setRefLayers()
1963{
1964  for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
1965  {
1966    Int iNuhLId = getLayerIdInNuh( i ); 
1967    m_numDirectRefLayers[ iNuhLId ] = 0; 
1968    for( Int j = 0; j < i; j++ )
1969    {
1970      if( getDirectDependencyFlag(i , j) )
1971      {
1972        m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
1973      }
1974    }
1975  }
1976}
1977
1978Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
1979{
1980  assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );     
1981  Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];   
1982  assert ( refLayerIdInNuh >= 0 ); 
1983  return refLayerIdInNuh;
1984}
1985
1986Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
1987{
1988  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
1989}
1990
1991#if H_3D
1992Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
1993{
1994  Int foundLayerIdinNuh = -1; 
1995
1996  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
1997  {
1998    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps ); 
1999    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
2000    {
2001      foundLayerIdinNuh = layerIdInNuh; 
2002      break; 
2003    }
2004  }
2005  assert( foundLayerIdinNuh != -1 ); 
2006
2007  return foundLayerIdinNuh;
2008}
2009#endif // H_3D
2010
2011
2012Int TComVPS::xGetDimBitOffset( Int j )
2013{
2014  Int dimBitOffset = 0; 
2015  if ( getSplittingFlag() && j == getNumScalabilityTypes() )
2016  {
2017     dimBitOffset = 6; 
2018  }
2019  else
2020  {
2021    for (Int dimIdx = 0; dimIdx <= j-1; dimIdx++)
2022    {
2023      dimBitOffset += getDimensionIdLen( dimIdx ); 
2024    }
2025  }
2026  return dimBitOffset; 
2027}
2028
2029Int TComVPS::inferDimensionId( Int i, Int j )
2030{
2031    return ( ( getLayerIdInNuh( i ) & ( (1 << xGetDimBitOffset( j + 1 ) ) - 1) ) >> xGetDimBitOffset( j ) ); 
2032}
2033
2034Int TComVPS::inferLastDimsionIdLenMinus1()
2035{
2036  return ( 5 - xGetDimBitOffset( getNumScalabilityTypes() - 1 ) ); 
2037}
2038
2039Int TComVPS::getNumLayersInIdList( Int lsIdx )
2040{
2041  assert( lsIdx >= 0 ); 
2042  assert( lsIdx <= getVpsNumLayerSetsMinus1() ); 
2043  Int numLayersInIdList = 0; 
2044  for (Int layerId = 0; layerId < getVpsMaxLayerId(); layerId++ )
2045  {
2046    numLayersInIdList += ( getLayerIdIncludedFlag( lsIdx, layerId ) ); 
2047  }
2048  return numLayersInIdList;
2049}
2050Int TComVPS::getNumViews()
2051{
2052  Int numViews = 1; 
2053  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
2054  {
2055    Int lId = getLayerIdInNuh( i ); 
2056    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
2057    {
2058      numViews++; 
2059    }   
2060  }
2061
2062  return numViews;
2063}
2064
2065Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
2066{
2067  assert( depth < 65 ); 
2068  Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps ); 
2069
2070  for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
2071  {
2072    if ( getDirectDependencyFlag( depLayeridInVps, i ) )
2073    {
2074      dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ ); 
2075    }
2076  }
2077  return dependentFlag;
2078}
2079#endif // H_MV
2080
2081// ------------------------------------------------------------------------------------------------
2082// Sequence parameter set (SPS)
2083// ------------------------------------------------------------------------------------------------
2084
2085TComSPS::TComSPS()
2086: m_SPSId                     (  0)
2087, m_VPSId                     (  0)
2088, m_chromaFormatIdc           (CHROMA_420)
2089, m_uiMaxTLayers              (  1)
2090// Structure
2091, m_picWidthInLumaSamples     (352)
2092, m_picHeightInLumaSamples    (288)
2093, m_log2MinCodingBlockSize    (  0)
2094, m_log2DiffMaxMinCodingBlockSize (0)
2095, m_uiMaxCUWidth              ( 32)
2096, m_uiMaxCUHeight             ( 32)
2097, m_uiMaxCUDepth              (  3)
2098, m_bLongTermRefsPresent      (false)
2099, m_uiQuadtreeTULog2MaxSize   (  0)
2100, m_uiQuadtreeTULog2MinSize   (  0)
2101, m_uiQuadtreeTUMaxDepthInter (  0)
2102, m_uiQuadtreeTUMaxDepthIntra (  0)
2103// Tool list
2104, m_usePCM                   (false)
2105, m_pcmLog2MaxSize            (  5)
2106, m_uiPCMLog2MinSize          (  7)
2107#if H_3D_QTLPC
2108, m_bUseQTL                   (false)
2109, m_bUsePC                    (false)
2110#endif
2111, m_bitDepthY                 (  8)
2112, m_bitDepthC                 (  8)
2113, m_qpBDOffsetY               (  0)
2114, m_qpBDOffsetC               (  0)
2115, m_useLossless               (false)
2116, m_uiPCMBitDepthLuma         (  8)
2117, m_uiPCMBitDepthChroma       (  8)
2118, m_bPCMFilterDisableFlag     (false)
2119, m_uiBitsForPOC              (  8)
2120, m_numLongTermRefPicSPS    (  0) 
2121, m_uiMaxTrSize               ( 32)
2122, m_bUseSAO                   (false) 
2123, m_bTemporalIdNestingFlag    (false)
2124, m_scalingListEnabledFlag    (false)
2125, m_useStrongIntraSmoothing   (false)
2126, m_vuiParametersPresentFlag  (false)
2127, m_vuiParameters             ()
2128#if H_MV
2129, m_pcVPS                     ( NULL )
2130, m_spsInferScalingListFlag   ( false )
2131, m_spsScalingListRefLayerId  ( 0 )
2132, m_updateRepFormatFlag       ( true ) 
2133, m_interViewMvVertConstraintFlag (false)
2134#endif
2135#if H_3D
2136, m_bCamParInSliceHeader      (false)
2137#endif
2138{
2139  for ( Int i = 0; i < MAX_TLAYER; i++ )
2140  {
2141    m_uiMaxLatencyIncrease[i] = 0;
2142    m_uiMaxDecPicBuffering[i] = 1;
2143    m_numReorderPics[i]       = 0;
2144  }
2145  m_scalingList = new TComScalingList;
2146  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2147  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2148}
2149
2150TComSPS::~TComSPS()
2151{
2152  delete m_scalingList;
2153  m_RPSList.destroy();
2154}
2155
2156Void  TComSPS::createRPSList( Int numRPS )
2157{ 
2158  m_RPSList.destroy();
2159  m_RPSList.create(numRPS);
2160}
2161
2162Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2163{
2164  if( !getVuiParametersPresentFlag() )
2165  {
2166    return;
2167  }
2168
2169  TComVUI *vui = getVuiParameters();
2170  TComHRD *hrd = vui->getHrdParameters();
2171
2172  TimingInfo *timingInfo = vui->getTimingInfo();
2173  timingInfo->setTimingInfoPresentFlag( true );
2174  switch( frameRate )
2175  {
2176  case 24:
2177    timingInfo->setNumUnitsInTick( 1125000 );    timingInfo->setTimeScale    ( 27000000 );
2178    break;
2179  case 25:
2180    timingInfo->setNumUnitsInTick( 1080000 );    timingInfo->setTimeScale    ( 27000000 );
2181    break;
2182  case 30:
2183    timingInfo->setNumUnitsInTick( 900900 );     timingInfo->setTimeScale    ( 27000000 );
2184    break;
2185  case 50:
2186    timingInfo->setNumUnitsInTick( 540000 );     timingInfo->setTimeScale    ( 27000000 );
2187    break;
2188  case 60:
2189    timingInfo->setNumUnitsInTick( 450450 );     timingInfo->setTimeScale    ( 27000000 );
2190    break;
2191  default:
2192    timingInfo->setNumUnitsInTick( 1001 );       timingInfo->setTimeScale    ( 60000 );
2193    break;
2194  }
2195
2196  Bool rateCnt = ( bitRate > 0 );
2197  hrd->setNalHrdParametersPresentFlag( rateCnt );
2198  hrd->setVclHrdParametersPresentFlag( rateCnt );
2199
2200  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2201
2202  if( hrd->getSubPicCpbParamsPresentFlag() )
2203  {
2204    hrd->setTickDivisorMinus2( 100 - 2 );                          //
2205    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
2206    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2207    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2208  }
2209  else
2210  {
2211    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false ); 
2212  }
2213
2214  hrd->setBitRateScale( 4 );                                       // in units of 2~( 6 + 4 ) = 1,024 bps
2215  hrd->setCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2216  hrd->setDuCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2217 
2218  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2219  if( randomAccess )
2220  {
2221    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
2222    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
2223  }
2224  else
2225  {
2226    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
2227    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
2228  }
2229
2230/*
2231   Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2232*/
2233  Int i, j;
2234  UInt birateValue, cpbSizeValue;
2235  UInt ducpbSizeValue;
2236  UInt duBitRateValue = 0;
2237
2238  for( i = 0; i < MAX_TLAYER; i ++ )
2239  {
2240    hrd->setFixedPicRateFlag( i, 1 );
2241    hrd->setPicDurationInTcMinus1( i, 0 );
2242    hrd->setLowDelayHrdFlag( i, 0 );
2243    hrd->setCpbCntMinus1( i, 0 );
2244
2245    birateValue  = bitRate;
2246    cpbSizeValue = bitRate;                                     // 1 second
2247    ducpbSizeValue = bitRate/numDU;
2248    duBitRateValue = bitRate;
2249    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2250    {
2251      hrd->setBitRateValueMinus1( i, j, 0, ( birateValue  - 1 ) );
2252      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2253      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
2254      hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2255
2256      hrd->setBitRateValueMinus1( i, j, 1, ( birateValue  - 1) );
2257      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2258      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
2259      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2260      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2261    }
2262  }
2263}
2264const Int TComSPS::m_winUnitX[]={1,2,2,1};
2265const Int TComSPS::m_winUnitY[]={1,2,1,1};
2266
2267TComPPS::TComPPS()
2268: m_PPSId                       (0)
2269, m_SPSId                       (0)
2270, m_picInitQPMinus26            (0)
2271, m_useDQP                      (false)
2272, m_bConstrainedIntraPred       (false)
2273, m_bSliceChromaQpFlag          (false)
2274, m_pcSPS                       (NULL)
2275, m_uiMaxCuDQPDepth             (0)
2276, m_uiMinCuDQPSize              (0)
2277, m_chromaCbQpOffset            (0)
2278, m_chromaCrQpOffset            (0)
2279, m_numRefIdxL0DefaultActive    (1)
2280, m_numRefIdxL1DefaultActive    (1)
2281, m_TransquantBypassEnableFlag  (false)
2282, m_useTransformSkip             (false)
2283, m_dependentSliceSegmentsEnabledFlag    (false)
2284, m_tilesEnabledFlag               (false)
2285, m_entropyCodingSyncEnabledFlag   (false)
2286, m_loopFilterAcrossTilesEnabledFlag  (true)
2287, m_uniformSpacingFlag           (0)
2288, m_iNumColumnsMinus1            (0)
2289, m_puiColumnWidth               (NULL)
2290, m_iNumRowsMinus1               (0)
2291, m_puiRowHeight                 (NULL)
2292, m_iNumSubstreams             (1)
2293, m_signHideFlag(0)
2294, m_cabacInitPresentFlag        (false)
2295, m_encCABACTableIdx            (I_SLICE)
2296, m_sliceHeaderExtensionPresentFlag    (false)
2297, m_loopFilterAcrossSlicesEnabledFlag (false)
2298, m_listsModificationPresentFlag(  0)
2299, m_numExtraSliceHeaderBits(0)
2300#if H_MV
2301, m_ppsInferScalingListFlag(false)
2302, m_ppsScalingListRefLayerId(0)
2303#endif
2304{
2305  m_scalingList = new TComScalingList;
2306}
2307
2308TComPPS::~TComPPS()
2309{
2310  if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2311  {
2312    if (m_puiColumnWidth) delete [] m_puiColumnWidth; 
2313    m_puiColumnWidth = NULL;
2314  }
2315  if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2316  {
2317    if (m_puiRowHeight) delete [] m_puiRowHeight;
2318    m_puiRowHeight = NULL;
2319  }
2320  delete m_scalingList;
2321}
2322
2323#if H_MV
2324Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
2325{
2326  if ( layerIdCurr > 0 )
2327  { 
2328    TComRepFormat* repFormat = vps->getRepFormat( vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ); 
2329    if ( !getUpdateRepFormatFlag() )
2330    {       
2331      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
2332      //// ToDo: add when supported:
2333      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
2334
2335      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
2336      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
2337
2338      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
2339      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
2340
2341      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2342      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
2343    }
2344    else
2345    {
2346      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
2347      //// ToDo: add when supported:
2348      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ;
2349
2350      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    ); 
2351      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   ); 
2352
2353      assert( getBitDepthY()              <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
2354      assert( getBitDepthC()              <= repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2355    }
2356  }
2357
2358  // Set conformance window
2359  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
2360  getConformanceWindow().scaleOffsets( scal );
2361  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
2362}
2363
2364Void TComSPS::inferScalingList( TComSPS* spsSrc )
2365{
2366  if ( getSpsInferScalingListFlag() ) 
2367  {
2368    assert( spsSrc != NULL ); 
2369    assert( !spsSrc->getSpsInferScalingListFlag() );             
2370    getScalingList()->inferFrom( spsSrc->getScalingList() ); 
2371  }
2372}
2373#endif
2374#if H_3D
2375Void
2376TComSPS::initCamParaSPS( UInt uiViewIndex, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
2377{
2378  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
2379 
2380  m_uiCamParPrecision     = ( uiViewIndex ? uiCamParPrecision : 0 );
2381  m_bCamParInSliceHeader  = ( uiViewIndex ? bCamParSlice  : false );
2382  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
2383  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
2384
2385  if( !m_bCamParInSliceHeader )
2386  {
2387    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
2388    {
2389      m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
2390      m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
2391      m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
2392      m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
2393    }
2394  }
2395}
2396#endif
2397TComReferencePictureSet::TComReferencePictureSet()
2398: m_numberOfPictures (0)
2399, m_numberOfNegativePictures (0)
2400, m_numberOfPositivePictures (0)
2401, m_numberOfLongtermPictures (0)
2402, m_interRPSPrediction (0) 
2403, m_deltaRIdxMinus1 (0)   
2404, m_deltaRPS (0) 
2405, m_numRefIdc (0) 
2406{
2407  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2408  ::memset( m_POC, 0, sizeof(m_POC) );
2409  ::memset( m_used, 0, sizeof(m_used) );
2410  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
2411}
2412
2413TComReferencePictureSet::~TComReferencePictureSet()
2414{
2415}
2416
2417Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2418{
2419  m_used[bufferNum] = used;
2420}
2421
2422Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2423{
2424  m_deltaPOC[bufferNum] = deltaPOC;
2425}
2426
2427Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2428{
2429  m_numberOfPictures = numberOfPictures;
2430}
2431
2432Int TComReferencePictureSet::getUsed(Int bufferNum)
2433{
2434  return m_used[bufferNum];
2435}
2436
2437Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2438{
2439  return m_deltaPOC[bufferNum];
2440}
2441
2442Int TComReferencePictureSet::getNumberOfPictures()
2443{
2444  return m_numberOfPictures;
2445}
2446
2447Int TComReferencePictureSet::getPOC(Int bufferNum)
2448{
2449  return m_POC[bufferNum];
2450}
2451
2452Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2453{
2454  m_POC[bufferNum] = POC;
2455}
2456
2457Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2458{
2459  return m_bCheckLTMSB[bufferNum];
2460}
2461
2462Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2463{
2464  m_bCheckLTMSB[bufferNum] = b;
2465}
2466
2467/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2468 * \param uiBufferNum
2469 * \param iRefIdc
2470 * \returns Void
2471 */
2472Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2473{
2474  m_refIdc[bufferNum] = refIdc;
2475}
2476
2477/** get the reference idc value at uiBufferNum
2478 * \param uiBufferNum
2479 * \returns Int
2480 */
2481Int  TComReferencePictureSet::getRefIdc(Int bufferNum)
2482{
2483  return m_refIdc[bufferNum];
2484}
2485
2486/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2487 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
2488 *  +ve values are in increasing order.
2489 * \returns Void
2490 */
2491Void TComReferencePictureSet::sortDeltaPOC()
2492{
2493  // sort in increasing order (smallest first)
2494  for(Int j=1; j < getNumberOfPictures(); j++)
2495  { 
2496    Int deltaPOC = getDeltaPOC(j);
2497    Bool used = getUsed(j);
2498    for (Int k=j-1; k >= 0; k--)
2499    {
2500      Int temp = getDeltaPOC(k);
2501      if (deltaPOC < temp)
2502      {
2503        setDeltaPOC(k+1, temp);
2504        setUsed(k+1, getUsed(k));
2505        setDeltaPOC(k, deltaPOC);
2506        setUsed(k, used);
2507      }
2508    }
2509  }
2510  // flip the negative values to largest first
2511  Int numNegPics = getNumberOfNegativePictures();
2512  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2513  { 
2514    Int deltaPOC = getDeltaPOC(j);
2515    Bool used = getUsed(j);
2516    setDeltaPOC(j, getDeltaPOC(k));
2517    setUsed(j, getUsed(k));
2518    setDeltaPOC(k, deltaPOC);
2519    setUsed(k, used);
2520  }
2521}
2522
2523/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2524 *  A "*" is added to the deltaPOC value if it is Used bu current.
2525 * \returns Void
2526 */
2527Void TComReferencePictureSet::printDeltaPOC()
2528{
2529  printf("DeltaPOC = { ");
2530  for(Int j=0; j < getNumberOfPictures(); j++)
2531  {
2532    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2533  } 
2534  if (getInterRPSPrediction()) 
2535  {
2536    printf("}, RefIdc = { ");
2537    for(Int j=0; j < getNumRefIdc(); j++)
2538    {
2539      printf("%d ", getRefIdc(j));
2540    } 
2541  }
2542  printf("}\n");
2543}
2544
2545TComRPSList::TComRPSList()
2546:m_referencePictureSets (NULL)
2547{
2548}
2549
2550TComRPSList::~TComRPSList()
2551{
2552}
2553
2554Void TComRPSList::create( Int numberOfReferencePictureSets)
2555{
2556  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2557  m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2558}
2559
2560Void TComRPSList::destroy()
2561{
2562  if (m_referencePictureSets)
2563  {
2564    delete [] m_referencePictureSets;
2565  }
2566  m_numberOfReferencePictureSets = 0;
2567  m_referencePictureSets = NULL;
2568}
2569
2570
2571
2572TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2573{
2574  return &m_referencePictureSets[referencePictureSetNum];
2575}
2576
2577Int TComRPSList::getNumberOfReferencePictureSets()
2578{
2579  return m_numberOfReferencePictureSets;
2580}
2581
2582Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2583{
2584  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2585}
2586
2587TComRefPicListModification::TComRefPicListModification()
2588: m_bRefPicListModificationFlagL0 (false)
2589, m_bRefPicListModificationFlagL1 (false)
2590{
2591  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2592  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2593}
2594
2595TComRefPicListModification::~TComRefPicListModification()
2596{
2597}
2598
2599TComScalingList::TComScalingList()
2600{
2601  init();
2602}
2603TComScalingList::~TComScalingList()
2604{
2605  destroy();
2606}
2607
2608/** set default quantization matrix to array
2609*/
2610Void TComSlice::setDefaultScalingList()
2611{
2612  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2613  {
2614    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2615    {
2616      getScalingList()->processDefaultMarix(sizeId, listId);
2617    }
2618  }
2619}
2620/** check if use default quantization matrix
2621 * \returns true if use default quantization matrix in all size
2622*/
2623Bool TComSlice::checkDefaultScalingList()
2624{
2625  UInt defaultCounter=0;
2626
2627  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2628  {
2629    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2630    {
2631      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
2632     && ((sizeId < SCALING_LIST_16x16) || (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
2633      {
2634        defaultCounter++;
2635      }
2636    }
2637  }
2638  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32
2639}
2640
2641#if H_MV
2642Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
2643{
2644  refPicSetInterLayer0.clear(); 
2645  refPicSetInterLayer1.clear(); 
2646
2647  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
2648  {
2649    Int layerIdRef = getRefPicLayerId( i ); 
2650    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ; 
2651    assert ( picRef != 0 ); 
2652
2653    picRef->getPicYuvRec()->extendPicBorder(); 
2654    picRef->setIsLongTerm( true );       
2655    picRef->getSlice(0)->setReferenced( true );       
2656
2657    Int viewIdCur  = getVPS()->getViewId( getLayerId() ); 
2658    Int viewIdZero = getVPS()->getViewId( 0 );
2659    Int viewIdRef  = getVPS()->getViewId( layerIdRef ); 
2660
2661    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
2662    {
2663      refPicSetInterLayer0.push_back( picRef ); 
2664    }
2665    else
2666    {
2667      refPicSetInterLayer1.push_back( picRef ); 
2668    }
2669    // Consider to check here:
2670    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "   
2671  }
2672}
2673
2674Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
2675{
2676  // Mark as shortterm
2677  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ ) 
2678  {
2679    refPicSetInterLayer0[i]->setIsLongTerm( false ); 
2680  }
2681
2682  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ ) 
2683  {
2684    refPicSetInterLayer1[i]->setIsLongTerm( false ); 
2685  }
2686
2687}
2688Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
2689{
2690  // Fill targetDecLayerIdSet with all layers if empty.
2691  if (targetDecLayerIdSet.size() == 0 )   
2692  {
2693    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
2694    {
2695      targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) ); 
2696    }
2697  }     
2698
2699  Int numTargetDecLayers = (Int) targetDecLayerIdSet.size(); 
2700  Int latestDecIdx; 
2701  for ( latestDecIdx = 0; latestDecIdx < numTargetDecLayers; latestDecIdx++)
2702  {
2703    if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
2704    {
2705      break; 
2706  }       
2707  }       
2708
2709  for( Int i = 0; i <= latestDecIdx; i++ ) 
2710  {
2711    if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ i ] ) )
2712    {
2713      TComPic* pcPic = ivPicLists->getPic( targetDecLayerIdSet[ i ], curPoc ); 
2714      if( pcPic->getSlice(0)->isReferenced() && pcPic->getSlice(0)->getTemporalLayerNonReferenceFlag() ) 
2715      { 
2716        Bool remainingInterLayerReferencesFlag = false; 
2717        for( Int j = latestDecIdx + 1; j < numTargetDecLayers; j++ )
2718        { 
2719          TComVPS* vpsSlice = pcPic->getSlice(0)->getVPS(); 
2720          if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
2721          {
2722            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
2723            {
2724              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
2725              {
2726                remainingInterLayerReferencesFlag = true;
2727          }
2728        }
2729          }
2730        }
2731        if( !remainingInterLayerReferencesFlag )
2732        {
2733          pcPic->getSlice(0)->setReferenced( false );                   
2734      }
2735    }
2736  }
2737}
2738}
2739
2740Void TComSlice::printRefPicList()
2741{ 
2742  for ( Int li = 0; li < 2; li++)
2743  {   
2744    std::cout << std::endl << "RefPicListL" <<  li << ":" << std::endl; 
2745    for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
2746    {     
2747      if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( true );
2748       
2749      m_apcRefPicList[li][rIdx]->print( false );
2750    }
2751  }
2752}
2753
2754Void TComSlice::markCurrPic( TComPic* currPic )
2755{
2756  if ( !currPic->getSlice(0)->getDiscardableFlag() )
2757  {
2758    currPic->getSlice(0)->setReferenced( true ) ; 
2759    currPic->setIsLongTerm( false ); 
2760  }
2761  else
2762  {
2763    currPic->getSlice(0)->setReferenced( false ) ; 
2764  }
2765}
2766
2767Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
2768{
2769  m_refPicSetInterLayer0 = refPicSetInterLayer0; 
2770  m_refPicSetInterLayer1 = refPicSetInterLayer1; 
2771}
2772
2773TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
2774{
2775  assert ( setIdc == 0 || setIdc == 1);   
2776  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
2777  assert( refPicSetInterLayer != 0 ); 
2778 
2779  TComPic* pcPic = NULL; 
2780  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
2781  {
2782    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
2783    {
2784      pcPic = (*refPicSetInterLayer)[ i ]; 
2785    }
2786  }
2787
2788  assert(pcPic != NULL); 
2789  return pcPic;
2790}
2791Int TComSlice::getNumActiveRefLayerPics()
2792{
2793  Int numActiveRefLayerPics; 
2794
2795  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerId() ) ==  0 )
2796  {
2797    numActiveRefLayerPics = 0; 
2798  }
2799  else if (getVPS()->getAllRefLayersActiveFlag() )
2800  {
2801    numActiveRefLayerPics = getVPS()->getNumDirectRefLayers( getLayerId() );
2802  }
2803  else if ( !getInterLayerPredEnabledFlag() )
2804  {
2805    numActiveRefLayerPics = 0; 
2806  }
2807  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
2808  {
2809    numActiveRefLayerPics = 1; 
2810  }
2811  else
2812  {
2813    numActiveRefLayerPics = getNumInterLayerRefPicsMinus1() + 1; 
2814  }
2815  return numActiveRefLayerPics;
2816}
2817
2818Int TComSlice::getRefPicLayerId( Int i )
2819{
2820  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
2821}
2822
2823#if H_3D_ARP
2824Void TComSlice::setARPStepNum()                                 
2825{
2826  Bool bAllIvRef = true;
2827
2828  if(!getVPS()->getUseAdvRP(getLayerId()))
2829  {
2830    m_nARPStepNum = 0;
2831  }
2832  else
2833  {
2834    for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
2835    {
2836      RefPicList  eRefPicList = RefPicList( iRefListId );
2837      Int iNumRefIdx = getNumRefIdx(eRefPicList);
2838     
2839      if( iNumRefIdx <= 0 )
2840      {
2841        continue;
2842      }
2843
2844      for ( Int i = 0; i < iNumRefIdx; i++ )
2845      {
2846        if( getRefPic( eRefPicList, i)->getPOC() != getPOC() )
2847        {
2848          bAllIvRef = false;
2849          break;
2850        }
2851      }
2852
2853      if( bAllIvRef == false ) { break; }
2854    }
2855    m_nARPStepNum = !bAllIvRef ? getVPS()->getARPStepNum(getLayerId()) : 0;
2856  }
2857}
2858#endif
2859#if H_3D_IC
2860Void TComSlice::xSetApplyIC()
2861{
2862  Int iMaxPelValue = ( 1 << g_bitDepthY ); 
2863  Int *aiRefOrgHist;
2864  Int *aiCurrHist;
2865  aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
2866  aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
2867  memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
2868  memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
2869  // Reference Idx Number
2870  Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
2871  TComPic* pcCurrPic = NULL;
2872  TComPic* pcRefPic = NULL;
2873  TComPicYuv* pcCurrPicYuv = NULL;
2874  TComPicYuv* pcRefPicYuvOrg = NULL;
2875  pcCurrPic = getPic();
2876  pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
2877  Int iWidth = pcCurrPicYuv->getWidth();
2878  Int iHeight = pcCurrPicYuv->getHeight();
2879
2880
2881  // Get InterView Reference picture
2882  // !!!!! Assume only one Interview Reference Picture in L0
2883  for ( Int i = 0; i < iNumRefIdx; i++ )
2884  {
2885    pcRefPic = getRefPic( REF_PIC_LIST_0, i );
2886    if ( pcRefPic != NULL )
2887    {
2888      if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
2889      {
2890        pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
2891      }
2892    }
2893  }
2894
2895  if ( pcRefPicYuvOrg != NULL )
2896  {
2897    Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
2898    Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
2899    Int iCurrStride = pcCurrPicYuv->getStride();
2900    Int iRefStride = pcRefPicYuvOrg->getStride();
2901    Int iSumOrgSAD = 0;
2902    Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
2903
2904    // Histogram building - luminance
2905    for ( Int y = 0; y < iHeight; y++ )
2906    {
2907      for ( Int x = 0; x < iWidth; x++ )
2908      {
2909        aiCurrHist[pCurrY[x]]++;
2910        aiRefOrgHist[pRefOrgY[x]]++;
2911      }
2912      pCurrY += iCurrStride;
2913      pRefOrgY += iRefStride;
2914    }
2915    // Histogram SAD
2916    for ( Int i = 0; i < iMaxPelValue; i++ )
2917    {
2918      iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
2919    }
2920    // Setting
2921    if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
2922    {
2923      m_bApplyIC = true;
2924    }
2925    else
2926    {
2927      m_bApplyIC = false;
2928    }
2929  }
2930
2931  xFree( aiCurrHist   );
2932  xFree( aiRefOrgHist );
2933  aiCurrHist = NULL;
2934  aiRefOrgHist = NULL;
2935}
2936#endif
2937#if H_3D
2938Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
2939{
2940  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
2941  {     
2942    for ( Int depthId = 0; depthId < 2; depthId++ )
2943    {
2944      m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , getPOC() ) : NULL;
2945    }       
2946  } 
2947}
2948Void TComSlice::setDepthToDisparityLUTs()
2949{ 
2950  Bool setupLUT = false; 
2951  Int layerIdInVPS = getVPS()->getLayerIdInNuh( m_layerId ); 
2952
2953#if H_3D_VSP
2954  setupLUT = setupLUT || getVPS()->getViewSynthesisPredFlag( layerIdInVPS); 
2955#endif
2956
2957#if H_3D_NBDV_REF
2958  setupLUT = setupLUT || getVPS()->getDepthRefinementFlag( layerIdInVPS );
2959#endif
2960
2961  if( !setupLUT )
2962    return; 
2963
2964  /// GT: Allocation should be moved to a better place later;
2965  if ( m_depthToDisparityB == NULL )
2966  {
2967    m_depthToDisparityB = new Int*[ getViewIndex() ];
2968    for ( Int i = 0; i < getViewIndex(); i++ )
2969    {
2970      m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
2971    }
2972  }
2973
2974  if ( m_depthToDisparityF == NULL )
2975  {
2976    m_depthToDisparityF= new Int*[ getViewIndex() ];
2977    for ( Int i = 0; i < getViewIndex(); i++ )
2978    {
2979      m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
2980    }
2981  }
2982
2983  assert( m_depthToDisparityB != NULL ); 
2984  assert( m_depthToDisparityF != NULL ); 
2985
2986  TComSPS* sps = getSPS(); 
2987
2988  Int log2Div = g_bitDepthY - 1 + sps->getCamParPrecision();
2989
2990  Bool camParaSH = m_pcSPS->hasCamParInSliceHeader();
2991
2992  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : sps->getCodedScale    (); 
2993  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : sps->getCodedOffset   (); 
2994  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : sps->getInvCodedScale (); 
2995  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : sps->getInvCodedOffset(); 
2996
2997  for (Int i = 0; i <= ( getViewIndex() - 1); i++)
2998  {
2999    for ( Int d = 0; d <= ( ( 1 << g_bitDepthY ) - 1 ); d++ )
3000    {
3001      Int offset =    ( codOffset  [ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3002      m_depthToDisparityB[ i ][ d ] = ( codScale [ i ] * d + offset ) >> log2Div; 
3003
3004      Int invOffset = ( invCodOffset[ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3005      m_depthToDisparityF[ i ][ d ] = ( invCodScale[ i ] * d + invOffset ) >> log2Div; 
3006    }
3007  }
3008}
3009#endif
3010#endif
3011/** get scaling matrix from RefMatrixID
3012 * \param sizeId size index
3013 * \param Index of input matrix
3014 * \param Index of reference matrix
3015 */
3016Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
3017{
3018  ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3019}
3020
3021/** parse syntax infomation
3022 *  \param pchFile syntax infomation
3023 *  \returns false if successful
3024 */
3025Bool TComScalingList::xParseScalingList(Char* pchFile)
3026{
3027  FILE *fp;
3028  Char line[1024];
3029  UInt sizeIdc,listIdc;
3030  UInt i,size = 0;
3031  Int *src=0,data;
3032  Char *ret;
3033  UInt  retval;
3034
3035  if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
3036  {
3037    printf("can't open file %s :: set Default Matrix\n",pchFile);
3038    return true;
3039  }
3040
3041  for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
3042  {
3043    size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
3044    for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
3045    {
3046      src = getScalingListAddress(sizeIdc, listIdc);
3047
3048      fseek(fp,0,0);
3049      do 
3050      {
3051        ret = fgets(line, 1024, fp);
3052        if ((ret==NULL)||(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
3053        {
3054          printf("Error: can't read Matrix :: set Default Matrix\n");
3055          return true;
3056        }
3057      }
3058      while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
3059      for (i=0; i<size; i++)
3060      {
3061        retval = fscanf(fp, "%d,", &data);
3062        if (retval!=1)
3063        {
3064          printf("Error: can't read Matrix :: set Default Matrix\n");
3065          return true;
3066        }
3067        src[i] = data;
3068      }
3069      //set DC value for default matrix check
3070      setScalingListDC(sizeIdc,listIdc,src[0]);
3071
3072      if(sizeIdc > SCALING_LIST_8x8)
3073      {
3074        fseek(fp,0,0);
3075        do 
3076        {
3077          ret = fgets(line, 1024, fp);
3078          if ((ret==NULL)||(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
3079          {
3080            printf("Error: can't read DC :: set Default Matrix\n");
3081            return true;
3082          }
3083        }
3084        while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
3085        retval = fscanf(fp, "%d,", &data);
3086        if (retval!=1)
3087        {
3088          printf("Error: can't read Matrix :: set Default Matrix\n");
3089          return true;
3090        }
3091        //overwrite DC value when size of matrix is larger than 16x16
3092        setScalingListDC(sizeIdc,listIdc,data);
3093      }
3094    }
3095  }
3096  fclose(fp);
3097  return false;
3098}
3099
3100#if H_MV
3101Void TComScalingList::inferFrom( TComScalingList* srcScLi )
3102{
3103  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3104  {
3105    for(Int listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
3106    {
3107      setRefMatrixId  (sizeId,listId, srcScLi->getRefMatrixId  (sizeId,listId));
3108      setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));         
3109      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3110    }
3111  }
3112}
3113#endif
3114/** initialization process of quantization matrix array
3115 */
3116Void TComScalingList::init()
3117{
3118  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3119  {
3120    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3121    {
3122      m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
3123    }
3124  }
3125  m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
3126}
3127
3128/** destroy quantization matrix array
3129 */
3130Void TComScalingList::destroy()
3131{
3132  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3133  {
3134    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3135    {
3136      if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
3137    }
3138  }
3139}
3140
3141/** get default address of quantization matrix
3142 * \param sizeId size index
3143 * \param listId list index
3144 * \returns pointer of quantization matrix
3145 */
3146Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
3147{
3148  Int *src = 0;
3149  switch(sizeId)
3150  {
3151    case SCALING_LIST_4x4:
3152      src = g_quantTSDefault4x4;
3153      break;
3154    case SCALING_LIST_8x8:
3155      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3156      break;
3157    case SCALING_LIST_16x16:
3158      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3159      break;
3160    case SCALING_LIST_32x32:
3161      src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3162      break;
3163    default:
3164      assert(0);
3165      src = NULL;
3166      break;
3167  }
3168  return src;
3169}
3170
3171/** process of default matrix
3172 * \param sizeId size index
3173 * \param Index of input matrix
3174 */
3175Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
3176{
3177  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3178  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
3179}
3180
3181/** check DC value of matrix for default matrix signaling
3182 */
3183Void TComScalingList::checkDcOfMatrix()
3184{
3185  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3186  {
3187    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3188    {
3189      //check default matrix?
3190      if(getScalingListDC(sizeId,listId) == 0)
3191      {
3192        processDefaultMarix(sizeId, listId);
3193      }
3194    }
3195  }
3196}
3197
3198ParameterSetManager::ParameterSetManager()
3199: m_vpsMap(MAX_NUM_VPS)
3200, m_spsMap(MAX_NUM_SPS)
3201, m_ppsMap(MAX_NUM_PPS)
3202, m_activeVPSId(-1)
3203#if !H_MV
3204, m_activeSPSId(-1)
3205, m_activePPSId(-1)
3206{
3207#else
3208{
3209  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3210  {
3211    m_activeSPSId[ i ] = -1; 
3212    m_activePPSId[ i ] = -1; 
3213  }
3214#endif
3215}
3216
3217
3218ParameterSetManager::~ParameterSetManager()
3219{
3220}
3221
3222//! activate a SPS from a active parameter sets SEI message
3223//! \returns true, if activation is successful
3224#if H_MV
3225Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
3226#else
3227Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
3228#endif
3229{
3230  TComSPS *sps = m_spsMap.getPS(spsId);
3231  if (sps)
3232  {
3233    Int vpsId = sps->getVPSId();
3234    if (m_vpsMap.getPS(vpsId))
3235    {
3236      m_activeVPSId = vpsId;
3237#if H_MV
3238      m_activeSPSId[ layerId ] = spsId;
3239#else
3240      m_activeSPSId = spsId;
3241#endif
3242      return true;
3243    }
3244    else
3245    {
3246      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
3247    }
3248  }
3249  else
3250  {
3251    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
3252  }
3253  return false;
3254}
3255
3256//! activate a PPS and depending on isIDR parameter also SPS and VPS
3257//! \returns true, if activation is successful
3258#if H_MV
3259Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
3260#else
3261Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
3262#endif
3263{
3264  TComPPS *pps = m_ppsMap.getPS(ppsId);
3265  if (pps)
3266  {
3267    Int spsId = pps->getSPSId();
3268#if H_MV
3269    if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
3270#else
3271    if (!isIRAP && (spsId != m_activeSPSId))
3272#endif
3273    {
3274      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
3275      return false;
3276    }
3277
3278    TComSPS *sps = m_spsMap.getPS(spsId);
3279    if (sps)
3280    {
3281      Int vpsId = sps->getVPSId();
3282      if (!isIRAP && (vpsId != m_activeVPSId))
3283      {
3284        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
3285        return false;
3286      }
3287      if (m_vpsMap.getPS(vpsId))
3288      {
3289#if H_MV
3290        m_activePPSId[ layerId ] = ppsId;
3291        m_activeVPSId = vpsId;
3292        m_activeSPSId[ layerId ] = spsId;
3293#else
3294        m_activePPSId = ppsId;
3295        m_activeVPSId = vpsId;
3296        m_activeSPSId = spsId;
3297#endif
3298        return true;
3299      }
3300      else
3301      {
3302        printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
3303      }
3304    }
3305    else
3306    {
3307      printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
3308    }
3309  }
3310  else
3311  {
3312    printf("Warning: tried to activate non-existing PPS.");
3313  }
3314  return false;
3315}
3316
3317ProfileTierLevel::ProfileTierLevel()
3318  : m_profileSpace    (0)
3319  , m_tierFlag        (false)
3320  , m_profileIdc      (0)
3321  , m_levelIdc        (0)
3322, m_progressiveSourceFlag  (false)
3323, m_interlacedSourceFlag   (false)
3324, m_nonPackedConstraintFlag(false)
3325, m_frameOnlyConstraintFlag(false)
3326{
3327  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
3328}
3329
3330TComPTL::TComPTL()
3331{
3332  ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3333  ::memset(m_subLayerLevelPresentFlag,   0, sizeof(m_subLayerLevelPresentFlag  ));
3334}
3335
3336#if H_MV
3337Void TComPTL::copyLevelFrom( TComPTL* source )
3338{
3339  getGeneralPTL()->setLevelIdc( source->getGeneralPTL()->getLevelIdc() );
3340  for( Int subLayer = 0; subLayer < 6; subLayer++ )
3341  {
3342    setSubLayerLevelPresentFlag( subLayer, source->getSubLayerLevelPresentFlag( subLayer ) );
3343    getSubLayerPTL( subLayer )->setLevelIdc( source->getSubLayerPTL( subLayer )->getLevelIdc() );
3344  }
3345}
3346#endif
3347//! \}
3348
3349#if H_MV
3350TComVPSVUI::TComVPSVUI()
3351{
3352  m_bitRatePresentVpsFlag = false;
3353  m_picRatePresentVpsFlag = false;
3354  for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
3355  {   
3356    for ( Int j = 0; j < MAX_TLAYER; j++)
3357    {   
3358      m_bitRatePresentFlag          [i][j] = false;
3359      m_picRatePresentFlag          [i][j] = false;
3360      m_avgBitRate                  [i][j] = -1;
3361      m_maxBitRate                  [i][j] = -1;
3362      m_constantPicRateIdc          [i][j] = -1;
3363      m_avgPicRate                  [i][j] = -1;
3364    }
3365  }
3366
3367  m_ilpRestrictedRefLayersFlag = false;
3368
3369  for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
3370  {         
3371    for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
3372    {   
3373      m_tileBoundariesAlignedFlag   [i][j] = false;
3374      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
3375      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
3376      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
3377    }
3378  }
3379}
3380#endif
Note: See TracBrowser for help on using the repository browser.