source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComSlice.cpp @ 964

Last change on this file since 964 was 964, checked in by tech, 10 years ago
  • Merged 11.0-dev0@963. (Update to HM 14.0 + MV-HEVC Draft 8 HLS)
  • Added coding results.
  • Changed version number.
  • Property svn:eol-style set to native
File size: 130.5 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_HLS_8_POC_Q0142_32
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_HLS_8_SYN_Q0041_03
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#if H_MV_HLS_8_SYN_39_19
1886  m_numAddLayerSets              = 0;   
1887  m_numAddOlss                   = 0; 
1888#else
1889  m_numAddLayerSets              = -1;   
1890#endif
1891  m_defaultOutputLayerIdc     = 0; 
1892 
1893  for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
1894  {
1895    m_layerSetIdxForOlsMinus1[i]  = -1; 
1896    m_profileLevelTierIdx[i]      = 0; 
1897    for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
1898    {
1899      m_outputLayerFlag[i][j] = false; 
1900    }
1901    m_altOutputLayerFlag[ i ]       = false; 
1902  }
1903
1904#if H_MV_HLS_8_PMS_Q0195_20
1905  m_repFormatIdxPresentFlag = false; 
1906#endif
1907  m_maxOneActiveRefLayerFlag = false; 
1908  m_directDepTypeLenMinus2   = 0;         
1909 
1910
1911#if H_MV_HLS_8_RPS_Q0100_36
1912  m_vpsExtensionFlag = true; 
1913#endif
1914  m_avcBaseLayerFlag = false;
1915  m_vpsNonVuiExtensionLength = 0;
1916  m_splittingFlag    = false;
1917 
1918  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
1919  {
1920    m_scalabilityMaskFlag[i] = false;
1921    m_dimensionIdLen [i]  = -1; 
1922  }
1923
1924  m_vpsNuhLayerIdPresentFlag = false;
1925
1926  for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
1927  {
1928    m_vpsProfilePresentFlag   [i] = false;
1929    m_layerSetIdxForOlsMinus1       [i] = 0;
1930    for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
1931    {
1932      m_outputLayerFlag[i][j] = false;
1933    }
1934  }
1935
1936  for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
1937  {
1938    m_layerIdInVps[i] =  (i == 0 ) ? 0 : -1;         
1939  }
1940
1941  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1942  {
1943    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1; 
1944    m_numDirectRefLayers[i] = 0; 
1945    m_vpsRepFormatIdx    [i] = 0; 
1946    m_pocLsbNotPresentFlag[i] = 0;
1947    m_repFormat          [i] = NULL; 
1948    m_viewIdVal          [i] = 0; 
1949
1950#if H_3D
1951    m_viewIndex         [i] = -1; 
1952    m_vpsDepthModesFlag [i] = false;
1953    m_ivMvScalingFlag = true; 
1954#endif
1955
1956    for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
1957    {
1958      m_directDependencyFlag[i][j] = false;
1959      m_directDependencyType[i][j] = -1; 
1960      m_refLayerId[i][j]           = -1; 
1961      m_maxTidIlRefPicsPlus1[i][j]  = 7;
1962    }
1963
1964    for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
1965    {
1966      m_dimensionId[i][j] = 0;
1967    }
1968#if H_3D_ARP
1969    m_uiUseAdvResPred[i]  = 0;
1970    m_uiARPStepNum[i]     = 1;
1971#endif
1972  }
1973  m_vpsVUI = new TComVPSVUI; 
1974  m_dpbSize = new TComDpbSize; 
1975
1976#if H_3D
1977  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1978  {
1979#if H_3D_IV_MERGE
1980    m_ivMvPredFlag         [ i ] = false;
1981#if H_3D_SPIVMP
1982    m_iSubPULog2Size       [ i ] = 0;
1983#endif
1984#endif
1985#if H_3D_VSP
1986    m_viewSynthesisPredFlag[ i ] = false;
1987#endif
1988#if H_3D_NBDV_REF
1989    m_depthRefinementFlag  [ i ] = false;
1990#endif
1991#if H_3D_INTER_SDC
1992    m_bInterSDCFlag        [ i ] = false;
1993#endif
1994#if H_3D_DBBP
1995    m_dbbpFlag             [ i ] = false;
1996#endif
1997#if H_3D_IV_MERGE
1998    m_bMPIFlag             [ i ] = false;
1999#endif
2000  } 
2001#endif
2002#endif
2003}
2004
2005TComVPS::~TComVPS()
2006{
2007  if( m_hrdParameters    != NULL )     delete[] m_hrdParameters;
2008  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
2009  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
2010#if H_MV
2011  if ( m_vpsVUI          != NULL )     delete m_vpsVUI; 
2012  if ( m_dpbSize         != NULL )     delete m_dpbSize; 
2013
2014  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2015  {
2016    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];   
2017  }
2018#endif
2019#if H_3D
2020  deleteCamPars();
2021#endif
2022}
2023
2024#if H_MV
2025
2026Bool TComVPS::checkVPSExtensionSyntax()
2027{
2028  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
2029  {
2030    // check layer_id_in_nuh constraint
2031    assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
2032  }
2033
2034
2035#if H_MV_HLS_8_PMS_Q0195_20
2036  //The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
2037  assert( getVpsNumRepFormatsMinus1() >= 0 ); 
2038  assert( getVpsNumRepFormatsMinus1() <= 255 ); 
2039#endif
2040
2041  return true; 
2042}
2043
2044Int TComVPS::getNumScalabilityTypes()
2045{
2046  return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
2047}
2048
2049Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
2050{
2051  assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES ); 
2052  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
2053  Int scalIdx = 0; 
2054  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
2055  {
2056    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
2057
2058  }
2059
2060  return scalIdx; 
2061}
2062Void TComVPS::setScalabilityMaskFlag( UInt val )
2063{
2064  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ ) 
2065  {
2066    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
2067  }
2068}
2069
2070Void TComVPS::setRefLayers()
2071{
2072  for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
2073  {
2074    Int iNuhLId = getLayerIdInNuh( i ); 
2075    m_numDirectRefLayers[ iNuhLId ] = 0; 
2076    for( Int j = 0; j < i; j++ )
2077    {
2078      if( getDirectDependencyFlag(i , j) )
2079      {
2080        m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
2081      }
2082    }
2083  }
2084
2085#if H_MV_HLS_8
2086  for (Int i = 0 ; i < MAX_NUM_LAYER_IDS; i++ )
2087  {
2088    m_numRefLayers[i] = 0; 
2089  }
2090
2091  for (Int currLayerId = 0; currLayerId <= 62; currLayerId++ ) 
2092  {
2093    for (Int i = 0 ; i < MAX_NUM_LAYER_IDS; i++ )
2094    {
2095      m_recursiveRefLayerFlag[currLayerId][i] = 0; 
2096    }
2097  }
2098
2099
2100  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
2101  {
2102    Int iNuhLId = getLayerIdInNuh( i );
2103    xSetRefLayerFlags( iNuhLId );
2104    for( Int j = 0; j < 63; j++ )
2105    {
2106      m_numRefLayers[ iNuhLId ]  +=  m_recursiveRefLayerFlag[ iNuhLId ][ j ];
2107    }
2108  }
2109
2110
2111  for( Int i = 0; i <= getMaxLayersMinus1(); i++ )  // Bug in spec "<" instead of "<="
2112  {
2113    Int iNuhLId = getLayerIdInNuh( i );
2114    Int predIdx = 0;
2115    for( Int j = iNuhLId + 1; j < 63; j++ )
2116    {
2117      if( m_recursiveRefLayerFlag[ j ][ iNuhLId ] )
2118      {
2119        m_predictedLayerId[ iNuhLId ][ predIdx++ ] = j;
2120      }
2121    }
2122    m_numPredictedLayers[ iNuhLId ] = predIdx;
2123  }
2124 
2125  Bool countedLayerIdxFlag[ MAX_NUM_LAYERS ]; 
2126  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
2127  {
2128    countedLayerIdxFlag[ i ] = 0;
2129  }
2130 
2131  for( Int i = 0, k = 0; i  <=  getMaxLayersMinus1(); i++ )
2132  {
2133    Int iNuhLId = getLayerIdInNuh( i );
2134    if( m_numDirectRefLayers[ iNuhLId ]  ==  0 )
2135    {
2136      m_treePartitionLayerIdList[ k ][ 0 ] = iNuhLId;
2137      m_numLayersInTreePartition[ k ]      = 1;
2138      for( Int j = 0; j < m_numPredictedLayers[ iNuhLId ]; j++ ) 
2139      {
2140        if( !countedLayerIdxFlag[ getLayerIdInVps( m_predictedLayerId[ iNuhLId ][ j ] ) ] )   
2141        {
2142          m_treePartitionLayerIdList[ k ][ m_numLayersInTreePartition[ k ] ] = m_predictedLayerId[ iNuhLId ][ j ];
2143          m_numLayersInTreePartition[ k ]++;
2144          countedLayerIdxFlag[ getLayerIdInVps( m_predictedLayerId[ iNuhLId ][ j ] ) ] = 1;
2145        }
2146      }
2147      k++;
2148    }
2149    m_numIndependentLayers = k;
2150  }
2151#endif
2152}
2153
2154Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
2155{
2156  assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );     
2157  Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];   
2158  assert ( refLayerIdInNuh >= 0 ); 
2159  return refLayerIdInNuh;
2160}
2161
2162Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
2163{
2164  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
2165}
2166
2167#if H_3D
2168Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
2169{
2170  Int foundLayerIdinNuh = -1; 
2171
2172  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
2173  {
2174    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps ); 
2175    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
2176    {
2177      foundLayerIdinNuh = layerIdInNuh; 
2178      break; 
2179    }
2180  }
2181#if !BUG_FIX_TK65
2182  assert( foundLayerIdinNuh != -1 ); 
2183#endif
2184  return foundLayerIdinNuh;
2185}
2186
2187Void TComVPS::createCamPars(Int iNumViews)
2188{
2189  Int i = 0, j = 0;
2190
2191  m_bCamParPresent = new Bool[ iNumViews ];
2192  m_bCamParInSliceHeader = new Bool[ iNumViews ];
2193
2194  m_aaaiCodedScale = new Int**[ iNumViews ];
2195  m_aaaiCodedOffset = new Int**[ iNumViews ];
2196  for ( i = 0; i < iNumViews ; i++ )
2197  {
2198    m_bCamParInSliceHeader[i] = false; 
2199    m_aaaiCodedScale[i] = new Int*[ 2 ];
2200    m_aaaiCodedOffset[i] = new Int*[ 2 ];
2201    for ( j = 0; j < 2; j++ )
2202    {
2203      m_aaaiCodedScale[i][j] = new Int[ MAX_NUM_LAYERS ];
2204      m_aaaiCodedOffset[i][j] = new Int[ MAX_NUM_LAYERS ];
2205      for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
2206      {
2207        m_aaaiCodedScale[i][j][k] = 0;
2208        m_aaaiCodedOffset[i][j][k] = 0;
2209      }
2210    }
2211  }
2212}
2213
2214Void TComVPS::deleteCamPars()
2215{
2216  Int iNumViews = getNumViews();
2217  Int i = 0, j = 0;
2218
2219  if ( m_bCamParPresent != NULL )
2220  {
2221    delete [] m_bCamParPresent;
2222  }
2223  if ( m_bCamParInSliceHeader != NULL )
2224  {
2225    delete [] m_bCamParInSliceHeader;
2226  }
2227
2228  if ( m_aaaiCodedScale != NULL )
2229  {
2230    for ( i = 0; i < iNumViews ; i++ )
2231    {
2232      for ( j = 0; j < 2; j++ )
2233      {
2234        delete [] m_aaaiCodedScale[i][j];
2235      }
2236      delete [] m_aaaiCodedScale[i];
2237    }
2238    delete [] m_aaaiCodedScale;
2239  }
2240
2241  if ( m_aaaiCodedOffset != NULL )
2242  {
2243    for ( i = 0; i < iNumViews ; i++ )
2244    {
2245      for ( j = 0; j < 2; j++ )
2246      {
2247        delete [] m_aaaiCodedOffset[i][j];
2248      }
2249      delete [] m_aaaiCodedOffset[i];
2250    }
2251    delete [] m_aaaiCodedOffset;
2252  }
2253}
2254
2255
2256Void
2257  TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
2258{
2259  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
2260
2261  m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
2262  m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent  : false );
2263  m_bCamParInSliceHeader[ uiViewIndex ]  = ( (uiViewIndex != 0)? bCamParSlice  : false );
2264
2265  if( !m_bCamParInSliceHeader[ uiViewIndex ] )
2266  {
2267    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
2268    {
2269      m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
2270      m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
2271      m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
2272      m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
2273    }
2274  }
2275}
2276
2277#endif // H_3D
2278
2279
2280Int TComVPS::xGetDimBitOffset( Int j )
2281{
2282  Int dimBitOffset = 0; 
2283  if ( getSplittingFlag() && j == getNumScalabilityTypes() )
2284  {
2285     dimBitOffset = 6; 
2286  }
2287  else
2288  {
2289    for (Int dimIdx = 0; dimIdx <= j-1; dimIdx++)
2290    {
2291      dimBitOffset += getDimensionIdLen( dimIdx ); 
2292    }
2293  }
2294  return dimBitOffset; 
2295}
2296
2297Int TComVPS::inferDimensionId( Int i, Int j )
2298{
2299    return ( ( getLayerIdInNuh( i ) & ( (1 << xGetDimBitOffset( j + 1 ) ) - 1) ) >> xGetDimBitOffset( j ) ); 
2300}
2301
2302Int TComVPS::inferLastDimsionIdLenMinus1()
2303{
2304  return ( 5 - xGetDimBitOffset( getNumScalabilityTypes() - 1 ) ); 
2305}
2306
2307Int TComVPS::getNumLayersInIdList( Int lsIdx )
2308{
2309  assert( lsIdx >= 0 ); 
2310  assert( lsIdx <= getVpsNumLayerSetsMinus1() ); 
2311  return (Int) m_layerSetLayerIdList[ lsIdx ].size(); 
2312}
2313
2314Int    TComVPS::getNumOutputLayerSets() 
2315{
2316#if H_MV_HLS_8_SYN_39_19
2317  return getNumAddOlss() + getNumLayerSets(); 
2318#else
2319  return getNumAddLayerSets() + getVpsNumLayerSetsMinus1() + 1; 
2320#endif
2321}
2322
2323Int TComVPS::getNumViews()
2324{
2325  Int numViews = 1; 
2326  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
2327  {
2328    Int lId = getLayerIdInNuh( i ); 
2329    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
2330    {
2331      numViews++; 
2332    }   
2333  }
2334
2335  return numViews;
2336}
2337
2338Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
2339{
2340  assert( depth < 65 ); 
2341  Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps ); 
2342
2343  for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
2344  {
2345    if ( getDirectDependencyFlag( depLayeridInVps, i ) )
2346    {
2347      dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ ); 
2348    }
2349  }
2350  return dependentFlag;
2351}
2352
2353Void TComVPS::deriveLayerSetLayerIdList()
2354{
2355  m_layerSetLayerIdList.resize( getVpsNumLayerSetsMinus1() + 1 ); 
2356  for (Int i = 0; i <= getVpsNumLayerSetsMinus1(); i++ )
2357  {
2358    for( Int m = 0; m  <= getVpsMaxLayerId(); m++ )
2359    {
2360      if( getLayerIdIncludedFlag( i, m) ) 
2361      {
2362        m_layerSetLayerIdList[ i ].push_back( m );       
2363      }
2364    }
2365  }
2366}
2367
2368Void TComVPS::initTargetLayerIdLists()
2369{
2370  m_targetDecLayerIdLists.resize( getNumOutputLayerSets() ); 
2371  m_targetOptLayerIdLists.resize( getNumOutputLayerSets() ); 
2372}
2373
2374Void TComVPS::deriveTargetLayerIdList( Int i )
2375{ 
2376  Int lsIdx = olsIdxToLsIdx( i );     
2377 
2378  for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
2379  {
2380    m_targetDecLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] ); 
2381    if( getOutputLayerFlag( i, j  ))
2382    {
2383      m_targetOptLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2384    }
2385  } 
2386#if H_MV_HLS_8_PMS_Q0165_18
2387  assert( getNumOutputLayersInOutputLayerSet( i ) > 0 ); 
2388#endif
2389}
2390
2391Bool TComVPS::inferOutputLayerFlag( Int i, Int j )
2392{
2393  Bool outputLayerFlag; 
2394  switch ( getDefaultOutputLayerIdc( ) )
2395  {
2396  case 0:
2397    outputLayerFlag = true; 
2398    break; 
2399  case 1:
2400    outputLayerFlag = ( j == m_layerSetLayerIdList[ olsIdxToLsIdx( i ) ].size() - 1 ); 
2401    break;
2402  case 2:
2403    if ( i == 0 && j == 0)
2404    {     
2405      outputLayerFlag = true;  // This is a software only fix for a bug in the spec. In spec outputLayerFlag is neither present nor inferred.
2406    }
2407    else
2408    {
2409      assert( 0 ); 
2410    }
2411    break; 
2412  default:     
2413    assert( 0 );
2414    break; 
2415  }
2416  return outputLayerFlag;
2417}
2418
2419Int TComVPS::getMaxSubLayersInLayerSetMinus1( Int i )
2420{
2421  Int maxSLMinus1 = 0; 
2422#if H_MV_HLS_8_MIS_Q0102_30
2423  for( Int k = 0; k < getNumLayersInIdList( i ); k++ )
2424  {
2425    Int lId = m_layerSetLayerIdList[i][k];
2426#else 
2427  Int optLsIdx    = olsIdxToLsIdx( i );
2428
2429  for( Int k = 0; k < getNumLayersInIdList( optLsIdx ); k++ )
2430  {
2431    Int lId = m_layerSetLayerIdList[optLsIdx][k];
2432#endif
2433    maxSLMinus1 = std::max( maxSLMinus1, getSubLayersVpsMaxMinus1( getLayerIdInVps( lId ) ));
2434  }
2435  return maxSLMinus1;
2436}
2437#if H_MV_HLS_8_RPS_Q0100_36
2438Void TComVPS::inferDbpSizeLayerSetZero( TComSPS* sps, Bool encoder )
2439{
2440  for( Int j = 0; j <= getMaxSubLayersInLayerSetMinus1( 0 ); j++ )
2441  {
2442    Int maxDecPicBufferingMinus1 = sps->getMaxDecPicBuffering( j ) - 1; 
2443    Int numReorderPics           = sps->getNumReorderPics    ( j ); 
2444    Int maxLatencyIncreasePlus1  = sps->getMaxLatencyIncrease( j ); 
2445
2446    if ( encoder )
2447    {
2448      assert( getDpbSize()->getMaxVpsDecPicBufferingMinus1(0, 0, j ) == maxDecPicBufferingMinus1 );
2449      assert( getDpbSize()->getMaxVpsNumReorderPics       (0,    j ) == numReorderPics           );
2450      assert( getDpbSize()->getMaxVpsLatencyIncreasePlus1 (0,    j ) == maxLatencyIncreasePlus1  );
2451    }
2452    else
2453    {
2454      getDpbSize()->setMaxVpsDecPicBufferingMinus1(0, 0, j, maxDecPicBufferingMinus1 );
2455      getDpbSize()->setMaxVpsNumReorderPics       (0,    j, numReorderPics           );
2456      getDpbSize()->setMaxVpsLatencyIncreasePlus1 (0,    j, maxLatencyIncreasePlus1  );       
2457    }     
2458  }
2459}
2460#endif
2461#endif // H_MV
2462
2463// ------------------------------------------------------------------------------------------------
2464// Sequence parameter set (SPS)
2465// ------------------------------------------------------------------------------------------------
2466
2467TComSPS::TComSPS()
2468: m_SPSId                     (  0)
2469, m_VPSId                     (  0)
2470, m_chromaFormatIdc           (CHROMA_420)
2471, m_uiMaxTLayers              (  1)
2472// Structure
2473, m_picWidthInLumaSamples     (352)
2474, m_picHeightInLumaSamples    (288)
2475, m_log2MinCodingBlockSize    (  0)
2476, m_log2DiffMaxMinCodingBlockSize (0)
2477, m_uiMaxCUWidth              ( 32)
2478, m_uiMaxCUHeight             ( 32)
2479, m_uiMaxCUDepth              (  3)
2480, m_bLongTermRefsPresent      (false)
2481, m_uiQuadtreeTULog2MaxSize   (  0)
2482, m_uiQuadtreeTULog2MinSize   (  0)
2483, m_uiQuadtreeTUMaxDepthInter (  0)
2484, m_uiQuadtreeTUMaxDepthIntra (  0)
2485// Tool list
2486, m_usePCM                   (false)
2487, m_pcmLog2MaxSize            (  5)
2488, m_uiPCMLog2MinSize          (  7)
2489#if H_3D_QTLPC
2490, m_bUseQTL                   (false)
2491, m_bUsePC                    (false)
2492#endif
2493, m_bitDepthY                 (  8)
2494, m_bitDepthC                 (  8)
2495, m_qpBDOffsetY               (  0)
2496, m_qpBDOffsetC               (  0)
2497, m_uiPCMBitDepthLuma         (  8)
2498, m_uiPCMBitDepthChroma       (  8)
2499, m_bPCMFilterDisableFlag     (false)
2500, m_uiBitsForPOC              (  8)
2501, m_numLongTermRefPicSPS    (  0) 
2502, m_uiMaxTrSize               ( 32)
2503, m_bUseSAO                   (false) 
2504, m_bTemporalIdNestingFlag    (false)
2505, m_scalingListEnabledFlag    (false)
2506, m_useStrongIntraSmoothing   (false)
2507, m_vuiParametersPresentFlag  (false)
2508, m_vuiParameters             ()
2509#if H_MV
2510, m_pcVPS                     ( NULL )
2511, m_spsInferScalingListFlag   ( false )
2512, m_spsScalingListRefLayerId  ( 0 )
2513
2514, m_updateRepFormatFlag       ( false ) 
2515, m_spsRepFormatIdx           ( 0 )
2516, m_interViewMvVertConstraintFlag (false)
2517#endif
2518#if H_3D
2519, m_bCamParInSliceHeader      (false)
2520#endif
2521{
2522  for ( Int i = 0; i < MAX_TLAYER; i++ )
2523  {
2524    m_uiMaxLatencyIncrease[i] = 0;
2525    m_uiMaxDecPicBuffering[i] = 1;
2526    m_numReorderPics[i]       = 0;
2527  }
2528  m_scalingList = new TComScalingList;
2529  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2530  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2531#if H_MV
2532#if !H_MV_HLS_8_SPS_NODOC_48
2533  m_spsExtensionPresentFlag = false; 
2534  for( Int i = 0; i < PS_EX_T_MAX_NUM; i++ ) 
2535  {
2536    m_spsExtensionTypeFlag[ i ] = false;
2537  }
2538#else
2539  m_spsRangeExtensionsFlag     = false;
2540  m_spsMultilayerExtensionFlag = false;
2541#if H_3D
2542  m_spsExtension5bits          = 0;
2543  m_sps3dExtensionFlag         = false; 
2544#else
2545  m_spsExtension6bits          = 0;
2546#endif
2547#endif
2548
2549  m_numScaledRefLayerOffsets = 0; 
2550
2551  for (Int i = 0; i < MAX_NUM_SCALED_REF_LAYERS; i++ )
2552  {
2553    m_scaledRefLayerId             [i] = -1;
2554  }
2555
2556  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
2557  {
2558    m_scaledRefLayerLeftOffset     [i] = 0;
2559    m_scaledRefLayerTopOffset      [i] = 0;
2560    m_scaledRefLayerRightOffset    [i] = 0;
2561    m_scaledRefLayerBottomOffset   [i] = 0;
2562  }
2563#endif
2564}
2565
2566TComSPS::~TComSPS()
2567{
2568  delete m_scalingList;
2569  m_RPSList.destroy();
2570}
2571
2572Void  TComSPS::createRPSList( Int numRPS )
2573{ 
2574  m_RPSList.destroy();
2575  m_RPSList.create(numRPS);
2576}
2577
2578Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2579{
2580  if( !getVuiParametersPresentFlag() )
2581  {
2582    return;
2583  }
2584
2585  TComVUI *vui = getVuiParameters();
2586  TComHRD *hrd = vui->getHrdParameters();
2587
2588  TimingInfo *timingInfo = vui->getTimingInfo();
2589  timingInfo->setTimingInfoPresentFlag( true );
2590  switch( frameRate )
2591  {
2592  case 24:
2593    timingInfo->setNumUnitsInTick( 1125000 );    timingInfo->setTimeScale    ( 27000000 );
2594    break;
2595  case 25:
2596    timingInfo->setNumUnitsInTick( 1080000 );    timingInfo->setTimeScale    ( 27000000 );
2597    break;
2598  case 30:
2599    timingInfo->setNumUnitsInTick( 900900 );     timingInfo->setTimeScale    ( 27000000 );
2600    break;
2601  case 50:
2602    timingInfo->setNumUnitsInTick( 540000 );     timingInfo->setTimeScale    ( 27000000 );
2603    break;
2604  case 60:
2605    timingInfo->setNumUnitsInTick( 450450 );     timingInfo->setTimeScale    ( 27000000 );
2606    break;
2607  default:
2608    timingInfo->setNumUnitsInTick( 1001 );       timingInfo->setTimeScale    ( 60000 );
2609    break;
2610  }
2611
2612  Bool rateCnt = ( bitRate > 0 );
2613  hrd->setNalHrdParametersPresentFlag( rateCnt );
2614  hrd->setVclHrdParametersPresentFlag( rateCnt );
2615
2616  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2617
2618  if( hrd->getSubPicCpbParamsPresentFlag() )
2619  {
2620    hrd->setTickDivisorMinus2( 100 - 2 );                          //
2621    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
2622    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2623    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2624  }
2625  else
2626  {
2627    hrd->setSubPicCpbParamsInPicTimingSEIFlag( false ); 
2628  }
2629
2630  hrd->setBitRateScale( 4 );                                       // in units of 2~( 6 + 4 ) = 1,024 bps
2631  hrd->setCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2632  hrd->setDuCpbSizeScale( 6 );                                       // in units of 2~( 4 + 4 ) = 1,024 bit
2633 
2634  hrd->setInitialCpbRemovalDelayLengthMinus1(15);                  // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2635  if( randomAccess )
2636  {
2637    hrd->setCpbRemovalDelayLengthMinus1(5);                        // 32 = 2^5 (plus 1)
2638    hrd->setDpbOutputDelayLengthMinus1 (5);                        // 32 + 3 = 2^6
2639  }
2640  else
2641  {
2642    hrd->setCpbRemovalDelayLengthMinus1(9);                        // max. 2^10
2643    hrd->setDpbOutputDelayLengthMinus1 (9);                        // max. 2^10
2644  }
2645
2646/*
2647   Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2648*/
2649  Int i, j;
2650  UInt birateValue, cpbSizeValue;
2651  UInt ducpbSizeValue;
2652  UInt duBitRateValue = 0;
2653
2654  for( i = 0; i < MAX_TLAYER; i ++ )
2655  {
2656    hrd->setFixedPicRateFlag( i, 1 );
2657    hrd->setPicDurationInTcMinus1( i, 0 );
2658    hrd->setLowDelayHrdFlag( i, 0 );
2659    hrd->setCpbCntMinus1( i, 0 );
2660
2661    birateValue  = bitRate;
2662    cpbSizeValue = bitRate;                                     // 1 second
2663    ducpbSizeValue = bitRate/numDU;
2664    duBitRateValue = bitRate;
2665    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2666    {
2667      hrd->setBitRateValueMinus1( i, j, 0, ( birateValue  - 1 ) );
2668      hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2669      hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
2670      hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2671
2672      hrd->setBitRateValueMinus1( i, j, 1, ( birateValue  - 1) );
2673      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2674      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
2675      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2676      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2677    }
2678  }
2679}
2680const Int TComSPS::m_winUnitX[]={1,2,2,1};
2681const Int TComSPS::m_winUnitY[]={1,2,1,1};
2682
2683TComPPS::TComPPS()
2684: m_PPSId                       (0)
2685, m_SPSId                       (0)
2686, m_picInitQPMinus26            (0)
2687, m_useDQP                      (false)
2688, m_bConstrainedIntraPred       (false)
2689, m_bSliceChromaQpFlag          (false)
2690, m_pcSPS                       (NULL)
2691, m_uiMaxCuDQPDepth             (0)
2692, m_uiMinCuDQPSize              (0)
2693, m_chromaCbQpOffset            (0)
2694, m_chromaCrQpOffset            (0)
2695, m_numRefIdxL0DefaultActive    (1)
2696, m_numRefIdxL1DefaultActive    (1)
2697, m_TransquantBypassEnableFlag  (false)
2698, m_useTransformSkip             (false)
2699, m_dependentSliceSegmentsEnabledFlag    (false)
2700, m_tilesEnabledFlag               (false)
2701, m_entropyCodingSyncEnabledFlag   (false)
2702, m_loopFilterAcrossTilesEnabledFlag  (true)
2703, m_uniformSpacingFlag           (0)
2704, m_iNumColumnsMinus1            (0)
2705, m_puiColumnWidth               (NULL)
2706, m_iNumRowsMinus1               (0)
2707, m_puiRowHeight                 (NULL)
2708, m_iNumSubstreams             (1)
2709, m_signHideFlag(0)
2710, m_cabacInitPresentFlag        (false)
2711, m_encCABACTableIdx            (I_SLICE)
2712, m_sliceHeaderExtensionPresentFlag    (false)
2713, m_loopFilterAcrossSlicesEnabledFlag (false)
2714, m_listsModificationPresentFlag(  0)
2715, m_numExtraSliceHeaderBits(0)
2716#if H_MV
2717, m_ppsInferScalingListFlag(false)
2718, m_ppsScalingListRefLayerId(0)
2719, m_pocResetInfoPresentFlag(false)
2720#if H_3D
2721, m_pcDLT(NULL)
2722#endif
2723#endif
2724{
2725  m_scalingList = new TComScalingList;
2726
2727#if H_MV
2728#if H_MV_HLS_8_SPS_NODOC_48
2729  m_ppsRangeExtensionsFlag     = false;
2730  m_ppsMultilayerExtensionFlag = false;
2731#if !H_3D
2732  m_ppsExtension6bits          = 0;
2733#else
2734  m_pps3dExtensionFlag         = false;
2735  m_ppsExtension5bits          = 0;
2736#endif
2737#else
2738  for( Int i = 0; i < PS_EX_T_MAX_NUM; i++ ) 
2739  {
2740    m_ppsExtensionTypeFlag[ i ] = false;
2741  }
2742#endif
2743#endif
2744}
2745
2746TComPPS::~TComPPS()
2747{
2748  if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2749  {
2750    if (m_puiColumnWidth) delete [] m_puiColumnWidth; 
2751    m_puiColumnWidth = NULL;
2752  }
2753  if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2754  {
2755    if (m_puiRowHeight) delete [] m_puiRowHeight;
2756    m_puiRowHeight = NULL;
2757  }
2758  delete m_scalingList;
2759}
2760
2761#if H_3D
2762TComDLT::TComDLT()
2763: m_bDltPresentFlag(false)
2764, m_iNumDepthViews(0)
2765, m_uiDepthViewBitDepth(8)
2766{
2767  m_uiDepthViewBitDepth = g_bitDepthY; 
2768
2769  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2770  {
2771    m_bUseDLTFlag                 [i] = false;
2772    m_bInterViewDltPredEnableFlag [i] = false;
2773
2774    // allocate some memory and initialize with default mapping
2775    m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
2776    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
2777
2778    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2779    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2780
2781    //default mapping
2782    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
2783    {
2784      m_iDepthValue2Idx[i][d] = d;
2785      m_iIdx2DepthValue[i][d] = d;
2786    }
2787  }
2788}
2789
2790TComDLT::~TComDLT()
2791{
2792  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2793  {
2794    if ( m_iDepthValue2Idx[i] != NULL ) 
2795    {
2796      xFree( m_iDepthValue2Idx[i] );
2797      m_iDepthValue2Idx[i] = NULL; 
2798    }
2799
2800    if ( m_iIdx2DepthValue[i] != NULL ) 
2801    {
2802      xFree( m_iIdx2DepthValue[i] );
2803      m_iIdx2DepthValue[i] = NULL; 
2804    }
2805  }
2806}
2807
2808Void TComDLT::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
2809{
2810  if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
2811    return;
2812
2813  // copy idx2DepthValue to internal array
2814  memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
2815
2816  UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
2817  for(Int p=0; p<=uiMaxDepthValue; p++)
2818  {
2819    Int iIdxDown    = 0;
2820    Int iIdxUp      = iNumDepthValues-1;
2821    Bool bFound     = false;
2822
2823    // iterate over indices to find lower closest depth
2824    Int i = 1;
2825    while(!bFound && i<iNumDepthValues)
2826    {
2827      if( m_iIdx2DepthValue[layerIdInVps][i] > p )
2828      {
2829        iIdxDown  = i-1;
2830        bFound    = true;
2831      }
2832
2833      i++;
2834    }
2835    // iterate over indices to find upper closest depth
2836    i = iNumDepthValues-2;
2837    bFound = false;
2838    while(!bFound && i>=0)
2839    {
2840      if( m_iIdx2DepthValue[layerIdInVps][i] < p )
2841      {
2842        iIdxUp  = i+1;
2843        bFound    = true;
2844      }
2845
2846      i--;
2847    }
2848
2849    // assert monotony
2850    assert(iIdxDown<=iIdxUp);
2851
2852    // assign closer depth value/idx
2853    if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
2854    {
2855      m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
2856    }
2857    else
2858    {
2859      m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
2860    }
2861
2862  }
2863
2864  // update DLT variables
2865  m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
2866  m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
2867}
2868
2869#if H_3D_DELTA_DLT
2870Void TComDLT::getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum )
2871{
2872  Bool abBM0[ 256 ];
2873  Bool abBM1[ 256 ];
2874 
2875  memset( abBM0, 0, sizeof( abBM0 ));
2876  memset( abBM1, 0, sizeof( abBM1 ));
2877 
2878  // convert reference DLT to bit string
2879  for( Int i = 0; i < uiDLTInRefNum; i++ )
2880  {
2881    abBM0[ piDLTInRef[ i ] ] = true;
2882  }
2883  // convert internal DLT to bit string
2884  for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
2885  {
2886    abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
2887  }
2888 
2889  *puiDeltaDLTOutNum = 0;
2890  for( Int i = 0; i < 256; i++ )
2891  {
2892    if( abBM0[ i ] ^ abBM1[ i ] )
2893    {
2894      piDeltaDLTOut[ *puiDeltaDLTOutNum ] = i;
2895      *puiDeltaDLTOutNum = *puiDeltaDLTOutNum + 1;
2896    }
2897  }
2898}
2899
2900Void TComDLT::setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum )
2901{
2902  Bool abBM0[ 256 ];
2903  Bool abBM1[ 256 ];
2904 
2905  memset( abBM0, 0, sizeof( abBM0 ));
2906  memset( abBM1, 0, sizeof( abBM1 ));
2907 
2908  // convert reference DLT to bit string
2909  for( Int i = 0; i < uiDLTInRefNum; i++ )
2910  {
2911    abBM0[ piDLTInRef[ i ] ] = true;
2912  }
2913  // convert delta DLT to bit string
2914  for( Int i = 0; i < uiDeltaDLTInNum; i++ )
2915  {
2916    abBM1[ piDeltaDLTIn[ i ] ] = true;
2917  }
2918 
2919  Int aiIdx2DepthValue[256];
2920  UInt uiNumDepthValues = 0;
2921  memset( aiIdx2DepthValue, 0, sizeof( aiIdx2DepthValue ));
2922 
2923  for( Int i = 0; i < 256; i++ )
2924  {
2925    if( abBM0[ i ] ^ abBM1[ i ] )
2926    {
2927      aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
2928    }
2929  }
2930 
2931  // update internal tables
2932  setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
2933}
2934#endif
2935
2936#endif
2937
2938#if H_MV
2939Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
2940{
2941  if ( layerIdCurr > 0 )
2942  { 
2943    Int            repFormatIdx = getUpdateRepFormatFlag() ?  getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
2944    TComRepFormat* repFormat    = vps->getRepFormat( repFormatIdx ); 
2945      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
2946      //// ToDo: add when supported:
2947      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
2948
2949      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
2950      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
2951
2952      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
2953      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
2954
2955      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2956      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
2957    if ( getLayerId() > 0 && getUpdateRepFormatFlag() )
2958    {
2959      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
2960      //// ToDo: add when supported:
2961      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ;
2962
2963      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    ); 
2964      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   ); 
2965
2966      assert( getBitDepthY()              <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
2967      assert( getBitDepthC()              <= repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
2968    }
2969  }
2970
2971  // Set conformance window
2972  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
2973  getConformanceWindow().scaleOffsets( scal );
2974  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
2975}
2976
2977Void TComSPS::inferScalingList( TComSPS* spsSrc )
2978{
2979  if ( getSpsInferScalingListFlag() ) 
2980  {
2981    assert( spsSrc != NULL ); 
2982    assert( !spsSrc->getSpsInferScalingListFlag() );             
2983    getScalingList()->inferFrom( spsSrc->getScalingList() ); 
2984  }
2985}
2986#endif
2987
2988TComReferencePictureSet::TComReferencePictureSet()
2989: m_numberOfPictures (0)
2990, m_numberOfNegativePictures (0)
2991, m_numberOfPositivePictures (0)
2992, m_numberOfLongtermPictures (0)
2993, m_interRPSPrediction (0) 
2994, m_deltaRIdxMinus1 (0)   
2995, m_deltaRPS (0) 
2996, m_numRefIdc (0) 
2997{
2998  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2999  ::memset( m_POC, 0, sizeof(m_POC) );
3000  ::memset( m_used, 0, sizeof(m_used) );
3001  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
3002}
3003
3004TComReferencePictureSet::~TComReferencePictureSet()
3005{
3006}
3007
3008Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
3009{
3010  m_used[bufferNum] = used;
3011}
3012
3013Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
3014{
3015  m_deltaPOC[bufferNum] = deltaPOC;
3016}
3017
3018Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
3019{
3020  m_numberOfPictures = numberOfPictures;
3021}
3022
3023Int TComReferencePictureSet::getUsed(Int bufferNum)
3024{
3025  return m_used[bufferNum];
3026}
3027
3028Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
3029{
3030  return m_deltaPOC[bufferNum];
3031}
3032
3033Int TComReferencePictureSet::getNumberOfPictures()
3034{
3035  return m_numberOfPictures;
3036}
3037
3038Int TComReferencePictureSet::getPOC(Int bufferNum)
3039{
3040  return m_POC[bufferNum];
3041}
3042
3043Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
3044{
3045  m_POC[bufferNum] = POC;
3046}
3047
3048Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
3049{
3050  return m_bCheckLTMSB[bufferNum];
3051}
3052
3053Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
3054{
3055  m_bCheckLTMSB[bufferNum] = b;
3056}
3057
3058/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
3059 * \param uiBufferNum
3060 * \param iRefIdc
3061 * \returns Void
3062 */
3063Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
3064{
3065  m_refIdc[bufferNum] = refIdc;
3066}
3067
3068/** get the reference idc value at uiBufferNum
3069 * \param uiBufferNum
3070 * \returns Int
3071 */
3072Int  TComReferencePictureSet::getRefIdc(Int bufferNum)
3073{
3074  return m_refIdc[bufferNum];
3075}
3076
3077/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
3078 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
3079 *  +ve values are in increasing order.
3080 * \returns Void
3081 */
3082Void TComReferencePictureSet::sortDeltaPOC()
3083{
3084  // sort in increasing order (smallest first)
3085  for(Int j=1; j < getNumberOfPictures(); j++)
3086  { 
3087    Int deltaPOC = getDeltaPOC(j);
3088    Bool used = getUsed(j);
3089    for (Int k=j-1; k >= 0; k--)
3090    {
3091      Int temp = getDeltaPOC(k);
3092      if (deltaPOC < temp)
3093      {
3094        setDeltaPOC(k+1, temp);
3095        setUsed(k+1, getUsed(k));
3096        setDeltaPOC(k, deltaPOC);
3097        setUsed(k, used);
3098      }
3099    }
3100  }
3101  // flip the negative values to largest first
3102  Int numNegPics = getNumberOfNegativePictures();
3103  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
3104  { 
3105    Int deltaPOC = getDeltaPOC(j);
3106    Bool used = getUsed(j);
3107    setDeltaPOC(j, getDeltaPOC(k));
3108    setUsed(j, getUsed(k));
3109    setDeltaPOC(k, deltaPOC);
3110    setUsed(k, used);
3111  }
3112}
3113
3114/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
3115 *  A "*" is added to the deltaPOC value if it is Used bu current.
3116 * \returns Void
3117 */
3118Void TComReferencePictureSet::printDeltaPOC()
3119{
3120  printf("DeltaPOC = { ");
3121  for(Int j=0; j < getNumberOfPictures(); j++)
3122  {
3123    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
3124  } 
3125  if (getInterRPSPrediction()) 
3126  {
3127    printf("}, RefIdc = { ");
3128    for(Int j=0; j < getNumRefIdc(); j++)
3129    {
3130      printf("%d ", getRefIdc(j));
3131    } 
3132  }
3133  printf("}\n");
3134}
3135
3136TComRPSList::TComRPSList()
3137:m_referencePictureSets (NULL)
3138{
3139}
3140
3141TComRPSList::~TComRPSList()
3142{
3143}
3144
3145Void TComRPSList::create( Int numberOfReferencePictureSets)
3146{
3147  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
3148  m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
3149}
3150
3151Void TComRPSList::destroy()
3152{
3153  if (m_referencePictureSets)
3154  {
3155    delete [] m_referencePictureSets;
3156  }
3157  m_numberOfReferencePictureSets = 0;
3158  m_referencePictureSets = NULL;
3159}
3160
3161
3162
3163TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
3164{
3165  return &m_referencePictureSets[referencePictureSetNum];
3166}
3167
3168Int TComRPSList::getNumberOfReferencePictureSets()
3169{
3170  return m_numberOfReferencePictureSets;
3171}
3172
3173Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
3174{
3175  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
3176}
3177
3178TComRefPicListModification::TComRefPicListModification()
3179: m_bRefPicListModificationFlagL0 (false)
3180, m_bRefPicListModificationFlagL1 (false)
3181{
3182  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
3183  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
3184}
3185
3186TComRefPicListModification::~TComRefPicListModification()
3187{
3188}
3189
3190TComScalingList::TComScalingList()
3191{
3192  init();
3193}
3194TComScalingList::~TComScalingList()
3195{
3196  destroy();
3197}
3198
3199/** set default quantization matrix to array
3200*/
3201Void TComSlice::setDefaultScalingList()
3202{
3203  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3204  {
3205    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
3206    {
3207      getScalingList()->processDefaultMatrix(sizeId, listId);
3208    }
3209  }
3210}
3211/** check if use default quantization matrix
3212 * \returns true if use default quantization matrix in all size
3213*/
3214Bool TComSlice::checkDefaultScalingList()
3215{
3216  UInt defaultCounter=0;
3217
3218  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3219  {
3220    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
3221    {
3222      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
3223     && ((sizeId < SCALING_LIST_16x16) || (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
3224      {
3225        defaultCounter++;
3226      }
3227    }
3228  }
3229  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32
3230}
3231
3232#if H_MV
3233Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
3234{
3235  refPicSetInterLayer0.clear(); 
3236  refPicSetInterLayer1.clear(); 
3237
3238  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
3239  {
3240    Int layerIdRef = getRefPicLayerId( i ); 
3241    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ; 
3242    assert ( picRef != 0 ); // There shall be no entry equal to "no reference picture" in RefPicSetInterLayer0 or RefPicSetInterLayer1.
3243
3244    picRef->getPicYuvRec()->extendPicBorder(); 
3245    picRef->setIsLongTerm( true );       
3246    picRef->getSlice(0)->setReferenced( true );       
3247
3248    Int viewIdCur  = getVPS()->getViewId( getLayerId() ); 
3249    Int viewIdZero = getVPS()->getViewId( 0 );
3250    Int viewIdRef  = getVPS()->getViewId( layerIdRef ); 
3251
3252    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
3253    {
3254      refPicSetInterLayer0.push_back( picRef ); 
3255    }
3256    else
3257    {
3258      refPicSetInterLayer1.push_back( picRef ); 
3259    }
3260    // Consider to check here:
3261    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "   
3262    assert( picRef->getSlice(0)->getDiscardableFlag() == false ); // "There shall be no picture that has discardable_flag equal to 1 in RefPicSetInterLayer0 or RefPicSetInterLayer1".       
3263  }
3264}
3265
3266Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
3267{
3268  // Mark as short-term
3269  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ ) 
3270  {
3271    refPicSetInterLayer0[i]->setIsLongTerm( false ); 
3272  }
3273
3274  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ ) 
3275  {
3276    refPicSetInterLayer1[i]->setIsLongTerm( false ); 
3277  }
3278
3279}
3280
3281#if !H_MV_HLS_8_DBP_NODOC_42
3282Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
3283{
3284  // Fill targetDecLayerIdSet with all layers if empty (at encoder side)
3285  if (targetDecLayerIdSet.size() == 0 )   
3286  {
3287    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
3288    {
3289      targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) ); 
3290    }
3291  }     
3292
3293  Int numTargetDecLayers = (Int) targetDecLayerIdSet.size(); 
3294  Int latestDecIdx; 
3295  for ( latestDecIdx = 0; latestDecIdx < numTargetDecLayers; latestDecIdx++)
3296  {
3297    if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
3298    {
3299      break; 
3300    }       
3301  }       
3302
3303  for( Int i = 0; i <= latestDecIdx; i++ ) 
3304  {
3305    if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ i ] ) )
3306    {
3307      TComPic* pcPic = ivPicLists->getPic( targetDecLayerIdSet[ i ], curPoc ); 
3308      if ( pcPic )
3309      {
3310        if( pcPic->getSlice(0)->isReferenced() && pcPic->getSlice(0)->getTemporalLayerNonReferenceFlag() ) 
3311        { 
3312          Bool remainingInterLayerReferencesFlag = false; 
3313          for( Int j = latestDecIdx + 1; j < numTargetDecLayers; j++ )
3314          { 
3315            TComVPS* vpsSlice = pcPic->getSlice(0)->getVPS(); 
3316            if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
3317            {
3318              for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
3319              {
3320                if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
3321                {
3322                  remainingInterLayerReferencesFlag = true;
3323                }
3324              }
3325            }
3326          }
3327          if( !remainingInterLayerReferencesFlag )
3328          {
3329            pcPic->getSlice(0)->setReferenced( false );                   
3330          }
3331        }
3332      }
3333    }
3334  }
3335}
3336#endif
3337Void TComSlice::printRefPicList()
3338{ 
3339  for ( Int li = 0; li < 2; li++)
3340  {   
3341    std::cout << std::endl << "RefPicListL" <<  li << ":" << std::endl; 
3342    for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
3343    {     
3344      if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( true );
3345       
3346      m_apcRefPicList[li][rIdx]->print( false );
3347    }
3348  }
3349}
3350
3351Void TComSlice::markCurrPic( TComPic* currPic )
3352{
3353
3354#if !H_MV_HLS_8_DBP_NODOC_42
3355  if ( !currPic->getSlice(0)->getDiscardableFlag() )
3356  {
3357#endif
3358    currPic->getSlice(0)->setReferenced( true ) ; 
3359    currPic->setIsLongTerm( false ); 
3360#if !H_MV_HLS_8_DBP_NODOC_42
3361  }
3362  else
3363  {
3364    currPic->getSlice(0)->setReferenced( false ) ; 
3365  }
3366#endif
3367
3368#if H_MV_HLS_7_VPS_P0300_27
3369  currPic->setReconMark( true );
3370  currPic->setPicOutputFlag( currPic->getSlice(0)->getPicOutputFlag() );
3371#endif
3372}
3373
3374Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
3375{
3376  m_refPicSetInterLayer0 = refPicSetInterLayer0; 
3377  m_refPicSetInterLayer1 = refPicSetInterLayer1; 
3378}
3379
3380TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
3381{
3382  assert ( setIdc == 0 || setIdc == 1);   
3383  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
3384  assert( refPicSetInterLayer != 0 ); 
3385 
3386  TComPic* pcPic = NULL; 
3387  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
3388  {
3389    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
3390    {
3391      pcPic = (*refPicSetInterLayer)[ i ]; 
3392    }
3393  }
3394
3395  assert(pcPic != NULL); 
3396  return pcPic;
3397}
3398
3399
3400Int  TComSlice::getRefLayerPicFlag( Int i ) 
3401{
3402  TComVPS* vps = getVPS(); 
3403  Int refLayerIdx = vps->getLayerIdInVps( vps->getRefLayerId( getLayerId(), i ) ); 
3404
3405#if H_MV_HLS_8_RPS_Q0060_17
3406  Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer() )  && ( getTLayer() == 0  ) &&
3407    ( vps->getMaxTidIlRefPicsPlus1( refLayerIdx, vps->getLayerIdInVps( getLayerId() )) > getTLayer() ); 
3408#else
3409  Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer() )  && 
3410    ( vps->getMaxTidIlRefPicsPlus1( refLayerIdx, vps->getLayerIdInVps( getLayerId() )) > getTLayer() ); 
3411#endif
3412
3413  return refLayerPicFlag;       
3414}   
3415
3416Int TComSlice::getRefLayerPicIdc( Int j ) 
3417{ 
3418  Int refLayerPicIdc = -1; 
3419  Int curj = 0; 
3420  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3421  {
3422    if( getRefLayerPicFlag( i ) )
3423    {
3424      if ( curj == j ) 
3425      {
3426        refLayerPicIdc = i;         
3427        break;
3428      }
3429      curj++; 
3430    }
3431  }
3432
3433  assert( curj == j ); 
3434  assert( refLayerPicIdc != -1 ); 
3435  return refLayerPicIdc; 
3436}
3437
3438Int  TComSlice::getNumRefLayerPics( )
3439{ 
3440  Int numRefLayerPics = 0; 
3441  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3442  {
3443    numRefLayerPics += getRefLayerPicFlag( i ); 
3444  }
3445  return numRefLayerPics; 
3446}
3447
3448
3449
3450Int TComSlice::getNumActiveRefLayerPics()
3451{
3452  Int numActiveRefLayerPics; 
3453
3454  if( getLayerId() == 0 || getNumRefLayerPics() ==  0 )
3455  {
3456    numActiveRefLayerPics = 0; 
3457  }
3458  else if (getVPS()->getAllRefLayersActiveFlag() )
3459  {
3460    numActiveRefLayerPics = getNumRefLayerPics(); 
3461  }
3462  else if ( !getInterLayerPredEnabledFlag() )
3463  {
3464    numActiveRefLayerPics = 0; 
3465  }
3466  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
3467  {
3468    numActiveRefLayerPics = 1; 
3469  }
3470  else
3471  {
3472    numActiveRefLayerPics = getNumInterLayerRefPicsMinus1() + 1; 
3473  }
3474  return numActiveRefLayerPics;
3475}
3476
3477Int TComSlice::getRefPicLayerId( Int i )
3478{
3479  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
3480}
3481
3482#if H_3D_ARP
3483Void TComSlice::setARPStepNum( TComPicLists*ivPicLists )
3484{
3485  Bool tempRefPicInListsFlag = false;
3486  if(!getVPS()->getUseAdvRP(getLayerId()) || this->isIRAP())
3487  {
3488    m_nARPStepNum = 0;
3489  }
3490  else
3491  {
3492    setFirstTRefIdx (REF_PIC_LIST_0, -1);
3493    setFirstTRefIdx (REF_PIC_LIST_1, -1);
3494    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3495    {
3496      Int diffPOC=MAX_INT;
3497      Int idx=-1;
3498      for(Int i = 0; i < getNumRefIdx(RefPicList(refListIdx)); i++ )
3499      {
3500        if ( getRefPic(RefPicList(refListIdx), i)->getPOC() != getPOC() )
3501        {
3502          if( abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC()) < diffPOC)
3503          {
3504            diffPOC=abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC());
3505            idx=i;
3506          }
3507        }
3508        if(idx>=0)
3509        {
3510          setFirstTRefIdx (RefPicList(refListIdx), idx);
3511        }
3512      }
3513    }
3514    tempRefPicInListsFlag = getFirstTRefIdx(REF_PIC_LIST_0) >= 0 || getFirstTRefIdx(REF_PIC_LIST_1) >= 0;
3515    m_nARPStepNum = tempRefPicInListsFlag ? getVPS()->getARPStepNum(getLayerId()) : 0;
3516  }
3517
3518  if (tempRefPicInListsFlag)
3519  {
3520    for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3521    {
3522      RefPicList eRefPicList = RefPicList( refListIdx );
3523      Int prevPOC = getRefPic(eRefPicList, getFirstTRefIdx(eRefPicList) )->getPOC();
3524      for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
3525      {
3526        Int layerIdInNuh = getRefPicLayerId( i );
3527        Int viewIdx = getVPS()->getViewId( layerIdInNuh );
3528        TComPic*pcPicPrev = ivPicLists->getPic(viewIdx, 0, prevPOC);
3529        if (getFirstTRefIdx(eRefPicList) >= 0 && pcPicPrev && pcPicPrev->getSlice( 0 )->isReferenced())
3530        {
3531          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
3532        }
3533        else
3534        {
3535          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = false;
3536        }
3537      }
3538    }
3539  }
3540}
3541#endif
3542#if H_3D_IC
3543#if MTK_LOW_LATENCY_IC_ENCODING_H0086
3544Void TComSlice::xSetApplyIC(Bool bUseLowLatencyICEnc)
3545#else
3546Void TComSlice::xSetApplyIC()
3547#endif
3548{
3549#if MTK_LOW_LATENCY_IC_ENCODING_H0086
3550  if(bUseLowLatencyICEnc)
3551  {
3552    Bool existInterViewRef=false;
3553    TComPic* pcCurrPic = getPic();
3554    TComPic* pcRefPic = NULL;
3555    for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_0 )) && !existInterViewRef; i++ )
3556    {
3557      pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3558      if ( pcRefPic != NULL )
3559      {
3560        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3561        {
3562          existInterViewRef = true;       
3563        }
3564      }
3565    }
3566
3567    for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_1 )) && !existInterViewRef; i++ )
3568    {
3569      pcRefPic = getRefPic( REF_PIC_LIST_1, i );
3570      if ( pcRefPic != NULL )
3571      {
3572        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3573        {
3574          existInterViewRef = true;       
3575        }
3576      }
3577    }
3578
3579    if(!existInterViewRef)
3580    {
3581      m_bApplyIC = false;
3582    }
3583    else
3584    {
3585      Int curLayer=getDepth();
3586      if( curLayer>9) curLayer=9; // Max layer is 10
3587
3588      m_bApplyIC = true;
3589      Int refLayer = curLayer-1;
3590      if( (refLayer>=0) && (g_aICEnableCANDIDATE[refLayer]>0) )
3591      {   
3592        Double ratio=Double(g_aICEnableNUM[refLayer])/Double(g_aICEnableCANDIDATE[refLayer]);
3593
3594        if( ratio > MTK_LOW_LATENCY_IC_ENCODING_THRESHOLD_H0086)
3595{
3596          m_bApplyIC=true;
3597        }
3598        else
3599        {
3600          m_bApplyIC=false;
3601        }
3602      }
3603      g_aICEnableNUM[curLayer]=0;
3604      g_aICEnableCANDIDATE[curLayer]=0;
3605      g_lastlayer=getDepth();
3606    }
3607  }
3608  else
3609  {
3610#endif
3611  Int iMaxPelValue = ( 1 << g_bitDepthY ); 
3612  Int *aiRefOrgHist;
3613  Int *aiCurrHist;
3614  aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
3615  aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
3616  memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
3617  memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
3618  // Reference Idx Number
3619  Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
3620  TComPic* pcCurrPic = NULL;
3621  TComPic* pcRefPic = NULL;
3622  TComPicYuv* pcCurrPicYuv = NULL;
3623  TComPicYuv* pcRefPicYuvOrg = NULL;
3624  pcCurrPic = getPic();
3625  pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
3626  Int iWidth = pcCurrPicYuv->getWidth();
3627  Int iHeight = pcCurrPicYuv->getHeight();
3628
3629
3630  // Get InterView Reference picture
3631  // !!!!! Assume only one Interview Reference Picture in L0
3632  for ( Int i = 0; i < iNumRefIdx; i++ )
3633  {
3634    pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3635    if ( pcRefPic != NULL )
3636    {
3637      if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3638      {
3639        pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
3640      }
3641    }
3642  }
3643
3644  if ( pcRefPicYuvOrg != NULL )
3645  {
3646    Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
3647    Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
3648    Int iCurrStride = pcCurrPicYuv->getStride();
3649    Int iRefStride = pcRefPicYuvOrg->getStride();
3650    Int iSumOrgSAD = 0;
3651    Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
3652
3653    // Histogram building - luminance
3654    for ( Int y = 0; y < iHeight; y++ )
3655    {
3656      for ( Int x = 0; x < iWidth; x++ )
3657      {
3658        aiCurrHist[pCurrY[x]]++;
3659        aiRefOrgHist[pRefOrgY[x]]++;
3660      }
3661      pCurrY += iCurrStride;
3662      pRefOrgY += iRefStride;
3663    }
3664    // Histogram SAD
3665    for ( Int i = 0; i < iMaxPelValue; i++ )
3666    {
3667      iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
3668    }
3669    // Setting
3670    if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
3671    {
3672      m_bApplyIC = true;
3673    }
3674    else
3675    {
3676      m_bApplyIC = false;
3677    }
3678  }
3679
3680  xFree( aiCurrHist   );
3681  xFree( aiRefOrgHist );
3682  aiCurrHist = NULL;
3683  aiRefOrgHist = NULL;
3684#if MTK_LOW_LATENCY_IC_ENCODING_H0086
3685  }//if(bUseLowLatencyICEnc)
3686#endif
3687}
3688#endif
3689#if H_3D
3690Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
3691{
3692  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3693  {     
3694    for ( Int depthId = 0; depthId < 2; depthId++ )
3695    {
3696      m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , getPOC() ) : NULL;
3697    }       
3698  } 
3699}
3700Void TComSlice::setDepthToDisparityLUTs()
3701{ 
3702  Bool setupLUT = false; 
3703  Int layerIdInVPS = getVPS()->getLayerIdInNuh( m_layerId ); 
3704
3705#if H_3D_VSP
3706  setupLUT = setupLUT || getVPS()->getViewSynthesisPredFlag( layerIdInVPS); 
3707#endif
3708
3709#if H_3D_NBDV_REF
3710  setupLUT = setupLUT || getVPS()->getDepthRefinementFlag( layerIdInVPS );
3711#endif
3712
3713#if H_3D_IV_MERGE
3714  setupLUT = setupLUT || ( getVPS()->getIvMvPredFlag(layerIdInVPS ) && getIsDepth() );
3715#endif
3716
3717#if H_3D_DDD
3718  if( getIsDepth() && getViewIndex() > 0 )
3719  {
3720      TComSlice *pcTextSlice = getTexturePic()->getSlice( 0 );
3721      memcpy( m_aiDDDInvScale, pcTextSlice->m_aiDDDInvScale, sizeof( Int ) * getViewIndex() );
3722      memcpy( m_aiDDDInvOffset, pcTextSlice->m_aiDDDInvOffset, sizeof( Int ) * getViewIndex() );
3723      memcpy( m_aiDDDShift, pcTextSlice->m_aiDDDShift, sizeof( Int ) * getViewIndex() );             
3724  } 
3725#endif
3726
3727  if( !setupLUT )
3728    return; 
3729
3730  /// GT: Allocation should be moved to a better place later;
3731  if ( m_depthToDisparityB == NULL )
3732  {
3733    m_depthToDisparityB = new Int*[ getViewIndex() ];
3734    for ( Int i = 0; i < getViewIndex(); i++ )
3735    {
3736      m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
3737    }
3738  }
3739
3740  if ( m_depthToDisparityF == NULL )
3741  {
3742    m_depthToDisparityF= new Int*[ getViewIndex() ];
3743    for ( Int i = 0; i < getViewIndex(); i++ )
3744    {
3745      m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ]; 
3746    }
3747  }
3748
3749  assert( m_depthToDisparityB != NULL ); 
3750  assert( m_depthToDisparityF != NULL ); 
3751
3752  TComVPS* vps = getVPS(); 
3753
3754  Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
3755  Int viewIndex = getViewIndex();
3756
3757  Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
3758
3759  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( viewIndex ); 
3760  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( viewIndex ); 
3761  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex ); 
3762  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex ); 
3763
3764  for (Int i = 0; i <= ( getViewIndex() - 1); i++)
3765  {
3766    for ( Int d = 0; d <= ( ( 1 << g_bitDepthY ) - 1 ); d++ )
3767    {
3768      Int offset =    ( codOffset  [ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3769      m_depthToDisparityB[ i ][ d ] = ( codScale [ i ] * d + offset ) >> log2Div; 
3770
3771      Int invOffset = ( invCodOffset[ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
3772      m_depthToDisparityF[ i ][ d ] = ( invCodScale[ i ] * d + invOffset ) >> log2Div; 
3773    }
3774
3775#if H_3D_DDD
3776    InitializeDDDPara( vps->getCamParPrecision(), codScale[ i ], codOffset[ i ], i );
3777#endif
3778  }
3779}
3780#endif
3781#endif
3782
3783#if H_3D_DDD
3784Void TComSlice::InitializeDDDPara( UInt uiCamParsCodedPrecision, Int  iCodedScale,Int  iCodedOffset, Int iBaseViewIdx )
3785{
3786    UInt uiViewId     = getViewIndex();
3787
3788    if( uiViewId == 0 )
3789    {
3790        m_aiDDDInvScale[ iBaseViewIdx ] = m_aiDDDInvOffset[ iBaseViewIdx ] = m_aiDDDShift[ iBaseViewIdx ] = 0;
3791        return;
3792    }
3793
3794
3795    Int iSign = iCodedScale >= 0 ? 1 : -1;
3796    iCodedScale = abs( iCodedScale );
3797
3798    Int iBitWidth = 0;
3799
3800    const Int iInvPres = 9;
3801
3802    while( ((( 1 << iBitWidth ) << 1 ) <= iCodedScale ) )
3803    {
3804        iBitWidth ++;
3805    }
3806    iBitWidth += iInvPres;
3807    Int iTargetValue =  1 << iBitWidth;
3808
3809    Int iMinError = MAX_INT;
3810    Int iBestD = 1 << ( iInvPres - 1 );
3811    for( Int d = 1 << ( iInvPres - 1 ); d < ( 1 << iInvPres ); d++ )
3812    {
3813        Int iError = abs( iCodedScale * d - iTargetValue );
3814        if( iError < iMinError )
3815        {
3816            iMinError = iError;
3817            iBestD = d;
3818        }
3819        if( iMinError == 0 )
3820        {
3821            break;
3822        }
3823    }
3824    Int iRoundingDir = 0;
3825    if( iCodedScale * iBestD > iTargetValue )
3826    {
3827        iRoundingDir = -1;
3828    }
3829    else if( iCodedScale * iBestD < iTargetValue )
3830    {
3831        iRoundingDir = 1;
3832    }
3833    Int iCamPres = uiCamParsCodedPrecision - 1;
3834    m_aiDDDInvScale [ iBaseViewIdx ] = ( iBestD << ( iCamPres + g_bitDepthY )) * iSign;
3835    m_aiDDDInvOffset[ iBaseViewIdx ] = -iSign * iBestD * ( iCodedOffset << g_bitDepthY );
3836    m_aiDDDShift    [ iBaseViewIdx ] = iBitWidth;
3837    m_aiDDDInvOffset[ iBaseViewIdx ] += 1 << ( m_aiDDDShift[ iBaseViewIdx ] - 1 );
3838    m_aiDDDInvOffset[ iBaseViewIdx ] += ( 1 << ( m_aiDDDShift[ iBaseViewIdx ] - 4 ) ) * iRoundingDir;
3839
3840    return;
3841}
3842#endif
3843
3844/** get scaling matrix from RefMatrixID
3845 * \param sizeId size index
3846 * \param Index of input matrix
3847 * \param Index of reference matrix
3848 */
3849Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
3850{
3851  ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3852}
3853
3854/** parse syntax infomation
3855 *  \param pchFile syntax infomation
3856 *  \returns false if successful
3857 */
3858Bool TComScalingList::xParseScalingList(Char* pchFile)
3859{
3860  FILE *fp;
3861  Char line[1024];
3862  UInt sizeIdc,listIdc;
3863  UInt i,size = 0;
3864  Int *src=0,data;
3865  Char *ret;
3866  UInt  retval;
3867
3868  if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
3869  {
3870    printf("can't open file %s :: set Default Matrix\n",pchFile);
3871    return true;
3872  }
3873
3874  for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
3875  {
3876    size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
3877    for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
3878    {
3879      src = getScalingListAddress(sizeIdc, listIdc);
3880
3881      fseek(fp,0,0);
3882      do 
3883      {
3884        ret = fgets(line, 1024, fp);
3885        if ((ret==NULL)||(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
3886        {
3887          printf("Error: can't read Matrix :: set Default Matrix\n");
3888          return true;
3889        }
3890      }
3891      while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
3892      for (i=0; i<size; i++)
3893      {
3894        retval = fscanf(fp, "%d,", &data);
3895        if (retval!=1)
3896        {
3897          printf("Error: can't read Matrix :: set Default Matrix\n");
3898          return true;
3899        }
3900        src[i] = data;
3901      }
3902      //set DC value for default matrix check
3903      setScalingListDC(sizeIdc,listIdc,src[0]);
3904
3905      if(sizeIdc > SCALING_LIST_8x8)
3906      {
3907        fseek(fp,0,0);
3908        do 
3909        {
3910          ret = fgets(line, 1024, fp);
3911          if ((ret==NULL)||(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
3912          {
3913            printf("Error: can't read DC :: set Default Matrix\n");
3914            return true;
3915          }
3916        }
3917        while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
3918        retval = fscanf(fp, "%d,", &data);
3919        if (retval!=1)
3920        {
3921          printf("Error: can't read Matrix :: set Default Matrix\n");
3922          return true;
3923        }
3924        //overwrite DC value when size of matrix is larger than 16x16
3925        setScalingListDC(sizeIdc,listIdc,data);
3926      }
3927    }
3928  }
3929  fclose(fp);
3930  return false;
3931}
3932
3933#if H_MV
3934Void TComScalingList::inferFrom( TComScalingList* srcScLi )
3935{
3936  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3937  {
3938    for(Int listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
3939    {
3940      setRefMatrixId  (sizeId,listId, srcScLi->getRefMatrixId  (sizeId,listId));
3941      setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));         
3942      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3943    }
3944  }
3945}
3946#endif
3947/** initialization process of quantization matrix array
3948 */
3949Void TComScalingList::init()
3950{
3951  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3952  {
3953    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3954    {
3955      m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
3956    }
3957  }
3958  m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
3959}
3960
3961/** destroy quantization matrix array
3962 */
3963Void TComScalingList::destroy()
3964{
3965  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3966  {
3967    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3968    {
3969      if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
3970    }
3971  }
3972}
3973
3974/** get default address of quantization matrix
3975 * \param sizeId size index
3976 * \param listId list index
3977 * \returns pointer of quantization matrix
3978 */
3979Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
3980{
3981  Int *src = 0;
3982  switch(sizeId)
3983  {
3984    case SCALING_LIST_4x4:
3985      src = g_quantTSDefault4x4;
3986      break;
3987    case SCALING_LIST_8x8:
3988      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3989      break;
3990    case SCALING_LIST_16x16:
3991      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3992      break;
3993    case SCALING_LIST_32x32:
3994      src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3995      break;
3996    default:
3997      assert(0);
3998      src = NULL;
3999      break;
4000  }
4001  return src;
4002}
4003
4004/** process of default matrix
4005 * \param sizeId size index
4006 * \param Index of input matrix
4007 */
4008Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
4009{
4010  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
4011  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
4012}
4013
4014/** check DC value of matrix for default matrix signaling
4015 */
4016Void TComScalingList::checkDcOfMatrix()
4017{
4018  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
4019  {
4020    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
4021    {
4022      //check default matrix?
4023      if(getScalingListDC(sizeId,listId) == 0)
4024      {
4025        processDefaultMatrix(sizeId, listId);
4026      }
4027    }
4028  }
4029}
4030
4031ParameterSetManager::ParameterSetManager()
4032: m_vpsMap(MAX_NUM_VPS)
4033, m_spsMap(MAX_NUM_SPS)
4034, m_ppsMap(MAX_NUM_PPS)
4035, m_activeVPSId(-1)
4036#if !H_MV
4037, m_activeSPSId(-1)
4038, m_activePPSId(-1)
4039{
4040#else
4041{
4042  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
4043  {
4044    m_activeSPSId[ i ] = -1; 
4045    m_activePPSId[ i ] = -1; 
4046  }
4047#endif
4048}
4049
4050
4051ParameterSetManager::~ParameterSetManager()
4052{
4053}
4054
4055//! activate a SPS from a active parameter sets SEI message
4056//! \returns true, if activation is successful
4057#if H_MV
4058Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
4059#else
4060Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
4061#endif
4062{
4063  TComSPS *sps = m_spsMap.getPS(spsId);
4064  if (sps)
4065  {
4066    Int vpsId = sps->getVPSId();
4067    if (m_vpsMap.getPS(vpsId))
4068    {
4069      m_activeVPSId = vpsId;
4070#if H_MV
4071      m_activeSPSId[ layerId ] = spsId;
4072#else
4073      m_activeSPSId = spsId;
4074#endif
4075      return true;
4076    }
4077    else
4078    {
4079      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
4080    }
4081  }
4082  else
4083  {
4084    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
4085  }
4086  return false;
4087}
4088
4089//! activate a PPS and depending on isIDR parameter also SPS and VPS
4090//! \returns true, if activation is successful
4091#if H_MV
4092Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
4093#else
4094Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
4095#endif
4096{
4097  TComPPS *pps = m_ppsMap.getPS(ppsId);
4098  if (pps)
4099  {
4100    Int spsId = pps->getSPSId();
4101#if H_MV
4102    if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
4103#else
4104    if (!isIRAP && (spsId != m_activeSPSId))
4105#endif
4106    {
4107      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
4108      return false;
4109    }
4110
4111    TComSPS *sps = m_spsMap.getPS(spsId);
4112    if (sps)
4113    {
4114      Int vpsId = sps->getVPSId();
4115      if (!isIRAP && (vpsId != m_activeVPSId))
4116      {
4117        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
4118        return false;
4119      }
4120      if (m_vpsMap.getPS(vpsId))
4121      {
4122#if H_MV
4123        m_activePPSId[ layerId ] = ppsId;
4124        m_activeVPSId = vpsId;
4125        m_activeSPSId[ layerId ] = spsId;
4126#else
4127        m_activePPSId = ppsId;
4128        m_activeVPSId = vpsId;
4129        m_activeSPSId = spsId;
4130#endif
4131        return true;
4132      }
4133      else
4134      {
4135        printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
4136      }
4137    }
4138    else
4139    {
4140      printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
4141    }
4142  }
4143  else
4144  {
4145    printf("Warning: tried to activate non-existing PPS.");
4146  }
4147  return false;
4148}
4149
4150ProfileTierLevel::ProfileTierLevel()
4151  : m_profileSpace    (0)
4152  , m_tierFlag        (false)
4153  , m_profileIdc      (0)
4154  , m_levelIdc        (0)
4155, m_progressiveSourceFlag  (false)
4156, m_interlacedSourceFlag   (false)
4157, m_nonPackedConstraintFlag(false)
4158, m_frameOnlyConstraintFlag(false)
4159{
4160  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
4161}
4162
4163TComPTL::TComPTL()
4164{
4165  ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
4166  ::memset(m_subLayerLevelPresentFlag,   0, sizeof(m_subLayerLevelPresentFlag  ));
4167}
4168
4169#if H_MV
4170Void TComPTL::copyLevelFrom( TComPTL* source )
4171{
4172  getGeneralPTL()->setLevelIdc( source->getGeneralPTL()->getLevelIdc() );
4173  for( Int subLayer = 0; subLayer < 6; subLayer++ )
4174  {
4175    setSubLayerLevelPresentFlag( subLayer, source->getSubLayerLevelPresentFlag( subLayer ) );
4176    getSubLayerPTL( subLayer )->setLevelIdc( source->getSubLayerPTL( subLayer )->getLevelIdc() );
4177  }
4178}
4179#endif
4180//! \}
4181
4182#if H_MV
4183TComVPSVUI::TComVPSVUI()
4184{
4185  m_crossLayerIrapAlignedFlag = true; 
4186  m_allLayersIdrAlignedFlag   = false; 
4187  m_bitRatePresentVpsFlag = false;
4188  m_picRatePresentVpsFlag = false;
4189  for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
4190  {   
4191    for ( Int j = 0; j < MAX_TLAYER; j++)
4192    {   
4193      m_bitRatePresentFlag          [i][j] = false;
4194      m_picRatePresentFlag          [i][j] = false;
4195      m_avgBitRate                  [i][j] = -1;
4196      m_maxBitRate                  [i][j] = -1;
4197      m_constantPicRateIdc          [i][j] = -1;
4198      m_avgPicRate                  [i][j] = -1;
4199    }
4200  }
4201
4202  m_ilpRestrictedRefLayersFlag = false;
4203
4204  for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
4205  {         
4206    for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
4207    {   
4208      m_tileBoundariesAlignedFlag   [i][j] = false;
4209      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
4210      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
4211      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
4212    }
4213    m_baseLayerParameterSetCompatibilityFlag[i] = false;
4214  }
4215  for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
4216  {
4217    m_videoSignalInfo          [i] = NULL;     
4218  }
4219
4220  m_vpsVuiBspHrdPresentFlag = false; 
4221  m_vpsVuiBspHrdParameters  = new TComVpsVuiBspHrdParameters();
4222}
4223
4224TComVPSVUI::~TComVPSVUI()
4225{
4226  for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
4227  {
4228    if (m_videoSignalInfo[ i ] != NULL )      delete m_videoSignalInfo[ i ];   
4229    m_videoSignalInfo    [ i ] = NULL; 
4230  }
4231
4232  if ( m_vpsVuiBspHrdParameters ) delete m_vpsVuiBspHrdParameters;
4233  m_vpsVuiBspHrdParameters = NULL; 
4234}
4235
4236Void TComVPSVUI::inferVpsVui( Bool encoderFlag )
4237{
4238  // inference of syntax elements that differ from default inference (as done in constructor), when VPS VUI is not present
4239  if (!encoderFlag )
4240  {
4241    setCrossLayerIrapAlignedFlag( false ); 
4242  }
4243  else
4244  {
4245    assert( !getCrossLayerIrapAlignedFlag() ); 
4246  }
4247}
4248
4249Void TComRepFormat::inferChromaAndBitDepth( TComRepFormat* prevRepFormat, Bool encoderFlag )
4250{
4251  if ( !encoderFlag )
4252  {
4253    setChromaAndBitDepthVpsPresentFlag( prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
4254    setSeparateColourPlaneVpsFlag     ( prevRepFormat->getSeparateColourPlaneVpsFlag     () );
4255    setBitDepthVpsLumaMinus8          ( prevRepFormat->getBitDepthVpsLumaMinus8          () );
4256    setBitDepthVpsChromaMinus8        ( prevRepFormat->getBitDepthVpsChromaMinus8        () );
4257  }
4258  else
4259  {
4260    assert( getChromaAndBitDepthVpsPresentFlag() == prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
4261    assert( getSeparateColourPlaneVpsFlag     () == prevRepFormat->getSeparateColourPlaneVpsFlag     () );
4262    assert( getBitDepthVpsLumaMinus8          () == prevRepFormat->getBitDepthVpsLumaMinus8          () );
4263    assert( getBitDepthVpsChromaMinus8        () == prevRepFormat->getBitDepthVpsChromaMinus8        () );
4264}
4265}
4266
4267Void TComVpsVuiBspHrdParameters::checkLayerInBspFlag( TComVPS* vps, Int h )
4268{
4269  // It is a requirement of bitstream conformance that bitstream partition with index j shall not include
4270  // direct or indirect reference layers of any layers in bitstream partition i for any values of i and j
4271  // in the range of 0 to num_bitstream_partitions[ h ] ?1, inclusive, such that i is less than j.
4272
4273  for ( Int partJ = 0; partJ < getNumBitstreamPartitions( h ); partJ++ )
4274  {       
4275    for ( Int partI = 0; partI < partJ; partI++ )
4276    {
4277      for ( Int layerJ = 0; layerJ < vps->getMaxLayersMinus1(); layerJ++ )
4278      {
4279        if ( m_layerInBspFlag[ h ][partJ][layerJ ] )
4280        {
4281          for ( Int layerI = 0; layerI < vps->getMaxLayersMinus1(); layerI++ )
4282          {
4283            if ( m_layerInBspFlag[ h ][partI][layerI] )
4284            {
4285              assert( !vps->getInDirectDependencyFlag( layerI, layerJ ) ); 
4286            }
4287          }
4288        }
4289      }
4290    }
4291  }
4292
4293  // ---------------
4294  // To be added:
4295  // 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
4296  // 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,
4297  // inclusive, the value of layer_in_bsp_flag[ h ][ i ][ j ] for at least one value of j in the range of 1 to
4298  // NumLayersInIdList[ h ] - 1, inclusive, shall be equal to 1.
4299  // ---------------
4300
4301
4302  // 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,
4303  // 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
4304  // NumLayersInIdList[ h ] − 1, inclusive.
4305
4306
4307  if ( getNumBitstreamPartitions( h ) == 1 )
4308  {
4309    Bool atLeastOneZero = false; 
4310    for ( Int j = 0; j <= vps->getNumLayersInIdList( h ) - 1; j++ )
4311    {
4312      atLeastOneZero = atLeastOneZero || !getLayerInBspFlag( h, 0, j ); 
4313    }   
4314    assert( atLeastOneZero ); 
4315  }
4316
4317 
4318  // 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 ]
4319  // shall be equal to 1 for at most one value of i in the range of 0 to num_bitstream_partitions[ h ] − 1, inclusive.
4320
4321  for ( Int j = 0; j <= vps->getNumLayersInIdList( h ) - 1; j++ )
4322  {
4323    Int numLayerInBsp = 0; 
4324    for ( Int i = 0; i <= getNumBitstreamPartitions( h ) - 1; i++ )
4325    {
4326      numLayerInBsp += ( getLayerInBspFlag( h, i, j ) ? 1 : 0 ); 
4327    }   
4328    assert( numLayerInBsp <= 1 ); 
4329  }
4330
4331}
4332
4333Void TComVUI::inferVideoSignalInfo( TComVPS* vps, Int layerIdCurr )
4334{
4335  if ( layerIdCurr == 0 || !vps->getVpsVuiPresentFlag() ) 
4336  {
4337    return; 
4338  }
4339
4340  TComVPSVUI* vpsVUI = vps->getVPSVUI(); 
4341  assert( vpsVUI != NULL ); 
4342
4343  TComVideoSignalInfo* videoSignalInfo = vpsVUI->getVideoSignalInfo( vpsVUI->getVpsVideoSignalInfoIdx( vps->getLayerIdInVps( layerIdCurr ) ) ); 
4344  assert( videoSignalInfo != NULL );
4345
4346  setVideoFormat            ( videoSignalInfo->getVideoVpsFormat            () ); 
4347  setVideoFullRangeFlag     ( videoSignalInfo->getVideoFullRangeVpsFlag     () );
4348  setColourPrimaries        ( videoSignalInfo->getColourPrimariesVps        () );
4349  setTransferCharacteristics( videoSignalInfo->getTransferCharacteristicsVps() );
4350  setMatrixCoefficients     ( videoSignalInfo->getMatrixCoeffsVps           () );
4351}
4352
4353TComDpbSize::TComDpbSize()
4354{
4355  for (Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++ )
4356  {     
4357    m_subLayerFlagInfoPresentFlag[i]  = false;
4358
4359    for (Int j = 0; j < MAX_TLAYER; j++  )
4360    {       
4361      m_subLayerDpbInfoPresentFlag [i][j] = ( j == 0) ;
4362      m_maxVpsNumReorderPics       [i][j] = 0;
4363      m_maxVpsLatencyIncreasePlus1 [i][j] = 0;
4364
4365      for (Int k = 0; k < MAX_NUM_LAYER_IDS; k++ )
4366      {
4367        m_maxVpsDecPicBufferingMinus1[i][k][j] = 0; 
4368      }
4369    }
4370  }
4371}
4372#endif
Note: See TracBrowser for help on using the repository browser.