source: SHVCSoftware/branches/SHM-1.1-dev/source/Lib/TLibCommon/TComSlice.h @ 582

Last change on this file since 582 was 42, checked in by seregin, 12 years ago

initializing base layer reference lists by copying the enhancement layer picture lists structure for the AVC metadata file reading
File size: 80.4 KB
RevLine 
[2]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
48//! \ingroup TLibCommon
49//! \{
50
51class TComPic;
52class TComTrQuant;
53
54#if SVC_EXTENSION
55class TComPicYuv;
56#endif
57// ====================================================================================================================
58// Constants
59// ====================================================================================================================
60
61/// max number of supported APS in software
62#define MAX_NUM_SUPPORTED_APS 1
63
64// ====================================================================================================================
65// Class definition
66// ====================================================================================================================
67
68/// Reference Picture Set class
69class TComReferencePictureSet
70{
71private:
72  Int  m_numberOfPictures;
73  Int  m_numberOfNegativePictures;
74  Int  m_numberOfPositivePictures;
75  Int  m_numberOfLongtermPictures;
76  Int  m_deltaPOC[MAX_NUM_REF_PICS];
77  Int  m_POC[MAX_NUM_REF_PICS];
78  Bool m_used[MAX_NUM_REF_PICS];
79  Bool m_interRPSPrediction;
80  Int  m_deltaRIdxMinus1;   
81  Int  m_deltaRPS; 
82  Int  m_numRefIdc; 
83  Int  m_refIdc[MAX_NUM_REF_PICS+1];
84  Bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
85  Int  m_pocLSBLT[MAX_NUM_REF_PICS];
86  Int  m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
87  Bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];
88
89public:
90  TComReferencePictureSet();
91  virtual ~TComReferencePictureSet();
92  Int   getPocLSBLT(Int i)                       { return m_pocLSBLT[i]; }
93  Void  setPocLSBLT(Int i, Int x)                { m_pocLSBLT[i] = x; }
94  Int   getDeltaPocMSBCycleLT(Int i)             { return m_deltaPOCMSBCycleLT[i]; }
95  Void  setDeltaPocMSBCycleLT(Int i, Int x)      { m_deltaPOCMSBCycleLT[i] = x; }
96  Bool  getDeltaPocMSBPresentFlag(Int i)         { return m_deltaPocMSBPresentFlag[i]; }
97  Void  setDeltaPocMSBPresentFlag(Int i, Bool x) { m_deltaPocMSBPresentFlag[i] = x;    }
98  Void setUsed(Int bufferNum, Bool used);
99  Void setDeltaPOC(Int bufferNum, Int deltaPOC);
100  Void setPOC(Int bufferNum, Int deltaPOC);
101  Void setNumberOfPictures(Int numberOfPictures);
102  Void setCheckLTMSBPresent(Int bufferNum, Bool b );
103  Bool getCheckLTMSBPresent(Int bufferNum);
104
105  Int  getUsed(Int bufferNum);
106  Int  getDeltaPOC(Int bufferNum);
107  Int  getPOC(Int bufferNum);
108  Int  getNumberOfPictures();
109
110  Void setNumberOfNegativePictures(Int number)  { m_numberOfNegativePictures = number; }
111  Int  getNumberOfNegativePictures()            { return m_numberOfNegativePictures; }
112  Void setNumberOfPositivePictures(Int number)  { m_numberOfPositivePictures = number; }
113  Int  getNumberOfPositivePictures()            { return m_numberOfPositivePictures; }
114  Void setNumberOfLongtermPictures(Int number)  { m_numberOfLongtermPictures = number; }
115  Int  getNumberOfLongtermPictures()            { return m_numberOfLongtermPictures; }
116
117  Void setInterRPSPrediction(Bool flag)         { m_interRPSPrediction = flag; }
118  Bool getInterRPSPrediction()                  { return m_interRPSPrediction; }
119  Void setDeltaRIdxMinus1(Int x)                { m_deltaRIdxMinus1 = x; }
120  Int  getDeltaRIdxMinus1()                     { return m_deltaRIdxMinus1; }
121  Void setDeltaRPS(Int x)                       { m_deltaRPS = x; }
122  Int  getDeltaRPS()                            { return m_deltaRPS; }
123  Void setNumRefIdc(Int x)                      { m_numRefIdc = x; }
124  Int  getNumRefIdc()                           { return m_numRefIdc; }
125
126  Void setRefIdc(Int bufferNum, Int refIdc);
127  Int  getRefIdc(Int bufferNum);
128
129  Void sortDeltaPOC();
130  Void printDeltaPOC();
131};
132
133/// Reference Picture Set set class
134class TComRPSList
135{
136private:
137  Int  m_numberOfReferencePictureSets;
138  TComReferencePictureSet* m_referencePictureSets;
139 
140public:
141  TComRPSList();
142  virtual ~TComRPSList();
143 
144  Void  create  (Int numberOfEntries);
145  Void  destroy ();
146
147
148  TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
149  Int getNumberOfReferencePictureSets();
150  Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
151};
152
153/// SCALING_LIST class
154class TComScalingList
155{
156public:
157  TComScalingList();
158  virtual ~TComScalingList();
159  Void     setScalingListPresentFlag    (Bool b)                               { m_scalingListPresentFlag = b;    }
160  Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
161#if TS_FLAT_QUANTIZATION_MATRIX
162  Bool     getUseTransformSkip    ()                                     { return m_useTransformSkip; }     
163  Void     setUseTransformSkip    (Bool b)                               { m_useTransformSkip = b;    }
164#endif
165  Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
166  Bool     checkPredMode                  (UInt sizeId, UInt listId);
167  Void     setRefMatrixId                 (UInt sizeId, UInt listId, UInt u)   { m_refMatrixId[sizeId][listId] = u;    }     //!< set reference matrix ID
168  UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
169  Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
170  Void     processDefaultMarix            (UInt sizeId, UInt listId);
171  Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
172
173  Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
174  Void     checkDcOfMatrix                ();
175  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
176  Bool     xParseScalingList              (char* pchFile);
177
178private:
179  Void     init                    ();
180  Void     destroy                 ();
181  Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
182  Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
183  UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
184  Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
185  UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
186  Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
187#if TS_FLAT_QUANTIZATION_MATRIX
188  Bool     m_useTransformSkip;                                                      //!< transform skipping flag for setting default scaling matrix for 4x4
189#endif
190};
191
192#if PROFILE_TIER_LEVEL_SYNTAX
193class ProfileTierLevel{
194  Int     m_profileSpace;
195  Bool    m_tierFlag;
196  Int     m_profileIdc;
197  Bool    m_profileCompatibilityFlag[32];
198  Int     m_levelIdc;
199
200public:
201  ProfileTierLevel();
202
203  Int   getProfileSpace() const   { return m_profileSpace; }
204  Void  setProfileSpace(Int x)    { m_profileSpace = x; }
205
206  Bool  getTierFlag()     const   { return m_tierFlag; }
207  Void  setTierFlag(Bool x)       { m_tierFlag = x; }
208
209  Int   getProfileIdc()   const   { return m_profileIdc; }
210  Void  setProfileIdc(Int x)      { m_profileIdc = x; }
211
212  Bool  getProfileCompatibilityFlag(Int i) const    { return m_profileCompatibilityFlag[i]; }
213  Void  setProfileCompatibilityFlag(Int i, Bool x)  { m_profileCompatibilityFlag[i] = x; }
214
215  Int   getLevelIdc()   const   { return m_levelIdc; }
216  Void  setLevelIdc(Int x)      { m_levelIdc = x; }
217};
218
219
220class TComPTL{
221  ProfileTierLevel m_generalPTL;
222  ProfileTierLevel m_subLayerPTL[6];      // max. value of max_sub_layers_minus1 is 6
223  Bool m_subLayerProfilePresentFlag[6];
224  Bool m_subLayerLevelPresentFlag[6];
225
226public:
227  TComPTL();
228  Bool getSubLayerProfilePresentFlag(Int i) const { return m_subLayerProfilePresentFlag[i]; }
229  Void setSubLayerProfilePresentFlag(Int i, Bool x) { m_subLayerProfilePresentFlag[i] = x; }
230 
231  Bool getSubLayerLevelPresentFlag(Int i) const { return m_subLayerLevelPresentFlag[i]; }
232  Void setSubLayerLevelPresentFlag(Int i, Bool x) { m_subLayerLevelPresentFlag[i] = x; }
233
234  ProfileTierLevel* getGeneralPTL()  { return &m_generalPTL; }
235  ProfileTierLevel* getSubLayerPTL(Int i)  { return &m_subLayerPTL[i]; }
236};
237#endif
238/// VPS class
239
240class TComVPS
241{
242private:
243  Int         m_VPSId;
244  UInt        m_uiMaxTLayers;
245  UInt        m_uiMaxLayers;
246  Bool        m_bTemporalIdNestingFlag;
247 
248  UInt        m_numReorderPics[MAX_TLAYER];
249  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER]; 
250  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
251#if VPS_SYNTAX_CHANGES
252  TComPTL     m_pcPTL;
253#endif
254public:
255  TComVPS();
256  virtual ~TComVPS();
257
258  Int     getVPSId       ()                   { return m_VPSId;          }
259  Void    setVPSId       (Int i)              { m_VPSId = i;             }
260
261  UInt    getMaxTLayers  ()                   { return m_uiMaxTLayers;   }
262  Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
263 
264  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
265  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
266
267  Bool    getTemporalNestingFlag   ()         { return m_bTemporalIdNestingFlag;   }
268  Void    setTemporalNestingFlag   (Bool t)   { m_bTemporalIdNestingFlag = t; }
269 
270  Void    setNumReorderPics(UInt v, UInt tLayer)                { m_numReorderPics[tLayer] = v;    }
271  UInt    getNumReorderPics(UInt tLayer)                        { return m_numReorderPics[tLayer]; }
272 
273  Void    setMaxDecPicBuffering(UInt v, UInt tLayer)            { m_uiMaxDecPicBuffering[tLayer] = v;    }
274  UInt    getMaxDecPicBuffering(UInt tLayer)                    { return m_uiMaxDecPicBuffering[tLayer]; }
275 
276  Void    setMaxLatencyIncrease(UInt v, UInt tLayer)            { m_uiMaxLatencyIncrease[tLayer] = v;    }
277  UInt    getMaxLatencyIncrease(UInt tLayer)                    { return m_uiMaxLatencyIncrease[tLayer]; }
278#if VPS_SYNTAX_CHANGES
279  TComPTL* getPTL() { return &m_pcPTL; }
280#endif 
281};
282
283#if BUFFERING_PERIOD_AND_TIMING_SEI
284struct HrdSubLayerInfo
285{
286  Bool fixedPicRateFlag;
287  UInt picDurationInTcMinus1;
288  Bool lowDelayHrdFlag;
289  UInt cpbCntMinus1;
290  UInt bitRateValueMinus1[MAX_CPB_CNT][2];
291  UInt cpbSizeValue      [MAX_CPB_CNT][2];
292  UInt cbrFlag           [MAX_CPB_CNT][2];
293};
294#endif
295#if SUPPORT_FOR_VUI
296class TComVUI
297{
298private:
299  Bool m_aspectRatioInfoPresentFlag;
300  Int  m_aspectRatioIdc;
301  Int  m_sarWidth;
302  Int  m_sarHeight;
303  Bool m_overscanInfoPresentFlag;
304  Bool m_overscanAppropriateFlag;
305  Bool m_videoSignalTypePresentFlag;
306  Int  m_videoFormat;
307  Bool m_videoFullRangeFlag;
308  Bool m_colourDescriptionPresentFlag;
309  Int  m_colourPrimaries;
310  Int  m_transferCharacteristics;
311  Int  m_matrixCoefficients;
312  Bool m_chromaLocInfoPresentFlag;
313  Int  m_chromaSampleLocTypeTopField;
314  Int  m_chromaSampleLocTypeBottomField;
315  Bool m_neutralChromaIndicationFlag;
316  Bool m_fieldSeqFlag;
317  Bool m_hrdParametersPresentFlag;
318  Bool m_bitstreamRestrictionFlag;
319  Bool m_tilesFixedStructureFlag;
320  Bool m_motionVectorsOverPicBoundariesFlag;
321  Int  m_maxBytesPerPicDenom;
322  Int  m_maxBitsPerMinCuDenom;
323  Int  m_log2MaxMvLengthHorizontal;
324  Int  m_log2MaxMvLengthVertical;
325#if BUFFERING_PERIOD_AND_TIMING_SEI
326  Bool m_timingInfoPresentFlag;
327  UInt m_numUnitsInTick;
328  UInt m_timeScale;
329  Bool m_nalHrdParametersPresentFlag;
330  Bool m_vclHrdParametersPresentFlag;
331  Bool m_subPicCpbParamsPresentFlag;
332  UInt m_tickDivisorMinus2;
333  UInt m_duCpbRemovalDelayLengthMinus1;
334  UInt m_bitRateScale;
335  UInt m_cpbSizeScale;
336  UInt m_initialCpbRemovalDelayLengthMinus1;
337  UInt m_cpbRemovalDelayLengthMinus1;
338  UInt m_dpbOutputDelayLengthMinus1;
339  UInt m_numDU;
340  HrdSubLayerInfo m_HRD[MAX_TLAYER];
341#endif
342public:
343  TComVUI()
344    :m_aspectRatioInfoPresentFlag(false)
345    ,m_aspectRatioIdc(0)
346    ,m_sarWidth(0)
347    ,m_sarHeight(0)
348    ,m_overscanInfoPresentFlag(false)
349    ,m_overscanAppropriateFlag(false)
350    ,m_videoSignalTypePresentFlag(false)
351    ,m_videoFormat(5)
352    ,m_videoFullRangeFlag(false)
353    ,m_colourDescriptionPresentFlag(false)
354    ,m_colourPrimaries(2)
355    ,m_transferCharacteristics(2)
356    ,m_matrixCoefficients(2)
357    ,m_chromaLocInfoPresentFlag(false)
358    ,m_chromaSampleLocTypeTopField(0)
359    ,m_chromaSampleLocTypeBottomField(0)
360    ,m_neutralChromaIndicationFlag(false)
361    ,m_fieldSeqFlag(false)
362    ,m_hrdParametersPresentFlag(false)
363    ,m_bitstreamRestrictionFlag(false)
364    ,m_tilesFixedStructureFlag(false)
365    ,m_motionVectorsOverPicBoundariesFlag(true)
366    ,m_maxBytesPerPicDenom(2)
367    ,m_maxBitsPerMinCuDenom(1)
368    ,m_log2MaxMvLengthHorizontal(15)
369    ,m_log2MaxMvLengthVertical(15)
370#if BUFFERING_PERIOD_AND_TIMING_SEI
371    ,m_timingInfoPresentFlag(false)
372    ,m_numUnitsInTick(1001)
373    ,m_timeScale(60000)
374    ,m_nalHrdParametersPresentFlag(0)
375    ,m_vclHrdParametersPresentFlag(0)
376    ,m_subPicCpbParamsPresentFlag(false)
377    ,m_tickDivisorMinus2(0)
378    ,m_duCpbRemovalDelayLengthMinus1(0)
379    ,m_bitRateScale(0)
380    ,m_cpbSizeScale(0)
381    ,m_initialCpbRemovalDelayLengthMinus1(0)
382    ,m_cpbRemovalDelayLengthMinus1(0)
383    ,m_dpbOutputDelayLengthMinus1(0)
384#endif
385  {}
386
387  virtual ~TComVUI() {}
388
389  Bool getAspectRatioInfoPresentFlag() { return m_aspectRatioInfoPresentFlag; }
390  Void setAspectRatioInfoPresentFlag(Bool i) { m_aspectRatioInfoPresentFlag = i; }
391
392  Int getAspectRatioIdc() { return m_aspectRatioIdc; }
393  Void setAspectRatioIdc(Int i) { m_aspectRatioIdc = i; }
394
395  Int getSarWidth() { return m_sarWidth; }
396  Void setSarWidth(Int i) { m_sarWidth = i; }
397
398  Int getSarHeight() { return m_sarHeight; }
399  Void setSarHeight(Int i) { m_sarHeight = i; }
400
401  Bool getOverscanInfoPresentFlag() { return m_overscanInfoPresentFlag; }
402  Void setOverscanInfoPresentFlag(Bool i) { m_overscanInfoPresentFlag = i; }
403
404  Bool getOverscanAppropriateFlag() { return m_overscanAppropriateFlag; }
405  Void setOverscanAppropriateFlag(Bool i) { m_overscanAppropriateFlag = i; }
406
407  Bool getVideoSignalTypePresentFlag() { return m_videoSignalTypePresentFlag; }
408  Void setVideoSignalTypePresentFlag(Bool i) { m_videoSignalTypePresentFlag = i; }
409
410  Int getVideoFormat() { return m_videoFormat; }
411  Void setVideoFormat(Int i) { m_videoFormat = i; }
412
413  Bool getVideoFullRangeFlag() { return m_videoFullRangeFlag; }
414  Void setVideoFullRangeFlag(Bool i) { m_videoFullRangeFlag = i; }
415
416  Bool getColourDescriptionPresentFlag() { return m_colourDescriptionPresentFlag; }
417  Void setColourDescriptionPresentFlag(Bool i) { m_colourDescriptionPresentFlag = i; }
418
419  Int getColourPrimaries() { return m_colourPrimaries; }
420  Void setColourPrimaries(Int i) { m_colourPrimaries = i; }
421
422  Int getTransferCharacteristics() { return m_transferCharacteristics; }
423  Void setTransferCharacteristics(Int i) { m_transferCharacteristics = i; }
424
425  Int getMatrixCoefficients() { return m_matrixCoefficients; }
426  Void setMatrixCoefficients(Int i) { m_matrixCoefficients = i; }
427
428  Bool getChromaLocInfoPresentFlag() { return m_chromaLocInfoPresentFlag; }
429  Void setChromaLocInfoPresentFlag(Bool i) { m_chromaLocInfoPresentFlag = i; }
430
431  Int getChromaSampleLocTypeTopField() { return m_chromaSampleLocTypeTopField; }
432  Void setChromaSampleLocTypeTopField(Int i) { m_chromaSampleLocTypeTopField = i; }
433
434  Int getChromaSampleLocTypeBottomField() { return m_chromaSampleLocTypeBottomField; }
435  Void setChromaSampleLocTypeBottomField(Int i) { m_chromaSampleLocTypeBottomField = i; }
436
437  Bool getNeutralChromaIndicationFlag() { return m_neutralChromaIndicationFlag; }
438  Void setNeutralChromaIndicationFlag(Bool i) { m_neutralChromaIndicationFlag = i; }
439
440  Bool getFieldSeqFlag() { return m_fieldSeqFlag; }
441  Void setFieldSeqFlag(Bool i) { m_fieldSeqFlag = i; }
442
443  Bool getHrdParametersPresentFlag() { return m_hrdParametersPresentFlag; }
444  Void setHrdParametersPresentFlag(Bool i) { m_hrdParametersPresentFlag = i; }
445
446  Bool getBitstreamRestrictionFlag() { return m_bitstreamRestrictionFlag; }
447  Void setBitstreamRestrictionFlag(Bool i) { m_bitstreamRestrictionFlag = i; }
448
449  Bool getTilesFixedStructureFlag() { return m_tilesFixedStructureFlag; }
450  Void setTilesFixedStructureFlag(Bool i) { m_tilesFixedStructureFlag = i; }
451
452  Bool getMotionVectorsOverPicBoundariesFlag() { return m_motionVectorsOverPicBoundariesFlag; }
453  Void setMotionVectorsOverPicBoundariesFlag(Bool i) { m_motionVectorsOverPicBoundariesFlag = i; }
454
455  Int getMaxBytesPerPicDenom() { return m_maxBytesPerPicDenom; }
456  Void setMaxBytesPerPicDenom(Int i) { m_maxBytesPerPicDenom = i; }
457
458  Int getMaxBitsPerMinCuDenom() { return m_maxBitsPerMinCuDenom; }
459  Void setMaxBitsPerMinCuDenom(Int i) { m_maxBitsPerMinCuDenom = i; }
460
461  Int getLog2MaxMvLengthHorizontal() { return m_log2MaxMvLengthHorizontal; }
462  Void setLog2MaxMvLengthHorizontal(Int i) { m_log2MaxMvLengthHorizontal = i; }
463
464  Int getLog2MaxMvLengthVertical() { return m_log2MaxMvLengthVertical; }
465  Void setLog2MaxMvLengthVertical(Int i) { m_log2MaxMvLengthVertical = i; }
466
467#if BUFFERING_PERIOD_AND_TIMING_SEI
468  Void setTimingInfoPresentFlag             ( Bool flag )  { m_timingInfoPresentFlag = flag;               }
469  Bool getTimingInfoPresentFlag             ( )            { return m_timingInfoPresentFlag;               }
470
471  Void setNumUnitsInTick                    ( UInt value ) { m_numUnitsInTick = value;                     }
472  UInt getNumUnitsInTick                    ( )            { return m_numUnitsInTick;                      }
473
474  Void setTimeScale                         ( UInt value ) { m_timeScale = value;                          }
475  UInt getTimeScale                         ( )            { return m_timeScale;                           }
476
477  Void setNalHrdParametersPresentFlag       ( Bool flag )  { m_nalHrdParametersPresentFlag = flag;         }
478  Bool getNalHrdParametersPresentFlag       ( )            { return m_nalHrdParametersPresentFlag;         }
479
480  Void setVclHrdParametersPresentFlag       ( Bool flag )  { m_vclHrdParametersPresentFlag = flag;         }
481  Bool getVclHrdParametersPresentFlag       ( )            { return m_vclHrdParametersPresentFlag;         }
482
483  Void setSubPicCpbParamsPresentFlag        ( Bool flag )  { m_subPicCpbParamsPresentFlag = flag;          }
484  Bool getSubPicCpbParamsPresentFlag        ( )            { return m_subPicCpbParamsPresentFlag;          }
485 
486  Void setTickDivisorMinus2                 ( UInt value ) { m_tickDivisorMinus2 = value;                  }
487  UInt getTickDivisorMinus2                 ( )            { return m_tickDivisorMinus2;                   }
488
489  Void setDuCpbRemovalDelayLengthMinus1     ( UInt value ) { m_duCpbRemovalDelayLengthMinus1 = value;      }
490  UInt getDuCpbRemovalDelayLengthMinus1     ( )            { return m_duCpbRemovalDelayLengthMinus1;       }
491
492  Void setBitRateScale                      ( UInt value ) { m_bitRateScale = value;                       }
493  UInt getBitRateScale                      ( )            { return m_bitRateScale;                        }
494
495  Void setCpbSizeScale                      ( UInt value ) { m_cpbSizeScale = value;                       }
496  UInt getCpbSizeScale                      ( )            { return m_cpbSizeScale;                        }
497
498  Void setInitialCpbRemovalDelayLengthMinus1( UInt value ) { m_initialCpbRemovalDelayLengthMinus1 = value; }
499  UInt getInitialCpbRemovalDelayLengthMinus1( )            { return m_initialCpbRemovalDelayLengthMinus1;  }
500
501  Void setCpbRemovalDelayLengthMinus1       ( UInt value ) { m_cpbRemovalDelayLengthMinus1 = value;        }
502  UInt getCpbRemovalDelayLengthMinus1       ( )            { return m_cpbRemovalDelayLengthMinus1;         }
503
504  Void setDpbOutputDelayLengthMinus1        ( UInt value ) { m_dpbOutputDelayLengthMinus1 = value;         }
505  UInt getDpbOutputDelayLengthMinus1        ( )            { return m_dpbOutputDelayLengthMinus1;          }
506
507  Void setFixedPicRateFlag       ( Int layer, Bool flag )  { m_HRD[layer].fixedPicRateFlag = flag;         }
508  Bool getFixedPicRateFlag       ( Int layer            )  { return m_HRD[layer].fixedPicRateFlag;         }
509
510  Void setPicDurationInTcMinus1  ( Int layer, UInt value ) { m_HRD[layer].picDurationInTcMinus1 = value;   }
511  UInt getPicDurationInTcMinus1  ( Int layer             ) { return m_HRD[layer].picDurationInTcMinus1;    }
512
513  Void setLowDelayHrdFlag        ( Int layer, Bool flag )  { m_HRD[layer].lowDelayHrdFlag = flag;          }
514  Bool getLowDelayHrdFlag        ( Int layer            )  { return m_HRD[layer].lowDelayHrdFlag;          }
515
516  Void setCpbCntMinus1           ( Int layer, UInt value ) { m_HRD[layer].cpbCntMinus1 = value; }
517  UInt getCpbCntMinus1           ( Int layer            )  { return m_HRD[layer].cpbCntMinus1; }
518
519  Void setBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
520  UInt getBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl];  }
521
522  Void setCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl] = value;       }
523  UInt getCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl            )  { return m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl];        }
524
525  Void setCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value;            }
526  Bool getCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl];             }
527
528  Void setNumDU                              ( UInt value ) { m_numDU = value;                            }
529  UInt getNumDU                              ( )            { return m_numDU;          }
530#endif
531};
532#endif
533
534/// SPS class
535class TComSPS
536{
537private:
538  Int         m_SPSId;
539#if !SPS_SYNTAX_CHANGES
540  Int         m_ProfileSpace;
541  Int         m_ProfileIdc;
542  Int         m_ReservedIndicatorFlags;
543  Int         m_LevelIdc;
544  UInt        m_ProfileCompatibility;
545#endif
546  Int         m_VPSId;
547  Int         m_chromaFormatIdc;
548
549  UInt        m_uiMaxTLayers;           // maximum number of temporal layers
550
551  // Structure
552  UInt        m_picWidthInLumaSamples;
553  UInt        m_picHeightInLumaSamples;
554  Bool        m_picCroppingFlag;
555  Int         m_picCropLeftOffset;
556  Int         m_picCropRightOffset;
557  Int         m_picCropTopOffset;
558  Int         m_picCropBottomOffset;
559  UInt        m_uiMaxCUWidth;
560  UInt        m_uiMaxCUHeight;
561  UInt        m_uiMaxCUDepth;
562  UInt        m_uiMinTrDepth;
563  UInt        m_uiMaxTrDepth;
564  TComRPSList m_RPSList;
565  Bool        m_bLongTermRefsPresent;
566  Bool        m_TMVPFlagsPresent;
567  Int         m_numReorderPics[MAX_TLAYER];
568 
569  // Tool list
570  UInt        m_uiQuadtreeTULog2MaxSize;
571  UInt        m_uiQuadtreeTULog2MinSize;
572  UInt        m_uiQuadtreeTUMaxDepthInter;
573  UInt        m_uiQuadtreeTUMaxDepthIntra;
574  Bool        m_usePCM;
575  UInt        m_pcmLog2MaxSize;
576  UInt        m_uiPCMLog2MinSize;
577  Bool        m_useAMP;
578#if !REMOVE_ALF
579  Bool        m_bUseALF;
580#endif
581#if !REMOVE_LMCHROMA
582  Bool        m_bUseLMChroma; // JL:
583#endif
584
585#if !PPS_TS_FLAG
586  Bool        m_useTransformSkip;
587  Bool        m_useTransformSkipFast;
588#endif
589
590  Bool        m_bUseLComb;
591#if !REMOVE_NSQT
592  Bool        m_useNSQT;
593#endif
594 
595  Bool        m_restrictedRefPicListsFlag;
596  Bool        m_listsModificationPresentFlag;
597
598  // Parameter
599#if !SPS_AMVP_CLEANUP
600  AMVP_MODE   m_aeAMVPMode[MAX_CU_DEPTH];
601#endif
602  UInt        m_uiBitDepth;
603  UInt        m_uiBitIncrement;
604  Int         m_qpBDOffsetY;
605  Int         m_qpBDOffsetC;
606
607  Bool        m_useLossless;
608
609  UInt        m_uiPCMBitDepthLuma;
610  UInt        m_uiPCMBitDepthChroma;
611  Bool        m_bPCMFilterDisableFlag;
612
613  UInt        m_uiBitsForPOC;
614#if LTRP_IN_SPS
615  UInt        m_numLongTermRefPicSPS;
616  UInt        m_ltRefPicPocLsbSps[33];
617  Bool        m_usedByCurrPicLtSPSFlag[33];
618#endif
619  // Max physical transform size
620  UInt        m_uiMaxTrSize;
621 
622  Int m_iAMPAcc[MAX_CU_DEPTH];
623#if !MOVE_LOOP_FILTER_SLICES_FLAG
624  Bool        m_bLFCrossSliceBoundaryFlag;
625#endif
626  Bool        m_bUseSAO; 
627
628  Bool        m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
629
630  Bool        m_scalingListEnabledFlag;
631  Bool        m_scalingListPresentFlag;
632  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
633  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER]; 
634  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
635
636  Bool        m_useDF;
637
638#if SUPPORT_FOR_VUI
639  Bool        m_vuiParametersPresentFlag;
640  TComVUI     m_vuiParameters;
641#endif
642
643  static const Int   m_cropUnitX[MAX_CHROMA_FORMAT_IDC+1];
644  static const Int   m_cropUnitY[MAX_CHROMA_FORMAT_IDC+1];
645#if SPS_SYNTAX_CHANGES
646  TComPTL     m_pcPTL;
647#endif
648#if SVC_EXTENSION
649  UInt m_layerId;
650#endif
[28]651#if REF_IDX_MFM
652  Bool m_bMFMEnabledFlag;
653#endif
[2]654public:
655  TComSPS();
656  virtual ~TComSPS();
657
658  Int  getVPSId       ()         { return m_VPSId;          }
659  Void setVPSId       (Int i)    { m_VPSId = i;             }
660  Int  getSPSId       ()         { return m_SPSId;          }
661  Void setSPSId       (Int i)    { m_SPSId = i;             }
662#if !SPS_SYNTAX_CHANGES
663  Int  getProfileSpace  ()       { return m_ProfileSpace;   }
664  Void setProfileSpace  (Int i)  { m_ProfileSpace = i;      }
665  Int  getProfileIdc  ()         { return m_ProfileIdc;     }
666  Void setProfileIdc  (Int i)    { m_ProfileIdc = i; if (m_ProfileSpace == 0) m_ProfileCompatibility |= (1 << (i - 1));    }
667  Int  getRsvdIndFlags  ()       { return m_ReservedIndicatorFlags;     }
668  Void setRsvdIndFlags  (Int i)  { m_ReservedIndicatorFlags = i;        }
669  Int  getLevelIdc    ()         { return m_LevelIdc;       }
670  Void setLevelIdc    (Int i)    { m_LevelIdc = i;          }
671  UInt getProfileCompat ()       { return m_ProfileCompatibility;       }
672  Void setProfileCompat (UInt i) { m_ProfileCompatibility = i; if (m_ProfileIdc != 0 && m_ProfileSpace == 0) m_ProfileCompatibility |= (1 << (m_ProfileIdc - 1));          }
673#endif
674  Int  getChromaFormatIdc ()         { return m_chromaFormatIdc;       }
675  Void setChromaFormatIdc (Int i)    { m_chromaFormatIdc = i;          }
676
677  static Int getCropUnitX (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_cropUnitX[chromaFormatIdc];      }
678  static Int getCropUnitY (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_cropUnitY[chromaFormatIdc];      }
679 
680  // structure
681  Void setPicWidthInLumaSamples       ( UInt u ) { m_picWidthInLumaSamples = u;        }
682  UInt getPicWidthInLumaSamples       ()         { return  m_picWidthInLumaSamples;    }
683  Void setPicHeightInLumaSamples      ( UInt u ) { m_picHeightInLumaSamples = u;       }
684  UInt getPicHeightInLumaSamples      ()         { return  m_picHeightInLumaSamples;   }
685
686  Bool getPicCroppingFlag() const          { return m_picCroppingFlag; }
687  Void setPicCroppingFlag(Bool val)        { m_picCroppingFlag = val; }
688  Int  getPicCropLeftOffset() const        { return m_picCropLeftOffset; }
689  Void setPicCropLeftOffset(Int val)       { m_picCropLeftOffset = val; }
690  Int  getPicCropRightOffset() const       { return m_picCropRightOffset; }
691  Void setPicCropRightOffset(Int val)      { m_picCropRightOffset = val; }
692  Int  getPicCropTopOffset() const         { return m_picCropTopOffset; }
693  Void setPicCropTopOffset(Int val)        { m_picCropTopOffset = val; }
694  Int  getPicCropBottomOffset() const      { return m_picCropBottomOffset; }
695  Void setPicCropBottomOffset(Int val)     { m_picCropBottomOffset = val; }
696#if LTRP_IN_SPS
697  UInt  getNumLongTermRefPicSPS()             { return m_numLongTermRefPicSPS; }
698  Void  setNumLongTermRefPicSPS(UInt val)     { m_numLongTermRefPicSPS = val; }
699
700  UInt  getLtRefPicPocLsbSps(UInt index)             { return m_ltRefPicPocLsbSps[index]; }
701  Void  setLtRefPicPocLsbSps(UInt index, UInt val)     { m_ltRefPicPocLsbSps[index] = val; }
702
703  Bool getUsedByCurrPicLtSPSFlag(Int i)        {return m_usedByCurrPicLtSPSFlag[i];}
704  Void setUsedByCurrPicLtSPSFlag(Int i, Bool x)      { m_usedByCurrPicLtSPSFlag[i] = x;}
705#endif
706  Void setMaxCUWidth  ( UInt u ) { m_uiMaxCUWidth = u;      }
707  UInt getMaxCUWidth  ()         { return  m_uiMaxCUWidth;  }
708  Void setMaxCUHeight ( UInt u ) { m_uiMaxCUHeight = u;     }
709  UInt getMaxCUHeight ()         { return  m_uiMaxCUHeight; }
710  Void setMaxCUDepth  ( UInt u ) { m_uiMaxCUDepth = u;      }
711  UInt getMaxCUDepth  ()         { return  m_uiMaxCUDepth;  }
712  Void setUsePCM      ( Bool b ) { m_usePCM = b;           }
713  Bool getUsePCM      ()         { return m_usePCM;        }
714  Void setPCMLog2MaxSize  ( UInt u ) { m_pcmLog2MaxSize = u;      }
715  UInt getPCMLog2MaxSize  ()         { return  m_pcmLog2MaxSize;  }
716  Void setPCMLog2MinSize  ( UInt u ) { m_uiPCMLog2MinSize = u;      }
717  UInt getPCMLog2MinSize  ()         { return  m_uiPCMLog2MinSize;  }
718  Void setBitsForPOC  ( UInt u ) { m_uiBitsForPOC = u;      }
719  UInt getBitsForPOC  ()         { return m_uiBitsForPOC;   }
720  Bool getUseAMP() { return m_useAMP; }
721  Void setUseAMP( Bool b ) { m_useAMP = b; }
722  Void setMinTrDepth  ( UInt u ) { m_uiMinTrDepth = u;      }
723  UInt getMinTrDepth  ()         { return  m_uiMinTrDepth;  }
724  Void setMaxTrDepth  ( UInt u ) { m_uiMaxTrDepth = u;      }
725  UInt getMaxTrDepth  ()         { return  m_uiMaxTrDepth;  }
726  Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u;    }
727  UInt getQuadtreeTULog2MaxSize()         { return m_uiQuadtreeTULog2MaxSize; }
728  Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u;    }
729  UInt getQuadtreeTULog2MinSize()         { return m_uiQuadtreeTULog2MinSize; }
730  Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u;    }
731  Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u;    }
732  UInt getQuadtreeTUMaxDepthInter()         { return m_uiQuadtreeTUMaxDepthInter; }
733  UInt getQuadtreeTUMaxDepthIntra()         { return m_uiQuadtreeTUMaxDepthIntra; }
734  Void setNumReorderPics(Int i, UInt tlayer)              { m_numReorderPics[tlayer] = i;    }
735  Int  getNumReorderPics(UInt tlayer)                     { return m_numReorderPics[tlayer]; }
736  Void         createRPSList( Int numRPS );
737  TComRPSList* getRPSList()                      { return &m_RPSList;          }
738  Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
739  Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
740  Bool      getTMVPFlagsPresent()         { return m_TMVPFlagsPresent; }
741  Void      setTMVPFlagsPresent(Bool b)   { m_TMVPFlagsPresent=b;      } 
742  // physical transform
743  Void setMaxTrSize   ( UInt u ) { m_uiMaxTrSize = u;       }
744  UInt getMaxTrSize   ()         { return  m_uiMaxTrSize;   }
745 
746  // Tool list
747#if !REMOVE_ALF
748  Bool getUseALF      ()         { return m_bUseALF;        }
749  Void setUseALF      ( Bool b ) { m_bUseALF  = b;          }
750#endif
751  Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
752  Bool getUseLComb    ()         { return m_bUseLComb;      }
753#if !REMOVE_LMCHROMA
754  Bool getUseLMChroma ()         { return m_bUseLMChroma;        }
755  Void setUseLMChroma ( Bool b ) { m_bUseLMChroma  = b;          }
756#endif
757
758#if !PPS_TS_FLAG
759  Bool getUseTransformSkip       ()         { return m_useTransformSkip;     }
760  Void setUseTransformSkip       ( Bool b ) { m_useTransformSkip  = b;       }
761  Bool getUseTransformSkipFast   ()         { return m_useTransformSkipFast; }
762  Void setUseTransformSkipFast   ( Bool b ) { m_useTransformSkipFast  = b;   }
763#endif
764
765  Bool getUseLossless ()         { return m_useLossless; }
766  Void setUseLossless ( Bool b ) { m_useLossless  = b; }
767#if !REMOVE_NSQT
768  Bool getUseNSQT() { return m_useNSQT; }
769  Void setUseNSQT( Bool b ) { m_useNSQT = b; }
770#endif
771 
772  Bool getRestrictedRefPicListsFlag    ()          { return m_restrictedRefPicListsFlag;   }
773  Void setRestrictedRefPicListsFlag    ( Bool b )  { m_restrictedRefPicListsFlag = b;      }
774  Bool getListsModificationPresentFlag ()          { return m_listsModificationPresentFlag; }
775  Void setListsModificationPresentFlag ( Bool b )  { m_listsModificationPresentFlag = b;    }
776
777#if !SPS_AMVP_CLEANUP
778  // AMVP mode (for each depth)
779  AMVP_MODE getAMVPMode ( UInt uiDepth ) { assert(uiDepth < g_uiMaxCUDepth);  return m_aeAMVPMode[uiDepth]; }
780  Void      setAMVPMode ( UInt uiDepth, AMVP_MODE eMode) { assert(uiDepth < g_uiMaxCUDepth);  m_aeAMVPMode[uiDepth] = eMode; }
781#endif
782
783  // AMP accuracy
784  Int       getAMPAcc   ( UInt uiDepth ) { return m_iAMPAcc[uiDepth]; }
785  Void      setAMPAcc   ( UInt uiDepth, Int iAccu ) { assert( uiDepth < g_uiMaxCUDepth);  m_iAMPAcc[uiDepth] = iAccu; }
786
787  // Bit-depth
788  UInt      getBitDepth     ()         { return m_uiBitDepth;     }
789  Void      setBitDepth     ( UInt u ) { m_uiBitDepth = u;        }
790  UInt      getBitIncrement ()         { return m_uiBitIncrement; }
791  Void      setBitIncrement ( UInt u ) { m_uiBitIncrement = u;    }
792  Int       getQpBDOffsetY  ()             { return m_qpBDOffsetY;   }
793  Void      setQpBDOffsetY  ( Int value  ) { m_qpBDOffsetY = value;  }
794  Int       getQpBDOffsetC  ()             { return m_qpBDOffsetC;   }
795  Void      setQpBDOffsetC  ( Int value  ) { m_qpBDOffsetC = value;  }
796#if !MOVE_LOOP_FILTER_SLICES_FLAG
797  Void      setLFCrossSliceBoundaryFlag     ( Bool   bValue  )    { m_bLFCrossSliceBoundaryFlag = bValue; }
798  Bool      getLFCrossSliceBoundaryFlag     ()                    { return m_bLFCrossSliceBoundaryFlag;   } 
799#endif
800  Void setUseSAO                  (Bool bVal)  {m_bUseSAO = bVal;}
801  Bool getUseSAO                  ()           {return m_bUseSAO;}
802
803  UInt      getMaxTLayers()                           { return m_uiMaxTLayers; }
804  Void      setMaxTLayers( UInt uiMaxTLayers )        { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
805
806  Bool      getTemporalIdNestingFlag()                { return m_bTemporalIdNestingFlag; }
807  Void      setTemporalIdNestingFlag( Bool bValue )   { m_bTemporalIdNestingFlag = bValue; }
808  UInt      getPCMBitDepthLuma     ()         { return m_uiPCMBitDepthLuma;     }
809  Void      setPCMBitDepthLuma     ( UInt u ) { m_uiPCMBitDepthLuma = u;        }
810  UInt      getPCMBitDepthChroma   ()         { return m_uiPCMBitDepthChroma;   }
811  Void      setPCMBitDepthChroma   ( UInt u ) { m_uiPCMBitDepthChroma = u;      }
812  Void      setPCMFilterDisableFlag     ( Bool   bValue  )    { m_bPCMFilterDisableFlag = bValue; }
813  Bool      getPCMFilterDisableFlag     ()                    { return m_bPCMFilterDisableFlag;   } 
814
815  Bool getScalingListFlag       ()         { return m_scalingListEnabledFlag;     }
816  Void setScalingListFlag       ( Bool b ) { m_scalingListEnabledFlag  = b;       }
817  Bool getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
818  Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
819  Void setScalingList      ( TComScalingList *scalingList);
820  TComScalingList* getScalingList ()       { return m_scalingList; }               //!< get ScalingList class pointer in SPS
821  UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
822  Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
823  UInt getMaxLatencyIncrease  (UInt tlayer)            { return m_uiMaxLatencyIncrease[tlayer];   }
824  Void setMaxLatencyIncrease  ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui;      }
825
826#if SUPPORT_FOR_VUI
827  Bool getVuiParametersPresentFlag() { return m_vuiParametersPresentFlag; }
828  Void setVuiParametersPresentFlag(Bool b) { m_vuiParametersPresentFlag = b; }
829  TComVUI* getVuiParameters() { return &m_vuiParameters; }
830#if BUFFERING_PERIOD_AND_TIMING_SEI
831  Void setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
832#endif
833#endif
834
835#if SPS_SYNTAX_CHANGES
836  TComPTL* getPTL()     { return &m_pcPTL; }
837#endif
838#if SVC_EXTENSION
839  Void     setLayerId(UInt layerId) { m_layerId = layerId; }
840  UInt     getLayerId() { return m_layerId; }
841#endif
[28]842#if REF_IDX_MFM
843  Void     setMFMEnabledFlag(Bool flag) {m_bMFMEnabledFlag = flag;}
844  Bool     getMFMEnabledFlag()          {return m_bMFMEnabledFlag;}
845#endif
[2]846};
847
848/// Reference Picture Lists class
849class TComRefPicListModification
850{
851private:
852  UInt      m_bRefPicListModificationFlagL0; 
853  UInt      m_bRefPicListModificationFlagL1; 
854  UInt      m_RefPicSetIdxL0[32];
855  UInt      m_RefPicSetIdxL1[32];
856   
857public:
858  TComRefPicListModification();
859  virtual ~TComRefPicListModification();
860 
861  Void  create                    ();
862  Void  destroy                   ();
863
864  Bool       getRefPicListModificationFlagL0() { return m_bRefPicListModificationFlagL0; }
865  Void       setRefPicListModificationFlagL0(Bool flag) { m_bRefPicListModificationFlagL0 = flag; }
866  Bool       getRefPicListModificationFlagL1() { return m_bRefPicListModificationFlagL1; }
867  Void       setRefPicListModificationFlagL1(Bool flag) { m_bRefPicListModificationFlagL1 = flag; }
868  Void       setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL0[idx] = refPicSetIdx; }
869  UInt       getRefPicSetIdxL0(UInt idx) { return m_RefPicSetIdxL0[idx]; }
870  Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
871  UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
872};
873
874/// PPS class
875class TComPPS
876{
877private:
878  Int         m_PPSId;                    // pic_parameter_set_id
879  Int         m_SPSId;                    // seq_parameter_set_id
880  Int         m_picInitQPMinus26;
881  Bool        m_useDQP;
882  Bool        m_bConstrainedIntraPred;    // constrained_intra_pred_flag
883#if CHROMA_QP_EXTENSION
884  Bool        m_bSliceChromaQpFlag;       // slicelevel_chroma_qp_flag
885#endif
886
887  // access channel
888  TComSPS*    m_pcSPS;
889  UInt        m_uiMaxCuDQPDepth;
890  UInt        m_uiMinCuDQPSize;
891
892  Int         m_chromaCbQpOffset;
893  Int         m_chromaCrQpOffset;
894
895  UInt        m_numRefIdxL0DefaultActive;
896  UInt        m_numRefIdxL1DefaultActive;
897
898#if !REMOVE_FGS
899  Int         m_iSliceGranularity;
900#endif
901 
902  Bool        m_bUseWeightPred;           // Use of Weighting Prediction (P_SLICE)
903  Bool        m_useWeightedBiPred;        // Use of Weighting Bi-Prediction (B_SLICE)
904  Bool        m_OutputFlagPresentFlag;   // Indicates the presence of output_flag in slice header
905
906  Bool        m_TransquantBypassEnableFlag; // Indicates presence of cu_transquant_bypass_flag in CUs.
907#if PPS_TS_FLAG
908  Bool        m_useTransformSkip;
909#endif
910#if !TILES_WPP_ENTROPYSLICES_FLAGS
911#if DEPENDENT_SLICES
912  Bool        m_bDependentSliceEnabledFlag;   // Indicates the presence of dependent_slices_flag in slice header
913  Bool        m_bCabacIndependentFlag;   // Indicates the presence of dependent_slices_flag in slice header
914#endif
915  UInt        m_tilesOrEntropyCodingSyncIdc;
916#else
917  Bool        m_dependentSliceEnabledFlag;     //!< Indicates the presence of dependent slices
918  Bool        m_tilesEnabledFlag;              //!< Indicates the presence of tiles
919  Bool        m_entropyCodingSyncEnabledFlag;  //!< Indicates the presence of wavefronts
920  Bool        m_entropySliceEnabledFlag;       //!< Indicates the presence of entropy slices
921#endif
922
923  Bool     m_loopFilterAcrossTilesEnabledFlag;
924  Int      m_uniformSpacingFlag;
925  Int      m_iNumColumnsMinus1;
926  UInt*    m_puiColumnWidth;
927  Int      m_iNumRowsMinus1;
928  UInt*    m_puiRowHeight;
929
930  Int      m_iNumSubstreams;
931
932  Int      m_signHideFlag;
933
934  Bool     m_cabacInitPresentFlag;
935  UInt     m_encCABACTableIdx;           // Used to transmit table selection across slices
936
937#if SLICE_HEADER_EXTENSION
938  Bool     m_sliceHeaderExtensionPresentFlag;
939#endif
940#if MOVE_LOOP_FILTER_SLICES_FLAG
941  Bool        m_loopFilterAcrossSlicesEnabledFlag;
942#endif
943  Bool     m_deblockingFilterControlPresentFlag;
944  Bool     m_deblockingFilterOverrideEnabledFlag;
945  Bool     m_picDisableDeblockingFilterFlag;
946  Int      m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
947  Int      m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
948  Bool     m_scalingListPresentFlag;
949  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
950  UInt m_log2ParallelMergeLevelMinus2;
951public:
952  TComPPS();
953  virtual ~TComPPS();
954 
955  Int       getPPSId ()      { return m_PPSId; }
956  Void      setPPSId (Int i) { m_PPSId = i; }
957  Int       getSPSId ()      { return m_SPSId; }
958  Void      setSPSId (Int i) { m_SPSId = i; }
959 
960#if !REMOVE_FGS
961  Int       getSliceGranularity()        { return m_iSliceGranularity; }
962  Void      setSliceGranularity( Int i ) { m_iSliceGranularity = i;    }
963#endif
964  Int       getPicInitQPMinus26 ()         { return  m_picInitQPMinus26; }
965  Void      setPicInitQPMinus26 ( Int i )  { m_picInitQPMinus26 = i;     }
966  Bool      getUseDQP ()                   { return m_useDQP;        }
967  Void      setUseDQP ( Bool b )           { m_useDQP   = b;         }
968  Bool      getConstrainedIntraPred ()         { return  m_bConstrainedIntraPred; }
969  Void      setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b;     }
970#if CHROMA_QP_EXTENSION
971  Bool      getSliceChromaQpFlag ()         { return  m_bSliceChromaQpFlag; }
972  Void      setSliceChromaQpFlag ( Bool b ) { m_bSliceChromaQpFlag = b;     }
973#endif
974
975  Void      setSPS              ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
976  TComSPS*  getSPS              ()         { return m_pcSPS;          }
977  Void      setMaxCuDQPDepth    ( UInt u ) { m_uiMaxCuDQPDepth = u;   }
978  UInt      getMaxCuDQPDepth    ()         { return m_uiMaxCuDQPDepth;}
979  Void      setMinCuDQPSize     ( UInt u ) { m_uiMinCuDQPSize = u;    }
980  UInt      getMinCuDQPSize     ()         { return m_uiMinCuDQPSize; }
981
982  Void      setChromaCbQpOffset( Int i ) { m_chromaCbQpOffset = i;    }
983  Int       getChromaCbQpOffset()        { return m_chromaCbQpOffset; }
984  Void      setChromaCrQpOffset( Int i ) { m_chromaCrQpOffset = i;    }
985  Int       getChromaCrQpOffset()        { return m_chromaCrQpOffset; }
986
987  Void      setNumRefIdxL0DefaultActive(UInt ui)    { m_numRefIdxL0DefaultActive=ui;     }
988  UInt      getNumRefIdxL0DefaultActive()           { return m_numRefIdxL0DefaultActive; }
989  Void      setNumRefIdxL1DefaultActive(UInt ui)    { m_numRefIdxL1DefaultActive=ui;     }
990  UInt      getNumRefIdxL1DefaultActive()           { return m_numRefIdxL1DefaultActive; }
991
992  Bool getUseWP                     ()          { return m_bUseWeightPred;  }
993  Bool getWPBiPred                  ()          { return m_useWeightedBiPred;     }
994  Void setUseWP                     ( Bool b )  { m_bUseWeightPred = b;     }
995  Void setWPBiPred                  ( Bool b )  { m_useWeightedBiPred = b;  }
996  Void      setOutputFlagPresentFlag( Bool b )  { m_OutputFlagPresentFlag = b;    }
997  Bool      getOutputFlagPresentFlag()          { return m_OutputFlagPresentFlag; }
998#if !TILES_WPP_ENTROPYSLICES_FLAGS
999#if DEPENDENT_SLICES
1000  Void      setDependentSliceEnabledFlag( Bool b )  { m_bDependentSliceEnabledFlag = b;    }
1001  Bool      getDependentSliceEnabledFlag()          { return m_bDependentSliceEnabledFlag; }
1002  Void      setCabacIndependentFlag( Bool b )  { m_bCabacIndependentFlag = b;    }
1003  Bool      getCabacIndependentFlag()          { return m_bCabacIndependentFlag; }
1004#endif
1005#endif
1006  Void      setTransquantBypassEnableFlag( Bool b ) { m_TransquantBypassEnableFlag = b; }
1007  Bool      getTransquantBypassEnableFlag()         { return m_TransquantBypassEnableFlag; }
1008
1009#if PPS_TS_FLAG
1010  Bool      getUseTransformSkip       ()         { return m_useTransformSkip;     }
1011  Void      setUseTransformSkip       ( Bool b ) { m_useTransformSkip  = b;       }
1012#endif
1013
1014  Void    setLoopFilterAcrossTilesEnabledFlag  (Bool b)    { m_loopFilterAcrossTilesEnabledFlag = b; }
1015  Bool    getLoopFilterAcrossTilesEnabledFlag  ()          { return m_loopFilterAcrossTilesEnabledFlag;   }
1016#if TILES_WPP_ENTROPYSLICES_FLAGS
1017  Bool    getDependentSliceEnabledFlag() const             { return m_dependentSliceEnabledFlag; }
1018  Void    setDependentSliceEnabledFlag(Bool val)           { m_dependentSliceEnabledFlag = val; }
1019  Bool    getTilesEnabledFlag() const                      { return m_tilesEnabledFlag; }
1020  Void    setTilesEnabledFlag(Bool val)                    { m_tilesEnabledFlag = val; }
1021  Bool    getEntropyCodingSyncEnabledFlag() const          { return m_entropyCodingSyncEnabledFlag; }
1022  Void    setEntropyCodingSyncEnabledFlag(Bool val)        { m_entropyCodingSyncEnabledFlag = val; }
1023  Bool    getEntropySliceEnabledFlag() const               { return m_entropySliceEnabledFlag; }
1024  Void    setEntropySliceEnabledFlag(Bool val)             { m_entropySliceEnabledFlag = val; }
1025#else
1026  UInt     getTilesOrEntropyCodingSyncIdc   ()                  { return m_tilesOrEntropyCodingSyncIdc;   }
1027  Void     setTilesOrEntropyCodingSyncIdc   ( UInt val )        { m_tilesOrEntropyCodingSyncIdc = val;    }
1028#endif
1029  Void     setUniformSpacingFlag            ( Bool b )          { m_uniformSpacingFlag = b; }
1030  Bool     getUniformSpacingFlag            ()                  { return m_uniformSpacingFlag; }
1031  Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
1032  Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
1033  Void     setColumnWidth ( UInt* columnWidth )
1034  {
1035    if( m_uniformSpacingFlag == 0 && m_iNumColumnsMinus1 > 0 )
1036    {
1037      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
1038
1039      for(Int i=0; i<m_iNumColumnsMinus1; i++)
1040      {
1041        m_puiColumnWidth[i] = columnWidth[i];
1042      }
1043    }
1044  }
1045  UInt     getColumnWidth  (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
1046  Void     setNumRowsMinus1( Int i )        { m_iNumRowsMinus1 = i; }
1047  Int      getNumRowsMinus1()               { return m_iNumRowsMinus1; }
1048  Void     setRowHeight    ( UInt* rowHeight )
1049  {
1050    if( m_uniformSpacingFlag == 0 && m_iNumRowsMinus1 > 0 )
1051    {
1052      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
1053
1054      for(Int i=0; i<m_iNumRowsMinus1; i++)
1055      {
1056        m_puiRowHeight[i] = rowHeight[i];
1057      }
1058    }
1059  }
1060  UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
1061  Void     setNumSubstreams(Int iNumSubstreams)               { m_iNumSubstreams = iNumSubstreams; }
1062  Int      getNumSubstreams()                                 { return m_iNumSubstreams; }
1063
1064  Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
1065  Int       getSignHideFlag()                    { return m_signHideFlag; }
1066
1067  Void     setCabacInitPresentFlag( Bool flag )     { m_cabacInitPresentFlag = flag;    }
1068  Void     setEncCABACTableIdx( Int idx )           { m_encCABACTableIdx = idx;         }
1069  Bool     getCabacInitPresentFlag()                { return m_cabacInitPresentFlag;    }
1070  UInt     getEncCABACTableIdx()                    { return m_encCABACTableIdx;        }
1071  Void     setDeblockingFilterControlPresentFlag( Bool val )  { m_deblockingFilterControlPresentFlag = val; }
1072  Bool     getDeblockingFilterControlPresentFlag()            { return m_deblockingFilterControlPresentFlag; }
1073  Void     setDeblockingFilterOverrideEnabledFlag( Bool val ) { m_deblockingFilterOverrideEnabledFlag = val; }
1074  Bool     getDeblockingFilterOverrideEnabledFlag()           { return m_deblockingFilterOverrideEnabledFlag; }
1075  Void     setPicDisableDeblockingFilterFlag(Bool val)        { m_picDisableDeblockingFilterFlag = val; }       //!< set offset for deblocking filter disabled
1076  Bool     getPicDisableDeblockingFilterFlag()                { return m_picDisableDeblockingFilterFlag; }      //!< get offset for deblocking filter disabled
1077  Void     setDeblockingFilterBetaOffsetDiv2(Int val)         { m_deblockingFilterBetaOffsetDiv2 = val; }       //!< set beta offset for deblocking filter
1078  Int      getDeblockingFilterBetaOffsetDiv2()                { return m_deblockingFilterBetaOffsetDiv2; }      //!< get beta offset for deblocking filter
1079  Void     setDeblockingFilterTcOffsetDiv2(Int val)           { m_deblockingFilterTcOffsetDiv2 = val; }               //!< set tc offset for deblocking filter
1080  Int      getDeblockingFilterTcOffsetDiv2()                  { return m_deblockingFilterTcOffsetDiv2; }              //!< get tc offset for deblocking filter
1081  Bool     getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
1082  Void     setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
1083  Void     setScalingList      ( TComScalingList *scalingList);
1084  TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in PPS
1085  UInt getLog2ParallelMergeLevelMinus2      ()                    { return m_log2ParallelMergeLevelMinus2; }
1086  Void setLog2ParallelMergeLevelMinus2      (UInt mrgLevel)       { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
1087#if MOVE_LOOP_FILTER_SLICES_FLAG
1088  Void      setLoopFilterAcrossSlicesEnabledFlag ( Bool   bValue  )    { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
1089  Bool      getLoopFilterAcrossSlicesEnabledFlag ()                    { return m_loopFilterAcrossSlicesEnabledFlag;   } 
1090#endif
1091#if SLICE_HEADER_EXTENSION
1092  Bool getSliceHeaderExtensionPresentFlag   ()                    { return m_sliceHeaderExtensionPresentFlag; }
1093  Void setSliceHeaderExtensionPresentFlag   (Bool val)            { m_sliceHeaderExtensionPresentFlag = val; }
1094#endif
1095};
1096
1097#if !REMOVE_APS
1098/// APS class
1099class TComAPS
1100{
1101public:
1102  TComAPS();
1103  virtual ~TComAPS();
1104
1105  Void      setAPSID      (Int iID)   {m_apsID = iID;            }  //!< set APS ID
1106  Int       getAPSID      ()          {return m_apsID;           }  //!< get APS ID
1107#if !REMOVE_ALF
1108  ALFParam** getAlfParam  ()                       { return m_alfParam;}
1109  Bool       getAlfEnabled(Int compIdx)            { return (m_alfParam[compIdx] == NULL)?(false):(m_alfParam[compIdx]->alf_flag ==1);}
1110  Void       setAlfEnabled(Bool bVal, Int compIdx) { m_alfParam[compIdx]->alf_flag= (bVal?1:0); }  //!< set ALF enabled/disabled in APS
1111#endif
1112  SAOParam* getSaoParam   ()          {return m_pSaoParam;       }  //!< get SAO parameters in APS
1113
1114  Void      createSaoParam();   //!< create SAO parameter object
1115  Void      destroySaoParam();  //!< destroy SAO parameter object
1116
1117#if !REMOVE_ALF
1118  Void      createAlfParam();   //!< create ALF parameter object
1119  Void      destroyAlfParam();  //!< destroy ALF parameter object
1120#endif
1121private:
1122  Int         m_apsID;        //!< APS ID
1123  SAOParam*   m_pSaoParam;    //!< SAO parameter object pointer
1124#if !REMOVE_ALF
1125  ALFParam*   m_alfParam[3];
1126#endif
1127public:
1128  TComAPS& operator= (const TComAPS& src);  //!< "=" operator for APS object
1129};
1130#endif
1131
1132typedef struct {
1133  // Explicit weighted prediction parameters parsed in slice header,
1134  // or Implicit weighted prediction parameters (8 bits depth values).
1135  Bool        bPresentFlag;
1136  UInt        uiLog2WeightDenom;
1137  Int         iWeight;
1138  Int         iOffset;
1139
1140  // Weighted prediction scaling values built from above parameters (bitdepth scaled):
1141  Int         w, o, offset, shift, round;
1142} wpScalingParam;
1143
1144typedef struct {
1145  Int64 iAC;
1146  Int64 iDC;
1147} wpACDCParam;
1148
1149/// slice header class
1150class TComSlice
1151{
1152 
1153private:
1154  //  Bitstream writing
1155#if !REMOVE_APS
1156  Int         m_iAPSId; //!< APS ID in slice header
1157#endif
1158#if !REMOVE_ALF
1159  Bool       m_alfEnabledFlag[3];
1160#endif
1161  bool       m_saoEnabledFlag;
1162#if SAO_TYPE_SHARING
1163  bool       m_saoEnabledFlagChroma;      ///< SAO Cb&Cr enabled flag
1164#else
1165  bool       m_saoEnabledFlagCb;      ///< SAO Cb enabled flag
1166  bool       m_saoEnabledFlagCr;      ///< SAO Cr enabled flag
1167#endif
1168  Int         m_iPPSId;               ///< picture parameter set ID
1169  Bool        m_PicOutputFlag;        ///< pic_output_flag
1170  Int         m_iPOC;
1171  Int         m_iLastIDR;
1172#if PREVREFPIC_DEFN
1173  static Int  m_prevPOC[MAX_TLAYER];
1174#else
1175  static Int  m_prevPOC;
1176#endif
1177  TComReferencePictureSet *m_pcRPS;
1178  TComReferencePictureSet m_LocalRPS;
1179  Int         m_iBDidx; 
1180  Int         m_iCombinationBDidx;
1181  Bool        m_bCombineWithReferenceFlag;
1182  TComRefPicListModification m_RefPicListModification;
1183  NalUnitType m_eNalUnitType;         ///< Nal unit type for the slice
1184  SliceType   m_eSliceType;
1185  Int         m_iSliceQp;
1186#if SLICEHEADER_SYNTAX_FIX
1187  Bool        m_dependentSliceFlag;
1188#endif
1189#if ADAPTIVE_QP_SELECTION
1190  Int         m_iSliceQpBase;
1191#endif
1192  Bool        m_deblockingFilterDisable;
1193  Bool        m_deblockingFilterOverrideFlag;      //< offsets for deblocking filter inherit from PPS
1194  Int         m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
1195  Int         m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
1196 
1197  Int         m_aiNumRefIdx   [3];    //  for multiple reference of current slice
1198
1199  Int         m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
1200  Int         m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
1201  Int         m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
1202  Int         m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
1203  Int         m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
1204  Bool        m_bRefPicListModificationFlagLC;
1205  Bool        m_bRefPicListCombinationFlag;
1206
1207  Bool        m_bCheckLDC;
1208
1209  //  Data
1210  Int         m_iSliceQpDelta;
1211#if CHROMA_QP_EXTENSION
1212  Int         m_iSliceQpDeltaCb;
1213  Int         m_iSliceQpDeltaCr;
1214#endif
1215  TComPic*    m_apcRefPicList [2][MAX_NUM_REF+1];
1216  Int         m_aiRefPOCList  [2][MAX_NUM_REF+1];
1217  Int         m_iDepth;
1218 
1219  // referenced slice?
1220  Bool        m_bRefenced;
1221 
1222  // access channel
1223  TComVPS*    m_pcVPS;
1224  TComSPS*    m_pcSPS;
1225  TComPPS*    m_pcPPS;
1226  TComPic*    m_pcPic;
1227#if ADAPTIVE_QP_SELECTION
1228  TComTrQuant* m_pcTrQuant;
1229#endif 
1230#if !REMOVE_APS
1231  TComAPS*    m_pcAPS;  //!< pointer to APS parameter object
1232#endif
1233  UInt        m_colFromL0Flag;  // collocated picture from List0 flag
1234 
1235  UInt        m_colRefIdx;
1236  UInt        m_maxNumMergeCand;
1237
1238
1239#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA
1240  Double      m_dLambdaLuma;
1241  Double      m_dLambdaChroma;
1242#else
1243  Double      m_dLambda;
1244#endif
1245
1246  Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
1247 
1248  Bool        m_bNoBackPredFlag;
1249  UInt        m_uiTLayer;
1250#if SVC_EXTENSION
1251  UInt        m_layerId;
1252  TComPic*    m_pcBaseColPic;
1253  TComPicYuv* m_pcFullPelBaseRec;
1254#endif
1255  Bool        m_bTLayerSwitchingFlag;
1256
1257  UInt        m_uiSliceMode;
1258  UInt        m_uiSliceArgument;
1259  UInt        m_uiSliceCurStartCUAddr;
1260  UInt        m_uiSliceCurEndCUAddr;
1261  UInt        m_uiSliceIdx;
1262  UInt        m_uiDependentSliceMode;
1263  UInt        m_uiDependentSliceArgument;
1264  UInt        m_uiDependentSliceCurStartCUAddr;
1265  UInt        m_uiDependentSliceCurEndCUAddr;
1266  Bool        m_bNextSlice;
1267  Bool        m_bNextDependentSlice;
1268  UInt        m_uiSliceBits;
1269  UInt        m_uiDependentSliceCounter;
1270  Bool        m_bFinalized;
1271
1272  wpScalingParam  m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
1273  wpACDCParam    m_weightACDCParam[3];                 // [0:Y, 1:U, 2:V]
1274  wpScalingParam  m_weightPredTableLC[2*MAX_NUM_REF][3]; // [refIdxLC][0:Y, 1:U, 2:V]
1275
1276  std::vector<UInt> m_tileByteLocation;
1277  UInt        m_uiTileOffstForMultES;
1278
1279  UInt*       m_puiSubstreamSizes;
1280  TComScalingList*     m_scalingList;                 //!< pointer of quantization matrix
1281  Bool        m_cabacInitFlag; 
1282
1283  Bool       m_bLMvdL1Zero;
1284  Int         m_numEntryPointOffsets;
1285#if TEMPORAL_LAYER_NON_REFERENCE
1286  Bool       m_temporalLayerNonReferenceFlag;
1287#endif
1288#if !REMOVE_NAL_REF_FLAG
1289  Bool        m_nalRefFlag;
1290#endif
1291  Bool       m_LFCrossSliceBoundaryFlag;
1292
1293  Bool       m_enableTMVPFlag;
1294
1295public:
1296  TComSlice();
1297  virtual ~TComSlice(); 
[11]1298#if SET_SLICE_LAYER_ID
1299  Void      initSlice       ( UInt layerId );
1300#else
[2]1301  Void      initSlice       ();
[11]1302#endif
[2]1303
1304  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
1305  TComVPS*  getVPS          () { return m_pcVPS; }
1306  Void      setSPS          ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
1307  TComSPS*  getSPS          () { return m_pcSPS; }
1308 
1309  Void      setPPS          ( TComPPS* pcPPS )         { assert(pcPPS!=NULL); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
1310  TComPPS*  getPPS          () { return m_pcPPS; }
1311
1312#if ADAPTIVE_QP_SELECTION
1313  Void          setTrQuant          ( TComTrQuant* pcTrQuant ) { m_pcTrQuant = pcTrQuant; }
1314  TComTrQuant*  getTrQuant          () { return m_pcTrQuant; }
1315#endif
1316
1317  Void      setPPSId        ( Int PPSId )         { m_iPPSId = PPSId; }
1318  Int       getPPSId        () { return m_iPPSId; }
1319#if !REMOVE_APS
1320  Void      setAPS          ( TComAPS* pcAPS ) { m_pcAPS = pcAPS; } //!< set APS pointer
1321  TComAPS*  getAPS          ()                 { return m_pcAPS;  } //!< get APS pointer
1322  Void      setAPSId        ( Int Id)          { m_iAPSId =Id;    } //!< set APS ID
1323  Int       getAPSId        ()                 { return m_iAPSId; } //!< get APS ID
1324#endif
1325  Void      setPicOutputFlag( Bool b )         { m_PicOutputFlag = b;    }
1326  Bool      getPicOutputFlag()                 { return m_PicOutputFlag; }
1327#if !REMOVE_ALF
1328  Void      setAlfEnabledFlag(Bool b, Int compIdx) { m_alfEnabledFlag[compIdx] = b;    }
1329  Bool      getAlfEnabledFlag(Int compIdx)         { return m_alfEnabledFlag[compIdx]; }
1330#endif
1331  Void      setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
1332  Bool      getSaoEnabledFlag() { return m_saoEnabledFlag; }
1333#if SAO_TYPE_SHARING
1334  Void      setSaoEnabledFlagChroma(Bool s) {m_saoEnabledFlagChroma =s; }       //!< set SAO Cb&Cr enabled flag
1335  Bool      getSaoEnabledFlagChroma() { return m_saoEnabledFlagChroma; }        //!< get SAO Cb&Cr enabled flag
1336#else
1337  Void      setSaoEnabledFlagCb(Bool s) {m_saoEnabledFlagCb =s; }       //!< set SAO Cb enabled flag
1338  Bool      getSaoEnabledFlagCb() { return m_saoEnabledFlagCb; }        //!< get SAO Cb enabled flag
1339  Void      setSaoEnabledFlagCr(Bool s) {m_saoEnabledFlagCr =s; }       //!< set SAO Cr enabled flag
1340  Bool      getSaoEnabledFlagCr() { return m_saoEnabledFlagCr; }        //!< get SAO Cr enabled flag
1341#endif
1342  Void      setRPS          ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
1343  TComReferencePictureSet*  getRPS          () { return m_pcRPS; }
1344  TComReferencePictureSet*  getLocalRPS     () { return &m_LocalRPS; }
1345
1346  Void      setRPSidx          ( Int iBDidx ) { m_iBDidx = iBDidx; }
1347  Int       getRPSidx          () { return m_iBDidx; }
1348  Void      setCombinationBDidx          ( Int iCombinationBDidx ) { m_iCombinationBDidx = iCombinationBDidx; }
1349  Int       getCombinationBDidx          () { return m_iCombinationBDidx; }
1350  Void      setCombineWithReferenceFlag          ( Bool bCombineWithReferenceFlag ) { m_bCombineWithReferenceFlag = bCombineWithReferenceFlag; }
1351  Bool      getCombineWithReferenceFlag          () { return m_bCombineWithReferenceFlag; }
1352#if PREVREFPIC_DEFN
1353  Int       getPrevPOC      ()                          { return  m_prevPOC[getTLayer()];       }
1354#else
1355  Int       getPrevPOC      ()                          { return  m_prevPOC;       }
1356#endif
1357  TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
1358  Void      setLastIDR(Int iIDRPOC)                       { m_iLastIDR = iIDRPOC; }
1359  Int       getLastIDR()                                  { return m_iLastIDR; }
1360  SliceType getSliceType    ()                          { return  m_eSliceType;         }
1361  Int       getPOC          ()                          { return  m_iPOC;           }
1362  Int       getSliceQp      ()                          { return  m_iSliceQp;           }
1363#if SLICEHEADER_SYNTAX_FIX
1364  Bool      getDependentSliceFlag() const               { return m_dependentSliceFlag; }
1365  void      setDependentSliceFlag(Bool val)             { m_dependentSliceFlag = val; }
1366#endif
1367#if ADAPTIVE_QP_SELECTION
1368  Int       getSliceQpBase  ()                          { return  m_iSliceQpBase;       }
1369#endif
1370  Int       getSliceQpDelta ()                          { return  m_iSliceQpDelta;      }
1371#if CHROMA_QP_EXTENSION
1372  Int       getSliceQpDeltaCb ()                          { return  m_iSliceQpDeltaCb;      }
1373  Int       getSliceQpDeltaCr ()                          { return  m_iSliceQpDeltaCr;      }
1374#endif
1375  Bool      getDeblockingFilterDisable()                { return  m_deblockingFilterDisable; }
1376  Bool      getDeblockingFilterOverrideFlag()           { return  m_deblockingFilterOverrideFlag; }
1377  Int       getDeblockingFilterBetaOffsetDiv2()         { return  m_deblockingFilterBetaOffsetDiv2; }
1378  Int       getDeblockingFilterTcOffsetDiv2()           { return  m_deblockingFilterTcOffsetDiv2; }
1379
1380  Int       getNumRefIdx        ( RefPicList e )                { return  m_aiNumRefIdx[e];             }
1381  TComPic*  getPic              ()                              { return  m_pcPic;                      }
1382  TComPic*  getRefPic           ( RefPicList e, Int iRefIdx)    { return  m_apcRefPicList[e][iRefIdx];  }
1383  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
1384  Int       getDepth            ()                              { return  m_iDepth;                     }
1385  UInt      getColFromL0Flag    ()                              { return  m_colFromL0Flag;              }
1386  UInt      getColRefIdx        ()                              { return  m_colRefIdx;                  }
1387  Void      checkColRefIdx      (UInt curSliceIdx, TComPic* pic);
1388  Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
1389  Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
1390  Int       getNumRpsCurrTempList();
1391  Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
1392  Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
1393  Int       getRefIdxFromIdxOfLC(Int iRefIdx)                   { return m_iRefIdxFromIdxOfLC[iRefIdx];       }
1394  Int       getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx)            { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
1395  Int       getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx)            { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
1396  Bool      getRefPicListModificationFlagLC()                   {return m_bRefPicListModificationFlagLC;}
1397  Void      setRefPicListModificationFlagLC(Bool bflag)         {m_bRefPicListModificationFlagLC=bflag;}     
1398  Bool      getRefPicListCombinationFlag()                      {return m_bRefPicListCombinationFlag;}
1399  Void      setRefPicListCombinationFlag(Bool bflag)            {m_bRefPicListCombinationFlag=bflag;}   
1400  Void      setReferenced(Bool b)                               { m_bRefenced = b; }
1401  Bool      isReferenced()                                      { return m_bRefenced; }
1402#if PREVREFPIC_DEFN
1403  Void      setPOC              ( Int i )
1404  {
1405    m_iPOC = i;
1406    if (isReferenced())
1407    {
1408      for (Int j = getTLayer(); j < (getSPS()->getMaxTLayers()); j++)
1409      {
1410        m_prevPOC[j] = i;
1411      }
1412    }
1413  }
1414#else 
1415  Void      setPOC              ( Int i )                       { m_iPOC              = i; if(getTLayer()==0) m_prevPOC=i; }
1416#endif
1417  Void      setNalUnitType      ( NalUnitType e )               { m_eNalUnitType      = e;      }
1418  NalUnitType getNalUnitType    ()                              { return m_eNalUnitType;        }
1419  Bool      getRapPicFlag       (); 
1420#if SUPPORT_FOR_RAP_N_LP
1421  Bool      getIdrPicFlag       ()                              { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
1422#endif
1423  Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList<TComPic*>& rcListPic);
1424  Void      decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
1425  Void      setSliceType        ( SliceType e )                 { m_eSliceType        = e;      }
1426  Void      setSliceQp          ( Int i )                       { m_iSliceQp          = i;      }
1427#if ADAPTIVE_QP_SELECTION
1428  Void      setSliceQpBase      ( Int i )                       { m_iSliceQpBase      = i;      }
1429#endif
1430  Void      setSliceQpDelta     ( Int i )                       { m_iSliceQpDelta     = i;      }
1431#if CHROMA_QP_EXTENSION
1432  Void      setSliceQpDeltaCb   ( Int i )                       { m_iSliceQpDeltaCb   = i;      }
1433  Void      setSliceQpDeltaCr   ( Int i )                       { m_iSliceQpDeltaCr   = i;      }
1434#endif
1435  Void      setDeblockingFilterDisable( Bool b )                { m_deblockingFilterDisable= b;      }
1436  Void      setDeblockingFilterOverrideFlag( Bool b )           { m_deblockingFilterOverrideFlag = b; }
1437  Void      setDeblockingFilterBetaOffsetDiv2( Int i )          { m_deblockingFilterBetaOffsetDiv2 = i; }
1438  Void      setDeblockingFilterTcOffsetDiv2( Int i )            { m_deblockingFilterTcOffsetDiv2 = i; }
1439 
1440  Void      setRefPic           ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
1441  Void      setRefPOC           ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
1442  Void      setNumRefIdx        ( RefPicList e, Int i )         { m_aiNumRefIdx[e]    = i;      }
1443  Void      setPic              ( TComPic* p )                  { m_pcPic             = p;      }
1444  Void      setDepth            ( Int iDepth )                  { m_iDepth            = iDepth; }
1445 
1446#if SVC_EXTENSION 
1447  Void      setBaseColPic       ( TComPic* p)                   { m_pcBaseColPic = p; }
1448  Void      setBaseColPic       ( TComList<TComPic*>& rcListPic , UInt layerID );
1449  TComPic*  getBaseColPic       ()  { return m_pcBaseColPic; }
1450
1451  Void      setLayerId (UInt layerId) { m_layerId = layerId; }
1452  UInt      getLayerId ()               { return m_layerId; }
1453
1454  Void        setFullPelBaseRec   ( TComPicYuv* p) { m_pcFullPelBaseRec = p; }
1455  TComPicYuv* getFullPelBaseRec   ()  { return  m_pcFullPelBaseRec;  }
[42]1456
1457#if AVC_SYNTAX
1458  Void      initBaseLayerRPL( TComSlice *pcSlice );
[2]1459#endif
[42]1460#endif
[28]1461
1462#if REF_IDX_MFM
1463  Void      setRefPOCListILP(TComPic** ilpPic, TComPic *pcRefPicBL);
1464#endif
1465
[2]1466  Void      setRefPicList       ( TComList<TComPic*>& rcListPic );
1467  Void      setRefPOCList       ();
1468  Void      setColFromL0Flag    ( UInt colFromL0 ) { m_colFromL0Flag = colFromL0; }
1469  Void      setColRefIdx        ( UInt refIdx) { m_colRefIdx = refIdx; }
1470  Void      setCheckLDC         ( Bool b )                      { m_bCheckLDC = b; }
1471  Void      setMvdL1ZeroFlag     ( Bool b)                       { m_bLMvdL1Zero = b; }
1472
1473  Bool      isIntra         ()                          { return  m_eSliceType == I_SLICE;  }
1474  Bool      isInterB        ()                          { return  m_eSliceType == B_SLICE;  }
1475  Bool      isInterP        ()                          { return  m_eSliceType == P_SLICE;  }
1476 
1477#if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA 
1478  Void      setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
1479  Double    getLambdaLuma() { return m_dLambdaLuma;        }
1480  Double    getLambdaChroma() { return m_dLambdaChroma;        }
1481#else
1482  Void      setLambda( Double d ) { m_dLambda = d; }
1483  Double    getLambda() { return m_dLambda;        }
1484#endif
1485 
1486  Void      initEqualRef();
1487  Bool      isEqualRef  ( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
1488  {
1489    if (iRefIdx1 < 0 || iRefIdx2 < 0) return false;
1490    return m_abEqualRef[e][iRefIdx1][iRefIdx2];
1491  }
1492 
1493  Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
1494  {
1495    m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
1496  }
1497 
1498  static Void      sortPicList         ( TComList<TComPic*>& rcListPic );
1499 
1500  Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
1501  Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
1502  Void generateCombinedList       ();
1503
1504  UInt getTLayer             ()                            { return m_uiTLayer;                      }
1505  Void setTLayer             ( UInt uiTLayer )             { m_uiTLayer = uiTLayer;                  }
1506
1507  Void setTLayerInfo( UInt uiTLayer );
1508  Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum ); 
1509  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
1510  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
1511#if STSA
1512  Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
1513#endif
1514  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
1515  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet);
1516
1517  Void setMaxNumMergeCand               (UInt val )         { m_maxNumMergeCand = val;                    }
1518  UInt getMaxNumMergeCand               ()                  { return m_maxNumMergeCand;                   }
1519
1520  Void setSliceMode                     ( UInt uiMode )     { m_uiSliceMode = uiMode;                     }
1521  UInt getSliceMode                     ()                  { return m_uiSliceMode;                       }
1522  Void setSliceArgument                 ( UInt uiArgument ) { m_uiSliceArgument = uiArgument;             }
1523  UInt getSliceArgument                 ()                  { return m_uiSliceArgument;                   }
1524  Void setSliceCurStartCUAddr           ( UInt uiAddr )     { m_uiSliceCurStartCUAddr = uiAddr;           }
1525  UInt getSliceCurStartCUAddr           ()                  { return m_uiSliceCurStartCUAddr;             }
1526  Void setSliceCurEndCUAddr             ( UInt uiAddr )     { m_uiSliceCurEndCUAddr = uiAddr;             }
1527  UInt getSliceCurEndCUAddr             ()                  { return m_uiSliceCurEndCUAddr;               }
1528  Void setSliceIdx                      ( UInt i)           { m_uiSliceIdx = i;                           }
1529  UInt getSliceIdx                      ()                  { return  m_uiSliceIdx;                       }
1530  Void copySliceInfo                    (TComSlice *pcSliceSrc);
1531  Void setDependentSliceMode              ( UInt uiMode )     { m_uiDependentSliceMode = uiMode;              }
1532  UInt getDependentSliceMode              ()                  { return m_uiDependentSliceMode;                }
1533  Void setDependentSliceArgument          ( UInt uiArgument ) { m_uiDependentSliceArgument = uiArgument;      }
1534  UInt getDependentSliceArgument          ()                  { return m_uiDependentSliceArgument;            }
1535  Void setDependentSliceCurStartCUAddr    ( UInt uiAddr )     { m_uiDependentSliceCurStartCUAddr = uiAddr;    }
1536  UInt getDependentSliceCurStartCUAddr    ()                  { return m_uiDependentSliceCurStartCUAddr;      }
1537  Void setDependentSliceCurEndCUAddr      ( UInt uiAddr )     { m_uiDependentSliceCurEndCUAddr = uiAddr;      }
1538  UInt getDependentSliceCurEndCUAddr      ()                  { return m_uiDependentSliceCurEndCUAddr;        }
1539  Void setNextSlice                     ( Bool b )          { m_bNextSlice = b;                           }
1540  Bool isNextSlice                      ()                  { return m_bNextSlice;                        }
1541  Void setNextDependentSlice              ( Bool b )          { m_bNextDependentSlice = b;                    }
1542  Bool isNextDependentSlice               ()                  { return m_bNextDependentSlice;                 }
1543  Void setSliceBits                     ( UInt uiVal )      { m_uiSliceBits = uiVal;                      }
1544  UInt getSliceBits                     ()                  { return m_uiSliceBits;                       } 
1545  Void setDependentSliceCounter           ( UInt uiVal )      { m_uiDependentSliceCounter = uiVal;            }
1546  UInt getDependentSliceCounter           ()                  { return m_uiDependentSliceCounter;             }
1547  Void setFinalized                     ( Bool uiVal )      { m_bFinalized = uiVal;                       }
1548  Bool getFinalized                     ()                  { return m_bFinalized;                        }
1549  Void  setWpScaling    ( wpScalingParam  wp[2][MAX_NUM_REF][3] ) { memcpy(m_weightPredTable, wp, sizeof(wpScalingParam)*2*MAX_NUM_REF*3); }
1550  Void  getWpScaling    ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
1551
1552  Void  resetWpScaling  (wpScalingParam  wp[2][MAX_NUM_REF][3]);
1553  Void  initWpScaling    (wpScalingParam  wp[2][MAX_NUM_REF][3]);
1554  Void  initWpScaling   ();
1555  inline Bool applyWP   () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPred()) ); }
1556
1557  Void  setWpAcDcParam  ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
1558  Void  getWpAcDcParam  ( wpACDCParam *&wp );
1559  Void  initWpAcDcParam ();
1560 
1561  Void setTileLocationCount             ( UInt cnt )               { return m_tileByteLocation.resize(cnt);    }
1562  UInt getTileLocationCount             ()                         { return (UInt) m_tileByteLocation.size();  }
1563  Void setTileLocation                  ( Int idx, UInt location ) { assert (idx<m_tileByteLocation.size());
1564                                                                     m_tileByteLocation[idx] = location;       }
1565  Void addTileLocation                  ( UInt location )          { m_tileByteLocation.push_back(location);   }
1566  UInt getTileLocation                  ( Int idx )                { return m_tileByteLocation[idx];           }
1567
1568  Void setTileOffstForMultES            (UInt uiOffset )      { m_uiTileOffstForMultES = uiOffset;        }
1569  UInt getTileOffstForMultES            ()                    { return m_uiTileOffstForMultES;            }
1570  Void allocSubstreamSizes              ( UInt uiNumSubstreams );
1571  UInt* getSubstreamSizes               ()                  { return m_puiSubstreamSizes; }
1572  Void  setScalingList              ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
1573  TComScalingList*   getScalingList ()                               { return m_scalingList; }
1574  Void  setDefaultScalingList       ();
1575  Bool  checkDefaultScalingList     ();
1576  Void      setCabacInitFlag  ( Bool val ) { m_cabacInitFlag = val;      }  //!< set CABAC initial flag
1577  Bool      getCabacInitFlag  ()           { return m_cabacInitFlag;     }  //!< get CABAC initial flag
1578  Void      setNumEntryPointOffsets(Int val)  { m_numEntryPointOffsets = val;     }
1579  Int       getNumEntryPointOffsets()         { return m_numEntryPointOffsets;    }
1580#if TEMPORAL_LAYER_NON_REFERENCE
1581  Bool      getTemporalLayerNonReferenceFlag()       { return m_temporalLayerNonReferenceFlag;}
1582  Void      setTemporalLayerNonReferenceFlag(Bool x) { m_temporalLayerNonReferenceFlag = x;}
1583#endif
1584#if !REMOVE_NAL_REF_FLAG
1585  Bool      getNalRefFlag()       { return m_nalRefFlag;}
1586  Void      setNalRefFlag(Bool x) { m_nalRefFlag = x;}
1587#endif
1588  Void      setLFCrossSliceBoundaryFlag     ( Bool   val )    { m_LFCrossSliceBoundaryFlag = val; }
1589  Bool      getLFCrossSliceBoundaryFlag     ()                { return m_LFCrossSliceBoundaryFlag;} 
1590
1591  Void      setEnableTMVPFlag     ( Bool   b )    { m_enableTMVPFlag = b; }
1592  Bool      getEnableTMVPFlag     ()              { return m_enableTMVPFlag;}
1593#if REF_IDX_FRAMEWORK
1594  Void      addRefPicList( TComPic **pIlpPicList, Int iRefPicNum, Int iInsertOffset=0 );
1595#endif
1596protected:
1597  TComPic*  xGetRefPic  (TComList<TComPic*>& rcListPic,
1598                         UInt                uiPOC);
1599  TComPic*  xGetLongTermRefPic  (TComList<TComPic*>& rcListPic,
1600                         UInt                uiPOC);
1601};// END CLASS DEFINITION TComSlice
1602
1603
1604template <class T> class ParameterSetMap
1605{
1606public:
1607  ParameterSetMap(Int maxId)
1608  :m_maxId (maxId)
1609  {}
1610
1611  ~ParameterSetMap()
1612  {
1613    for (typename std::map<Int,T *>::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
1614    {
1615      delete (*i).second;
1616    }
1617  }
1618
1619  Void storePS(Int psId, T *ps)
1620  {
1621    assert ( psId < m_maxId );
1622    if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
1623    {
1624      delete m_paramsetMap[psId];
1625    }
1626    m_paramsetMap[psId] = ps; 
1627  }
1628
1629  Void mergePSList(ParameterSetMap<T> &rPsList)
1630  {
1631    for (typename std::map<Int,T *>::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
1632    {
1633      storePS(i->first, i->second);
1634    }
1635    rPsList.m_paramsetMap.clear();
1636  }
1637
1638
1639  T* getPS(Int psId)
1640  {
1641    return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId];
1642  }
1643
1644  T* getFirstPS()
1645  {
1646    return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second;
1647  }
1648
1649private:
1650  std::map<Int,T *> m_paramsetMap;
1651  Int               m_maxId;
1652};
1653
1654class ParameterSetManager
1655{
1656public:
1657  ParameterSetManager();
1658  virtual ~ParameterSetManager();
1659
1660  //! store sequence parameter set and take ownership of it
1661  Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
1662  //! get pointer to existing video parameter set 
1663  TComVPS* getVPS(Int vpsId)  { return m_vpsMap.getPS(vpsId); };
1664  TComVPS* getFirstVPS()      { return m_vpsMap.getFirstPS(); };
1665 
1666  //! store sequence parameter set and take ownership of it
1667  Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
1668  //! get pointer to existing sequence parameter set 
1669  TComSPS* getSPS(Int spsId)  { return m_spsMap.getPS(spsId); };
1670  TComSPS* getFirstSPS()      { return m_spsMap.getFirstPS(); };
1671
1672  //! store picture parameter set and take ownership of it
1673  Void storePPS(TComPPS *pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
1674  //! get pointer to existing picture parameter set 
1675  TComPPS* getPPS(Int ppsId)  { return m_ppsMap.getPS(ppsId); };
1676  TComPPS* getFirstPPS()      { return m_ppsMap.getFirstPS(); };
1677
1678#if !REMOVE_APS
1679  //! store adaptation parameter set and take ownership of it
1680  Void storeAPS(TComAPS *aps) { m_apsMap.storePS( aps->getAPSID(), aps); };
1681  //! getPointer to existing adaptation parameter set 
1682  TComAPS* getAPS(Int apsId)  { return m_apsMap.getPS(apsId); };
1683#endif
1684protected:
1685 
1686  ParameterSetMap<TComVPS> m_vpsMap;
1687  ParameterSetMap<TComSPS> m_spsMap; 
1688  ParameterSetMap<TComPPS> m_ppsMap;
1689#if !REMOVE_APS
1690  ParameterSetMap<TComAPS> m_apsMap;
1691#endif
1692};
1693
1694//! \}
1695
1696#endif // __TCOMSLICE__
Note: See TracBrowser for help on using the repository browser.