source: 3DVCSoftware/branches/HTM-11.2-dev2-MediaTek/source/Lib/TLibCommon/TComSlice.cpp @ 1007

Last change on this file since 1007 was 1007, checked in by mediatek-htm, 10 years ago

JCT3V-I0099. Changes of sub-PU size signaling and lim_qt_pred_flag signaling in VPS extension 2. Remove use_qtl_flag and use_pc_flag.

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