source: 3DVCSoftware/branches/HTM-9.0r1-F0122/source/Lib/TLibCommon/TComSlice.cpp @ 744

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

Merged HTM-8.2-dev0@723.

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