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

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

Macro removal part 1.

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