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

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

Initial integration of VSP into HTM 4.0.1. The version used for JCT3V-B0102 at Shanghai meeting.

  • VC9 project/solution files updated. Other Visual C++ project/solution files are not updated.
  • Linux make file updated.

TODO

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