source: 3DVCSoftware/branches/HTM-9.2-dev0/source/Lib/TLibCommon/TComSlice.cpp @ 767

Last change on this file since 767 was 767, checked in by tech, 10 years ago

Cleanup part 4

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