source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComSlice.h @ 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: 76.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.h
35    \brief    slice header and SPS class (header)
36*/
37
38#ifndef __TCOMSLICE__
39#define __TCOMSLICE__
40
41#include <cstring>
42#include <map>
43#include <vector>
44#include "CommonDef.h"
45#include "TComRom.h"
46#include "TComList.h"
47//! \ingroup TLibCommon
48//! \{
49
50class TComPic;
51class TComTrQuant;
52#if DEPTH_MAP_GENERATION
53class TComDepthMapGenerator;
54#endif
55#if HHI_INTER_VIEW_RESIDUAL_PRED
56class TComResidualGenerator;
57#endif
58// ====================================================================================================================
59// Constants
60// ====================================================================================================================
61
62/// max number of supported APS in software
63#define MAX_NUM_SUPPORTED_APS 1
64
65// ====================================================================================================================
66// Class definition
67// ====================================================================================================================
68
69#if RPS_IN_SPS
70/// Reference Picture Set class
71class TComReferencePictureSet
72{
73private:
74  Int  m_numberOfPictures;
75  Int  m_numberOfNegativePictures;
76  Int  m_numberOfPositivePictures;
77  Int  m_numberOfLongtermPictures;
78  Int  m_deltaPOC[MAX_NUM_REF_PICS];
79  Int  m_POC[MAX_NUM_REF_PICS];
80  Bool m_used[MAX_NUM_REF_PICS];
81  Bool m_interRPSPrediction;
82  Int  m_deltaRIdxMinus1;   
83  Int  m_deltaRPS; 
84  Int  m_numRefIdc; 
85  Int  m_refIdc[MAX_NUM_REF_PICS+1];
86
87public:
88  TComReferencePictureSet();
89  virtual ~TComReferencePictureSet();
90
91  Void setNumberOfPictures(Int numberOfPictures);
92  Int  getNumberOfPictures();
93  Void setNumberOfNegativePictures(Int number)  { m_numberOfNegativePictures = number; }
94  Int  getNumberOfNegativePictures()            { return m_numberOfNegativePictures; }
95  Void setNumberOfPositivePictures(Int number)  { m_numberOfPositivePictures = number; }
96  Int  getNumberOfPositivePictures()            { return m_numberOfPositivePictures; }
97  Void setNumberOfLongtermPictures(Int number)  { m_numberOfLongtermPictures = number; }
98  Int  getNumberOfLongtermPictures()            { return m_numberOfLongtermPictures; }
99
100  Void setDeltaPOC(Int bufferNum, Int deltaPOC);
101  Int  getDeltaPOC(Int bufferNum);
102  Void setPOC(Int bufferNum, Int deltaPOC);
103  Int  getPOC(Int bufferNum);
104
105  Void setUsed(Int bufferNum, Bool used);
106  Int  getUsed(Int bufferNum);
107
108  Void setInterRPSPrediction(Bool flag)         { m_interRPSPrediction = flag; }
109  Bool getInterRPSPrediction()                  { return m_interRPSPrediction; }
110  Void setDeltaRIdxMinus1(Int x)                { m_deltaRIdxMinus1 = x; }
111  Int  getDeltaRIdxMinus1()                     { return m_deltaRIdxMinus1; }
112  Void setDeltaRPS(Int x)                       { m_deltaRPS = x; }
113  Int  getDeltaRPS()                            { return m_deltaRPS; }
114  Void setNumRefIdc(Int x)                      { m_numRefIdc = x; }
115  Int  getNumRefIdc()                           { return m_numRefIdc; }
116
117  Void setRefIdc(Int bufferNum, Int refIdc);
118  Int  getRefIdc(Int bufferNum);
119
120  Void sortDeltaPOC();
121  Void printDeltaPOC();
122};
123
124/// Reference Picture Set set class
125class TComRPSList
126{
127private:
128  Int  m_numberOfReferencePictureSets;
129  TComReferencePictureSet* m_referencePictureSets;
130 
131public:
132  TComRPSList();
133  virtual ~TComRPSList();
134 
135  Void  create  (Int numberOfEntries);
136  Void  destroy ();
137
138
139  TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
140  Int getNumberOfReferencePictureSets();
141  Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
142};
143#endif
144
145#if VIDYO_VPS_INTEGRATION
146/// VPS class
147
148class TComVPS
149{
150private:
151  Int         m_VPSId;
152  UInt        m_uiMaxTLayers;
153  UInt        m_uiMaxLayers;
154  Bool        m_bTemporalIdNestingFlag;
155
156  UInt        m_uiExtensionType;
157 
158  Bool        m_bDependentFlag[MAX_LAYER_NUM];
159  UInt        m_uiViewId[MAX_LAYER_NUM];
160  Bool        m_bDepthFlag[MAX_LAYER_NUM];
161  Int         m_iViewOrderIdx[MAX_LAYER_NUM];
162  UInt        m_uiDependentLayer[MAX_LAYER_NUM];
163
164  UInt        m_numReorderPics[MAX_TLAYER];
165  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER]; 
166  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
167 
168public:
169  TComVPS();
170  virtual ~TComVPS();
171 
172  Int     getVPSId       ()                   { return m_VPSId;          }
173  Void    setVPSId       (Int i)              { m_VPSId = i;             }
174 
175  UInt    getMaxTLayers  ()                   { return m_uiMaxTLayers;   }
176  Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
177   
178  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
179  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
180 
181  Bool    getTemporalNestingFlag   ()         { return m_uiMaxLayers;   }
182  Void    setTemporalNestingFlag   (UInt t)   { m_bTemporalIdNestingFlag = t; }
183 
184  Void    setExtensionType(UInt v)                     { m_uiExtensionType = v;    }
185  UInt    getExtensionType()                             { return m_uiExtensionType; }
186 
187  Void    setDependentFlag(Bool d, UInt layer)              { m_bDependentFlag[layer] = d;    }
188  Bool    getDependentFlag(UInt layer)                      { return m_bDependentFlag[layer]; }
189
190  Void    setViewId(UInt v, UInt layer)                     { m_uiViewId[layer] = v;    }
191  UInt    getViewId(UInt layer)                             { return m_uiViewId[layer]; }
192 
193  Void    setDepthFlag(Bool d, UInt layer)                  { m_bDepthFlag[layer] = d;    }
194  Bool    getDepthFlag(UInt layer)                          { return m_bDepthFlag[layer]; }
195
196  Void    setViewOrderIdx(Int v, UInt layer)                { m_iViewOrderIdx[layer] = v;    }
197  Int     getViewOrderIdx(UInt layer)                       { return m_iViewOrderIdx[layer]; }
198 
199  Void    setDependentLayer(UInt v, UInt layer)                     { m_uiDependentLayer[layer] = v;    }
200  UInt    getDependentLayer(UInt layer)                             { return m_uiDependentLayer[layer]; }
201 
202  Void    setNumReorderPics(UInt v, UInt tLayer)                { m_numReorderPics[tLayer] = v;    }
203  UInt    getNumReorderPics(UInt tLayer)                        { return m_numReorderPics[tLayer]; }
204 
205  Void    setMaxDecPicBuffering(UInt v, UInt tLayer)          { m_uiMaxDecPicBuffering[tLayer] = v;    }
206  UInt    getMaxDecPicBuffering(UInt tLayer)                  { return m_uiMaxDecPicBuffering[tLayer]; }
207 
208  Void    setMaxLatencyIncrease(UInt v, UInt tLayer)                { m_uiMaxLatencyIncrease[tLayer] = v;    }
209  UInt    getMaxLatencyIncrease(UInt tLayer)                        { return m_uiMaxLatencyIncrease[tLayer]; }
210 
211};
212
213#endif
214
215/// SPS class
216class TComSPS
217{
218private:
219#if VIDYO_VPS_INTEGRATION
220  Int          m_VPSId;
221#endif
222  Int         m_SPSId;
223  Int         m_ProfileIdc;
224  Int         m_LevelIdc;
225  Int         m_chromaFormatIdc;
226
227  UInt        m_uiMaxTLayers;           // maximum number of temporal layers
228
229  UInt        m_uiViewId;
230  Int         m_iViewOrderIdx;
231  Bool        m_bDepth;
232  UInt        m_uiCamParPrecision;
233  Bool        m_bCamParInSliceHeader;
234  Int         m_aaiCodedScale [2][MAX_VIEW_NUM];
235  Int         m_aaiCodedOffset[2][MAX_VIEW_NUM];
236
237  // Structure
238  UInt        m_picWidthInLumaSamples;
239  UInt        m_picHeightInLumaSamples;
240#if PIC_CROPPING
241  Bool        m_picCroppingFlag;
242  Int         m_picCropLeftOffset;
243  Int         m_picCropRightOffset;
244  Int         m_picCropTopOffset;
245  Int         m_picCropBottomOffset;
246#else
247  Int         m_aiPad[2];
248#endif
249  UInt        m_uiMaxCUWidth;
250  UInt        m_uiMaxCUHeight;
251  UInt        m_uiMaxCUDepth;
252  UInt        m_uiMinTrDepth;
253  UInt        m_uiMaxTrDepth;
254#if RPS_IN_SPS
255  TComRPSList* m_RPSList;
256  Bool        m_bLongTermRefsPresent;
257#endif
258#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
259  Int         m_numReorderPics[MAX_TLAYER];
260#else
261  Int         m_maxNumberOfReferencePictures;
262  Int         m_numReorderFrames;
263#endif
264 
265  Int         m_iNumberOfUsableInterViewRefs;
266  Int         m_aiUsableInterViewRefs[MAX_VIEW_NUM];
267
268  // Tool list
269  UInt        m_uiQuadtreeTULog2MaxSize;
270  UInt        m_uiQuadtreeTULog2MinSize;
271  UInt        m_uiQuadtreeTUMaxDepthInter;
272  UInt        m_uiQuadtreeTUMaxDepthIntra;
273  Bool        m_usePCM;
274  UInt        m_pcmLog2MaxSize;
275  UInt        m_uiPCMLog2MinSize;
276  Bool        m_bDisInter4x4;
277  Bool        m_useAMP;
278  Bool        m_bUseALF;
279#if LCU_SYNTAX_ALF
280  Bool        m_bALFCoefInSlice;
281#endif
282#if !PIC_CROPPING
283  Bool        m_bUsePAD;
284#endif
285  Bool        m_bUseLMChroma; // JL:
286
287  Bool        m_bUseLComb;
288  Bool        m_bLCMod;
289  Bool        m_useNSQT;
290 
291#if H0412_REF_PIC_LIST_RESTRICTION
292  Bool        m_restrictedRefPicListsFlag;
293  Bool        m_listsModificationPresentFlag;
294#endif
295
296  // Parameter
297  AMVP_MODE   m_aeAMVPMode[MAX_CU_DEPTH];
298  UInt        m_uiBitDepth;
299  UInt        m_uiBitIncrement;
300#if H0736_AVC_STYLE_QP_RANGE
301  Int         m_qpBDOffsetY;
302  Int         m_qpBDOffsetC;
303#endif
304
305#if LOSSLESS_CODING
306  Bool        m_useLossless;
307#endif
308
309  UInt        m_uiPCMBitDepthLuma;
310  UInt        m_uiPCMBitDepthChroma;
311  Bool        m_bPCMFilterDisableFlag;
312
313  UInt        m_uiBitsForPOC;
314  // Max physical transform size
315  UInt        m_uiMaxTrSize;
316 
317  Int m_iAMPAcc[MAX_CU_DEPTH];
318
319  Bool        m_bLFCrossSliceBoundaryFlag;
320  Bool        m_bUseSAO; 
321#if HHI_MPI
322  Bool        m_bUseMVI;
323#endif
324
325  Bool     m_bLFCrossTileBoundaryFlag;
326  Int      m_iUniformSpacingIdr;
327  Int      m_iTileBoundaryIndependenceIdr;
328  Int      m_iNumColumnsMinus1;
329  UInt*    m_puiColumnWidth;
330  Int      m_iNumRowsMinus1;
331  UInt*    m_puiRowHeight;
332 
333  Bool        m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
334
335  Bool        m_scalingListEnabledFlag;
336#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
337  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER]; 
338  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
339#else
340  UInt        m_uiMaxDecFrameBuffering; 
341  UInt        m_uiMaxLatencyIncrease;
342#endif
343
344  Bool        m_useDF;
345
346#if TILES_WPP_ENTRY_POINT_SIGNALLING
347  UInt        m_tilesOrEntropyCodingSyncIdc;
348  Int         m_numSubstreams;
349#endif
350
351#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
352  Bool  m_bUseDMM;
353#endif
354
355#if DEPTH_MAP_GENERATION
356  UInt  m_uiPredDepthMapGeneration;
357  UInt  m_uiPdmPrecision;
358  Int   m_aiPdmScaleNomDelta[MAX_VIEW_NUM];
359  Int   m_aiPdmOffset       [MAX_VIEW_NUM];
360#endif
361
362#if HHI_INTER_VIEW_MOTION_PRED
363  UInt  m_uiMultiviewMvPredMode;
364#endif
365#if HHI_INTER_VIEW_RESIDUAL_PRED
366  UInt  m_uiMultiviewResPredMode;
367#endif
368
369#if DEPTH_MAP_GENERATION
370  TComDepthMapGenerator* m_pcDepthMapGenerator;
371#endif
372#if HHI_INTER_VIEW_RESIDUAL_PRED
373  TComResidualGenerator* m_pcResidualGenerator;
374#endif
375
376public:
377  TComSPS();
378  virtual ~TComSPS();
379#if VIDYO_VPS_INTEGRATION
380  Int  getVPSId       ()         { return m_VPSId;          }
381  Void setVPSId       (Int i)    { m_VPSId = i;             }
382#endif
383  Int  getSPSId       ()         { return m_SPSId;          }
384  Void setSPSId       (Int i)    { m_SPSId = i;             }
385  Int  getProfileIdc  ()         { return m_ProfileIdc;     }
386  Void setProfileIdc  (Int i)    { m_ProfileIdc = i;        }
387  Int  getLevelIdc    ()         { return m_LevelIdc;       }
388  Void setLevelIdc    (Int i)    { m_LevelIdc = i;          }
389
390  Int  getChromaFormatIdc ()         { return m_chromaFormatIdc;       }
391  Void setChromaFormatIdc (Int i)    { m_chromaFormatIdc = i;          }
392 
393  // structure
394  Void setPicWidthInLumaSamples       ( UInt u ) { m_picWidthInLumaSamples = u;        }
395  UInt getPicWidthInLumaSamples       ()         { return  m_picWidthInLumaSamples;    }
396  Void setPicHeightInLumaSamples      ( UInt u ) { m_picHeightInLumaSamples = u;       }
397  UInt getPicHeightInLumaSamples      ()         { return  m_picHeightInLumaSamples;   }
398
399#if PIC_CROPPING
400  Bool getPicCroppingFlag() const          { return m_picCroppingFlag; }
401  Void setPicCroppingFlag(Bool val)        { m_picCroppingFlag = val; }
402  Int  getPicCropLeftOffset() const        { return m_picCropLeftOffset; }
403  Void setPicCropLeftOffset(Int val)       { m_picCropLeftOffset = val; }
404  Int  getPicCropRightOffset() const       { return m_picCropRightOffset; }
405  Void setPicCropRightOffset(Int val)      { m_picCropRightOffset = val; }
406  Int  getPicCropTopOffset() const         { return m_picCropTopOffset; }
407  Void setPicCropTopOffset(Int val)        { m_picCropTopOffset = val; }
408  Int  getPicCropBottomOffset() const      { return m_picCropBottomOffset; }
409  Void setPicCropBottomOffset(Int val)     { m_picCropBottomOffset = val; }
410#endif
411
412  Void setMaxCUWidth  ( UInt u ) { m_uiMaxCUWidth = u;      }
413  UInt getMaxCUWidth  ()         { return  m_uiMaxCUWidth;  }
414  Void setMaxCUHeight ( UInt u ) { m_uiMaxCUHeight = u;     }
415  UInt getMaxCUHeight ()         { return  m_uiMaxCUHeight; }
416  Void setMaxCUDepth  ( UInt u ) { m_uiMaxCUDepth = u;      }
417  UInt getMaxCUDepth  ()         { return  m_uiMaxCUDepth;  }
418  Void setUsePCM      ( Bool b ) { m_usePCM = b;           }
419  Bool getUsePCM      ()         { return m_usePCM;        }
420  Void setPCMLog2MaxSize  ( UInt u ) { m_pcmLog2MaxSize = u;      }
421  UInt getPCMLog2MaxSize  ()         { return  m_pcmLog2MaxSize;  }
422  Void setPCMLog2MinSize  ( UInt u ) { m_uiPCMLog2MinSize = u;      }
423  UInt getPCMLog2MinSize  ()         { return  m_uiPCMLog2MinSize;  }
424  Void setBitsForPOC  ( UInt u ) { m_uiBitsForPOC = u;      }
425  UInt getBitsForPOC  ()         { return m_uiBitsForPOC;   }
426  Bool getDisInter4x4()         { return m_bDisInter4x4;        }
427  Void setDisInter4x4      ( Bool b ) { m_bDisInter4x4  = b;          }
428  Bool getUseAMP() { return m_useAMP; }
429  Void setUseAMP( Bool b ) { m_useAMP = b; }
430  Void setMinTrDepth  ( UInt u ) { m_uiMinTrDepth = u;      }
431  UInt getMinTrDepth  ()         { return  m_uiMinTrDepth;  }
432  Void setMaxTrDepth  ( UInt u ) { m_uiMaxTrDepth = u;      }
433  UInt getMaxTrDepth  ()         { return  m_uiMaxTrDepth;  }
434  Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u;    }
435  UInt getQuadtreeTULog2MaxSize()         { return m_uiQuadtreeTULog2MaxSize; }
436  Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u;    }
437  UInt getQuadtreeTULog2MinSize()         { return m_uiQuadtreeTULog2MinSize; }
438  Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u;    }
439  Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u;    }
440  UInt getQuadtreeTUMaxDepthInter()         { return m_uiQuadtreeTUMaxDepthInter; }
441  UInt getQuadtreeTUMaxDepthIntra()         { return m_uiQuadtreeTUMaxDepthIntra; }
442#if !PIC_CROPPING
443  Void setPad         (Int iPad[2]) { m_aiPad[0] = iPad[0]; m_aiPad[1] = iPad[1]; }
444#endif
445#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
446  Void setNumReorderPics(Int i, UInt tlayer)              { m_numReorderPics[tlayer] = i;    }
447  Int  getNumReorderPics(UInt tlayer)                     { return m_numReorderPics[tlayer]; }
448#else
449  Void setMaxNumberOfReferencePictures( Int u )  { m_maxNumberOfReferencePictures = u;    }
450  Int  getMaxNumberOfReferencePictures()         { return m_maxNumberOfReferencePictures; }
451  Void setNumReorderFrames( Int i )              { m_numReorderFrames = i;    }
452  Int  getNumReorderFrames()                     { return m_numReorderFrames; }
453#endif
454#if RPS_IN_SPS
455  Void      setRPSList( TComRPSList* RPSList )   { m_RPSList = RPSList;       }
456  TComRPSList* getRPSList()                      { return m_RPSList;          }
457  Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
458  Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
459#endif
460
461  Void setNumberOfUsableInterViewRefs( Int number )      { m_iNumberOfUsableInterViewRefs = number;    }
462  Int  getNumberOfUsableInterViewRefs()                  { return m_iNumberOfUsableInterViewRefs;      }
463  Void setUsableInterViewRef( Int pos, Int deltaViewId ) { m_aiUsableInterViewRefs[pos] = deltaViewId; }
464  Int  getUsableInterViewRef( Int pos )                  { return m_aiUsableInterViewRefs[pos];        }
465
466#if !PIC_CROPPING
467  Void setPadX        ( Int  u ) { m_aiPad[0] = u; }
468  Void setPadY        ( Int  u ) { m_aiPad[1] = u; }
469  Int  getPad         ( Int  u ) { assert(u < 2); return m_aiPad[u];}
470  Int* getPad         ( )        { return m_aiPad; }
471#endif
472 
473  // physical transform
474  Void setMaxTrSize   ( UInt u ) { m_uiMaxTrSize = u;       }
475  UInt getMaxTrSize   ()         { return  m_uiMaxTrSize;   }
476 
477  // Tool list
478  Bool getUseALF      ()         { return m_bUseALF;        }
479#if LCU_SYNTAX_ALF
480  Void setUseALFCoefInSlice(Bool b) {m_bALFCoefInSlice = b;}
481  Bool getUseALFCoefInSlice()    {return m_bALFCoefInSlice;}
482#endif
483
484#if !PIC_CROPPING
485  Bool getUsePAD      ()         { return m_bUsePAD;        }
486  Void setUsePAD      ( Bool b ) { m_bUsePAD   = b;         }
487#endif
488  Void setUseALF      ( Bool b ) { m_bUseALF  = b;          }
489  Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
490  Bool getUseLComb    ()         { return m_bUseLComb;      }
491  Void setLCMod       (Bool b)   { m_bLCMod = b;     }
492  Bool getLCMod       ()         { return m_bLCMod;  }
493
494  Bool getUseLMChroma ()         { return m_bUseLMChroma;        }
495  Void setUseLMChroma ( Bool b ) { m_bUseLMChroma  = b;          }
496
497#if LOSSLESS_CODING
498  Bool getUseLossless ()         { return m_useLossless; }
499  Void setUseLossless ( Bool b ) { m_useLossless  = b; }
500#endif
501  Bool getUseNSQT() { return m_useNSQT; }
502  Void setUseNSQT( Bool b ) { m_useNSQT = b; }
503 
504#if H0412_REF_PIC_LIST_RESTRICTION
505  Bool getRestrictedRefPicListsFlag    ()          { return m_restrictedRefPicListsFlag;   }
506  Void setRestrictedRefPicListsFlag    ( Bool b )  { m_restrictedRefPicListsFlag = b;      }
507  Bool getListsModificationPresentFlag ()          { return m_listsModificationPresentFlag; }
508  Void setListsModificationPresentFlag ( Bool b )  { m_listsModificationPresentFlag = b;    }
509#endif
510
511  // AMVP mode (for each depth)
512  AMVP_MODE getAMVPMode ( UInt uiDepth ) { assert(uiDepth < g_uiMaxCUDepth);  return m_aeAMVPMode[uiDepth]; }
513  Void      setAMVPMode ( UInt uiDepth, AMVP_MODE eMode) { assert(uiDepth < g_uiMaxCUDepth);  m_aeAMVPMode[uiDepth] = eMode; }
514 
515  // AMP accuracy
516  Int       getAMPAcc   ( UInt uiDepth ) { return m_iAMPAcc[uiDepth]; }
517  Void      setAMPAcc   ( UInt uiDepth, Int iAccu ) { assert( uiDepth < g_uiMaxCUDepth);  m_iAMPAcc[uiDepth] = iAccu; }
518
519  // Bit-depth
520  UInt      getBitDepth     ()         { return m_uiBitDepth;     }
521  Void      setBitDepth     ( UInt u ) { m_uiBitDepth = u;        }
522  UInt      getBitIncrement ()         { return m_uiBitIncrement; }
523  Void      setBitIncrement ( UInt u ) { m_uiBitIncrement = u;    }
524#if H0736_AVC_STYLE_QP_RANGE
525  Int       getQpBDOffsetY  ()             { return m_qpBDOffsetY;   }
526  Void      setQpBDOffsetY  ( Int value  ) { m_qpBDOffsetY = value;  }
527  Int       getQpBDOffsetC  ()             { return m_qpBDOffsetC;   }
528  Void      setQpBDOffsetC  ( Int value  ) { m_qpBDOffsetC = value;  }
529#endif
530
531  Void      setLFCrossSliceBoundaryFlag     ( Bool   bValue  )    { m_bLFCrossSliceBoundaryFlag = bValue; }
532  Bool      getLFCrossSliceBoundaryFlag     ()                    { return m_bLFCrossSliceBoundaryFlag;   } 
533
534  Void setUseDF                   ( Bool b ) { m_useDF = b; }
535  Bool getUseDF                   ()         { return m_useDF; }
536
537  Void setUseSAO                  (Bool bVal)  {m_bUseSAO = bVal;}
538  Bool getUseSAO                  ()           {return m_bUseSAO;}
539
540#if HHI_MPI
541  Void setUseMVI                  (Bool bVal)  {m_bUseMVI = bVal;}
542  Bool getUseMVI                  ()           {return m_bUseMVI;}
543#endif
544
545  UInt      getMaxTLayers()                           { return m_uiMaxTLayers; }
546  Void      setMaxTLayers( UInt uiMaxTLayers )        { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
547
548  Bool      getTemporalIdNestingFlag()                { return m_bTemporalIdNestingFlag; }
549  Void      setTemporalIdNestingFlag( Bool bValue )   { m_bTemporalIdNestingFlag = bValue; }
550  UInt      getPCMBitDepthLuma     ()         { return m_uiPCMBitDepthLuma;     }
551  Void      setPCMBitDepthLuma     ( UInt u ) { m_uiPCMBitDepthLuma = u;        }
552  UInt      getPCMBitDepthChroma   ()         { return m_uiPCMBitDepthChroma;   }
553  Void      setPCMBitDepthChroma   ( UInt u ) { m_uiPCMBitDepthChroma = u;      }
554  Void      setPCMFilterDisableFlag     ( Bool   bValue  )    { m_bPCMFilterDisableFlag = bValue; }
555  Bool      getPCMFilterDisableFlag     ()                    { return m_bPCMFilterDisableFlag;   } 
556
557  Void    setLFCrossTileBoundaryFlag               ( Bool   bValue  )    { m_bLFCrossTileBoundaryFlag = bValue; }
558  Bool    getLFCrossTileBoundaryFlag               ()                    { return m_bLFCrossTileBoundaryFlag;   }
559  Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
560  Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
561#if !REMOVE_TILE_DEPENDENCE
562  Void     setTileBoundaryIndependenceIdr   ( Int i )           { m_iTileBoundaryIndependenceIdr = i; }
563  Int      getTileBoundaryIndependenceIdr   ()                  { return m_iTileBoundaryIndependenceIdr; }
564#endif
565  Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
566  Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
567  Void     setColumnWidth ( UInt* columnWidth )
568  {
569    if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
570    {
571      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
572
573      for(Int i=0; i<m_iNumColumnsMinus1; i++)
574      {
575        m_puiColumnWidth[i] = columnWidth[i];
576     }
577    }
578  }
579  UInt     getColumnWidth  (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
580  Void     setNumRowsMinus1( Int i )        { m_iNumRowsMinus1 = i; }
581  Int      getNumRowsMinus1()               { return m_iNumRowsMinus1; }
582  Void     setRowHeight    ( UInt* rowHeight )
583  {
584    if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
585    {
586      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
587
588      for(Int i=0; i<m_iNumRowsMinus1; i++)
589      {
590        m_puiRowHeight[i] = rowHeight[i];
591      }
592    }
593  }
594  UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
595  Bool getScalingListFlag       ()         { return m_scalingListEnabledFlag;     }
596  Void setScalingListFlag       ( Bool b ) { m_scalingListEnabledFlag  = b;       }
597#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
598  UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
599  Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
600  UInt getMaxLatencyIncrease  (UInt tlayer)            { return m_uiMaxLatencyIncrease[tlayer];   }
601  Void setMaxLatencyIncrease  ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui;      }
602#else
603  UInt getMaxDecFrameBuffering  ()            { return m_uiMaxDecFrameBuffering; }
604  Void setMaxDecFrameBuffering  ( UInt ui )   { m_uiMaxDecFrameBuffering = ui;   }
605  UInt getMaxLatencyIncrease    ()            { return m_uiMaxLatencyIncrease;   }
606  Void setMaxLatencyIncrease    ( UInt ui )   { m_uiMaxLatencyIncrease= ui;      }
607#endif
608#if TILES_WPP_ENTRY_POINT_SIGNALLING
609  UInt getTilesOrEntropyCodingSyncIdc ()                    { return m_tilesOrEntropyCodingSyncIdc;   }
610  Void setTilesOrEntropyCodingSyncIdc ( UInt val )          { m_tilesOrEntropyCodingSyncIdc = val;    }
611  Int  getNumSubstreams               ()                    { return m_numSubstreams;                 }
612  Void setNumSubstreams               ( Int numSubstreams ) { m_numSubstreams = numSubstreams;        }
613#endif
614
615#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
616  Bool getUseDMM()         { return m_bUseDMM; }
617  Void setUseDMM( Bool b ) { m_bUseDMM = b;    }
618#endif
619
620  Void initMultiviewSPS      ( UInt uiViewId, Int iViewOrderIdx = 0, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
621  Void initMultiviewSPSDepth ( UInt uiViewId, Int iViewOrderIdx );
622
623  UInt getViewId             ()  { return m_uiViewId; }
624  Int  getViewOrderIdx       ()  { return m_iViewOrderIdx; }
625  Bool isDepth               ()  { return m_bDepth; }
626  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
627  Bool hasCamParInSliceHeader()  { return m_bCamParInSliceHeader; }
628  Int* getCodedScale         ()  { return m_aaiCodedScale [0]; }
629  Int* getCodedOffset        ()  { return m_aaiCodedOffset[0]; }
630  Int* getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
631  Int* getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
632
633
634#if DEPTH_MAP_GENERATION
635  Void setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode = 0, UInt uiPdmMvPredMode = 0, UInt uiPdmPrec = 0, Int** aaiPdmScaleNomDelta = 0, Int** aaiPdmOffset = 0 );
636#endif
637#if HHI_INTER_VIEW_RESIDUAL_PRED
638  Void  setMultiviewResPredMode  ( UInt uiResPrdMode ) { m_uiMultiviewResPredMode = uiResPrdMode; }
639#endif
640
641#if DEPTH_MAP_GENERATION
642  UInt getPredDepthMapGeneration()          { return m_uiPredDepthMapGeneration; }
643  UInt getPdmPrecision          ()          { return m_uiPdmPrecision;           }
644  Int* getPdmScaleNomDelta      ()          { return m_aiPdmScaleNomDelta;       }
645  Int* getPdmOffset             ()          { return m_aiPdmOffset;              }
646#endif
647
648#if HHI_INTER_VIEW_MOTION_PRED
649  UInt  getMultiviewMvPredMode   ()          { return m_uiMultiviewMvPredMode;    }
650#endif
651#if HHI_INTER_VIEW_RESIDUAL_PRED
652  UInt  getMultiviewResPredMode  ()          { return m_uiMultiviewResPredMode;   }
653#endif
654
655#if DEPTH_MAP_GENERATION
656  Void                    setDepthMapGenerator( TComDepthMapGenerator* pcDepthMapGenerator )  { m_pcDepthMapGenerator = pcDepthMapGenerator; }
657  TComDepthMapGenerator*  getDepthMapGenerator()                                              { return m_pcDepthMapGenerator; }
658#endif
659#if HHI_INTER_VIEW_RESIDUAL_PRED
660  Void                    setResidualGenerator( TComResidualGenerator* pcResidualGenerator )  { m_pcResidualGenerator = pcResidualGenerator; }
661  TComResidualGenerator*  getResidualGenerator()                                              { return m_pcResidualGenerator; }
662#endif
663};
664
665#if !RPS_IN_SPS
666/// Reference Picture Set class
667class TComReferencePictureSet
668{
669private:
670  Int m_numberOfPictures;
671  Int m_numberOfNegativePictures;
672  Int m_numberOfPositivePictures;
673  Int m_numberOfLongtermPictures;
674  Int  m_deltaPOC[MAX_NUM_REF_PICS];
675  Int  m_POC[MAX_NUM_REF_PICS];
676  Bool m_used[MAX_NUM_REF_PICS];
677  Bool m_interRPSPrediction;
678  Int  m_deltaRIdxMinus1;   
679  Int  m_deltaRPS; 
680  Int  m_numRefIdc; 
681  Int  m_refIdc[MAX_NUM_REF_PICS+1];
682
683public:
684  TComReferencePictureSet();
685  virtual ~TComReferencePictureSet();
686
687  Void setUsed(Int bufferNum, Bool used);
688  Void setDeltaPOC(Int bufferNum, Int deltaPOC);
689  Void setPOC(Int bufferNum, Int deltaPOC);
690  Void setNumberOfPictures(Int numberOfPictures);
691
692  Int  getUsed(Int bufferNum);
693  Int  getDeltaPOC(Int bufferNum);
694  Int  getPOC(Int bufferNum);
695  Int  getNumberOfPictures();
696
697  Void setNumberOfNegativePictures(Int number)  { m_numberOfNegativePictures = number; }
698  Int  getNumberOfNegativePictures()            { return m_numberOfNegativePictures; }
699  Void setNumberOfPositivePictures(Int number)  { m_numberOfPositivePictures = number; }
700  Int  getNumberOfPositivePictures()            { return m_numberOfPositivePictures; }
701  Void setNumberOfLongtermPictures(Int number)  { m_numberOfLongtermPictures = number; }
702  Int  getNumberOfLongtermPictures()            { return m_numberOfLongtermPictures; }
703
704  Void setInterRPSPrediction(Bool flag)         { m_interRPSPrediction = flag; }
705  Bool getInterRPSPrediction()                  { return m_interRPSPrediction; }
706  Void setDeltaRIdxMinus1(Int x)                { m_deltaRIdxMinus1 = x; }
707  Int  getDeltaRIdxMinus1()                     { return m_deltaRIdxMinus1; }
708  Void setDeltaRPS(Int x)                       { m_deltaRPS = x; }
709  Int  getDeltaRPS()                            { return m_deltaRPS; }
710  Void setNumRefIdc(Int x)                      { m_numRefIdc = x; }
711  Int  getNumRefIdc()                           { return m_numRefIdc; }
712
713  Void setRefIdc(Int bufferNum, Int refIdc);
714  Int  getRefIdc(Int bufferNum);
715
716  Void sortDeltaPOC();
717  Void printDeltaPOC();
718};
719
720/// Reference Picture Set set class
721class TComRPSList
722{
723private:
724  Int  m_numberOfReferencePictureSets;
725  TComReferencePictureSet* m_referencePictureSets;
726 
727public:
728  TComRPSList();
729  virtual ~TComRPSList();
730 
731  Void  create  (Int numberOfEntries);
732  Void  destroy ();
733
734
735  TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
736  Int getNumberOfReferencePictureSets();
737  Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
738};
739#endif
740
741/// Reference Picture Lists class
742class TComRefPicListModification
743{
744private:
745  UInt      m_bRefPicListModificationFlagL0; 
746  UInt      m_bRefPicListModificationFlagL1; 
747#if !H0137_0138_LIST_MODIFICATION
748  UInt      m_uiNumberOfRefPicListModificationsL0;
749  UInt      m_uiNumberOfRefPicListModificationsL1;
750  UInt      m_ListIdcL0[32];
751#endif
752  UInt      m_RefPicSetIdxL0[32];
753#if !H0137_0138_LIST_MODIFICATION
754  UInt      m_ListIdcL1[32];
755#endif
756  UInt      m_RefPicSetIdxL1[32];
757   
758public:
759  TComRefPicListModification();
760  virtual ~TComRefPicListModification();
761 
762  Void  create                    ();
763  Void  destroy                   ();
764
765  Bool       getRefPicListModificationFlagL0() { return m_bRefPicListModificationFlagL0; }
766  Void       setRefPicListModificationFlagL0(Bool flag) { m_bRefPicListModificationFlagL0 = flag; }
767  Bool       getRefPicListModificationFlagL1() { return m_bRefPicListModificationFlagL1; }
768  Void       setRefPicListModificationFlagL1(Bool flag) { m_bRefPicListModificationFlagL1 = flag; }
769#if !H0137_0138_LIST_MODIFICATION
770  UInt       getNumberOfRefPicListModificationsL0() { return m_uiNumberOfRefPicListModificationsL0; }
771  Void       setNumberOfRefPicListModificationsL0(UInt nr) { m_uiNumberOfRefPicListModificationsL0 = nr; }
772  UInt       getNumberOfRefPicListModificationsL1() { return m_uiNumberOfRefPicListModificationsL1; }
773  Void       setNumberOfRefPicListModificationsL1(UInt nr) { m_uiNumberOfRefPicListModificationsL1 = nr; }
774  Void       setListIdcL0(UInt idx, UInt idc) { m_ListIdcL0[idx] = idc; }
775  UInt       getListIdcL0(UInt idx) { return m_ListIdcL0[idx]; }
776#endif
777  Void       setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL0[idx] = refPicSetIdx; }
778  UInt       getRefPicSetIdxL0(UInt idx) { return m_RefPicSetIdxL0[idx]; }
779#if !H0137_0138_LIST_MODIFICATION
780  Void       setListIdcL1(UInt idx, UInt idc) { m_ListIdcL1[idx] = idc; }
781  UInt       getListIdcL1(UInt idx) { return m_ListIdcL1[idx]; }
782#endif
783  Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
784  UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
785};
786
787/// PPS class
788class TComPPS
789{
790private:
791  Int         m_PPSId;                    // pic_parameter_set_id
792  Int         m_SPSId;                    // seq_parameter_set_id
793  Int         m_picInitQPMinus26;
794  Bool        m_useDQP;
795  Bool        m_bConstrainedIntraPred;    // constrained_intra_pred_flag
796 
797  // access channel
798  TComSPS*    m_pcSPS;
799#if !RPS_IN_SPS
800  TComRPSList* m_RPSList;
801#endif
802  UInt        m_uiMaxCuDQPDepth;
803  UInt        m_uiMinCuDQPSize;
804
805  Int        m_iChromaQpOffset;
806  Int        m_iChromaQpOffset2nd;
807
808#if !RPS_IN_SPS
809  Bool        m_bLongTermRefsPresent;
810#endif
811
812#if !H0566_TLA
813  UInt        m_uiNumTlayerSwitchingFlags;            // num_temporal_layer_switching_point_flags
814  Bool        m_abTLayerSwitchingFlag[ MAX_TLAYER ];  // temporal_layer_switching_point_flag
815#endif
816
817  Int         m_iSliceGranularity;
818
819  Bool        m_bUseWeightPred;           // Use of Weighting Prediction (P_SLICE)
820  UInt        m_uiBiPredIdc;              // Use of Weighting Bi-Prediction (B_SLICE)
821
822#if H0388
823  Bool        m_OutputFlagPresentFlag;   // Indicates the presence of output_flag in slice header
824#endif
825
826  Int      m_iTileBehaviorControlPresentFlag;
827  Bool     m_bLFCrossTileBoundaryFlag;
828  Int      m_iColumnRowInfoPresent;
829  Int      m_iUniformSpacingIdr;
830#if !REMOVE_TILE_DEPENDENCE
831  Int      m_iTileBoundaryIndependenceIdr;
832#endif
833  Int      m_iNumColumnsMinus1;
834  UInt*    m_puiColumnWidth;
835  Int      m_iNumRowsMinus1;
836  UInt*    m_puiRowHeight;
837 
838  Int      m_iEntropyCodingMode; // !!! in PPS now, but also remains in slice header!
839#if !WPP_SIMPLIFICATION 
840  Int      m_iEntropyCodingSynchro;
841  Bool     m_bCabacIstateReset;
842#endif
843  Int      m_iNumSubstreams;
844
845  Bool     m_enableTMVPFlag;
846
847#if MULTIBITS_DATA_HIDING
848  Int      m_signHideFlag;
849  Int      m_signHidingThreshold;
850#endif
851
852#if CABAC_INIT_FLAG
853  Bool     m_cabacInitPresentFlag;
854  UInt     m_encCABACTableIdx;           // Used to transmit table selection across slices
855#if POZNAN_CABAC_INIT_FLAG_FIX
856  UInt     m_encPrevPOC;
857#endif
858#endif
859#if DBL_CONTROL
860  Bool     m_DeblockingFilterControlPresent;
861#endif
862#if PARALLEL_MERGE
863  UInt m_log2ParallelMergeLevelMinus2;
864#endif
865public:
866  TComPPS();
867  virtual ~TComPPS();
868 
869  Int       getPPSId ()      { return m_PPSId; }
870  Void      setPPSId (Int i) { m_PPSId = i; }
871  Int       getSPSId ()      { return m_SPSId; }
872  Void      setSPSId (Int i) { m_SPSId = i; }
873 
874  Int       getSliceGranularity()        { return m_iSliceGranularity; }
875  Void      setSliceGranularity( Int i ) { m_iSliceGranularity = i;    }
876  Int       getPicInitQPMinus26 ()         { return  m_picInitQPMinus26; }
877  Void      setPicInitQPMinus26 ( Int i )  { m_picInitQPMinus26 = i;     }
878  Bool      getUseDQP ()                   { return m_useDQP;        }
879  Void      setUseDQP ( Bool b )           { m_useDQP   = b;         }
880  Bool      getConstrainedIntraPred ()         { return  m_bConstrainedIntraPred; }
881  Void      setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b;     }
882
883#if !H0566_TLA
884  UInt      getNumTLayerSwitchingFlags()                                  { return m_uiNumTlayerSwitchingFlags; }
885  Void      setNumTLayerSwitchingFlags( UInt uiNumTlayerSwitchingFlags )  { assert( uiNumTlayerSwitchingFlags < MAX_TLAYER ); m_uiNumTlayerSwitchingFlags = uiNumTlayerSwitchingFlags; }
886
887  Bool      getTLayerSwitchingFlag( UInt uiTLayer )                       { assert( uiTLayer < MAX_TLAYER ); return m_abTLayerSwitchingFlag[ uiTLayer ]; }
888  Void      setTLayerSwitchingFlag( UInt uiTLayer, Bool bValue )          { m_abTLayerSwitchingFlag[ uiTLayer ] = bValue; }
889#endif
890
891#if !RPS_IN_SPS
892  Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
893  Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
894#endif
895  Void      setSPS              ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
896  TComSPS*  getSPS              ()         { return m_pcSPS;          }
897#if !RPS_IN_SPS
898  Void      setRPSList          ( TComRPSList* RPSList ) { m_RPSList = RPSList; }
899  TComRPSList* getRPSList       ()         { return m_RPSList;        }
900#endif
901  Void      setMaxCuDQPDepth    ( UInt u ) { m_uiMaxCuDQPDepth = u;   }
902  UInt      getMaxCuDQPDepth    ()         { return m_uiMaxCuDQPDepth;}
903  Void      setMinCuDQPSize     ( UInt u ) { m_uiMinCuDQPSize = u;    }
904  UInt      getMinCuDQPSize     ()         { return m_uiMinCuDQPSize; }
905
906  Void      setChromaQpOffset   ( Int i ) { m_iChromaQpOffset = i; }
907  Int       getChromaQpOffset   () { return m_iChromaQpOffset;}
908  Void      setChromaQpOffset2nd( Int i ) { m_iChromaQpOffset2nd = i; }
909  Int       getChromaQpOffset2nd() { return m_iChromaQpOffset2nd;}
910
911  Bool getUseWP                     ()          { return m_bUseWeightPred;  }
912  UInt getWPBiPredIdc               ()          { return m_uiBiPredIdc;     }
913
914  Void setUseWP                     ( Bool b )  { m_bUseWeightPred = b;     }
915  Void setWPBiPredIdc               ( UInt u )  { m_uiBiPredIdc = u;        }
916
917#if H0388
918  Void      setOutputFlagPresentFlag( Bool b )  { m_OutputFlagPresentFlag = b;    }
919  Bool      getOutputFlagPresentFlag()          { return m_OutputFlagPresentFlag; }
920#endif
921
922  Void    setTileBehaviorControlPresentFlag        ( Int i )             { m_iTileBehaviorControlPresentFlag = i;    }
923  Int     getTileBehaviorControlPresentFlag        ()                    { return m_iTileBehaviorControlPresentFlag; }
924  Void    setLFCrossTileBoundaryFlag               ( Bool   bValue  )    { m_bLFCrossTileBoundaryFlag = bValue; }
925  Bool    getLFCrossTileBoundaryFlag               ()                    { return m_bLFCrossTileBoundaryFlag;   }
926  Void     setColumnRowInfoPresent          ( Int i )           { m_iColumnRowInfoPresent = i; }
927  Int      getColumnRowInfoPresent          ()                  { return m_iColumnRowInfoPresent; }
928  Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
929  Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
930#if !REMOVE_TILE_DEPENDENCE
931  Void     setTileBoundaryIndependenceIdr   ( Int i )           { m_iTileBoundaryIndependenceIdr = i; }
932  Int      getTileBoundaryIndependenceIdr   ()                  { return m_iTileBoundaryIndependenceIdr; }
933#endif
934  Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
935  Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
936  Void     setColumnWidth ( UInt* columnWidth )
937  {
938    if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
939    {
940      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
941
942      for(Int i=0; i<m_iNumColumnsMinus1; i++)
943      {
944        m_puiColumnWidth[i] = columnWidth[i];
945      }
946    }
947  }
948  UInt     getColumnWidth  (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
949  Void     setNumRowsMinus1( Int i )        { m_iNumRowsMinus1 = i; }
950  Int      getNumRowsMinus1()               { return m_iNumRowsMinus1; }
951  Void     setRowHeight    ( UInt* rowHeight )
952  {
953    if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
954    {
955      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
956
957      for(Int i=0; i<m_iNumRowsMinus1; i++)
958      {
959        m_puiRowHeight[i] = rowHeight[i];
960      }
961    }
962  }
963  UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
964  Void     setEntropyCodingMode(Int iEntropyCodingMode)       { m_iEntropyCodingMode = iEntropyCodingMode; }
965  Int      getEntropyCodingMode()                             { return m_iEntropyCodingMode; }
966#if !WPP_SIMPLIFICATION
967  Void     setEntropyCodingSynchro(Int iEntropyCodingSynchro) { m_iEntropyCodingSynchro = iEntropyCodingSynchro; }
968  Int      getEntropyCodingSynchro()                          { return m_iEntropyCodingSynchro; }
969  Void     setCabacIstateReset(Bool bCabacIstateReset)        { m_bCabacIstateReset = bCabacIstateReset; }
970  Bool     getCabacIstateReset()                              { return m_bCabacIstateReset; }
971#endif
972  Void     setNumSubstreams(Int iNumSubstreams)               { m_iNumSubstreams = iNumSubstreams; }
973  Int      getNumSubstreams()                                 { return m_iNumSubstreams; }
974
975#if MULTIBITS_DATA_HIDING
976  Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
977  Void      setTSIG( Int tsig )                 { m_signHidingThreshold = tsig; }
978  Int       getSignHideFlag()                    { return m_signHideFlag; }
979  Int       getTSIG()                            { return m_signHidingThreshold; }
980#endif
981
982  Void     setEnableTMVPFlag( Bool b )  { m_enableTMVPFlag = b;    }
983  Bool     getEnableTMVPFlag()          { return m_enableTMVPFlag; }
984
985#if CABAC_INIT_FLAG
986  Void     setCabacInitPresentFlag( Bool flag )     { m_cabacInitPresentFlag = flag;    }
987  Void     setEncCABACTableIdx( Int idx )           { m_encCABACTableIdx = idx;         }
988  Bool     getCabacInitPresentFlag()                { return m_cabacInitPresentFlag;    }
989  UInt     getEncCABACTableIdx()                    { return m_encCABACTableIdx;        }
990#if POZNAN_CABAC_INIT_FLAG_FIX
991  Void     setEncPrevPOC(UInt uiPOC)                { m_encPrevPOC = uiPOC;             }
992  UInt     getEncPrevPOC()                          { return m_encPrevPOC;              }
993#endif
994#endif
995#if DBL_CONTROL
996  Void setDeblockingFilterControlPresent    ( Bool bValue )       { m_DeblockingFilterControlPresent = bValue; }
997  Bool getDeblockingFilterControlPresent    ()                    { return m_DeblockingFilterControlPresent; }
998#endif
999#if PARALLEL_MERGE
1000  UInt getLog2ParallelMergeLevelMinus2      ()                    { return m_log2ParallelMergeLevelMinus2; }
1001  Void setLog2ParallelMergeLevelMinus2      (UInt mrgLevel)       { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
1002#endif
1003};
1004
1005/// SCALING_LIST class
1006class TComScalingList
1007{
1008public:
1009  TComScalingList();
1010  virtual ~TComScalingList();
1011  Void     setScalingListPresentFlag    (Bool b)                               { m_scalingListPresentFlag = b;    }
1012  Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
1013  Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
1014  Bool     checkPredMode                  (UInt sizeId, UInt listId);
1015  Void     setRefMatrixId                 (UInt sizeId, UInt listId, UInt u)   { m_refMatrixId[sizeId][listId] = u;    }     //!< set reference matrix ID
1016  UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
1017  Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
1018  Void     processDefaultMarix            (UInt sizeId, UInt listId);
1019#if SCALING_LIST
1020  Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
1021  Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
1022  Void     checkDcOfMatrix                ();
1023  Void     setUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId, Bool b)   { m_useDefaultScalingMatrixFlag[sizeId][listId] = b;    } //!< set default matrix enabled/disabled in each matrix
1024  Bool     getUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId)           { return m_useDefaultScalingMatrixFlag[sizeId][listId]; } //!< get default matrix enabled/disabled in each matrix
1025#endif
1026  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
1027  Bool     xParseScalingList              (char* pchFile);
1028
1029private:
1030  Void     init                    ();
1031  Void     destroy                 ();
1032#if SCALING_LIST
1033  Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
1034  Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
1035#endif
1036  UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
1037  Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
1038  UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
1039  Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
1040};
1041
1042/// APS class
1043class TComAPS
1044{
1045public:
1046  TComAPS();
1047  virtual ~TComAPS();
1048
1049  Void      setAPSID      (Int iID)   {m_apsID = iID;            }  //!< set APS ID
1050  Int       getAPSID      ()          {return m_apsID;           }  //!< get APS ID
1051  Void      setSaoEnabled (Bool bVal) {m_bSaoEnabled = bVal;     }  //!< set SAO enabled/disabled in APS
1052  Bool      getSaoEnabled ()          {return m_bSaoEnabled;     }  //!< get SAO enabled/disabled in APS
1053  Void      setAlfEnabled (Bool bVal) {m_bAlfEnabled = bVal;     }  //!< set ALF enabled/disabled in APS
1054  Bool      getAlfEnabled ()          {return m_bAlfEnabled;     }  //!< get ALF enabled/disabled in APS
1055
1056#if LCU_SYNTAX_ALF
1057  AlfParamSet* getAlfParam   ()          {return m_alfParamSet;}
1058#else
1059  ALFParam* getAlfParam   ()          {return m_pAlfParam;       }  //!< get ALF parameters in APS
1060#endif
1061  SAOParam* getSaoParam   ()          {return m_pSaoParam;       }  //!< get SAO parameters in APS
1062
1063  Void      createSaoParam();   //!< create SAO parameter object
1064  Void      destroySaoParam();  //!< destroy SAO parameter object
1065
1066  Void      createAlfParam();   //!< create ALF parameter object
1067  Void      destroyAlfParam();  //!< destroy ALF parameter object
1068
1069  Void      setLoopFilterOffsetInAPS(Bool val)  {m_loopFilterOffsetInAPS = val; }      //!< set offset for deblocking filter enabled/disabled in APS
1070  Bool      getLoopFilterOffsetInAPS()          {return m_loopFilterOffsetInAPS; }     //!< get offset for deblocking filter enabled/disabled in APS
1071  Void      setLoopFilterDisable(Bool val)      {m_loopFilterDisable = val; }          //!< set offset for deblocking filter disabled
1072  Bool      getLoopFilterDisable()              {return m_loopFilterDisable; }         //!< get offset for deblocking filter disabled
1073  Void      setLoopFilterBetaOffset(Int val)    {m_loopFilterBetaOffsetDiv2 = val; }    //!< set beta offset for deblocking filter
1074  Int       getLoopFilterBetaOffset()           {return m_loopFilterBetaOffsetDiv2; }   //!< get beta offset for deblocking filter
1075  Void      setLoopFilterTcOffset(Int val)      {m_loopFilterTcOffsetDiv2 = val; }      //!< set tc offset for deblocking filter
1076  Int       getLoopFilterTcOffset()             {return m_loopFilterTcOffsetDiv2; }     //!< get tc offset for deblocking filter
1077
1078  Void      createScalingList();
1079  Void      destroyScalingList();
1080  Void      setScalingListEnabled (Bool bVal) { m_scalingListEnabled = bVal; }  //!< set ScalingList enabled/disabled in APS
1081  Bool      getScalingListEnabled ()          { return m_scalingListEnabled; }  //!< get ScalingList enabled/disabled in APS
1082  TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in APS
1083#if SAO_UNIT_INTERLEAVING
1084  Bool     getSaoInterleavingFlag() {return m_saoInterleavingFlag;}             //!< get SAO interleaving flag in APS
1085  Void     setSaoInterleavingFlag(Bool bVal) {m_saoInterleavingFlag = bVal;}    //!< set SAO interleaving flag in APS
1086#endif
1087
1088private:
1089  Int         m_apsID;        //!< APS ID
1090  Bool        m_bSaoEnabled;  //!< SAO enabled/disabled in APS (true for enabled)
1091  Bool        m_bAlfEnabled;  //!< ALF enabled/disabled in APS (true for enabled)
1092  SAOParam*   m_pSaoParam;    //!< SAO parameter object pointer
1093#if LCU_SYNTAX_ALF
1094  AlfParamSet*   m_alfParamSet;
1095#else
1096  ALFParam*   m_pAlfParam;    //!< ALF parameter object pointer
1097#endif
1098  Bool        m_loopFilterOffsetInAPS;       //< offset for deblocking filter in 0 = slice header, 1 = APS
1099  Bool        m_loopFilterDisable;           //< Deblocking filter enabled/disabled in APS
1100  Int         m_loopFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
1101  Int         m_loopFilterTcOffsetDiv2;      //< tc offset for deblocking filter
1102  Bool        m_scalingListEnabled;     //!< ScalingList enabled/disabled in APS (true for enabled)
1103  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
1104#if SAO_UNIT_INTERLEAVING
1105  Bool        m_saoInterleavingFlag;    //!< SAO interleaving flag
1106#endif
1107
1108public:
1109  TComAPS& operator= (const TComAPS& src);  //!< "=" operator for APS object
1110};
1111
1112typedef struct {
1113  // Explicit weighted prediction parameters parsed in slice header,
1114  // or Implicit weighted prediction parameters (8 bits depth values).
1115  Bool        bPresentFlag;
1116  UInt        uiLog2WeightDenom;
1117  Int         iWeight;
1118  Int         iOffset;
1119
1120  // Weighted prediction scaling values built from above parameters (bitdepth scaled):
1121  Int         w, o, offset, shift, round;
1122} wpScalingParam;
1123
1124typedef struct {
1125  Int64 iAC;
1126  Int64 iDC;
1127} wpACDCParam;
1128
1129/// slice header class
1130class TComSlice
1131{
1132 
1133private:
1134  //  Bitstream writing
1135  Int         m_iAPSId; //!< APS ID in slice header
1136  bool       m_alfEnabledFlag;
1137  bool       m_saoEnabledFlag;
1138#if SAO_UNIT_INTERLEAVING
1139  bool       m_saoInterleavingFlag;   ///< SAO interleaving flag
1140  bool       m_saoEnabledFlagCb;      ///< SAO Cb enabled flag
1141  bool       m_saoEnabledFlagCr;      ///< SAO Cr enabled flag
1142#endif
1143  Int         m_iPPSId;               ///< picture parameter set ID
1144#if H0388
1145  Bool        m_PicOutputFlag;        ///< pic_output_flag
1146#endif
1147  Int         m_iPOC;
1148  Int         m_iLastIDR;
1149  static Int  m_prevPOC;
1150  TComReferencePictureSet *m_pcRPS;
1151  TComReferencePictureSet m_LocalRPS;
1152  Int         m_iBDidx; 
1153  Int         m_iCombinationBDidx;
1154  Bool        m_bCombineWithReferenceFlag;
1155  TComRefPicListModification m_RefPicListModification;
1156  NalUnitType m_eNalUnitType;            ///< Nal unit type for the slice
1157  NalUnitType m_eNalUnitTypeBaseViewMvc; ///< Nal unit type of the base view slice for multiview coding
1158  SliceType   m_eSliceType;
1159  Int         m_iSliceQp;
1160#if ADAPTIVE_QP_SELECTION
1161  Int         m_iSliceQpBase;
1162#endif
1163  Bool        m_bLoopFilterDisable;
1164  Bool        m_loopFilterOffsetInAPS;
1165  Bool        m_inheritDblParamFromAPS;      //< offsets for deblocking filter inherit from APS
1166  Int         m_loopFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
1167  Int         m_loopFilterTcOffsetDiv2;      //< tc offset for deblocking filter
1168 
1169  Int         m_aiNumRefIdx   [3];    //  for multiple reference of current slice
1170
1171  Int         m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
1172  Int         m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
1173  Int         m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
1174  Int         m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
1175  Int         m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
1176  Bool        m_bRefPicListModificationFlagLC;
1177  Bool        m_bRefPicListCombinationFlag;
1178
1179  Bool        m_bCheckLDC;
1180
1181  //  Data
1182  Int         m_iSliceQpDelta;
1183  TComPic*    m_apcRefPicList  [2][MAX_NUM_REF+1];
1184  Int         m_aiRefPOCList   [2][MAX_NUM_REF+1];
1185  Int         m_aiRefViewIdList[2][MAX_NUM_REF+1];
1186  TComPic*    m_pcTexturePic;
1187  Int         m_iDepth;
1188 
1189  // referenced slice?
1190  Bool        m_bRefenced;
1191 
1192  // access channel
1193#if VIDYO_VPS_INTEGRATION
1194  TComVPS*    m_pcVPS;
1195#endif
1196  TComSPS*    m_pcSPS;
1197  TComPPS*    m_pcPPS;
1198  TComPic*    m_pcPic;
1199#if ADAPTIVE_QP_SELECTION
1200  TComTrQuant* m_pcTrQuant;
1201#endif 
1202  TComAPS*    m_pcAPS;  //!< pointer to APS parameter object
1203
1204  UInt        m_uiColDir;  // direction to get colocated CUs
1205 
1206#if COLLOCATED_REF_IDX
1207  UInt        m_colRefIdx;
1208#endif
1209
1210#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA
1211  Double      m_dLambdaLuma;
1212  Double      m_dLambdaChroma;
1213#else
1214  Double      m_dLambda;
1215#endif
1216
1217  Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
1218 
1219  Bool        m_bNoBackPredFlag;
1220  Bool        m_bRefIdxCombineCoding;
1221
1222  UInt        m_uiTLayer;
1223  Bool        m_bTLayerSwitchingFlag;
1224
1225  UInt        m_uiSliceMode;
1226  UInt        m_uiSliceArgument;
1227  UInt        m_uiSliceCurStartCUAddr;
1228  UInt        m_uiSliceCurEndCUAddr;
1229  UInt        m_uiSliceIdx;
1230  UInt        m_uiEntropySliceMode;
1231  UInt        m_uiEntropySliceArgument;
1232  UInt        m_uiEntropySliceCurStartCUAddr;
1233  UInt        m_uiEntropySliceCurEndCUAddr;
1234  Bool        m_bNextSlice;
1235  Bool        m_bNextEntropySlice;
1236  UInt        m_uiSliceBits;
1237  UInt        m_uiEntropySliceCounter;
1238  Bool        m_bFinalized;
1239
1240  wpScalingParam  m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
1241  wpACDCParam    m_weightACDCParam[3];                 // [0:Y, 1:U, 2:V]
1242  wpScalingParam  m_weightPredTableLC[2*MAX_NUM_REF][3]; // [refIdxLC][0:Y, 1:U, 2:V]
1243
1244  UInt        *m_uiTileByteLocation;
1245  UInt        m_uiTileCount;
1246  Int         m_iTileMarkerFlag;
1247  UInt        m_uiTileOffstForMultES;
1248
1249  UInt*       m_puiSubstreamSizes;
1250  TComScalingList*     m_scalingList;                 //!< pointer of quantization matrix
1251#if CABAC_INIT_FLAG
1252  Bool        m_cabacInitFlag; 
1253#else
1254  Int         m_cabacInitIdc; 
1255#endif
1256
1257#if H0111_MVD_L1_ZERO
1258  Bool       m_bLMvdL1Zero;
1259#endif
1260#if TILES_WPP_ENTRY_POINT_SIGNALLING
1261  Int         m_numEntryPointOffsets;
1262#endif
1263
1264  Int        m_viewId;
1265  Bool       m_isDepth;
1266  Int        m_aaiCodedScale [2][MAX_VIEW_NUM];
1267  Int        m_aaiCodedOffset[2][MAX_VIEW_NUM];
1268
1269#if SONY_COLPIC_AVAILABILITY
1270  Int        m_iViewOrderIdx;
1271#endif
1272
1273#if FORCE_REF_VSP
1274  Int        m_iRefIdxVsp[2]; // L0/L1
1275#endif
1276
1277#if VSP_SLICE_HEADER
1278  Bool      m_bVspFlag;
1279#endif
1280
1281public:
1282  TComSlice();
1283  virtual ~TComSlice();
1284 
1285  Void      initSlice       ();
1286  Void      initTiles();
1287
1288#if VIDYO_VPS_INTEGRATION
1289  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
1290  TComVPS*  getVPS          () { return m_pcVPS; }
1291#endif
1292  Void      setSPS          ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
1293  TComSPS*  getSPS          () { return m_pcSPS; }
1294 
1295  Void      setPPS          ( TComPPS* pcPPS )         { assert(pcPPS!=NULL); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
1296  TComPPS*  getPPS          () { return m_pcPPS; }
1297
1298#if ADAPTIVE_QP_SELECTION
1299  Void          setTrQuant          ( TComTrQuant* pcTrQuant ) { m_pcTrQuant = pcTrQuant; }
1300  TComTrQuant*  getTrQuant          () { return m_pcTrQuant; }
1301#endif
1302
1303  Void      setPPSId        ( Int PPSId )         { m_iPPSId = PPSId; }
1304  Int       getPPSId        () { return m_iPPSId; }
1305  Void      setAPS          ( TComAPS* pcAPS ) { m_pcAPS = pcAPS; } //!< set APS pointer
1306  TComAPS*  getAPS          ()                 { return m_pcAPS;  } //!< get APS pointer
1307  Void      setAPSId        ( Int Id)          { m_iAPSId =Id;    } //!< set APS ID
1308  Int       getAPSId        ()                 { return m_iAPSId; } //!< get APS ID
1309#if H0388
1310  Void      setPicOutputFlag( Bool b )         { m_PicOutputFlag = b;    }
1311  Bool      getPicOutputFlag()                 { return m_PicOutputFlag; }
1312#endif
1313  Void      setAlfEnabledFlag(Bool s) {m_alfEnabledFlag =s; }
1314  Bool      getAlfEnabledFlag() { return m_alfEnabledFlag; }
1315  Void      setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
1316  Bool      getSaoEnabledFlag() { return m_saoEnabledFlag; }
1317#if SAO_UNIT_INTERLEAVING
1318  Void      setSaoInterleavingFlag(Bool s) {m_saoInterleavingFlag =s; } //!< set SAO interleaving flag
1319  Bool      getSaoInterleavingFlag() { return m_saoInterleavingFlag;  } //!< get SAO interleaving flag
1320  Void      setSaoEnabledFlagCb(Bool s) {m_saoEnabledFlagCb =s; }       //!< set SAO Cb enabled flag
1321  Bool      getSaoEnabledFlagCb() { return m_saoEnabledFlagCb; }        //!< get SAO Cb enabled flag
1322  Void      setSaoEnabledFlagCr(Bool s) {m_saoEnabledFlagCr =s; }       //!< set SAO Cr enabled flag
1323  Bool      getSaoEnabledFlagCr() { return m_saoEnabledFlagCr; }        //!< get SAO Cr enabled flag
1324#endif
1325  Void      setRPS          ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
1326  TComReferencePictureSet*  getRPS          () { return m_pcRPS; }
1327  TComReferencePictureSet*  getLocalRPS     () { return &m_LocalRPS; }
1328
1329  Void      setRPSidx          ( Int iBDidx ) { m_iBDidx = iBDidx; }
1330  Int       getRPSidx          () { return m_iBDidx; }
1331  Void      setCombinationBDidx          ( Int iCombinationBDidx ) { m_iCombinationBDidx = iCombinationBDidx; }
1332  Int       getCombinationBDidx          () { return m_iCombinationBDidx; }
1333  Void      setCombineWithReferenceFlag          ( Bool bCombineWithReferenceFlag ) { m_bCombineWithReferenceFlag = bCombineWithReferenceFlag; }
1334  Bool      getCombineWithReferenceFlag          () { return m_bCombineWithReferenceFlag; }
1335  Int       getPrevPOC      ()                          { return  m_prevPOC;       }
1336
1337  TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
1338  Void      setLastIDR(Int iIDRPOC)                       { m_iLastIDR = iIDRPOC; }
1339  Int       getLastIDR()                                  { return m_iLastIDR; }
1340  SliceType getSliceType    ()                          { return  m_eSliceType;         }
1341  Int       getPOC          ()                          { return  m_iPOC;           }
1342  Int       getSliceQp      ()                          { return  m_iSliceQp;           }
1343#if ADAPTIVE_QP_SELECTION
1344  Int       getSliceQpBase  ()                          { return  m_iSliceQpBase;       }
1345#endif
1346  Int       getSliceQpDelta ()                          { return  m_iSliceQpDelta;      }
1347  Bool      getLoopFilterDisable()                      { return  m_bLoopFilterDisable; }
1348  Bool      getLoopFilterOffsetInAPS()                  { return  m_loopFilterOffsetInAPS;}
1349  Bool      getInheritDblParamFromAPS()                 { return  m_inheritDblParamFromAPS; }
1350  Int       getLoopFilterBetaOffset()                   { return  m_loopFilterBetaOffsetDiv2; }
1351  Int       getLoopFilterTcOffset()                     { return  m_loopFilterTcOffsetDiv2; }
1352
1353  Int       getNumRefIdx        ( RefPicList e )                { return  m_aiNumRefIdx[e];             }
1354  TComPic*  getPic              ()                              { return  m_pcPic;                      }
1355  TComPic*  getRefPic           ( RefPicList e, Int iRefIdx)    { return  m_apcRefPicList[e][iRefIdx];  }
1356  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
1357  Int       getRefViewId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefViewIdList[e][iRefIdx]; }
1358  TComPic*  getTexturePic       () const                        { return  m_pcTexturePic; }
1359#if SONY_COLPIC_AVAILABILITY
1360  Int       getViewOrderIdx     ()                                  { return  m_iViewOrderIdx;              }
1361#endif
1362  Int       getDepth            ()                              { return  m_iDepth;                     }
1363  UInt      getColDir           ()                              { return  m_uiColDir;                   }
1364#if COLLOCATED_REF_IDX
1365  Bool      getColRefIdx        ()                              { return  m_colRefIdx;                  }
1366  Void      checkColRefIdx      (UInt curSliceIdx, TComPic* pic);
1367#endif
1368  Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
1369#if H0111_MVD_L1_ZERO
1370  Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
1371#endif
1372  Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
1373  Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
1374  Int       getRefIdxFromIdxOfLC(Int iRefIdx)                   { return m_iRefIdxFromIdxOfLC[iRefIdx];       }
1375  Int       getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx)            { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
1376  Int       getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx)            { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
1377  Bool      getRefPicListModificationFlagLC()                   {return m_bRefPicListModificationFlagLC;}
1378  Void      setRefPicListModificationFlagLC(Bool bflag)         {m_bRefPicListModificationFlagLC=bflag;}     
1379  Bool      getRefPicListCombinationFlag()                      {return m_bRefPicListCombinationFlag;}
1380  Void      setRefPicListCombinationFlag(Bool bflag)            {m_bRefPicListCombinationFlag=bflag;}     
1381  Void      setListIdFromIdxOfLC(Int  iRefIdx, UInt uiVal)      { m_eListIdFromIdxOfLC[iRefIdx]=uiVal; }
1382  Void      setRefIdxFromIdxOfLC(Int  iRefIdx, UInt uiVal)      { m_iRefIdxFromIdxOfLC[iRefIdx]=uiVal; }
1383  Void      setRefIdxOfLC       (RefPicList e, Int iRefIdx, Int RefIdxLC)     { m_iRefIdxOfLC[e][iRefIdx]=RefIdxLC;}
1384
1385  Void      setReferenced(Bool b)                               { m_bRefenced = b; }
1386  Bool      isReferenced()                                      { return m_bRefenced; }
1387 
1388  Void      setPOC              ( Int i )                       { m_iPOC              = i; if(getTLayer()==0) m_prevPOC=i; }
1389  Void      setNalUnitType      ( NalUnitType e )               { m_eNalUnitType      = e;      }
1390  NalUnitType getNalUnitType    ()                              { return m_eNalUnitType;        }
1391  Void      setNalUnitTypeBaseViewMvc  ( NalUnitType e )        { m_eNalUnitTypeBaseViewMvc = e;    }
1392  NalUnitType getNalUnitTypeBaseViewMvc()                       { return m_eNalUnitTypeBaseViewMvc; }
1393  Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, TComList<TComPic*>& rcListPic);
1394  Void      decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
1395  Void      setSliceType        ( SliceType e )                 { m_eSliceType        = e;      }
1396  Void      setSliceQp          ( Int i )                       { m_iSliceQp          = i;      }
1397#if ADAPTIVE_QP_SELECTION
1398  Void      setSliceQpBase      ( Int i )                       { m_iSliceQpBase      = i;      }
1399#endif
1400  Void      setSliceQpDelta     ( Int i )                       { m_iSliceQpDelta     = i;      }
1401  Void      setLoopFilterDisable( Bool b )                      { m_bLoopFilterDisable= b;      }
1402  Void      setLoopFilterOffsetInAPS( Bool b )                  { m_loopFilterOffsetInAPS = b;}
1403  Void      setInheritDblParamFromAPS( Bool b )                 { m_inheritDblParamFromAPS = b; }
1404  Void      setLoopFilterBetaOffset( Int i )                    { m_loopFilterBetaOffsetDiv2 = i; }
1405  Void      setLoopFilterTcOffset( Int i )                      { m_loopFilterTcOffsetDiv2 = i; }
1406 
1407  Void      setRefPic           ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
1408  Void      setRefPOC           ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
1409  Void      setRefViewId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefViewIdList[e][iRefIdx] = i; }
1410  Void      setTexturePic       ( TComPic *pcTexturePic )       { m_pcTexturePic = pcTexturePic; }
1411#if SONY_COLPIC_AVAILABILITY
1412  Void      setViewOrderIdx     ( Int i )                       { m_iViewOrderIdx     = i;      }
1413#endif
1414  Void      setNumRefIdx        ( RefPicList e, Int i )         { m_aiNumRefIdx[e]    = i;      }
1415  Void      setPic              ( TComPic* p )                  { m_pcPic             = p;      }
1416  Void      setDepth            ( Int iDepth )                  { m_iDepth            = iDepth; }
1417 
1418  Int       getNumPocTotalCurr();
1419  Int       getNumPocTotalCurrMvc();
1420#if VSP_N
1421  Void      setRefPicListMvc    ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics, TComPic* pcVspPic );
1422#else
1423  Void      setRefPicListMvc    ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics );
1424#endif
1425  Void      setRefPOCnViewListsMvc();
1426
1427  Void      setColDir           ( UInt uiDir ) { m_uiColDir = uiDir; }
1428#if COLLOCATED_REF_IDX
1429  Void      setColRefIdx        ( UInt refIdx) { m_colRefIdx = refIdx; }
1430#endif
1431  Void      setCheckLDC         ( Bool b )                      { m_bCheckLDC = b; }
1432#if H0111_MVD_L1_ZERO
1433  Void      setMvdL1ZeroFlag     ( Bool b)                       { m_bLMvdL1Zero = b; }
1434#endif 
1435
1436  Bool      isIntra         ()                          { return  m_eSliceType == I_SLICE;  }
1437  Bool      isInterB        ()                          { return  m_eSliceType == B_SLICE;  }
1438  Bool      isInterP        ()                          { return  m_eSliceType == P_SLICE;  }
1439 
1440#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA 
1441  Void      setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
1442  Double    getLambdaLuma() { return m_dLambdaLuma;        }
1443  Double    getLambdaChroma() { return m_dLambdaChroma;        }
1444#else
1445  Void      setLambda( Double d ) { m_dLambda = d; }
1446  Double    getLambda() { return m_dLambda;        }
1447#endif
1448 
1449  Void      initEqualRef();
1450  Bool      isEqualRef  ( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
1451  {
1452    if (iRefIdx1 < 0 || iRefIdx2 < 0) return false;
1453    return m_abEqualRef[e][iRefIdx1][iRefIdx2];
1454  }
1455 
1456  Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
1457  {
1458    m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
1459  }
1460 
1461  static Void      sortPicList         ( TComList<TComPic*>& rcListPic );
1462 
1463  Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
1464  Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
1465  Bool getRefIdxCombineCoding() { return m_bRefIdxCombineCoding; }
1466  Void setRefIdxCombineCoding( Bool b ) { m_bRefIdxCombineCoding = b; }
1467  Void generateCombinedList       ();
1468
1469  UInt getTLayer             ()                            { return m_uiTLayer;                      }
1470  Void setTLayer             ( UInt uiTLayer )             { m_uiTLayer = uiTLayer;                  }
1471
1472#if !H0566_TLA
1473  Bool getTLayerSwitchingFlag()                            { return m_bTLayerSwitchingFlag;          }
1474  Void setTLayerSwitchingFlag( Bool bValue )               { m_bTLayerSwitchingFlag = bValue;        }
1475#endif
1476
1477  Void setTLayerInfo( UInt uiTLayer );
1478  Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum ); 
1479  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
1480#if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
1481  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
1482#endif
1483#if START_DECODING_AT_CRA
1484  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag, Int pocRandomAccess = 0);
1485#else
1486  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag);
1487#endif
1488  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet);
1489
1490  Void decodingMarkingForNoTMVP( TComList<TComPic*>& rcListPic, Int currentPOC );
1491
1492  UInt m_uiMaxNumMergeCand;
1493  Void setMaxNumMergeCand               (UInt maxNumMergeCand ) { m_uiMaxNumMergeCand = maxNumMergeCand;  }
1494  UInt getMaxNumMergeCand               ()                  {return m_uiMaxNumMergeCand;                  }
1495
1496  Void setSliceMode                     ( UInt uiMode )     { m_uiSliceMode = uiMode;                     }
1497  UInt getSliceMode                     ()                  { return m_uiSliceMode;                       }
1498  Void setSliceArgument                 ( UInt uiArgument ) { m_uiSliceArgument = uiArgument;             }
1499  UInt getSliceArgument                 ()                  { return m_uiSliceArgument;                   }
1500  Void setSliceCurStartCUAddr           ( UInt uiAddr )     { m_uiSliceCurStartCUAddr = uiAddr;           }
1501  UInt getSliceCurStartCUAddr           ()                  { return m_uiSliceCurStartCUAddr;             }
1502  Void setSliceCurEndCUAddr             ( UInt uiAddr )     { m_uiSliceCurEndCUAddr = uiAddr;             }
1503  UInt getSliceCurEndCUAddr             ()                  { return m_uiSliceCurEndCUAddr;               }
1504  Void setSliceIdx                      ( UInt i)           { m_uiSliceIdx = i;                           }
1505  UInt getSliceIdx                      ()                  { return  m_uiSliceIdx;                       }
1506  Void copySliceInfo                    (TComSlice *pcSliceSrc);
1507  Void setEntropySliceMode              ( UInt uiMode )     { m_uiEntropySliceMode = uiMode;              }
1508  UInt getEntropySliceMode              ()                  { return m_uiEntropySliceMode;                }
1509  Void setEntropySliceArgument          ( UInt uiArgument ) { m_uiEntropySliceArgument = uiArgument;      }
1510  UInt getEntropySliceArgument          ()                  { return m_uiEntropySliceArgument;            }
1511  Void setEntropySliceCurStartCUAddr    ( UInt uiAddr )     { m_uiEntropySliceCurStartCUAddr = uiAddr;    }
1512  UInt getEntropySliceCurStartCUAddr    ()                  { return m_uiEntropySliceCurStartCUAddr;      }
1513  Void setEntropySliceCurEndCUAddr      ( UInt uiAddr )     { m_uiEntropySliceCurEndCUAddr = uiAddr;      }
1514  UInt getEntropySliceCurEndCUAddr      ()                  { return m_uiEntropySliceCurEndCUAddr;        }
1515  Void setNextSlice                     ( Bool b )          { m_bNextSlice = b;                           }
1516  Bool isNextSlice                      ()                  { return m_bNextSlice;                        }
1517  Void setNextEntropySlice              ( Bool b )          { m_bNextEntropySlice = b;                    }
1518  Bool isNextEntropySlice               ()                  { return m_bNextEntropySlice;                 }
1519  Void setSliceBits                     ( UInt uiVal )      { m_uiSliceBits = uiVal;                      }
1520  UInt getSliceBits                     ()                  { return m_uiSliceBits;                       } 
1521  Void setEntropySliceCounter           ( UInt uiVal )      { m_uiEntropySliceCounter = uiVal;            }
1522  UInt getEntropySliceCounter           ()                  { return m_uiEntropySliceCounter;             }
1523  Void setFinalized                     ( Bool uiVal )      { m_bFinalized = uiVal;                       }
1524  Bool getFinalized                     ()                  { return m_bFinalized;                        }
1525  Void  setWpScaling    ( wpScalingParam  wp[2][MAX_NUM_REF][3] ) { memcpy(m_weightPredTable, wp, sizeof(wpScalingParam)*2*MAX_NUM_REF*3); }
1526  Void  getWpScaling    ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
1527
1528  Void  resetWpScaling  (wpScalingParam  wp[2][MAX_NUM_REF][3]);
1529  Void  initWpScaling    (wpScalingParam  wp[2][MAX_NUM_REF][3]);
1530  Void  initWpScaling   ();
1531  inline Bool applyWP   () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPredIdc()) ); }
1532 
1533  Void  setWpAcDcParam  ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
1534  Void  getWpAcDcParam  ( wpACDCParam *&wp );
1535  Void  initWpAcDcParam ();
1536  Void  copyWPtable     (wpScalingParam *&wp_src, wpScalingParam *&wp_dst);
1537  Void  getWpScalingLC  ( Int iRefIdx, wpScalingParam *&wp);
1538  Void  resetWpScalingLC(wpScalingParam  wp[2*MAX_NUM_REF][3]);
1539  Void  setWpParamforLC();
1540  Void setTileLocationCount             ( UInt uiCount )      { m_uiTileCount = uiCount;                  }
1541  UInt getTileLocationCount             ()                    { return m_uiTileCount;                     }
1542  Void setTileLocation                  ( Int i, UInt uiLOC ) { m_uiTileByteLocation[i] = uiLOC;          }
1543  UInt getTileLocation                  ( Int i )             { return m_uiTileByteLocation[i];           }
1544  Void setTileMarkerFlag                ( Int iFlag )         { m_iTileMarkerFlag = iFlag;                }
1545  Int  getTileMarkerFlag                ()                    { return m_iTileMarkerFlag;                 }
1546  Void setTileOffstForMultES            (UInt uiOffset )      { m_uiTileOffstForMultES = uiOffset;        }
1547  UInt getTileOffstForMultES            ()                    { return m_uiTileOffstForMultES;            }
1548  Void allocSubstreamSizes              ( UInt uiNumSubstreams );
1549  UInt* getSubstreamSizes               ()                  { return m_puiSubstreamSizes; }
1550  Void  setScalingList              ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
1551  TComScalingList*   getScalingList ()                               { return m_scalingList; }
1552  Void  setDefaultScalingList       ();
1553  Bool  checkDefaultScalingList     ();
1554#if CABAC_INIT_FLAG
1555  Void      setCabacInitFlag  ( Bool val ) { m_cabacInitFlag = val;      }  //!< set CABAC initial flag
1556  Bool      getCabacInitFlag  ()           { return m_cabacInitFlag;     }  //!< get CABAC initial flag
1557#else
1558  Void      setCABACinitIDC(Int iVal) {m_cabacInitIdc = iVal;    }  //!< set CABAC initial IDC number
1559  Int       getCABACinitIDC()         {return m_cabacInitIdc;    }  //!< get CABAC initial IDC number
1560#endif
1561#if TILES_WPP_ENTRY_POINT_SIGNALLING
1562  Void      setNumEntryPointOffsets(Int val)  { m_numEntryPointOffsets = val;     }
1563  Int       getNumEntryPointOffsets()         { return m_numEntryPointOffsets;    }
1564#endif
1565
1566  Void setViewId( Int viewId )       { m_viewId = viewId;   }
1567  Int  getViewId()                   { return m_viewId;     }
1568  Void setIsDepth( Bool isDepth )    { m_isDepth = isDepth; }
1569  Bool getIsDepth()                  { return m_isDepth;    }
1570 
1571  Void      initMultiviewSlice    ( Int** aaiScale = 0, Int** aaiOffset = 0 );
1572
1573  Int*      getCodedScale         ()  { return m_aaiCodedScale [0]; }
1574  Int*      getCodedOffset        ()  { return m_aaiCodedOffset[0]; }
1575  Int*      getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
1576  Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
1577
1578#if FORCE_REF_VSP
1579  Void      setRefIdxVsp ( Int idx, Int refList ) { m_iRefIdxVsp[refList] = idx; }
1580  Int       getRefIdxVsp ( Int refList )          { return m_iRefIdxVsp[refList]; }
1581#endif
1582
1583#if VSP_SLICE_HEADER
1584  Void      setVspFlag          ( Bool val )    { m_bVspFlag = val; }
1585  Bool      getVspFlag          ()              { return m_bVspFlag; }
1586#endif
1587
1588protected:
1589  TComPic*  xGetRefPic        (TComList<TComPic*>& rcListPic, UInt uiPOC);
1590  TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, UInt uiPOC);
1591  TComPic*  xGetInterViewRefPic( std::vector<TComPic*>& rcListIvPic, UInt uiViewId );
1592};// END CLASS DEFINITION TComSlice
1593
1594
1595template <class T> class ParameterSetMap
1596{
1597public:
1598  ParameterSetMap(Int maxId)
1599  :m_maxId (maxId)
1600  {}
1601
1602  ~ParameterSetMap()
1603  {
1604    for (typename std::map<Int,T *>::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
1605    {
1606      delete (*i).second;
1607    }
1608  }
1609
1610  Void storePS(Int psId, T *ps)
1611  {
1612    assert ( psId < m_maxId );
1613    if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
1614    {
1615      delete m_paramsetMap[psId];
1616    }
1617    m_paramsetMap[psId] = ps; 
1618  }
1619
1620  Void mergePSList(ParameterSetMap<T> &rPsList)
1621  {
1622    for (typename std::map<Int,T *>::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
1623    {
1624      storePS(i->first, i->second);
1625    }
1626    rPsList.m_paramsetMap.clear();
1627  }
1628
1629
1630  T* getPS(Int psId)
1631  {
1632    return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId];
1633  }
1634
1635  T* getFirstPS()
1636  {
1637    return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second;
1638  }
1639
1640private:
1641  std::map<Int,T *> m_paramsetMap;
1642  Int               m_maxId;
1643};
1644
1645class ParameterSetManager
1646{
1647public:
1648  ParameterSetManager();
1649  virtual ~ParameterSetManager();
1650#if VIDYO_VPS_INTEGRATION
1651  //! store video parameter set and take ownership of it
1652  Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
1653  //! get pointer to existing video parameter set 
1654  TComVPS* getVPS(Int vpsId)  { return m_vpsMap.getPS(vpsId); };
1655  TComVPS* getFirstVPS()      { return m_vpsMap.getFirstPS(); };
1656#endif
1657  //! store sequence parameter set and take ownership of it
1658  Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
1659  //! get pointer to existing sequence parameter set 
1660  TComSPS* getSPS(Int spsId)  { return m_spsMap.getPS(spsId); };
1661  TComSPS* getFirstSPS()      { return m_spsMap.getFirstPS(); };
1662
1663  //! store picture parameter set and take ownership of it
1664  Void storePPS(TComPPS *pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
1665  //! get pointer to existing picture parameter set 
1666  TComPPS* getPPS(Int ppsId)  { return m_ppsMap.getPS(ppsId); };
1667  TComPPS* getFirstPPS()      { return m_ppsMap.getFirstPS(); };
1668
1669  //! store adaptation parameter set and take ownership of it
1670  Void storeAPS(TComAPS *aps) { m_apsMap.storePS( aps->getAPSID(), aps); };
1671  //! getPointer to existing adaptation parameter set 
1672  TComAPS* getAPS(Int apsId)  { return m_apsMap.getPS(apsId); };
1673
1674protected:
1675  ParameterSetMap<TComSPS> m_spsMap; 
1676  ParameterSetMap<TComPPS> m_ppsMap; 
1677  ParameterSetMap<TComAPS> m_apsMap; 
1678#if VIDYO_VPS_INTEGRATION
1679  ParameterSetMap<TComVPS> m_vpsMap; 
1680#endif
1681};
1682
1683//! \}
1684
1685#endif // __TCOMSLICE__
Note: See TracBrowser for help on using the repository browser.