source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComSlice.cpp @ 213

Last change on this file since 213 was 213, checked in by mitsubishi-htm, 12 years ago

A final release, as planned

  • Migrate to HTM 5.1
  • For VC project files, only VC9 file is updated
  • To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva
  • Property svn:eol-style set to native
File size: 79.6 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, 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
42//! \ingroup TLibCommon
43//! \{
44
45TComSlice::TComSlice()
46#if QC_MVHEVC_B0046
47: m_iPPSId                        ( 0  )
48#else
49: m_iPPSId                        ( -1 )
50#endif
51, m_iPOC                          ( 0 )
52, m_iLastIDR                      ( 0 )
53, m_eNalUnitType                  ( NAL_UNIT_CODED_SLICE_IDR )
54, m_eNalUnitTypeBaseViewMvc       ( NAL_UNIT_INVALID )
55, m_eSliceType                    ( I_SLICE )
56, m_iSliceQp                      ( 0 )
57#if ADAPTIVE_QP_SELECTION
58, m_iSliceQpBase                  ( 0 )
59#endif
60, m_bLoopFilterDisable            ( false )
61, m_inheritDblParamFromAPS       ( true )
62, m_loopFilterBetaOffsetDiv2    ( 0 )
63, m_loopFilterTcOffsetDiv2      ( 0 )
64, m_bRefPicListModificationFlagLC ( false )
65, m_bRefPicListCombinationFlag    ( false )
66, m_bCheckLDC                     ( false )
67, m_iSliceQpDelta                 ( 0 )
68, m_pcTexturePic                  ( NULL )
69, m_iDepth                        ( 0 )
70, m_bRefenced                     ( false )
71, m_pcSPS                         ( NULL )
72, m_pcPPS                         ( NULL )
73, m_pcPic                         ( NULL )
74, m_uiColDir                      ( 0 )
75#if COLLOCATED_REF_IDX
76, m_colRefIdx                     ( 0 )
77#endif
78#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA
79, m_dLambdaLuma( 0.0 )
80, m_dLambdaChroma( 0.0 )
81#else
82, m_dLambda                       ( 0.0 )
83#endif
84, m_bNoBackPredFlag               ( false )
85, m_bRefIdxCombineCoding          ( false )
86, m_uiTLayer                      ( 0 )
87, m_bTLayerSwitchingFlag          ( false )
88, m_uiSliceMode                   ( 0 )
89, m_uiSliceArgument               ( 0 )
90, m_uiSliceCurStartCUAddr         ( 0 )
91, m_uiSliceCurEndCUAddr           ( 0 )
92, m_uiSliceIdx                    ( 0 )
93, m_uiEntropySliceMode            ( 0 )
94, m_uiEntropySliceArgument        ( 0 )
95, m_uiEntropySliceCurStartCUAddr  ( 0 )
96, m_uiEntropySliceCurEndCUAddr    ( 0 )
97, m_bNextSlice                    ( false )
98, m_bNextEntropySlice             ( false )
99, m_uiSliceBits                   ( 0 )
100, m_uiEntropySliceCounter         ( 0 )
101, m_bFinalized                    ( false )
102, m_uiTileByteLocation            ( NULL )
103, m_uiTileCount                   ( 0 )
104, m_iTileMarkerFlag               ( 0 )
105, m_uiTileOffstForMultES          ( 0 )
106, m_puiSubstreamSizes             ( NULL )
107#if CABAC_INIT_FLAG
108, m_cabacInitFlag                 ( false )
109#else
110, m_cabacInitIdc                 ( -1 )
111#endif
112#if TILES_WPP_ENTRY_POINT_SIGNALLING
113, m_numEntryPointOffsets          ( 0 )
114#endif
115#if SONY_COLPIC_AVAILABILITY
116, m_iViewOrderIdx                 ( 0 )
117#endif
118#if LGE_ILLUCOMP_B0045
119, m_bApplyIC                      ( false )
120#endif
121#if VSP_CFG
122, m_uiNumVspRefPics               ( 0 )
123#endif
124{
125  m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = m_aiNumRefIdx[2] = 0;
126
127#if FORCE_REF_VSP
128  m_iRefIdxVsp[0] = m_iRefIdxVsp[1] = NOT_VALID;
129#endif
130 
131  initEqualRef();
132 
133  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
134  {
135    m_iRefIdxOfLC[REF_PIC_LIST_0][iNumCount]=-1;
136    m_iRefIdxOfLC[REF_PIC_LIST_1][iNumCount]=-1;
137    m_eListIdFromIdxOfLC[iNumCount]=0;
138    m_iRefIdxFromIdxOfLC[iNumCount]=0;
139    m_iRefIdxOfL0FromRefIdxOfL1[iNumCount] = -1;
140    m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
141  }   
142  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF+1; iNumCount++)
143  {
144    m_apcRefPicList  [0][iNumCount] = NULL;
145    m_apcRefPicList  [1][iNumCount] = NULL;
146    m_aiRefPOCList   [0][iNumCount] = 0;
147    m_aiRefPOCList   [1][iNumCount] = 0;
148    m_aiRefViewIdList[0][iNumCount] = 0;
149    m_aiRefViewIdList[1][iNumCount] = 0;
150  }
151  m_bCombineWithReferenceFlag = 0;
152  resetWpScaling(m_weightPredTable);
153  resetWpScalingLC(m_weightPredTableLC);
154  initWpAcDcParam();
155#if QC_IV_AS_LT_B0046
156  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF+1; iNumCount++)
157  {
158     m_bWasLongTerm[0][iNumCount] = false;
159     m_bWasLongTerm[1][iNumCount] = false;
160  }
161#endif
162
163#if VSP_SLICE_HEADER
164  m_bVspFlag = false;
165#if VSP_CFG
166  memset( m_uiVspRefPos[0], 0, sizeof(UInt)*MAX_NUM_REF_PICS );
167  memset( m_uiVspRefPos[1], 0, sizeof(UInt)*MAX_NUM_REF_PICS );
168#else
169  m_bVspDepthDisableFlag = false;
170#endif
171#endif
172}
173
174TComSlice::~TComSlice()
175{
176  if (m_uiTileByteLocation) 
177  {
178    delete [] m_uiTileByteLocation;
179    m_uiTileByteLocation = NULL;
180  }
181  delete[] m_puiSubstreamSizes;
182  m_puiSubstreamSizes = NULL;
183}
184
185
186Void TComSlice::initSlice()
187{
188  m_aiNumRefIdx[0]      = 0;
189  m_aiNumRefIdx[1]      = 0;
190 
191  m_uiColDir = 0;
192 
193#if COLLOCATED_REF_IDX
194  m_colRefIdx = 0;
195#endif
196  m_pcTexturePic = NULL;
197
198  initEqualRef();
199  m_bNoBackPredFlag = false;
200  m_bRefIdxCombineCoding = false;
201  m_bRefPicListCombinationFlag = false;
202  m_bRefPicListModificationFlagLC = false;
203  m_bCheckLDC = false;
204
205  m_aiNumRefIdx[REF_PIC_LIST_C]      = 0;
206
207  m_uiMaxNumMergeCand = MRG_MAX_NUM_CANDS_SIGNALED;
208
209  m_bFinalized=false;
210
211  m_uiTileCount          = 0;
212#if CABAC_INIT_FLAG
213  m_cabacInitFlag        = false;
214#endif
215#if TILES_WPP_ENTRY_POINT_SIGNALLING
216  m_numEntryPointOffsets = 0;
217#endif
218#if VSP_SLICE_HEADER
219  m_bVspFlag = false;
220#if VSP_CFG
221  m_uiNumVspRefPics = 0;
222  memset( m_uiVspRefPos[0], 0, sizeof(UInt)*MAX_NUM_REF_PICS );
223  memset( m_uiVspRefPos[1], 0, sizeof(UInt)*MAX_NUM_REF_PICS );
224#else
225  m_bVspDepthDisableFlag = false;
226#endif
227#endif
228
229}
230
231Void TComSlice::initTiles()
232{
233  Int iWidth             = m_pcSPS->getPicWidthInLumaSamples();
234  Int iHeight            = m_pcSPS->getPicHeightInLumaSamples();
235  UInt uiWidthInCU       = ( iWidth %g_uiMaxCUWidth  ) ? iWidth /g_uiMaxCUWidth  + 1 : iWidth /g_uiMaxCUWidth;
236  UInt uiHeightInCU      = ( iHeight%g_uiMaxCUHeight ) ? iHeight/g_uiMaxCUHeight + 1 : iHeight/g_uiMaxCUHeight;
237  UInt uiNumCUsInFrame   = uiWidthInCU * uiHeightInCU;
238
239  if (m_uiTileByteLocation==NULL) m_uiTileByteLocation   = new UInt[uiNumCUsInFrame];
240}
241
242
243/**
244 - allocate table to contain substream sizes to be written to the slice header.
245 .
246 \param uiNumSubstreams Number of substreams -- the allocation will be this value - 1.
247 */
248Void  TComSlice::allocSubstreamSizes(UInt uiNumSubstreams)
249{
250  delete[] m_puiSubstreamSizes;
251  m_puiSubstreamSizes = new UInt[uiNumSubstreams > 0 ? uiNumSubstreams-1 : 0];
252}
253
254Void  TComSlice::sortPicList        (TComList<TComPic*>& rcListPic)
255{
256  TComPic*    pcPicExtract;
257  TComPic*    pcPicInsert;
258 
259  TComList<TComPic*>::iterator    iterPicExtract;
260  TComList<TComPic*>::iterator    iterPicExtract_1;
261  TComList<TComPic*>::iterator    iterPicInsert;
262 
263  for (Int i = 1; i < (Int)(rcListPic.size()); i++)
264  {
265    iterPicExtract = rcListPic.begin();
266    for (Int j = 0; j < i; j++) iterPicExtract++;
267    pcPicExtract = *(iterPicExtract);
268    pcPicExtract->setCurrSliceIdx(0);
269   
270    iterPicInsert = rcListPic.begin();
271    while (iterPicInsert != iterPicExtract)
272    {
273      pcPicInsert = *(iterPicInsert);
274      pcPicInsert->setCurrSliceIdx(0);
275      if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
276      {
277        break;
278      }
279     
280      iterPicInsert++;
281    }
282   
283    iterPicExtract_1 = iterPicExtract;    iterPicExtract_1++;
284   
285    //  swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
286    rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
287    rcListPic.erase  (iterPicExtract);
288  }
289}
290
291TComPic* TComSlice::xGetRefPic( TComList<TComPic*>& rcListPic, UInt uiPOC )
292{
293  TComList<TComPic*>::iterator  iterPic = rcListPic.begin(); 
294  TComPic*                      pcPic = *(iterPic);
295  while ( iterPic != rcListPic.end() )
296  {
297    if(pcPic->getPOC() == uiPOC)
298    {
299      break;
300    }
301    iterPic++;
302    pcPic = *(iterPic);
303  }
304  return  pcPic;
305}
306
307
308TComPic* TComSlice::xGetLongTermRefPic( TComList<TComPic*>& rcListPic, UInt uiPOC )
309{
310  TComList<TComPic*>::iterator  iterPic = rcListPic.begin(); 
311  TComPic*                      pcPic = *(iterPic);
312  TComPic*                      pcStPic = pcPic;
313  while ( iterPic != rcListPic.end() )
314  {
315    pcPic = *(iterPic);
316    if(pcPic && (pcPic->getPOC()%(1<<getSPS()->getBitsForPOC())) == (uiPOC%(1<<getSPS()->getBitsForPOC())))
317    {
318      if(pcPic->getIsLongTerm())
319        return pcPic;
320      else
321        pcStPic = pcPic;
322      break;
323    }
324
325    iterPic++;
326  }
327  return  pcStPic;
328}
329
330TComPic* TComSlice::xGetInterViewRefPic( std::vector<TComPic*>& rcListIvPic, UInt uiViewId )
331{
332  TComPic* pcPic = NULL;
333  for( Int k = 0; k < rcListIvPic.size(); k++ )
334  {
335    if( rcListIvPic[k]->getViewId() == uiViewId )
336    {
337      pcPic = rcListIvPic[k];
338      break;
339    }
340  }
341
342  assert( pcPic != NULL );
343  return pcPic;
344}
345
346Int TComSlice::getNumPocTotalCurr()
347{
348  if( m_eSliceType == I_SLICE ) 
349  {
350    return 0;
351  }
352
353  Int numPocTotalCurr = 0;
354  for( UInt i = 0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++ )
355  {
356    if(m_pcRPS->getUsed(i))
357    {
358      numPocTotalCurr++;
359    }
360  }
361
362  return numPocTotalCurr;
363}
364
365Int TComSlice::getNumPocTotalCurrMvc()
366{
367  if( m_eSliceType == I_SLICE ) 
368  {
369    return 0;
370  }
371  return getNumPocTotalCurr() + m_pcSPS->getNumberOfUsableInterViewRefs();
372}
373
374Void TComSlice::setRefPOCnViewListsMvc()
375{
376  for(Int iDir = 0; iDir < 2; iDir++)
377  {
378    for(Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
379    {
380      m_aiRefPOCList   [iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
381      m_aiRefViewIdList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getViewId();
382    }
383  }
384}
385
386Void TComSlice::generateCombinedList()
387{
388  if(m_aiNumRefIdx[REF_PIC_LIST_C] > 0)
389  {
390    m_aiNumRefIdx[REF_PIC_LIST_C]=0;
391    for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
392    {
393      m_iRefIdxOfLC[REF_PIC_LIST_0][iNumCount]=-1;
394      m_iRefIdxOfLC[REF_PIC_LIST_1][iNumCount]=-1;
395      m_eListIdFromIdxOfLC[iNumCount]=0;
396      m_iRefIdxFromIdxOfLC[iNumCount]=0;
397      m_iRefIdxOfL0FromRefIdxOfL1[iNumCount] = -1;
398      m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
399    }
400
401    for (Int iNumRefIdx = 0; iNumRefIdx < MAX_NUM_REF; iNumRefIdx++)
402    {
403      if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_0])
404      {
405        Bool bTempRefIdxInL2 = true;
406        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
407        {
408          if( (m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC()    == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC()   ) &&
409              (m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getViewId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getViewId())    )
410          {
411            m_iRefIdxOfL1FromRefIdxOfL0[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
412            m_iRefIdxOfL0FromRefIdxOfL1[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
413            bTempRefIdxInL2 = false;
414            break;
415          }
416        }
417
418        if(bTempRefIdxInL2 == true)
419        { 
420          m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_0;
421          m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
422          m_iRefIdxOfLC[REF_PIC_LIST_0][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
423        }
424      }
425
426      if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_1])
427      {
428        Bool bTempRefIdxInL2 = true;
429        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
430        {
431          if( (m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC()    == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC()   ) &&
432              (m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getViewId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getViewId())    )
433          {
434            m_iRefIdxOfL0FromRefIdxOfL1[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
435            m_iRefIdxOfL1FromRefIdxOfL0[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
436            bTempRefIdxInL2 = false;
437            break;
438          }
439        }
440        if(bTempRefIdxInL2 == true)
441        {
442          m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_1;
443          m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
444          m_iRefIdxOfLC[REF_PIC_LIST_1][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
445        }
446      }
447    }
448  }
449}
450
451#if VSP_N
452Void TComSlice::setRefPicListMvc( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics, TComPic* pcVspPic )
453#else
454Void TComSlice::setRefPicListMvc( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics )
455#endif
456{
457  if( m_eSliceType == I_SLICE )
458  {
459    ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList) );
460    ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ) );
461
462    return;
463  }
464
465  TComPic*  pcRefPic;
466  TComPic*  RefPicSetStCurr0[16];
467  TComPic*  RefPicSetStCurr1[16];
468  TComPic*  RefPicSetLtCurr [16];
469  TComPic*  RefPicSetIvCurr [16];
470#if VSP_N
471  TComPic*  RefPicSetVspCurr [16] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}; //for Linux comp
472#endif
473
474  UInt NumPocStCurr0 = 0;
475  UInt NumPocStCurr1 = 0;
476  UInt NumPocLtCurr  = 0;
477  UInt NumPocIvCurr  = 0;
478#if VSP_N
479  UInt NumPocVspCurr  = 0;
480#endif
481
482  Int i;
483  // short term negative
484  for( i = 0; i < m_pcRPS->getNumberOfNegativePictures(); i++ )
485  {
486    if( m_pcRPS->getUsed(i) )
487    {
488      pcRefPic = xGetRefPic( rcListPic, getPOC() + m_pcRPS->getDeltaPOC(i) );
489      pcRefPic->setIsLongTerm( 0 );
490      pcRefPic->getPicYuvRec()->extendPicBorder();
491      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
492      NumPocStCurr0++;
493    }
494  }
495  // short term positive
496  for( ; i < m_pcRPS->getNumberOfNegativePictures() + m_pcRPS->getNumberOfPositivePictures(); i++ )
497  {
498    if( m_pcRPS->getUsed(i) )
499    {
500      pcRefPic = xGetRefPic( rcListPic, getPOC() + m_pcRPS->getDeltaPOC(i) );
501      pcRefPic->setIsLongTerm( 0 );
502      pcRefPic->getPicYuvRec()->extendPicBorder();
503      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
504      NumPocStCurr1++;
505    }
506  }
507  // long term
508  for( i = m_pcRPS->getNumberOfNegativePictures() + m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures() - 1; i > m_pcRPS->getNumberOfNegativePictures() + m_pcRPS->getNumberOfPositivePictures() - 1 ; i-- )
509  {
510    if( m_pcRPS->getUsed(i) )
511    {
512      pcRefPic = xGetLongTermRefPic( rcListPic, m_pcRPS->getPOC(i) );
513      pcRefPic->setIsLongTerm( 1 );
514      pcRefPic->getPicYuvRec()->extendPicBorder();
515      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
516      NumPocLtCurr++;
517    }
518  }
519  // inter-view
520  for( i = 0; i < m_pcSPS->getNumberOfUsableInterViewRefs(); i++ )
521  {
522    pcRefPic = xGetInterViewRefPic( rapcInterViewRefPics, getViewId() + m_pcSPS->getUsableInterViewRef(i) );
523#if QC_IV_AS_LT_B0046
524    pcRefPic->setIsLongTerm( 1 );
525#else
526    pcRefPic->setIsLongTerm( 0 );
527#endif
528    pcRefPic->getPicYuvRec()->extendPicBorder();
529    RefPicSetIvCurr[NumPocIvCurr] = pcRefPic;
530    NumPocIvCurr++;
531  }
532#if VSP_N
533  if( pcVspPic )
534  {
535    pcRefPic = pcVspPic;
536    pcRefPic->setIsLongTerm( 0 );
537    pcRefPic->getPicYuvRec()->extendPicBorder();
538    RefPicSetVspCurr[NumPocVspCurr] = pcRefPic;
539    NumPocVspCurr++;
540  }
541#endif
542
543  // ref_pic_list_init
544  UInt cIdx = 0;
545  UInt num_ref_idx_l0_active_minus1 = m_aiNumRefIdx[0] - 1;
546  UInt num_ref_idx_l1_active_minus1 = m_aiNumRefIdx[1] - 1;
547
548  assert( (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) == getNumPocTotalCurrMvc() );
549#if VSP_N
550  Int numRpsCurrTempList0 = max( (num_ref_idx_l0_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr + NumPocVspCurr) );
551  Int numRpsCurrTempList1 = max( (num_ref_idx_l1_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr + NumPocVspCurr) );
552#else
553  Int numRpsCurrTempList0 = max( (num_ref_idx_l0_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) );
554  Int numRpsCurrTempList1 = max( (num_ref_idx_l1_active_minus1 + 1), (NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + NumPocIvCurr) );
555#endif
556
557  assert( numRpsCurrTempList0 <= 16 );
558  TComPic* refPicListTemp0[16];
559  assert( numRpsCurrTempList1 <= 16 );
560  TComPic* refPicListTemp1[16];
561
562  cIdx = 0;
563  while( cIdx < numRpsCurrTempList0 )
564  {
565    for( i = 0; i < NumPocStCurr0 && cIdx < numRpsCurrTempList0; cIdx++, i++ ) { refPicListTemp0[cIdx] = RefPicSetStCurr0[i]; }
566    for( i = 0; i < NumPocStCurr1 && cIdx < numRpsCurrTempList0; cIdx++, i++ ) { refPicListTemp0[cIdx] = RefPicSetStCurr1[i]; }
567    for( i = 0; i < NumPocLtCurr  && cIdx < numRpsCurrTempList0; cIdx++, i++ ) { refPicListTemp0[cIdx] = RefPicSetLtCurr [i]; }
568    for( i = 0; i < NumPocIvCurr  && cIdx < numRpsCurrTempList0; cIdx++, i++ ) { refPicListTemp0[cIdx] = RefPicSetIvCurr [i]; }
569  }
570
571  cIdx = 0;
572  while( cIdx < numRpsCurrTempList1 && m_eSliceType == B_SLICE )
573  {
574    for( i = 0; i < NumPocStCurr1 && cIdx < numRpsCurrTempList1; cIdx++, i++ ) { refPicListTemp1[cIdx] = RefPicSetStCurr1[i]; }
575    for( i = 0; i < NumPocStCurr0 && cIdx < numRpsCurrTempList1; cIdx++, i++ ) { refPicListTemp1[cIdx] = RefPicSetStCurr0[i]; }
576    for( i = 0; i < NumPocLtCurr  && cIdx < numRpsCurrTempList1; cIdx++, i++ ) { refPicListTemp1[cIdx] = RefPicSetLtCurr [i]; }
577    for( i = 0; i < NumPocIvCurr  && cIdx < numRpsCurrTempList1; cIdx++, i++ ) { refPicListTemp1[cIdx] = RefPicSetIvCurr [i]; }
578  }
579
580#if VSP_CFG
581  UInt cIdxTmp;
582  for( cIdx = 0, cIdxTmp = 0; cIdx <= num_ref_idx_l0_active_minus1; cIdx ++ )
583#else
584  for( cIdx = 0; cIdx <= num_ref_idx_l0_active_minus1; cIdx ++ )
585#endif
586  {
587#if VSP_N
588#if VSP_CFG
589    Int iVspRefPos = getVspRefPos(REF_PIC_LIST_0, 0);
590    iVspRefPos = ( iVspRefPos > 0 ? iVspRefPos - 1 : -1 );
591    if( pcVspPic && iVspRefPos != -1 && cIdx == (iVspRefPos >= num_ref_idx_l0_active_minus1 ? num_ref_idx_l0_active_minus1 : iVspRefPos) )
592#else
593    if( pcVspPic && cIdx == num_ref_idx_l0_active_minus1 )
594#endif
595    {
596      m_apcRefPicList[0][cIdx] = RefPicSetVspCurr[0];
597#if FORCE_REF_VSP
598      m_iRefIdxVsp[0] = cIdx;
599#endif
600    }
601    else
602    {
603#if VSP_CFG
604      m_apcRefPicList[0][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? refPicListTemp0[ m_RefPicListModification.getRefPicSetIdxL0(cIdxTmp) ] : refPicListTemp0[cIdxTmp];
605      cIdxTmp++;
606#else
607      m_apcRefPicList[0][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? refPicListTemp0[ m_RefPicListModification.getRefPicSetIdxL0(cIdx) ] : refPicListTemp0[cIdx];
608#endif
609    }
610#if QC_IV_AS_LT_B0046
611    setWasLongTerm(m_apcRefPicList[0][cIdx]->getIsLongTerm(), REF_PIC_LIST_0, cIdx);
612#endif
613#else
614    m_apcRefPicList[0][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? refPicListTemp0[ m_RefPicListModification.getRefPicSetIdxL0(cIdx) ] : refPicListTemp0[cIdx];
615#if QC_IV_AS_LT_B0046
616    setWasLongTerm(m_apcRefPicList[0][cIdx]->getIsLongTerm(), REF_PIC_LIST_0, cIdx);
617#endif
618#endif
619  }
620  if( m_eSliceType == P_SLICE )
621  {
622    m_aiNumRefIdx[1] = 0;
623    ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]) );
624  }
625  else
626  {
627#if VSP_CFG
628    for( cIdx = 0, cIdxTmp = 0; cIdx <= num_ref_idx_l1_active_minus1; cIdx ++ )
629#else
630    for( cIdx = 0; cIdx <= num_ref_idx_l1_active_minus1; cIdx ++ )
631#endif
632    {
633#if VSP_N
634#if VSP_CFG
635      Int iVspRefPos = getVspRefPos(REF_PIC_LIST_1, 0);
636      iVspRefPos = ( iVspRefPos > 0 ? iVspRefPos - 1 : -1 );
637      if( pcVspPic && iVspRefPos != -1 && cIdx == (iVspRefPos >= num_ref_idx_l1_active_minus1 ? num_ref_idx_l1_active_minus1 : iVspRefPos) )
638#else
639      if( pcVspPic && cIdx == num_ref_idx_l1_active_minus1 )
640#endif
641      {
642        m_apcRefPicList[1][cIdx] = RefPicSetVspCurr[0];
643#if FORCE_REF_VSP
644        m_iRefIdxVsp[1] = cIdx;
645#endif
646      }
647      else
648      {
649#if VSP_CFG
650        m_apcRefPicList[1][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(cIdxTmp) ] : refPicListTemp1[cIdxTmp];
651        cIdxTmp++;
652#else
653        m_apcRefPicList[1][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(cIdx) ] : refPicListTemp1[cIdx];
654#endif
655      }
656#if QC_IV_AS_LT_B0046
657      setWasLongTerm(m_apcRefPicList[1][cIdx]->getIsLongTerm(), REF_PIC_LIST_1, cIdx);
658#endif
659#else
660      m_apcRefPicList[1][cIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(cIdx) ] : refPicListTemp1[cIdx];
661#if QC_IV_AS_LT_B0046
662      setWasLongTerm(m_apcRefPicList[1][cIdx]->getIsLongTerm(), REF_PIC_LIST_1, cIdx);
663#endif
664#endif
665    }
666  }
667}
668
669Void TComSlice::initEqualRef()
670{
671  for (Int iDir = 0; iDir < 2; iDir++)
672  {
673    for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
674    {
675      for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
676      {
677        m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
678      }
679    }
680  }
681}
682
683Void TComSlice::initMultiviewSlice( Int** aaiScale, Int** aaiOffset )
684{
685  if( m_pcSPS->hasCamParInSliceHeader() )
686  {
687    UInt uiViewId = m_pcSPS->getViewId();
688    for( UInt uiBaseViewId = 0; uiBaseViewId < uiViewId; uiBaseViewId++ )
689    {
690      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aaiScale [ uiBaseViewId ][     uiViewId ];
691      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aaiScale [     uiViewId ][ uiBaseViewId ];
692      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aaiOffset[ uiBaseViewId ][     uiViewId ];
693      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aaiOffset[     uiViewId ][ uiBaseViewId ];
694    }
695  }
696}
697
698#if COLLOCATED_REF_IDX
699Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
700{
701  Int i;
702  TComSlice* curSlice = pic->getSlice(curSliceIdx);
703  Int currColRefPOC =  curSlice->getRefPOC( RefPicList(curSlice->getColDir()), curSlice->getColRefIdx());
704  TComSlice* preSlice;
705  Int preColRefPOC;
706  for(i=curSliceIdx-1; i>=0; i--)
707  {
708    preSlice = pic->getSlice(i);
709    if(preSlice->getSliceType() != I_SLICE)
710    {
711      preColRefPOC  = preSlice->getRefPOC( RefPicList(preSlice->getColDir()), preSlice->getColRefIdx());
712      if(currColRefPOC != preColRefPOC)
713      {
714        printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
715        exit(EXIT_FAILURE);
716      }
717      else
718      {
719        break;
720      }
721    }
722  }
723}
724#endif
725Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, TComList<TComPic*>& rcListPic)
726{
727  for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
728  {
729    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
730    {
731      assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
732    }
733  }
734  for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
735  {
736    if(pocCRA < MAX_UINT && getPOC() > pocCRA)
737    {
738      assert(pReferencePictureSet->getPOC(i) >= pocCRA);
739    }
740  }
741#if H0566_TLA
742  if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
743#else
744  if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR ) // CDR picture found
745#endif
746  {
747    pocCRA = getPOC();
748  }
749}
750
751/** Function for marking the reference pictures when an IDR and CRA is encountered.
752 * \param pocCRA POC of the CRA picture
753 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
754 * \param rcListPic reference to the reference picture list
755 * This function marks the reference pictures as "unused for reference" in the following conditions.
756 * If the nal_unit_type is IDR all pictures in the reference picture list 
757 * is marked as "unused for reference"
758 * Otherwise do for the CRA case (non CRA case has no effect since both if conditions below will not be true)
759 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
760 *    temporal reference is greater than the temporal reference of the latest CRA picture (pocCRA),
761 *    mark all reference pictures except the latest CRA picture as "unused for reference" and set
762 *    the bRefreshPending flag to false.
763 *    If the nal_unit_type is CRA, set the bRefreshPending flag to true and pocCRA to the temporal
764 *    reference of the current picture.
765 * Note that the current picture is already placed in the reference list and its marking is not changed.
766 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
767 */
768Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
769{
770  TComPic*                 rpcPic;
771  UInt uiPOCCurr = getPOC(); 
772
773  if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_IDR )  // IDR
774  {
775    // mark all pictures as not used for reference
776    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
777    while (iterPic != rcListPic.end())
778    {
779      rpcPic = *(iterPic);
780      rpcPic->setCurrSliceIdx(0);
781      if (rpcPic->getPOC() != uiPOCCurr) rpcPic->getSlice(0)->setReferenced(false);
782      iterPic++;
783    }
784  }
785  else // CRA or No DR
786  {
787    if (bRefreshPending==true && uiPOCCurr > pocCRA) // CRA reference marking pending
788    {
789      TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
790      while (iterPic != rcListPic.end())
791      {
792        rpcPic = *(iterPic);
793        if (rpcPic->getPOC() != uiPOCCurr && rpcPic->getPOC() != pocCRA) rpcPic->getSlice(0)->setReferenced(false);
794        iterPic++;
795      }
796      bRefreshPending = false; 
797    }
798#if H0566_TLA
799    if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
800#else
801    if( getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR ) // CDR picture found
802#endif
803    {
804      bRefreshPending = true; 
805      pocCRA = uiPOCCurr;
806    }
807  }
808}
809
810Void TComSlice::copySliceInfo(TComSlice *pSrc)
811{
812  assert( pSrc != NULL );
813
814  Int i, j, k;
815
816  m_iPOC                 = pSrc->m_iPOC;
817  m_viewId               = pSrc->m_viewId;
818#if SONY_COLPIC_AVAILABILITY
819  m_iViewOrderIdx        = pSrc->m_iViewOrderIdx;
820#endif
821  m_eNalUnitType         = pSrc->m_eNalUnitType;
822  m_eNalUnitTypeBaseViewMvc = pSrc->m_eNalUnitTypeBaseViewMvc;
823  m_eSliceType           = pSrc->m_eSliceType;
824  m_iSliceQp             = pSrc->m_iSliceQp;
825#if ADAPTIVE_QP_SELECTION
826  m_iSliceQpBase         = pSrc->m_iSliceQpBase;
827#endif
828  m_bLoopFilterDisable   = pSrc->m_bLoopFilterDisable;
829  m_inheritDblParamFromAPS = pSrc->m_inheritDblParamFromAPS;
830  m_loopFilterBetaOffsetDiv2 = pSrc->m_loopFilterBetaOffsetDiv2;
831  m_loopFilterTcOffsetDiv2 = pSrc->m_loopFilterTcOffsetDiv2;
832 
833  for (i = 0; i < 3; i++)
834  {
835    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
836  }
837
838  for (i = 0; i < 2; i++)
839  {
840    for (j = 0; j < MAX_NUM_REF_LC; j++)
841    {
842       m_iRefIdxOfLC[i][j]  = pSrc->m_iRefIdxOfLC[i][j];
843    }
844  }
845  for (i = 0; i < MAX_NUM_REF_LC; i++)
846  {
847    m_eListIdFromIdxOfLC[i] = pSrc->m_eListIdFromIdxOfLC[i];
848    m_iRefIdxFromIdxOfLC[i] = pSrc->m_iRefIdxFromIdxOfLC[i];
849    m_iRefIdxOfL1FromRefIdxOfL0[i] = pSrc->m_iRefIdxOfL1FromRefIdxOfL0[i];
850    m_iRefIdxOfL0FromRefIdxOfL1[i] = pSrc->m_iRefIdxOfL0FromRefIdxOfL1[i];
851  }
852  m_bRefPicListModificationFlagLC = pSrc->m_bRefPicListModificationFlagLC;
853  m_bRefPicListCombinationFlag    = pSrc->m_bRefPicListCombinationFlag;
854  m_bCheckLDC             = pSrc->m_bCheckLDC;
855  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
856  for (i = 0; i < 2; i++)
857  {
858    for (j = 0; j < MAX_NUM_REF; j++)
859    {
860      m_apcRefPicList  [i][j] = pSrc->m_apcRefPicList  [i][j];
861      m_aiRefPOCList   [i][j] = pSrc->m_aiRefPOCList   [i][j];
862      m_aiRefViewIdList[i][j] = pSrc->m_aiRefViewIdList[i][j];
863    }
864  } 
865  m_iDepth               = pSrc->m_iDepth;
866
867  // referenced slice
868  m_bRefenced            = pSrc->m_bRefenced;
869
870  // access channel
871  m_pcSPS                = pSrc->m_pcSPS;
872  m_pcPPS                = pSrc->m_pcPPS;
873  m_pcRPS                = pSrc->m_pcRPS;
874  m_iLastIDR             = pSrc->m_iLastIDR;
875
876  m_pcPic                = pSrc->m_pcPic;
877  m_pcAPS                = pSrc->m_pcAPS;
878  m_iAPSId               = pSrc->m_iAPSId;
879
880  m_uiColDir             = pSrc->m_uiColDir;
881#if COLLOCATED_REF_IDX
882  m_colRefIdx            = pSrc->m_colRefIdx;
883#endif
884#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA
885  m_dLambdaLuma          = pSrc->m_dLambdaLuma;
886  m_dLambdaChroma        = pSrc->m_dLambdaChroma;
887#else
888  m_dLambda              = pSrc->m_dLambda;
889#endif
890  for (i = 0; i < 2; i++)
891  {
892    for (j = 0; j < MAX_NUM_REF; j++)
893    {
894      for (k =0; k < MAX_NUM_REF; k++)
895      {
896        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
897      }
898    }
899  }
900
901  m_bNoBackPredFlag      = pSrc->m_bNoBackPredFlag;
902  m_bRefIdxCombineCoding = pSrc->m_bRefIdxCombineCoding;
903
904  m_uiTLayer                      = pSrc->m_uiTLayer;
905  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
906
907  m_uiSliceMode                   = pSrc->m_uiSliceMode;
908  m_uiSliceArgument               = pSrc->m_uiSliceArgument;
909  m_uiSliceCurStartCUAddr         = pSrc->m_uiSliceCurStartCUAddr;
910  m_uiSliceCurEndCUAddr           = pSrc->m_uiSliceCurEndCUAddr;
911  m_uiSliceIdx                    = pSrc->m_uiSliceIdx;
912  m_uiEntropySliceMode            = pSrc->m_uiEntropySliceMode;
913  m_uiEntropySliceArgument        = pSrc->m_uiEntropySliceArgument; 
914  m_uiEntropySliceCurStartCUAddr  = pSrc->m_uiEntropySliceCurStartCUAddr;
915  m_uiEntropySliceCurEndCUAddr    = pSrc->m_uiEntropySliceCurEndCUAddr;
916  m_bNextSlice                    = pSrc->m_bNextSlice;
917  m_bNextEntropySlice             = pSrc->m_bNextEntropySlice;
918  m_iTileMarkerFlag             = pSrc->m_iTileMarkerFlag;
919  for ( int e=0 ; e<2 ; e++ )
920    for ( int n=0 ; n<MAX_NUM_REF ; n++ )
921      memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
922
923  m_saoEnabledFlag = pSrc->m_saoEnabledFlag; 
924#if SAO_UNIT_INTERLEAVING
925  m_saoInterleavingFlag = pSrc->m_saoInterleavingFlag;
926  m_saoEnabledFlagCb = pSrc->m_saoEnabledFlagCb;
927  m_saoEnabledFlagCr = pSrc->m_saoEnabledFlagCr; 
928#endif
929#if CABAC_INIT_FLAG
930  m_cabacInitFlag                = pSrc->m_cabacInitFlag;
931#endif
932#if TILES_WPP_ENTRY_POINT_SIGNALLING
933  m_numEntryPointOffsets  = pSrc->m_numEntryPointOffsets;
934#endif
935
936#if H0111_MVD_L1_ZERO
937  m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
938#endif
939}
940
941int TComSlice::m_prevPOC = 0;
942/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
943 * \param uiTLayer Temporal layer ID of the current slice
944 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
945 * the SPS's temporal_id_nesting_flag and the parsed PPS.  Then, current slice's temporal layer ID and
946 * temporal_layer_switching_point_flag is set accordingly.
947 */
948Void TComSlice::setTLayerInfo( UInt uiTLayer )
949{
950#if !H0566_TLA
951  // If temporal_id_nesting_flag == 1, then num_temporal_layer_switching_point_flags shall be inferred to be 0 and temporal_layer_switching_point_flag shall be inferred to be 1 for all temporal layers
952  if ( m_pcSPS->getTemporalIdNestingFlag() ) 
953  {
954    m_pcPPS->setNumTLayerSwitchingFlags( 0 );
955    for ( UInt i = 0; i < MAX_TLAYER; i++ )
956    {
957      m_pcPPS->setTLayerSwitchingFlag( i, true );
958    }
959  }
960  else 
961  {
962    for ( UInt i = m_pcPPS->getNumTLayerSwitchingFlags(); i < MAX_TLAYER; i++ )
963    {
964      m_pcPPS->setTLayerSwitchingFlag( i, false );
965    }
966  }
967#endif
968
969  m_uiTLayer = uiTLayer;
970#if !H0566_TLA
971  m_bTLayerSwitchingFlag = m_pcPPS->getTLayerSwitchingFlag( uiTLayer );
972#endif
973}
974
975#if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
976/** Function for checking if this is a switching-point
977*/
978Bool TComSlice::isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
979{
980  TComPic* rpcPic;
981  // loop through all pictures in the reference picture buffer
982  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
983  while ( iterPic != rcListPic.end())
984  {
985    rpcPic = *(iterPic++);
986    if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
987    {
988      if(rpcPic->getTLayer() >= getTLayer())
989      {
990        return false;
991      }
992    }
993  }
994  return true;
995}
996#endif
997
998/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
999*/
1000Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1001{
1002  TComPic* rpcPic;
1003  Int i, isReference;
1004
1005  Int j = 0;
1006  // loop through all pictures in the reference picture buffer
1007  TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1008  while ( iterPic != rcListPic.end())
1009  {
1010    j++;
1011    rpcPic = *(iterPic++);
1012
1013    isReference = 0;
1014    // loop through all pictures in the Reference Picture Set to see if the picture should be kept as reference picture
1015    for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1016    {
1017#if QC_IV_AS_LT_B0046
1018       if( rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1019#else
1020      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1021#endif
1022      {
1023        isReference = 1;
1024        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1025        rpcPic->setIsLongTerm(0);
1026      }
1027    }
1028    // long term pictures
1029    for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1030    {
1031#if QC_IV_AS_LT_B0046
1032     if( (rpcPic->getPicSym()->getSlice(0)->getPOC()%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC())) == pReferencePictureSet->getPOC(i)%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC()))
1033#else
1034      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()))
1035#endif
1036      {
1037        isReference = 1;
1038        rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1039      }
1040    }
1041    // mark the picture as "unused for reference" if it is not in
1042    // the Reference Picture Set
1043    if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)   
1044    {           
1045      rpcPic->getSlice( 0 )->setReferenced( false );   
1046      rpcPic->setIsLongTerm(0);
1047    }
1048  } 
1049}
1050
1051/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1052*/
1053#if START_DECODING_AT_CRA
1054Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag, Int pocRandomAccess)
1055#else
1056Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag)
1057#endif
1058{
1059  TComPic* rpcPic;
1060  Int i, isAvailable, j;
1061  Int atLeastOneLost = 0;
1062  Int atLeastOneRemoved = 0;
1063  Int iPocLost = 0;
1064
1065  // loop through all long-term pictures in the Reference Picture Set
1066  // to see if the picture should be kept as reference picture
1067  for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1068  {
1069    j = 0;
1070    isAvailable = 0;
1071    // loop through all pictures in the reference picture buffer
1072    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1073    while ( iterPic != rcListPic.end())
1074    {
1075      j++;
1076      rpcPic = *(iterPic++);
1077      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())
1078      {
1079        isAvailable = 1;
1080      }
1081    }
1082    // if there was no such long-term check the short terms
1083    if(!isAvailable)
1084    {
1085      iterPic = rcListPic.begin();
1086      while ( iterPic != rcListPic.end())
1087      {
1088        j++;
1089        rpcPic = *(iterPic++);
1090
1091        if((rpcPic->getPicSym()->getSlice(0)->getPOC()%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC())) == (this->getPOC() + pReferencePictureSet->getDeltaPOC(i))%(1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC()) && rpcPic->getSlice(0)->isReferenced())
1092        {
1093          isAvailable = 1;
1094          rpcPic->setIsLongTerm(1);
1095          break;
1096        }
1097      }
1098    }
1099    // report that a picture is lost if it is in the Reference Picture Set
1100    // but not available as reference picture
1101    if(isAvailable == 0)   
1102    {           
1103#if START_DECODING_AT_CRA
1104      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1105      {
1106#endif
1107        if(!pReferencePictureSet->getUsed(i) )
1108        {
1109          if(outputFlag)
1110            printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1111          atLeastOneRemoved = 1;
1112        }
1113        else
1114        {
1115          if(outputFlag)
1116            printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1117          atLeastOneLost = 1;
1118          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1119        }
1120#if START_DECODING_AT_CRA
1121      }
1122#endif
1123    }
1124  } 
1125  // loop through all short-term pictures in the Reference Picture Set
1126  // to see if the picture should be kept as reference picture
1127  for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1128  {
1129    j = 0;
1130    isAvailable = 0;
1131    // loop through all pictures in the reference picture buffer
1132    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1133    while ( iterPic != rcListPic.end())
1134    {
1135      j++;
1136      rpcPic = *(iterPic++);
1137
1138      if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1139      {
1140        isAvailable = 1;
1141      }
1142    }
1143    // report that a picture is lost if it is in the Reference Picture Set
1144    // but not available as reference picture
1145    if(isAvailable == 0)   
1146    {           
1147#if START_DECODING_AT_CRA
1148      if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1149      {
1150#endif
1151        if(!pReferencePictureSet->getUsed(i) )
1152        {
1153          if(outputFlag)
1154            printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1155          atLeastOneRemoved = 1;
1156        }
1157        else
1158        {
1159          if(outputFlag)
1160            printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1161          atLeastOneLost = 1;
1162          iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1163        }
1164#if START_DECODING_AT_CRA
1165      }
1166#endif
1167    }
1168  }   
1169  if(atLeastOneLost)
1170  {
1171    return iPocLost+1;
1172  }
1173  if(atLeastOneRemoved)
1174  {
1175    return -2;
1176  }
1177  else
1178    return 0;
1179}
1180
1181/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1182*/
1183Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
1184{
1185  TComPic* rpcPic;
1186  Int i, j;
1187  Int k = 0;
1188  Int nrOfNegativePictures = 0;
1189  Int nrOfPositivePictures = 0;
1190  TComReferencePictureSet* pcRPS = this->getLocalRPS();
1191
1192  // loop through all pictures in the Reference Picture Set
1193  for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1194  {
1195    j = 0;
1196    // loop through all pictures in the reference picture buffer
1197    TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1198    while ( iterPic != rcListPic.end())
1199    {
1200      j++;
1201      rpcPic = *(iterPic++);
1202
1203      if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1204      {
1205        // This picture exists as a reference picture
1206        // and should be added to the explicit Reference Picture Set
1207        pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1208        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i));
1209        if(pcRPS->getDeltaPOC(k) < 0)
1210          nrOfNegativePictures++;
1211        else
1212          nrOfPositivePictures++;
1213        k++;
1214      }
1215    }
1216  }
1217  pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1218  pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1219  pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1220  // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1221  // inter RPS prediction with.  Here we just use the reference used by pReferencePictureSet.
1222  // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1223  if (!pReferencePictureSet->getInterRPSPrediction())
1224  {
1225    pcRPS->setInterRPSPrediction(false);
1226    pcRPS->setNumRefIdc(0);
1227  }
1228  else
1229  {
1230    Int rIdx =  this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1231    Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1232#if RPS_IN_SPS
1233    TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1234#else
1235    TComReferencePictureSet* pcRefRPS = this->getPPS()->getRPSList()->getReferencePictureSet(rIdx);
1236#endif
1237    Int iRefPics = pcRefRPS->getNumberOfPictures();
1238    Int iNewIdc=0;
1239    for(i=0; i<= iRefPics; i++) 
1240    {
1241      Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0);  // check if the reference abs POC is >= 0
1242      Int iRefIdc = 0;
1243      for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the  pictures in the new RPS
1244      {
1245        if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1246        {
1247          if (pcRPS->getUsed(j))
1248          {
1249            iRefIdc = 1;
1250          }
1251          else
1252          {
1253            iRefIdc = 2;
1254          }
1255        }
1256      }
1257      pcRPS->setRefIdc(i, iRefIdc);
1258      iNewIdc++;
1259    }
1260    pcRPS->setInterRPSPrediction(true);
1261    pcRPS->setNumRefIdc(iNewIdc);
1262    pcRPS->setDeltaRPS(deltaRPS); 
1263#if RPS_IN_SPS
1264    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1265#else
1266    pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getPPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1267#endif
1268  }
1269
1270  this->setRPS(pcRPS);
1271  this->setRPSidx(-1);
1272}
1273
1274Void TComSlice::decodingMarkingForNoTMVP( TComList<TComPic*>& rcListPic, Int currentPOC )
1275{
1276  TComList<TComPic*>::iterator it;
1277  for ( it = rcListPic.begin(); it != rcListPic.end(); it++ )
1278  {
1279    if ( (*it)->getSlice(0)->getPOC() != currentPOC )
1280    {
1281      (*it)->setUsedForTMVP( false );
1282    }
1283  }
1284}
1285
1286/** get AC and DC values for weighted pred
1287 * \param *wp
1288 * \returns Void
1289 */
1290Void  TComSlice::getWpAcDcParam(wpACDCParam *&wp)
1291{
1292  wp = m_weightACDCParam;
1293}
1294
1295/** init AC and DC values for weighted pred
1296 * \returns Void
1297 */
1298Void  TComSlice::initWpAcDcParam()
1299{
1300  for(Int iComp = 0; iComp < 3; iComp++ )
1301  {
1302    m_weightACDCParam[iComp].iAC = 0;
1303    m_weightACDCParam[iComp].iDC = 0;
1304  }
1305}
1306
1307/** get WP tables for weighted pred
1308 * \param RefPicList
1309 * \param iRefIdx
1310 * \param *&wpScalingParam
1311 * \returns Void
1312 */
1313Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
1314{
1315  wp = m_weightPredTable[e][iRefIdx];
1316}
1317
1318/** reset Default WP tables settings : no weight.
1319 * \param wpScalingParam
1320 * \returns Void
1321 */
1322Void  TComSlice::resetWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
1323{
1324  for ( int e=0 ; e<2 ; e++ ) 
1325  {
1326    for ( int i=0 ; i<MAX_NUM_REF ; i++ )
1327    {
1328      for ( int yuv=0 ; yuv<3 ; yuv++ ) 
1329      {
1330        wpScalingParam  *pwp = &(wp[e][i][yuv]);
1331        pwp->bPresentFlag      = false;
1332        pwp->uiLog2WeightDenom = 0;
1333        pwp->uiLog2WeightDenom = 0;
1334        pwp->iWeight           = 1;
1335        pwp->iOffset           = 0;
1336      }
1337    }
1338  }
1339}
1340
1341/** init WP table
1342 * \returns Void
1343 */
1344Void  TComSlice::initWpScaling()
1345{
1346  initWpScaling(m_weightPredTable);
1347}
1348
1349/** set WP tables
1350 * \param wpScalingParam
1351 * \returns Void
1352 */
1353Void  TComSlice::initWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
1354{
1355  for ( int e=0 ; e<2 ; e++ ) 
1356  {
1357    for ( int i=0 ; i<MAX_NUM_REF ; i++ )
1358    {
1359      for ( int yuv=0 ; yuv<3 ; yuv++ ) 
1360      {
1361        wpScalingParam  *pwp = &(wp[e][i][yuv]);
1362        if ( !pwp->bPresentFlag ) {
1363          // Inferring values not present :
1364          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1365          pwp->iOffset = 0;
1366        }
1367
1368        pwp->w      = pwp->iWeight;
1369        pwp->o      = pwp->iOffset * (1 << (g_uiBitDepth-8));
1370        pwp->shift  = pwp->uiLog2WeightDenom;
1371        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1372      }
1373    }
1374  }
1375}
1376
1377/** get WP tables for weighted pred of LC
1378 * \param iRefIdxLC
1379 * \param *&wpScalingParam
1380 * \returns Void
1381 */
1382Void TComSlice::getWpScalingLC( Int iRefIdx, wpScalingParam *&wp )
1383{
1384  wp = m_weightPredTableLC[iRefIdx];
1385}
1386/** reset Default WP tables settings for LC : no weight.
1387 * \param wpScalingParam
1388 * \returns Void
1389 */
1390Void TComSlice::resetWpScalingLC(wpScalingParam  wp[2*MAX_NUM_REF][3])
1391{
1392  for ( int i=0 ; i<2*MAX_NUM_REF ; i++ )
1393  {
1394    for ( int yuv=0 ; yuv<3 ; yuv++ ) 
1395    {
1396      wpScalingParam  *pwp = &(wp[i][yuv]);
1397      pwp->bPresentFlag      = false;
1398      pwp->uiLog2WeightDenom = 0;
1399      pwp->uiLog2WeightDenom = 0;
1400      pwp->iWeight           = 1;
1401      pwp->iOffset           = 0;
1402    }
1403  }
1404}
1405/** set current WP tables settings for LC
1406 * \returns Void
1407 */
1408Void TComSlice::setWpParamforLC()
1409{
1410  for ( Int iRefIdx=0 ; iRefIdx<getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
1411  {
1412    RefPicList eRefPicList = (RefPicList)getListIdFromIdxOfLC(iRefIdx);
1413    Int iCombRefIdx = getRefIdxFromIdxOfLC(iRefIdx);
1414
1415    wpScalingParam  *wp_src, *wp_dst;
1416    getWpScalingLC(iRefIdx, wp_src);
1417    getWpScaling(eRefPicList, iCombRefIdx, wp_dst);
1418    copyWPtable(wp_src, wp_dst);
1419
1420    if(eRefPicList == REF_PIC_LIST_0)
1421    {
1422      Int iRefIdxL1 = getRefIdxOfL1FromRefIdxOfL0(iCombRefIdx);
1423      if(iRefIdxL1 >= 0)
1424      {
1425        getWpScaling(REF_PIC_LIST_1, iRefIdxL1, wp_dst);
1426        copyWPtable(wp_src, wp_dst);
1427      }
1428    }
1429    if(eRefPicList == REF_PIC_LIST_1)
1430    {
1431      Int iRefIdxL0 = getRefIdxOfL0FromRefIdxOfL1(iCombRefIdx);
1432      if(iRefIdxL0 >= 0)
1433      {
1434        getWpScaling(REF_PIC_LIST_0, iRefIdxL0, wp_dst);
1435        copyWPtable(wp_src, wp_dst);
1436      }
1437    }
1438  }
1439  initWpScaling();
1440}
1441/** copy source WP tables to destination table for LC
1442 * \param wpScalingParam *&wp_src : source
1443 * \param wpScalingParam *&wp_dst : destination
1444 * \returns Void
1445 */
1446Void TComSlice::copyWPtable(wpScalingParam *&wp_src, wpScalingParam *&wp_dst)
1447{
1448  for ( Int iComp = 0; iComp < 3; iComp++ )
1449  {
1450    wp_dst[iComp].uiLog2WeightDenom = (iComp==0) ? wp_src[0].uiLog2WeightDenom : wp_src[1].uiLog2WeightDenom;
1451    wp_dst[iComp].bPresentFlag = wp_src[iComp].bPresentFlag;
1452    wp_dst[iComp].iWeight = wp_src[iComp].iWeight;
1453    wp_dst[iComp].iOffset = wp_src[iComp].iOffset;
1454  }
1455}
1456
1457#if LGE_ILLUCOMP_B0045
1458Void TComSlice::xSetApplyIC() // comment (S.Shimizu): better to support multiple inter-view reference frames (= write one flag for each inter-view reference frame including VSP ref)?
1459{
1460  Int iMaxPelValue = (1<<g_uiBitDepth); 
1461  Int *aiRefOrgHist;
1462  Int *aiCurrHist;
1463  aiRefOrgHist = new Int;
1464  aiCurrHist   = new Int;
1465  aiRefOrgHist = (Int *)xMalloc(Int,iMaxPelValue);
1466  aiCurrHist   = (Int *)xMalloc(Int,iMaxPelValue);
1467  memset(aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
1468  memset(aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
1469  // Reference Idx Number
1470  Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
1471  TComPic* pcCurrPic = NULL;
1472  TComPic* pcRefPic = NULL;
1473  TComPicYuv* pcCurrPicYuv = NULL;
1474  TComPicYuv* pcRefPicYuvOrg = NULL;
1475  pcCurrPic = getPic();
1476  pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
1477  Int iWidth = pcCurrPicYuv->getWidth();
1478  Int iHeight = pcCurrPicYuv->getHeight();
1479
1480
1481  // Get InterView Reference picture
1482  // !!!!! Assume only one Interview Reference Picture in L0
1483  for (Int i = 0; i < iNumRefIdx; i++)
1484  {
1485    pcRefPic = getRefPic( REF_PIC_LIST_0, i);
1486    if (pcRefPic != NULL)
1487    {
1488      // Current Picture
1489      if (pcCurrPic->getViewId() != pcRefPic->getViewId())
1490      {
1491        pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
1492      }
1493    }
1494  }
1495  if (pcRefPicYuvOrg != NULL)
1496  {
1497    Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
1498    Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
1499    Int iCurrStride = pcCurrPicYuv->getStride();
1500    Int iRefStride = pcRefPicYuvOrg->getStride();
1501    Int iSumOrgSAD = 0;
1502    double dThresholdOrgSAD = 0.05;
1503    // Histogram building - luminance
1504    for ( Int y = 0; y < iHeight; y++)
1505    {
1506      for ( Int x = 0; x < iWidth; x++)
1507      {
1508        aiCurrHist[pCurrY[x]]++;
1509        aiRefOrgHist[pRefOrgY[x]]++;
1510      }
1511      pCurrY += iCurrStride;
1512      pRefOrgY += iRefStride;
1513    }
1514    // Calc SAD
1515    for (Int i = 0; i < iMaxPelValue; i++)
1516    {
1517      iSumOrgSAD += abs(aiCurrHist[i] - aiRefOrgHist[i]);
1518    }
1519    // Setting
1520    if ( iSumOrgSAD > Int(dThresholdOrgSAD * iWidth * iHeight) )
1521    {
1522      m_bApplyIC = true;
1523    }
1524    else
1525    {
1526      m_bApplyIC = false;
1527    }
1528  }
1529  xFree(aiCurrHist);
1530  xFree(aiRefOrgHist);
1531  aiCurrHist = NULL;
1532  aiRefOrgHist = NULL;
1533}
1534#endif
1535
1536// ------------------------------------------------------------------------------------------------
1537// Video parameter set (VPS)
1538// ------------------------------------------------------------------------------------------------
1539#if QC_MVHEVC_B0046
1540TComVPS::TComVPS()
1541: m_VPSId                     (  0)
1542, m_uiMaxTLayers              (  1)
1543, m_uiMaxLayers               (  1)
1544, m_bTemporalIdNestingFlag    (false)
1545, m_uiNumHRDParameter         (  0)
1546, m_numAddiLayerOperationPoints (2)
1547, m_numAddiProLevelSets       (  1)
1548{
1549  for( Int i = 0; i < MAX_LAYER_NUM; i++)
1550  {
1551  m_numOpLayerIdMinus1[i] = 0;
1552  if(i)
1553      m_numDirectRefLayer[i] = 1;
1554  else
1555    m_numDirectRefLayer[i] = 0;
1556  for( Int j = 0; j < MAX_LAYER_NUM; j++)
1557  {
1558    m_numDirectRefID[i][j] = 0;
1559    m_numOpLayerId[i][j]   = 0;
1560  }
1561    m_uiViewId[i] = 0;
1562    m_iViewOrderIdx[i] = 0;
1563  }
1564 
1565  for( Int i = 0; i < MAX_TLAYER; i++)
1566  {
1567    m_numReorderPics[i] = 0;
1568    m_uiMaxDecPicBuffering[i] = 0; 
1569    m_uiMaxLatencyIncrease[i] = 0;
1570  }
1571}
1572
1573TComVPS::~TComVPS()
1574{
1575}
1576#else
1577#if VIDYO_VPS_INTEGRATION
1578TComVPS::TComVPS()
1579: m_VPSId                     (  0)
1580, m_uiMaxTLayers              (  1)
1581, m_uiMaxLayers               (  1)
1582, m_bTemporalIdNestingFlag    (false)
1583, m_uiExtensionType           (  0)
1584{
1585  for( Int i = 0; i < MAX_LAYER_NUM; i++)
1586  {
1587    m_uiDependentLayer[i] = i? i-1: 0;
1588    m_bDependentFlag[i] = false;
1589    m_uiViewId[i] = 0;
1590    m_bDepthFlag[i] = 0;
1591    m_iViewOrderIdx[i] = 0;
1592  }
1593 
1594  for( Int i = 0; i < MAX_TLAYER; i++)
1595  {
1596    m_numReorderPics[i] = 0;
1597    m_uiMaxDecPicBuffering[i] = 0; 
1598    m_uiMaxLatencyIncrease[i] = 0;
1599  }
1600}
1601
1602TComVPS::~TComVPS()
1603{
1604 
1605 
1606}
1607
1608#endif
1609#endif
1610
1611// ------------------------------------------------------------------------------------------------
1612// Sequence parameter set (SPS)
1613// ------------------------------------------------------------------------------------------------
1614
1615TComSPS::TComSPS()
1616#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
1617: m_VPSId                     (  0)
1618, m_SPSId                     (  0)
1619#else
1620: m_SPSId                     (  0)
1621#endif
1622, m_ProfileIdc                (  0)
1623, m_LevelIdc                  (  0)
1624, m_chromaFormatIdc           (CHROMA_420)
1625, m_uiMaxTLayers              (  1)
1626// Structure
1627, m_picWidthInLumaSamples     (352)
1628, m_picHeightInLumaSamples    (288)
1629#if PIC_CROPPING
1630, m_picCroppingFlag           (false)
1631, m_picCropLeftOffset         (  0)
1632, m_picCropRightOffset        (  0)
1633, m_picCropTopOffset          (  0)
1634, m_picCropBottomOffset       (  0) 
1635#endif
1636, m_uiMaxCUWidth              ( 32)
1637, m_uiMaxCUHeight             ( 32)
1638, m_uiMaxCUDepth              (  3)
1639, m_uiMinTrDepth              (  0)
1640, m_uiMaxTrDepth              (  1)
1641#if RPS_IN_SPS
1642, m_bLongTermRefsPresent      (false)
1643#endif
1644#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1645, m_numReorderFrames          (  0)
1646#endif
1647, m_iNumberOfUsableInterViewRefs( 0 )
1648, m_uiQuadtreeTULog2MaxSize   (  0)
1649, m_uiQuadtreeTULog2MinSize   (  0)
1650, m_uiQuadtreeTUMaxDepthInter (  0)
1651, m_uiQuadtreeTUMaxDepthIntra (  0)
1652// Tool list
1653, m_usePCM                   (false)
1654, m_pcmLog2MaxSize            (  5)
1655, m_uiPCMLog2MinSize          (  7)
1656, m_bDisInter4x4              (  1)
1657, m_bUseALF                   (false)
1658#if LCU_SYNTAX_ALF
1659, m_bALFCoefInSlice           (false)
1660#endif
1661#if !PIC_CROPPING
1662, m_bUsePAD                   (false)
1663#endif
1664, m_bUseLMChroma              (false)
1665, m_bUseLComb                 (false)
1666, m_bLCMod                    (false)
1667#if H0412_REF_PIC_LIST_RESTRICTION
1668#if QC_MVHEVC_B0046
1669, m_restrictedRefPicListsFlag   (  0)
1670#else
1671, m_restrictedRefPicListsFlag   (  1)
1672#endif
1673, m_listsModificationPresentFlag(  0)
1674#endif
1675, m_uiBitDepth                (  8)
1676, m_uiBitIncrement            (  0)
1677#if H0736_AVC_STYLE_QP_RANGE
1678, m_qpBDOffsetY               (  0)
1679, m_qpBDOffsetC               (  0)
1680#endif
1681#if LOSSLESS_CODING
1682, m_useLossless               (false)
1683#endif
1684, m_uiPCMBitDepthLuma         (  8)
1685, m_uiPCMBitDepthChroma       (  8)
1686, m_bPCMFilterDisableFlag     (false)
1687, m_uiBitsForPOC              (  8)
1688, m_uiMaxTrSize               ( 32)
1689, m_bLFCrossSliceBoundaryFlag (false)
1690, m_bUseSAO                   (false) 
1691#if HHI_MPI
1692, m_bUseMVI                   (false)
1693#endif
1694, m_bLFCrossTileBoundaryFlag  (false) 
1695, m_iUniformSpacingIdr        (  0 )
1696, m_iTileBoundaryIndependenceIdr (  0 )
1697, m_iNumColumnsMinus1         (  0 )
1698, m_puiColumnWidth            ( NULL )
1699, m_iNumRowsMinus1            (  0 )
1700, m_puiRowHeight              ( NULL )
1701, m_bTemporalIdNestingFlag    (false)
1702, m_scalingListEnabledFlag    (false)
1703#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1704, m_uiMaxDecFrameBuffering    (  0)
1705, m_uiMaxLatencyIncrease      (  0)
1706#endif
1707#if TILES_WPP_ENTRY_POINT_SIGNALLING
1708,  m_tilesOrEntropyCodingSyncIdc( 0 )
1709,  m_numSubstreams              ( 0 )
1710#endif
1711#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1712, m_bUseDMM                   (false)
1713#endif
1714#if FLEX_CODING_ORDER_M23723 && HHI_DMM_PRED_TEX
1715, m_bUseDMM34                   (false)
1716#endif
1717#if OL_QTLIMIT_PREDCODING_B0068
1718, m_bUseQTLPC                 (false)
1719#endif
1720#if VSP_N
1721, m_bVspPresentFlag           (false)
1722#if VSP_CFG
1723, m_bVspDepthPresentFlag      (false)
1724#endif
1725, m_bIsFirstInView            (false)
1726#endif
1727{
1728  // AMVP parameter
1729  ::memset( m_aeAMVPMode, 0, sizeof( m_aeAMVPMode ) );
1730#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1731  for ( Int i = 0; i < MAX_TLAYER; i++ )
1732  {
1733    m_uiMaxLatencyIncrease[i] = 0;
1734    m_uiMaxDecPicBuffering[i] = 0;
1735    m_numReorderPics[i]       = 0;
1736  }
1737#endif
1738
1739  m_uiViewId              = 0;
1740  m_iViewOrderIdx         = 0;
1741  m_bDepth                = false;
1742  m_uiCamParPrecision     = 0;
1743  m_bCamParInSliceHeader  = false;
1744  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
1745  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
1746
1747#if DEPTH_MAP_GENERATION
1748  m_uiPredDepthMapGeneration = 0;
1749  m_uiPdmPrecision           = 0;
1750  ::memset( m_aiPdmScaleNomDelta, 0x00, sizeof( m_aiPdmScaleNomDelta  ) );
1751  ::memset( m_aiPdmOffset,        0x00, sizeof( m_aiPdmOffset         ) );
1752#endif
1753#if HHI_INTER_VIEW_MOTION_PRED
1754  m_uiMultiviewMvPredMode    = 0;
1755#endif
1756
1757  ::memset( m_aiUsableInterViewRefs, 0, sizeof( m_aiUsableInterViewRefs ) );
1758 
1759#if RWTH_SDC_DLT_B0036
1760  m_bUseDLT = false;
1761 
1762  m_uiBitsPerDepthValue = g_uiBitDepth;
1763  m_uiNumDepthmapValues = 0;
1764  m_uiDepthValue2Idx    = NULL;
1765  m_uiIdx2DepthValue    = NULL;
1766#endif
1767}
1768
1769TComSPS::~TComSPS()
1770{
1771  if( m_iNumColumnsMinus1 > 0 && m_iUniformSpacingIdr == 0 )
1772  {
1773    delete [] m_puiColumnWidth; 
1774    m_puiColumnWidth = NULL;
1775  }
1776  if( m_iNumRowsMinus1 > 0 && m_iUniformSpacingIdr == 0 )
1777  {
1778    delete [] m_puiRowHeight;
1779    m_puiRowHeight = NULL;
1780  }
1781}
1782
1783#if RWTH_SDC_DLT_B0036
1784Void TComSPS::setDepthLUTs(UInt* uidx2DepthValue, UInt uiNumDepthValues)
1785{
1786  UInt uiMaxDepthValue = g_uiIBDI_MAX;
1787 
1788  // allocate some memory
1789  if( m_uiNumDepthmapValues == 0 )
1790  {
1791    m_uiNumDepthmapValues = uiMaxDepthValue+1;
1792    m_uiBitsPerDepthValue = (UInt)ceil(Log2(m_uiNumDepthmapValues));
1793   
1794    m_uiDepthValue2Idx    = (UInt*) xMalloc(UInt, m_uiNumDepthmapValues);
1795    m_uiIdx2DepthValue    = (UInt*) xMalloc(UInt, m_uiNumDepthmapValues);
1796   
1797    //default mapping
1798    for (Int i=0; i<m_uiNumDepthmapValues; i++)
1799    {
1800      m_uiDepthValue2Idx[i] = i;
1801      m_uiIdx2DepthValue[i] = i;
1802    }
1803  }
1804 
1805  if( uidx2DepthValue == NULL || uiNumDepthValues == 0 ) // default mapping only
1806    return;
1807 
1808  // copy idx2DepthValue to internal array
1809  memcpy(m_uiIdx2DepthValue, uidx2DepthValue, uiNumDepthValues*sizeof(UInt));
1810 
1811  for(Int p=0; p<=uiMaxDepthValue; p++)
1812  {
1813    Int iIdxDown    = 0;
1814    Int iIdxUp      = uiNumDepthValues-1;
1815    Bool bFound     = false;
1816   
1817    // iterate over indices to find lower closest depth
1818    Int i = 1;
1819    while(!bFound && i<uiNumDepthValues)
1820    {
1821      if( m_uiIdx2DepthValue[i] > p )
1822      {
1823        iIdxDown  = i-1;
1824        bFound    = true;
1825      }
1826     
1827      i++;
1828    }
1829    // iterate over indices to find upper closest depth
1830    i = uiNumDepthValues-2;
1831    bFound = false;
1832    while(!bFound && i>=0)
1833    {
1834      if( m_uiIdx2DepthValue[i] < p )
1835      {
1836        iIdxUp  = i+1;
1837        bFound    = true;
1838      }
1839     
1840      i--;
1841    }
1842   
1843    // assert monotony
1844    assert(iIdxDown<=iIdxUp);
1845   
1846    // assign closer depth value/idx
1847    if( abs(p-(Int)m_uiIdx2DepthValue[iIdxDown]) < abs(p-(Int)m_uiIdx2DepthValue[iIdxUp]) )
1848    {
1849      m_uiDepthValue2Idx[p] = iIdxDown;
1850    }
1851    else
1852    {
1853      m_uiDepthValue2Idx[p] = iIdxUp;
1854    }
1855   
1856  }
1857 
1858  // update globals
1859  m_uiNumDepthmapValues = uiNumDepthValues;
1860  m_uiBitsPerDepthValue = (UInt)ceil(Log2(m_uiNumDepthmapValues));
1861}
1862#endif
1863
1864TComPPS::TComPPS()
1865: m_PPSId                       (0)
1866, m_SPSId                       (0)
1867, m_picInitQPMinus26            (0)
1868, m_useDQP                      (false)
1869, m_bConstrainedIntraPred       (false)
1870, m_pcSPS                       (NULL)
1871, m_uiMaxCuDQPDepth             (0)
1872, m_uiMinCuDQPSize              (0)
1873, m_iChromaQpOffset             (0)
1874, m_iChromaQpOffset2nd          (0)
1875#if !RPS_IN_SPS
1876, m_bLongTermRefsPresent        (false)
1877#endif
1878#if !H0566_TLA
1879, m_uiNumTlayerSwitchingFlags   (0)
1880#endif
1881, m_iSliceGranularity           (0)
1882, m_iTileBehaviorControlPresentFlag (0)
1883, m_bLFCrossTileBoundaryFlag     (true)
1884, m_iColumnRowInfoPresent        (0)
1885, m_iUniformSpacingIdr           (0)
1886#if !REMOVE_TILE_DEPENDENCE
1887, m_iTileBoundaryIndependenceIdr (0)
1888#endif
1889, m_iNumColumnsMinus1            (0)
1890, m_puiColumnWidth               (NULL)
1891, m_iNumRowsMinus1               (0)
1892, m_puiRowHeight                 (NULL)
1893#if !WPP_SIMPLIFICATION
1894,  m_iEntropyCodingSynchro      (0)
1895,  m_bCabacIstateReset          (false)
1896#endif
1897,  m_iNumSubstreams             (1)
1898#if MULTIBITS_DATA_HIDING
1899, m_signHideFlag(0)
1900, m_signHidingThreshold(0)
1901#endif
1902#if CABAC_INIT_FLAG
1903, m_cabacInitPresentFlag        (false)
1904, m_encCABACTableIdx            (0)
1905#if FIX_POZNAN_CABAC_INIT_FLAG
1906, m_encPrevPOC            (0)
1907#endif
1908#endif
1909{
1910#if !H0566_TLA
1911  for ( UInt i = 0; i < MAX_TLAYER; i++ )
1912  {
1913    m_abTLayerSwitchingFlag[i] = false;
1914  }
1915#endif
1916}
1917
1918TComPPS::~TComPPS()
1919{
1920  if( m_iNumColumnsMinus1 > 0 && m_iUniformSpacingIdr == 0 )
1921  {
1922    if (m_puiColumnWidth) delete [] m_puiColumnWidth; 
1923    m_puiColumnWidth = NULL;
1924  }
1925  if( m_iNumRowsMinus1 > 0 && m_iUniformSpacingIdr == 0 )
1926  {
1927    if (m_puiRowHeight) delete [] m_puiRowHeight;
1928    m_puiRowHeight = NULL;
1929  }
1930}
1931
1932Void
1933TComSPS::initMultiviewSPS( UInt uiViewId, Int iViewOrderIdx, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
1934{
1935#if !QC_MVHEVC_B0046
1936  AOT( uiViewId == 0 && iViewOrderIdx != 0 );
1937  AOT( uiViewId != 0 && iViewOrderIdx == 0 );
1938  AOT( uiViewId != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) );
1939#endif
1940  m_uiViewId              = uiViewId;
1941  m_iViewOrderIdx         = iViewOrderIdx;
1942  m_bDepth                = false;
1943  m_uiCamParPrecision     = ( m_uiViewId ? uiCamParPrecision : 0 );
1944  m_bCamParInSliceHeader  = ( m_uiViewId ? bCamParSlice  : false );
1945  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
1946  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
1947#if !QC_MVHEVC_B0046
1948  if( !m_bCamParInSliceHeader )
1949  {
1950    for( UInt uiBaseViewId = 0; uiBaseViewId < m_uiViewId; uiBaseViewId++ )
1951    {
1952      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aaiScale [ uiBaseViewId ][   m_uiViewId ];
1953      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aaiScale [   m_uiViewId ][ uiBaseViewId ];
1954      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aaiOffset[ uiBaseViewId ][   m_uiViewId ];
1955      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aaiOffset[   m_uiViewId ][ uiBaseViewId ];
1956    }
1957  }
1958#endif
1959}
1960
1961Void
1962TComSPS::initMultiviewSPSDepth( UInt uiViewId, Int iViewOrderIdx )
1963{
1964  AOT( uiViewId == 0 && iViewOrderIdx != 0 );
1965  AOT( uiViewId != 0 && iViewOrderIdx == 0 );
1966
1967  m_uiViewId              = uiViewId;
1968  m_iViewOrderIdx         = iViewOrderIdx;
1969  m_bDepth                = true;
1970  m_uiCamParPrecision     = 0;
1971  m_bCamParInSliceHeader  = false;
1972  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
1973  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
1974}
1975
1976#if VSP_N
1977Void
1978TComSPS::initMultiviewSPSFlex( UInt uiViewId, Int iViewOrderIdx, Bool bDepth, Bool bPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
1979{
1980  AOT( uiViewId == 0 && iViewOrderIdx != 0 );
1981  AOT( uiViewId != 0 && iViewOrderIdx == 0 );
1982  //AOT( uiViewId != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) );
1983
1984  m_uiViewId              = uiViewId;
1985  m_iViewOrderIdx         = iViewOrderIdx;
1986  m_bDepth                = bDepth;
1987  m_uiCamParPrecision     = ( m_uiViewId && bPresent ? uiCamParPrecision : 0 );
1988  m_bCamParInSliceHeader  = ( m_uiViewId && bPresent ? bCamParSlice  : false );
1989  if( bPresent && !m_bCamParInSliceHeader )
1990  {
1991    for( UInt uiBaseViewId = 0; uiBaseViewId < m_uiViewId; uiBaseViewId++ )
1992    {
1993      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aaiScale [ uiBaseViewId ][   m_uiViewId ];
1994      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aaiScale [   m_uiViewId ][ uiBaseViewId ];
1995      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aaiOffset[ uiBaseViewId ][   m_uiViewId ];
1996      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aaiOffset[   m_uiViewId ][ uiBaseViewId ];
1997    }
1998  }
1999}
2000
2001Void
2002TComSPS::copyCameraParameterPre( UInt uiCamParPrecision, Bool bCamParSlice )
2003{
2004  m_uiCamParPrecision     = uiCamParPrecision;
2005  m_bCamParInSliceHeader  = bCamParSlice;
2006}
2007Void
2008TComSPS::copyCameraParameterPost( Int* aiScale0, Int* aiScale1, Int* aiOffset0, Int* aiOffset1 )
2009{
2010  if( !m_bCamParInSliceHeader )
2011  {
2012    for( UInt uiBaseViewId = 0; uiBaseViewId < m_uiViewId; uiBaseViewId++ )
2013    {
2014      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aiScale0 [ uiBaseViewId ];
2015      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aiScale1 [ uiBaseViewId ];
2016      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aiOffset0[ uiBaseViewId ];
2017      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aiOffset1[ uiBaseViewId ];
2018    }
2019  }
2020}
2021#endif
2022
2023#if DEPTH_MAP_GENERATION
2024Void
2025TComSPS::setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode, UInt uiPdmMvPredMode, UInt uiPdmPrec, Int** aaiPdmScaleNomDelta, Int** aaiPdmOffset )
2026{ 
2027  AOF( m_uiViewId == uiViewId );
2028  AOF( m_bDepth   == bIsDepth );
2029  AOT( ( uiViewId == 0 || bIsDepth ) && uiPdmGenMode );
2030  AOT( uiPdmGenMode && ( aaiPdmScaleNomDelta == 0 || aaiPdmOffset == 0 ) );
2031  AOT( uiPdmMvPredMode && uiPdmGenMode == 0 );
2032
2033  m_uiPredDepthMapGeneration = uiPdmGenMode;
2034#if HHI_INTER_VIEW_MOTION_PRED
2035  m_uiMultiviewMvPredMode    = uiPdmMvPredMode;
2036#endif
2037
2038  m_uiPdmPrecision           = ( m_uiPredDepthMapGeneration ? uiPdmPrec : 0 );
2039  ::memset( m_aiPdmScaleNomDelta, 0x00, sizeof( m_aiPdmScaleNomDelta  ) );
2040  ::memset( m_aiPdmOffset,        0x00, sizeof( m_aiPdmOffset         ) );
2041  if( m_uiPredDepthMapGeneration )
2042  {
2043    for( UInt uiBaseId = 0; uiBaseId < m_uiViewId; uiBaseId++ )
2044    {
2045      m_aiPdmScaleNomDelta[ uiBaseId ]  = aaiPdmScaleNomDelta[ m_uiViewId ][ uiBaseId ];
2046      m_aiPdmOffset       [ uiBaseId ]  = aaiPdmOffset       [ m_uiViewId ][ uiBaseId ];
2047    }
2048  }
2049}
2050#endif
2051
2052TComReferencePictureSet::TComReferencePictureSet()
2053: m_numberOfPictures (0)
2054, m_numberOfNegativePictures (0)
2055, m_numberOfPositivePictures (0)
2056, m_numberOfLongtermPictures (0)
2057, m_interRPSPrediction (0) 
2058, m_deltaRIdxMinus1 (0)   
2059, m_deltaRPS (0) 
2060, m_numRefIdc (0) 
2061{
2062  ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2063  ::memset( m_POC, 0, sizeof(m_POC) );
2064  ::memset( m_used, 0, sizeof(m_used) );
2065  ::memset( m_refIdc, 0, sizeof(m_refIdc) );
2066}
2067
2068TComReferencePictureSet::~TComReferencePictureSet()
2069{
2070}
2071
2072Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2073{
2074  m_used[bufferNum] = used;
2075}
2076
2077Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2078{
2079  m_deltaPOC[bufferNum] = deltaPOC;
2080}
2081
2082Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2083{
2084  m_numberOfPictures = numberOfPictures;
2085}
2086
2087Int TComReferencePictureSet::getUsed(Int bufferNum)
2088{
2089  return m_used[bufferNum];
2090}
2091
2092Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2093{
2094  return m_deltaPOC[bufferNum];
2095}
2096
2097Int TComReferencePictureSet::getNumberOfPictures()
2098{
2099  return m_numberOfPictures;
2100}
2101
2102Int TComReferencePictureSet::getPOC(Int bufferNum)
2103{
2104  return m_POC[bufferNum];
2105}
2106Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2107{
2108  m_POC[bufferNum] = POC;
2109}
2110
2111/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2112 * \param uiBufferNum
2113 * \param iRefIdc
2114 * \returns Void
2115 */
2116Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2117{
2118  m_refIdc[bufferNum] = refIdc;
2119}
2120
2121/** get the reference idc value at uiBufferNum
2122 * \param uiBufferNum
2123 * \returns Int
2124 */
2125Int  TComReferencePictureSet::getRefIdc(Int bufferNum)
2126{
2127  return m_refIdc[bufferNum];
2128}
2129
2130/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2131 *  deltaPOC values are sorted with -ve values before the +ve values.  -ve values are in decreasing order.
2132 *  +ve values are in increasing order.
2133 * \returns Void
2134 */
2135Void TComReferencePictureSet::sortDeltaPOC()
2136{
2137  // sort in increasing order (smallest first)
2138  for(Int j=1; j < getNumberOfPictures(); j++)
2139  { 
2140    Int deltaPOC = getDeltaPOC(j);
2141    Bool used = getUsed(j);
2142    for (Int k=j-1; k >= 0; k--)
2143    {
2144      Int temp = getDeltaPOC(k);
2145      if (deltaPOC < temp)
2146      {
2147        setDeltaPOC(k+1, temp);
2148        setUsed(k+1, getUsed(k));
2149        setDeltaPOC(k, deltaPOC);
2150        setUsed(k, used);
2151      }
2152    }
2153  }
2154  // flip the negative values to largest first
2155  Int numNegPics = getNumberOfNegativePictures();
2156  for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2157  { 
2158    Int deltaPOC = getDeltaPOC(j);
2159    Bool used = getUsed(j);
2160    setDeltaPOC(j, getDeltaPOC(k));
2161    setUsed(j, getUsed(k));
2162    setDeltaPOC(k, deltaPOC);
2163    setUsed(k, used);
2164  }
2165}
2166
2167/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2168 *  A "*" is added to the deltaPOC value if it is Used bu current.
2169 * \returns Void
2170 */
2171Void TComReferencePictureSet::printDeltaPOC()
2172{
2173  printf("DeltaPOC = { ");
2174  for(Int j=0; j < getNumberOfPictures(); j++)
2175  {
2176    printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2177  } 
2178  if (getInterRPSPrediction()) 
2179  {
2180    printf("}, RefIdc = { ");
2181    for(Int j=0; j < getNumRefIdc(); j++)
2182    {
2183      printf("%d ", getRefIdc(j));
2184    } 
2185  }
2186  printf("}\n");
2187}
2188
2189TComRPSList::TComRPSList()
2190{
2191}
2192
2193TComRPSList::~TComRPSList()
2194{
2195}
2196
2197Void TComRPSList::create( Int numberOfReferencePictureSets)
2198{
2199  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2200  m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2201}
2202
2203Void TComRPSList::destroy()
2204{
2205  delete [] m_referencePictureSets;
2206  m_numberOfReferencePictureSets = 0;
2207  m_referencePictureSets = NULL;
2208}
2209
2210
2211
2212TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2213{
2214  return &m_referencePictureSets[referencePictureSetNum];
2215}
2216
2217Int TComRPSList::getNumberOfReferencePictureSets()
2218{
2219  return m_numberOfReferencePictureSets;
2220}
2221
2222Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2223{
2224  m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2225}
2226
2227TComRefPicListModification::TComRefPicListModification()
2228: m_bRefPicListModificationFlagL0 (false)
2229, m_bRefPicListModificationFlagL1 (false)
2230#if !H0137_0138_LIST_MODIFICATION
2231, m_uiNumberOfRefPicListModificationsL0 (0)
2232, m_uiNumberOfRefPicListModificationsL1 (0)
2233#endif
2234{
2235#if !H0137_0138_LIST_MODIFICATION
2236  ::memset( m_ListIdcL0, 0, sizeof(m_ListIdcL0) );
2237#endif
2238  ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2239#if !H0137_0138_LIST_MODIFICATION
2240  ::memset( m_ListIdcL1, 0, sizeof(m_ListIdcL1) );
2241#endif
2242  ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2243}
2244
2245TComRefPicListModification::~TComRefPicListModification()
2246{
2247}
2248
2249TComAPS::TComAPS()
2250{
2251  m_apsID = 0;
2252  m_bAlfEnabled = false;
2253  m_bSaoEnabled = false;
2254  m_pSaoParam = NULL;
2255#if LCU_SYNTAX_ALF
2256  m_alfParamSet = NULL;
2257#else
2258  m_pAlfParam = NULL;
2259#endif
2260  m_scalingList = NULL;
2261  m_scalingListEnabled = false;
2262}
2263
2264TComAPS::~TComAPS()
2265{
2266
2267}
2268
2269TComAPS& TComAPS::operator= (const TComAPS& src)
2270{
2271  m_apsID       = src.m_apsID;
2272  m_loopFilterOffsetInAPS = src.m_loopFilterOffsetInAPS;
2273  m_loopFilterDisable = src.m_loopFilterDisable;
2274  m_loopFilterBetaOffsetDiv2 = src.m_loopFilterBetaOffsetDiv2;
2275  m_loopFilterTcOffsetDiv2 = src.m_loopFilterTcOffsetDiv2;
2276  m_bAlfEnabled = src.m_bAlfEnabled;
2277  m_bSaoEnabled = src.m_bSaoEnabled;
2278  m_pSaoParam   = src.m_pSaoParam; 
2279#if LCU_SYNTAX_ALF
2280  m_alfParamSet    = src.m_alfParamSet;
2281#else
2282  m_pAlfParam   = src.m_pAlfParam; 
2283#endif
2284  m_scalingList = src.m_scalingList;
2285  m_scalingListEnabled = src.m_scalingListEnabled;
2286#if SAO_UNIT_INTERLEAVING
2287  m_saoInterleavingFlag = src.m_saoInterleavingFlag;
2288#endif
2289
2290  return *this;
2291}
2292
2293Void TComAPS::createSaoParam()
2294{
2295  m_pSaoParam = new SAOParam;
2296}
2297
2298Void TComAPS::destroySaoParam()
2299{
2300  if(m_pSaoParam != NULL)
2301  {
2302    delete m_pSaoParam;
2303    m_pSaoParam = NULL;
2304  }
2305}
2306
2307Void TComAPS::createAlfParam()
2308{
2309#if LCU_SYNTAX_ALF
2310  m_alfParamSet = new AlfParamSet;
2311#else
2312  m_pAlfParam = new ALFParam;
2313#endif
2314}
2315Void TComAPS::destroyAlfParam()
2316{
2317#if LCU_SYNTAX_ALF
2318  if(m_alfParamSet != NULL)
2319  {
2320    delete m_alfParamSet;
2321    m_alfParamSet = NULL;
2322  }
2323#else
2324  if(m_pAlfParam != NULL)
2325  {
2326    delete m_pAlfParam;
2327    m_pAlfParam = NULL;
2328  }
2329#endif
2330}
2331
2332Void TComAPS::createScalingList()
2333{
2334  m_scalingList = new TComScalingList;
2335}
2336Void TComAPS::destroyScalingList()
2337{
2338  delete m_scalingList;
2339}
2340
2341TComScalingList::TComScalingList()
2342{
2343  init();
2344}
2345TComScalingList::~TComScalingList()
2346{
2347  destroy();
2348}
2349
2350/** set default quantization matrix to array
2351*/
2352Void TComSlice::setDefaultScalingList()
2353{
2354  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2355  {
2356    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2357    {
2358      getScalingList()->processDefaultMarix(sizeId, listId);
2359    }
2360  }
2361}
2362/** check if use default quantization matrix
2363 * \returns true if use default quantization matrix in all size
2364*/
2365#if SCALING_LIST
2366Bool TComSlice::checkDefaultScalingList()
2367{
2368  UInt defaultCounter=0;
2369
2370  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2371  {
2372    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2373    {
2374      if(getScalingList()->getUseDefaultScalingMatrixFlag(sizeId,listId))
2375      {
2376        defaultCounter++;
2377      }
2378    }
2379  }
2380  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? true : false; // -4 for 32x32
2381}
2382#else
2383Bool TComSlice::checkDefaultScalingList()
2384{
2385  UInt i;
2386  Int *dst=0;
2387  Int *src=0;
2388  UInt defaultCounter=0;
2389
2390  //4x4
2391  for(i=0;i<SCALING_LIST_NUM;i++)
2392  {
2393    src = (i<3) ? g_quantIntraDefault4x4 : g_quantInterDefault4x4;
2394    dst = getScalingList()->getScalingListAddress(SCALING_LIST_4x4,i);
2395    if(::memcmp(dst,src,sizeof(UInt)*16) == 0) defaultCounter++;
2396  }
2397
2398  //8x8
2399  for(i=0;i<SCALING_LIST_NUM;i++)
2400  {
2401    src = (i<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2402    dst = getScalingList()->getScalingListAddress(SCALING_LIST_8x8,i);
2403    if(::memcmp(dst,src,sizeof(UInt)*64) == 0) defaultCounter++;
2404  }
2405  //16x16
2406  for(i=0;i<SCALING_LIST_NUM;i++)
2407  {
2408    src = (i<3) ? g_quantIntraDefault16x16 : g_quantInterDefault16x16;
2409    dst = getScalingList()->getScalingListAddress(SCALING_LIST_16x16,i);
2410    if(::memcmp(dst,src,sizeof(UInt)*256) == 0) defaultCounter++;
2411  }
2412  //32x32
2413  for(i=0;i<SCALING_LIST_NUM_32x32;i++)
2414  {
2415    src = (i<1) ? g_quantIntraDefault32x32 : g_quantInterDefault32x32;
2416    dst = getScalingList()->getScalingListAddress(SCALING_LIST_32x32,i*3);
2417    if(::memcmp(dst,src,sizeof(UInt)*1024) == 0) defaultCounter++;
2418  }
2419  return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? true : false; // -4 for 32x32
2420}
2421#endif
2422/** get scaling matrix from RefMatrixID
2423 * \param sizeId size index
2424 * \param Index of input matrix
2425 * \param Index of reference matrix
2426 */
2427Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
2428{
2429#if SCALING_LIST
2430  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListAddress(sizeId, refListId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2431#else
2432  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListAddress(sizeId, refListId),sizeof(Int)*g_scalingListSize[sizeId]);
2433#endif
2434}
2435/** parse syntax infomation
2436 *  \param pchFile syntax infomation
2437 *  \returns false if successful
2438 */
2439Bool TComScalingList::xParseScalingList(char* pchFile)
2440{
2441  FILE *fp;
2442  Char line[1024];
2443  UInt sizeIdc,listIdc;
2444  UInt i,size = 0;
2445  Int *src=0,data;
2446  Char *ret;
2447  UInt  retval;
2448
2449  if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
2450  {
2451    printf("can't open file %s :: set Default Matrix\n",pchFile);
2452    return true;
2453  }
2454
2455  for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2456  {
2457#if SCALING_LIST
2458    size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
2459#else
2460    size = g_scalingListSize[sizeIdc];
2461#endif
2462    for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
2463    {
2464      src = getScalingListAddress(sizeIdc, listIdc);
2465
2466      fseek(fp,0,0);
2467      do 
2468      {
2469        ret = fgets(line, 1024, fp);
2470        if ((ret==NULL)||(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
2471        {
2472          printf("Error: can't read Matrix :: set Default Matrix\n");
2473          return true;
2474        }
2475      }
2476      while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
2477      for (i=0; i<size; i++)
2478      {
2479        retval = fscanf(fp, "%d,", &data);
2480        if (retval!=1)
2481        {
2482          printf("Error: can't read Matrix :: set Default Matrix\n");
2483          return true;
2484        }
2485        src[i] = data;
2486      }
2487#if SCALING_LIST
2488      //set DC value for default matrix check
2489      setScalingListDC(sizeIdc,listIdc,src[0]);
2490
2491      if(sizeIdc > SCALING_LIST_8x8)
2492      {
2493        fseek(fp,0,0);
2494        do 
2495        {
2496          ret = fgets(line, 1024, fp);
2497          if ((ret==NULL)||(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
2498          {
2499            printf("Error: can't read DC :: set Default Matrix\n");
2500            return true;
2501          }
2502        }
2503        while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
2504          retval = fscanf(fp, "%d,", &data);
2505          if (retval!=1)
2506          {
2507            printf("Error: can't read Matrix :: set Default Matrix\n");
2508            return true;
2509          }
2510          //overwrite DC value when size of matrix is larger than 16x16
2511          setScalingListDC(sizeIdc,listIdc,data);
2512      }
2513#endif
2514    }
2515  }
2516  fclose(fp);
2517  return false;
2518}
2519
2520/** initialization process of quantization matrix array
2521 */
2522Void TComScalingList::init()
2523{
2524  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2525  {
2526    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2527    {
2528#if SCALING_LIST
2529      m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
2530#else
2531      m_scalingListCoef[sizeId][listId] = new Int [g_scalingListSize[sizeId]];
2532#endif
2533    }
2534  }
2535  m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
2536}
2537/** destroy quantization matrix array
2538 */
2539Void TComScalingList::destroy()
2540{
2541  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2542  {
2543    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2544    {
2545      if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
2546    }
2547  }
2548}
2549/** get default address of quantization matrix
2550 * \param sizeId size index
2551 * \param listId list index
2552 * \returns pointer of quantization matrix
2553 */
2554Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
2555{
2556  Int *src = 0;
2557  switch(sizeId)
2558  {
2559    case SCALING_LIST_4x4:
2560      src = (listId<3) ? g_quantIntraDefault4x4 : g_quantInterDefault4x4;
2561      break;
2562    case SCALING_LIST_8x8:
2563      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2564      break;
2565#if SCALING_LIST
2566    case SCALING_LIST_16x16:
2567      src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2568      break;
2569    case SCALING_LIST_32x32:
2570      src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2571      break;
2572#else
2573    case SCALING_LIST_16x16:
2574      src = (listId<3) ? g_quantIntraDefault16x16 : g_quantInterDefault16x16;
2575      break;
2576    case SCALING_LIST_32x32:
2577      src = (listId<1) ? g_quantIntraDefault32x32 : g_quantInterDefault32x32;
2578      break;
2579#endif
2580    default:
2581      assert(0);
2582      src = NULL;
2583      break;
2584  }
2585  return src;
2586}
2587/** process of default matrix
2588 * \param sizeId size index
2589 * \param Index of input matrix
2590 */
2591Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
2592{
2593#if SCALING_LIST
2594  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2595  setUseDefaultScalingMatrixFlag(sizeId,listId,true);
2596  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
2597#else
2598  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*(Int)g_scalingListSize[sizeId]);
2599#endif
2600}
2601#if SCALING_LIST
2602/** check DC value of matrix for default matrix signaling
2603 */
2604Void TComScalingList::checkDcOfMatrix()
2605{
2606  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2607  {
2608    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2609    {
2610      setUseDefaultScalingMatrixFlag(sizeId,listId,false);
2611      //check default matrix?
2612      if(getScalingListDC(sizeId,listId) == 0)
2613      {
2614        processDefaultMarix(sizeId, listId);
2615      }
2616    }
2617  }
2618}
2619#endif
2620
2621ParameterSetManager::ParameterSetManager()
2622: m_spsMap(MAX_NUM_SPS)
2623, m_ppsMap(MAX_NUM_PPS)
2624, m_apsMap(MAX_NUM_APS)
2625#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
2626, m_vpsMap(MAX_NUM_VPS)
2627#endif
2628{
2629}
2630
2631
2632ParameterSetManager::~ParameterSetManager()
2633{
2634}
2635
2636//! \}
Note: See TracBrowser for help on using the repository browser.