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

Last change on this file since 1312 was 1295, checked in by seregin, 9 years ago

port rev 4327 (TComSlice::m_prevTid0POC)

  • Property svn:eol-style set to native
File size: 186.7 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-2015, 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#include "TComChromaFormat.h"
48
49//! \ingroup TLibCommon
50//! \{
51
52class TComPic;
53class TComTrQuant;
54
55#if SVC_EXTENSION
56class TComPicYuv;
57class TComSPS;
58#endif
59// ====================================================================================================================
60// Constants
61// ====================================================================================================================
62
63static const UInt REF_PIC_LIST_NUM_IDX=32;
64
65// ====================================================================================================================
66// Class definition
67// ====================================================================================================================
68
69/// Reference Picture Set class
70class TComReferencePictureSet
71{
72private:
73  Int  m_numberOfPictures;
74  Int  m_numberOfNegativePictures;
75  Int  m_numberOfPositivePictures;
76  Int  m_numberOfLongtermPictures;
77  Int  m_deltaPOC[MAX_NUM_REF_PICS];
78  Int  m_POC[MAX_NUM_REF_PICS];
79  Bool m_used[MAX_NUM_REF_PICS];
80  Bool m_interRPSPrediction;
81  Int  m_deltaRIdxMinus1;
82  Int  m_deltaRPS;
83  Int  m_numRefIdc;
84  Int  m_refIdc[MAX_NUM_REF_PICS+1];
85  Bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
86  Int  m_pocLSBLT[MAX_NUM_REF_PICS];
87  Int  m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
88  Bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];
89
90public:
91          TComReferencePictureSet();
92  virtual ~TComReferencePictureSet();
93  Int     getPocLSBLT(Int i) const                     { return m_pocLSBLT[i];               }
94  Void    setPocLSBLT(Int i, Int x)                    { m_pocLSBLT[i] = x;                  }
95  Int     getDeltaPocMSBCycleLT(Int i) const           { return m_deltaPOCMSBCycleLT[i];     }
96  Void    setDeltaPocMSBCycleLT(Int i, Int x)          { m_deltaPOCMSBCycleLT[i] = x;        }
97  Bool    getDeltaPocMSBPresentFlag(Int i) const       { return m_deltaPocMSBPresentFlag[i]; }
98  Void    setDeltaPocMSBPresentFlag(Int i, Bool x)     { m_deltaPocMSBPresentFlag[i] = x;    }
99  Void    setUsed(Int bufferNum, Bool used);
100  Void    setDeltaPOC(Int bufferNum, Int deltaPOC);
101  Void    setPOC(Int bufferNum, Int deltaPOC);
102  Void    setNumberOfPictures(Int numberOfPictures);
103  Void    setCheckLTMSBPresent(Int bufferNum, Bool b );
104  Bool    getCheckLTMSBPresent(Int bufferNum) const;
105
106  Int     getUsed(Int bufferNum) const;
107  Int     getDeltaPOC(Int bufferNum) const;
108  Int     getPOC(Int bufferNum) const;
109  Int     getNumberOfPictures() const;
110
111  Void    setNumberOfNegativePictures(Int number)      { m_numberOfNegativePictures = number; }
112  Int     getNumberOfNegativePictures() const          { return m_numberOfNegativePictures;   }
113  Void    setNumberOfPositivePictures(Int number)      { m_numberOfPositivePictures = number; }
114  Int     getNumberOfPositivePictures() const          { return m_numberOfPositivePictures;   }
115  Void    setNumberOfLongtermPictures(Int number)      { m_numberOfLongtermPictures = number; }
116  Int     getNumberOfLongtermPictures() const          { return m_numberOfLongtermPictures;   }
117
118  Void    setInterRPSPrediction(Bool flag)             { m_interRPSPrediction = flag;         }
119  Bool    getInterRPSPrediction() const                { return m_interRPSPrediction;         }
120  Void    setDeltaRIdxMinus1(Int x)                    { m_deltaRIdxMinus1 = x;               }
121  Int     getDeltaRIdxMinus1() const                   { return m_deltaRIdxMinus1;            }
122  Void    setDeltaRPS(Int x)                           { m_deltaRPS = x;                      }
123  Int     getDeltaRPS() const                          { return m_deltaRPS;                   }
124  Void    setNumRefIdc(Int x)                          { m_numRefIdc = x;                     }
125  Int     getNumRefIdc() const                         { return m_numRefIdc;                  }
126
127  Void    setRefIdc(Int bufferNum, Int refIdc);
128  Int     getRefIdc(Int bufferNum) const ;
129
130  Void    sortDeltaPOC();
131  Void    printDeltaPOC() const;
132};
133
134/// Reference Picture Set set class
135class TComRPSList
136{
137private:
138  std::vector<TComReferencePictureSet> m_referencePictureSets;
139
140public:
141                                 TComRPSList()                                            { }
142  virtual                        ~TComRPSList()                                           { }
143
144  Void                           create  (Int numberOfEntries)                            { m_referencePictureSets.resize(numberOfEntries);         }
145  Void                           destroy ()                                               { }
146
147
148  TComReferencePictureSet*       getReferencePictureSet(Int referencePictureSetNum)       { return &m_referencePictureSets[referencePictureSetNum]; }
149  const TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum) const { return &m_referencePictureSets[referencePictureSetNum]; }
150
151  Int                            getNumberOfReferencePictureSets() const                  { return Int(m_referencePictureSets.size());              }
152};
153
154/// SCALING_LIST class
155class TComScalingList
156{
157public:
158             TComScalingList();
159  virtual    ~TComScalingList()                                                 { }
160  Int*       getScalingListAddress(UInt sizeId, UInt listId)                    { return &(m_scalingListCoef[sizeId][listId][0]);            } //!< get matrix coefficient
161  const Int* getScalingListAddress(UInt sizeId, UInt listId) const              { return &(m_scalingListCoef[sizeId][listId][0]);            } //!< get matrix coefficient
162  Void       checkPredMode(UInt sizeId, UInt listId);
163
164  Void       setRefMatrixId(UInt sizeId, UInt listId, UInt u)                   { m_refMatrixId[sizeId][listId] = u;                         } //!< set reference matrix ID
165  UInt       getRefMatrixId(UInt sizeId, UInt listId) const                     { return m_refMatrixId[sizeId][listId];                      } //!< get reference matrix ID
166
167  const Int* getScalingListDefaultAddress(UInt sizeId, UInt listId);                                                                           //!< get default matrix coefficient
168  Void       processDefaultMatrix(UInt sizeId, UInt listId);
169
170  Void       setScalingListDC(UInt sizeId, UInt listId, UInt u)                 { m_scalingListDC[sizeId][listId] = u;                       } //!< set DC value
171  Int        getScalingListDC(UInt sizeId, UInt listId) const                   { return m_scalingListDC[sizeId][listId];                    } //!< get DC value
172
173  Void       setScalingListPredModeFlag(UInt sizeId, UInt listId, Bool bIsDPCM) { m_scalingListPredModeFlagIsDPCM[sizeId][listId] = bIsDPCM; }
174  Bool       getScalingListPredModeFlag(UInt sizeId, UInt listId) const         { return m_scalingListPredModeFlagIsDPCM[sizeId][listId];    }
175
176  Void       checkDcOfMatrix();
177  Void       processRefMatrix(UInt sizeId, UInt listId , UInt refListId );
178  Bool       xParseScalingList(Char* pchFile);
179  Void       setDefaultScalingList();
180  Bool       checkDefaultScalingList();
181
182private:
183  Void       outputScalingLists(std::ostream &os) const;
184  Bool             m_scalingListPredModeFlagIsDPCM [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
185  Int              m_scalingListDC                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
186  UInt             m_refMatrixId                   [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
187  std::vector<Int> m_scalingListCoef               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
188};
189
190class ProfileTierLevel
191{
192  Int               m_profileSpace;
193  Level::Tier       m_tierFlag;
194  Profile::Name     m_profileIdc;
195  Bool              m_profileCompatibilityFlag[32];
196  Level::Name       m_levelIdc;
197
198  Bool              m_progressiveSourceFlag;
199  Bool              m_interlacedSourceFlag;
200  Bool              m_nonPackedConstraintFlag;
201  Bool              m_frameOnlyConstraintFlag;
202  UInt              m_bitDepthConstraintValue;
203  ChromaFormat      m_chromaFormatConstraintValue;
204  Bool              m_intraConstraintFlag;
205  Bool              m_lowerBitRateConstraintFlag;
206
207public:
208                ProfileTierLevel();
209
210  Int           getProfileSpace() const                     { return m_profileSpace;                }
211  Void          setProfileSpace(Int x)                      { m_profileSpace = x;                   }
212
213  Level::Tier   getTierFlag() const                         { return m_tierFlag;                    }
214  Void          setTierFlag(Level::Tier x)                  { m_tierFlag = x;                       }
215
216  Profile::Name getProfileIdc() const                       { return m_profileIdc;                  }
217  Void          setProfileIdc(Profile::Name x)              { m_profileIdc = x;                     }
218
219  Bool          getProfileCompatibilityFlag(Int i) const    { return m_profileCompatibilityFlag[i]; }
220  Void          setProfileCompatibilityFlag(Int i, Bool x)  { m_profileCompatibilityFlag[i] = x;    }
221
222  Level::Name   getLevelIdc() const                         { return m_levelIdc;                    }
223  Void          setLevelIdc(Level::Name x)                  { m_levelIdc = x;                       }
224
225  Bool          getProgressiveSourceFlag() const            { return m_progressiveSourceFlag;       }
226  Void          setProgressiveSourceFlag(Bool b)            { m_progressiveSourceFlag = b;          }
227
228  Bool          getInterlacedSourceFlag() const             { return m_interlacedSourceFlag;        }
229  Void          setInterlacedSourceFlag(Bool b)             { m_interlacedSourceFlag = b;           }
230
231  Bool          getNonPackedConstraintFlag() const          { return m_nonPackedConstraintFlag;     }
232  Void          setNonPackedConstraintFlag(Bool b)          { m_nonPackedConstraintFlag = b;        }
233
234  Bool          getFrameOnlyConstraintFlag() const          { return m_frameOnlyConstraintFlag;     }
235  Void          setFrameOnlyConstraintFlag(Bool b)          { m_frameOnlyConstraintFlag = b;        }
236
237  UInt          getBitDepthConstraint() const               { return m_bitDepthConstraintValue;     }
238  Void          setBitDepthConstraint(UInt bitDepth)        { m_bitDepthConstraintValue=bitDepth;   }
239
240  ChromaFormat  getChromaFormatConstraint() const           { return m_chromaFormatConstraintValue; }
241  Void          setChromaFormatConstraint(ChromaFormat fmt) { m_chromaFormatConstraintValue=fmt;    }
242
243  Bool          getIntraConstraintFlag() const              { return m_intraConstraintFlag;         }
244  Void          setIntraConstraintFlag(Bool b)              { m_intraConstraintFlag = b;            }
245
246  Bool          getLowerBitRateConstraintFlag() const       { return m_lowerBitRateConstraintFlag;  }
247  Void          setLowerBitRateConstraintFlag(Bool b)       { m_lowerBitRateConstraintFlag = b;     }
248
249#if SVC_EXTENSION
250  Void          copyProfileInfo(ProfileTierLevel *ptl);
251#endif
252};
253
254
255class TComPTL
256{
257  ProfileTierLevel m_generalPTL;
258  ProfileTierLevel m_subLayerPTL    [MAX_TLAYER-1];      // max. value of max_sub_layers_minus1 is MAX_TLAYER-1 (= 6)
259  Bool m_subLayerProfilePresentFlag [MAX_TLAYER-1];
260  Bool m_subLayerLevelPresentFlag   [MAX_TLAYER-1];
261
262public:
263                          TComPTL();
264  Bool                    getSubLayerProfilePresentFlag(Int i) const   { return m_subLayerProfilePresentFlag[i]; }
265  Void                    setSubLayerProfilePresentFlag(Int i, Bool x) { m_subLayerProfilePresentFlag[i] = x;    }
266
267  Bool                    getSubLayerLevelPresentFlag(Int i) const     { return m_subLayerLevelPresentFlag[i];   }
268  Void                    setSubLayerLevelPresentFlag(Int i, Bool x)   { m_subLayerLevelPresentFlag[i] = x;      }
269
270  ProfileTierLevel*       getGeneralPTL()                              { return &m_generalPTL;                   }
271  const ProfileTierLevel* getGeneralPTL() const                        { return &m_generalPTL;                   }
272  ProfileTierLevel*       getSubLayerPTL(Int i)                        { return &m_subLayerPTL[i];               }
273  const ProfileTierLevel* getSubLayerPTL(Int i) const                  { return &m_subLayerPTL[i];               }
274
275#if SVC_EXTENSION
276  Void                    copyProfileInfo(TComPTL *ptl);
277#endif
278};
279
280/// VPS class
281
282struct HrdSubLayerInfo
283{
284  Bool fixedPicRateFlag;
285  Bool fixedPicRateWithinCvsFlag;
286  UInt picDurationInTcMinus1;
287  Bool lowDelayHrdFlag;
288  UInt cpbCntMinus1;
289  UInt bitRateValueMinus1[MAX_CPB_CNT][2];
290  UInt cpbSizeValue      [MAX_CPB_CNT][2];
291  UInt ducpbSizeValue    [MAX_CPB_CNT][2];
292  Bool cbrFlag           [MAX_CPB_CNT][2];
293  UInt duBitRateValue    [MAX_CPB_CNT][2];
294};
295
296class TComHRD
297{
298private:
299  Bool m_nalHrdParametersPresentFlag;
300  Bool m_vclHrdParametersPresentFlag;
301  Bool m_subPicCpbParamsPresentFlag;
302  UInt m_tickDivisorMinus2;
303  UInt m_duCpbRemovalDelayLengthMinus1;
304  Bool m_subPicCpbParamsInPicTimingSEIFlag;
305  UInt m_dpbOutputDelayDuLengthMinus1;
306  UInt m_bitRateScale;
307  UInt m_cpbSizeScale;
308  UInt m_ducpbSizeScale;
309  UInt m_initialCpbRemovalDelayLengthMinus1;
310  UInt m_cpbRemovalDelayLengthMinus1;
311  UInt m_dpbOutputDelayLengthMinus1;
312  HrdSubLayerInfo m_HRD[MAX_TLAYER];
313
314public:
315  TComHRD()
316  :m_nalHrdParametersPresentFlag       (0)
317  ,m_vclHrdParametersPresentFlag       (0)
318  ,m_subPicCpbParamsPresentFlag        (false)
319  ,m_tickDivisorMinus2                 (0)
320  ,m_duCpbRemovalDelayLengthMinus1     (0)
321  ,m_subPicCpbParamsInPicTimingSEIFlag (false)
322  ,m_dpbOutputDelayDuLengthMinus1      (0)
323  ,m_bitRateScale                      (0)
324  ,m_cpbSizeScale                      (0)
325  ,m_initialCpbRemovalDelayLengthMinus1(23)
326  ,m_cpbRemovalDelayLengthMinus1       (23)
327  ,m_dpbOutputDelayLengthMinus1        (23)
328  {}
329
330  virtual ~TComHRD() {}
331
332  Void    setNalHrdParametersPresentFlag( Bool flag )                                { m_nalHrdParametersPresentFlag = flag;                      }
333  Bool    getNalHrdParametersPresentFlag( ) const                                    { return m_nalHrdParametersPresentFlag;                      }
334
335  Void    setVclHrdParametersPresentFlag( Bool flag )                                { m_vclHrdParametersPresentFlag = flag;                      }
336  Bool    getVclHrdParametersPresentFlag( ) const                                    { return m_vclHrdParametersPresentFlag;                      }
337
338  Void    setSubPicCpbParamsPresentFlag( Bool flag )                                 { m_subPicCpbParamsPresentFlag = flag;                       }
339  Bool    getSubPicCpbParamsPresentFlag( ) const                                     { return m_subPicCpbParamsPresentFlag;                       }
340
341  Void    setTickDivisorMinus2( UInt value )                                         { m_tickDivisorMinus2 = value;                               }
342  UInt    getTickDivisorMinus2( ) const                                              { return m_tickDivisorMinus2;                                }
343
344  Void    setDuCpbRemovalDelayLengthMinus1( UInt value )                             { m_duCpbRemovalDelayLengthMinus1 = value;                   }
345  UInt    getDuCpbRemovalDelayLengthMinus1( ) const                                  { return m_duCpbRemovalDelayLengthMinus1;                    }
346
347  Void    setSubPicCpbParamsInPicTimingSEIFlag( Bool flag)                           { m_subPicCpbParamsInPicTimingSEIFlag = flag;                }
348  Bool    getSubPicCpbParamsInPicTimingSEIFlag( ) const                              { return m_subPicCpbParamsInPicTimingSEIFlag;                }
349
350  Void    setDpbOutputDelayDuLengthMinus1(UInt value )                               { m_dpbOutputDelayDuLengthMinus1 = value;                    }
351  UInt    getDpbOutputDelayDuLengthMinus1( ) const                                   { return m_dpbOutputDelayDuLengthMinus1;                     }
352
353  Void    setBitRateScale( UInt value )                                              { m_bitRateScale = value;                                    }
354  UInt    getBitRateScale( ) const                                                   { return m_bitRateScale;                                     }
355
356  Void    setCpbSizeScale( UInt value )                                              { m_cpbSizeScale = value;                                    }
357  UInt    getCpbSizeScale( ) const                                                   { return m_cpbSizeScale;                                     }
358  Void    setDuCpbSizeScale( UInt value )                                            { m_ducpbSizeScale = value;                                  }
359  UInt    getDuCpbSizeScale( ) const                                                 { return m_ducpbSizeScale;                                   }
360
361  Void    setInitialCpbRemovalDelayLengthMinus1( UInt value )                        { m_initialCpbRemovalDelayLengthMinus1 = value;              }
362  UInt    getInitialCpbRemovalDelayLengthMinus1( ) const                             { return m_initialCpbRemovalDelayLengthMinus1;               }
363
364  Void    setCpbRemovalDelayLengthMinus1( UInt value )                               { m_cpbRemovalDelayLengthMinus1 = value;                     }
365  UInt    getCpbRemovalDelayLengthMinus1( ) const                                    { return m_cpbRemovalDelayLengthMinus1;                      }
366
367  Void    setDpbOutputDelayLengthMinus1( UInt value )                                { m_dpbOutputDelayLengthMinus1 = value;                      }
368  UInt    getDpbOutputDelayLengthMinus1( ) const                                     { return m_dpbOutputDelayLengthMinus1;                       }
369
370  Void    setFixedPicRateFlag( Int layer, Bool flag )                                { m_HRD[layer].fixedPicRateFlag = flag;                      }
371  Bool    getFixedPicRateFlag( Int layer ) const                                     { return m_HRD[layer].fixedPicRateFlag;                      }
372
373  Void    setFixedPicRateWithinCvsFlag( Int layer, Bool flag )                       { m_HRD[layer].fixedPicRateWithinCvsFlag = flag;             }
374  Bool    getFixedPicRateWithinCvsFlag( Int layer ) const                            { return m_HRD[layer].fixedPicRateWithinCvsFlag;             }
375
376  Void    setPicDurationInTcMinus1( Int layer, UInt value )                          { m_HRD[layer].picDurationInTcMinus1 = value;                }
377  UInt    getPicDurationInTcMinus1( Int layer ) const                                { return m_HRD[layer].picDurationInTcMinus1;                 }
378
379  Void    setLowDelayHrdFlag( Int layer, Bool flag )                                 { m_HRD[layer].lowDelayHrdFlag = flag;                       }
380  Bool    getLowDelayHrdFlag( Int layer ) const                                      { return m_HRD[layer].lowDelayHrdFlag;                       }
381
382  Void    setCpbCntMinus1( Int layer, UInt value )                                   { m_HRD[layer].cpbCntMinus1 = value;                         }
383  UInt    getCpbCntMinus1( Int layer ) const                                         { return m_HRD[layer].cpbCntMinus1;                          }
384
385  Void    setBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value )   { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
386  UInt    getBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const         { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl];  }
387
388  Void    setCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value )   { m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl] = value;       }
389  UInt    getCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const         { return m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl];        }
390  Void    setDuCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl] = value;     }
391  UInt    getDuCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const       { return m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl];      }
392  Void    setDuBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl] = value;     }
393  UInt    getDuBitRateValueMinus1(Int layer, Int cpbcnt, Int nalOrVcl ) const        { return m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl];      }
394  Void    setCbrFlag( Int layer, Int cpbcnt, Int nalOrVcl, Bool value )              { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value;            }
395  Bool    getCbrFlag( Int layer, Int cpbcnt, Int nalOrVcl ) const                    { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl];             }
396
397  Bool    getCpbDpbDelaysPresentFlag( ) const                      { return getNalHrdParametersPresentFlag() || getVclHrdParametersPresentFlag(); }
398
399#if SVC_EXTENSION
400Void copyCommonInformation( TComHRD *refHrd )
401{
402  m_nalHrdParametersPresentFlag         = refHrd->getNalHrdParametersPresentFlag();
403  m_vclHrdParametersPresentFlag         = refHrd->getVclHrdParametersPresentFlag();
404  m_subPicCpbParamsPresentFlag          = refHrd->getSubPicCpbParamsPresentFlag();
405  m_tickDivisorMinus2                   = refHrd->getTickDivisorMinus2();
406  m_duCpbRemovalDelayLengthMinus1       = refHrd->getDuCpbRemovalDelayLengthMinus1();
407  m_subPicCpbParamsInPicTimingSEIFlag   = refHrd->getSubPicCpbParamsInPicTimingSEIFlag();
408  m_dpbOutputDelayDuLengthMinus1        = refHrd->getDpbOutputDelayDuLengthMinus1();
409  m_bitRateScale                        = refHrd->getBitRateScale();
410  m_cpbSizeScale                        = refHrd->getCpbSizeScale();
411  m_ducpbSizeScale                      = refHrd->getDuCpbSizeScale();
412  m_initialCpbRemovalDelayLengthMinus1  = refHrd->getInitialCpbRemovalDelayLengthMinus1();
413  m_cpbRemovalDelayLengthMinus1         = refHrd->getCpbRemovalDelayLengthMinus1();
414  m_dpbOutputDelayLengthMinus1          = refHrd->getDpbOutputDelayLengthMinus1();
415}
416#endif
417};
418
419class TimingInfo
420{
421  Bool m_timingInfoPresentFlag;
422  UInt m_numUnitsInTick;
423  UInt m_timeScale;
424  Bool m_pocProportionalToTimingFlag;
425  Int  m_numTicksPocDiffOneMinus1;
426public:
427  TimingInfo()
428  : m_timingInfoPresentFlag      (false)
429  , m_numUnitsInTick             (1001)
430  , m_timeScale                  (60000)
431  , m_pocProportionalToTimingFlag(false)
432  , m_numTicksPocDiffOneMinus1   (0)
433  {}
434
435  Void setTimingInfoPresentFlag( Bool flag )   { m_timingInfoPresentFlag = flag;       }
436  Bool getTimingInfoPresentFlag( ) const       { return m_timingInfoPresentFlag;       }
437
438  Void setNumUnitsInTick( UInt value )         { m_numUnitsInTick = value;             }
439  UInt getNumUnitsInTick( ) const              { return m_numUnitsInTick;              }
440
441  Void setTimeScale( UInt value )              { m_timeScale = value;                  }
442  UInt getTimeScale( ) const                   { return m_timeScale;                   }
443
444  Void setPocProportionalToTimingFlag(Bool x)  { m_pocProportionalToTimingFlag = x;    }
445  Bool getPocProportionalToTimingFlag( ) const { return m_pocProportionalToTimingFlag; }
446
447  Void setNumTicksPocDiffOneMinus1(Int x)      { m_numTicksPocDiffOneMinus1 = x;       }
448  Int  getNumTicksPocDiffOneMinus1( ) const    { return m_numTicksPocDiffOneMinus1;    }
449};
450
451struct ChromaQpAdj
452{
453  union
454  {
455    struct {
456      Int CbOffset;
457      Int CrOffset;
458    } comp;
459    Int offset[2]; /* two chroma components */
460  } u;
461};
462
463
464class Window
465{
466private:
467  Bool m_enabledFlag;
468  Int  m_winLeftOffset;
469  Int  m_winRightOffset;
470  Int  m_winTopOffset;
471  Int  m_winBottomOffset;
472public:
473  Window()
474  : m_enabledFlag    (false)
475  , m_winLeftOffset  (0)
476  , m_winRightOffset (0)
477  , m_winTopOffset   (0)
478  , m_winBottomOffset(0)
479  { }
480
481  Bool getWindowEnabledFlag() const   { return m_enabledFlag;                          }
482  Int  getWindowLeftOffset() const    { return m_enabledFlag ? m_winLeftOffset : 0;    }
483  Void setWindowLeftOffset(Int val)   { m_winLeftOffset = val; m_enabledFlag = true;   }
484  Int  getWindowRightOffset() const   { return m_enabledFlag ? m_winRightOffset : 0;   }
485  Void setWindowRightOffset(Int val)  { m_winRightOffset = val; m_enabledFlag = true;  }
486  Int  getWindowTopOffset() const     { return m_enabledFlag ? m_winTopOffset : 0;     }
487  Void setWindowTopOffset(Int val)    { m_winTopOffset = val; m_enabledFlag = true;    }
488  Int  getWindowBottomOffset() const  { return m_enabledFlag ? m_winBottomOffset: 0;   }
489  Void setWindowBottomOffset(Int val) { m_winBottomOffset = val; m_enabledFlag = true; }
490
491#if SVC_EXTENSION
492  Bool hasEqualOffset(const Window& ref) const
493  {
494    return (    this->getWindowLeftOffset()   == ref.getWindowLeftOffset()
495             && this->getWindowTopOffset()    == ref.getWindowTopOffset()
496             && this->getWindowRightOffset()  == ref.getWindowRightOffset()
497             && this->getWindowBottomOffset() == ref.getWindowBottomOffset() );
498  }
499#endif
500
501 Void setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
502  {
503    m_enabledFlag     = true;
504    m_winLeftOffset   = offsetLeft;
505    m_winRightOffset  = offsetLRight;
506    m_winTopOffset    = offsetLTop;
507    m_winBottomOffset = offsetLBottom;
508  }
509};
510
511#if SVC_EXTENSION
512struct ResamplingPhase
513{
514 Bool phasePresentFlag;
515 Int  phaseHorLuma;
516 Int  phaseVerLuma;
517 Int  phaseHorChroma;
518 Int  phaseVerChroma;
519
520 ResamplingPhase()
521  : phasePresentFlag (false)
522  , phaseHorLuma     (0)
523  , phaseVerLuma     (0)
524  , phaseHorChroma   (0)
525  , phaseVerChroma   (0)
526 {
527 }
528};
529
530class RepFormat
531{
532  Bool m_chromaAndBitDepthVpsPresentFlag;
533  ChromaFormat m_chromaFormatVpsIdc;
534  Bool m_separateColourPlaneVpsFlag;
535  Int  m_picWidthVpsInLumaSamples;
536  Int  m_picHeightVpsInLumaSamples;
537  Int  m_bitDepthVpsLuma;               // coded as minus8
538  Int  m_bitDepthVpsChroma;             // coded as minus8
539
540  Window m_conformanceWindowVps;
541
542public:
543  RepFormat();
544  Bool getChromaAndBitDepthVpsPresentFlag() const             { return m_chromaAndBitDepthVpsPresentFlag;                        }
545  void setChromaAndBitDepthVpsPresentFlag(Bool x)             { m_chromaAndBitDepthVpsPresentFlag = x;                           }
546
547  ChromaFormat getChromaFormatVpsIdc() const                  { return m_chromaFormatVpsIdc;                                     }
548  Void setChromaFormatVpsIdc(ChromaFormat x)                  { m_chromaFormatVpsIdc = x;                                        }
549
550  Bool getSeparateColourPlaneVpsFlag() const                  { return m_separateColourPlaneVpsFlag;                             }
551  Void setSeparateColourPlaneVpsFlag(Bool x)                  { m_separateColourPlaneVpsFlag = x;                                }
552
553  Int  getPicWidthVpsInLumaSamples() const                    { return m_picWidthVpsInLumaSamples;                               }
554  Void setPicWidthVpsInLumaSamples(Int x)                     { m_picWidthVpsInLumaSamples = x;                                  }
555
556  Int  getPicHeightVpsInLumaSamples() const                   { return m_picHeightVpsInLumaSamples;                              }
557  Void setPicHeightVpsInLumaSamples(Int x)                    { m_picHeightVpsInLumaSamples = x;                                 }
558
559  Int  getBitDepthVpsLuma() const                             { return m_bitDepthVpsLuma;                                        }
560  Void setBitDepthVpsLuma(Int x)                              { m_bitDepthVpsLuma = x;                                           }
561   
562  Int  getBitDepthVpsChroma() const                           { return m_bitDepthVpsChroma;                                      }
563  Void setBitDepthVpsChroma(Int x)                            { m_bitDepthVpsChroma = x;                                         }
564
565  Int  getBitDepthVps(ChannelType type) const                 { return isLuma(type) ? m_bitDepthVpsLuma : m_bitDepthVpsChroma;   }
566
567  Window& getConformanceWindowVps()                           { return m_conformanceWindowVps;                                   }
568  const Window& getConformanceWindowVps() const               { return m_conformanceWindowVps;                                   }
569  Void    setConformanceWindowVps(Window& conformanceWindow ) { m_conformanceWindowVps = conformanceWindow;                      }
570};
571#endif
572
573class TComVPS
574{
575private:
576  Int                   m_VPSId;
577  UInt                  m_uiMaxTLayers;
578  UInt                  m_uiMaxLayers;
579  Bool                  m_bTemporalIdNestingFlag;
580
581  UInt                  m_numReorderPics[MAX_TLAYER];
582  UInt                  m_uiMaxDecPicBuffering[MAX_TLAYER];
583  UInt                  m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
584
585  UInt                  m_numHrdParameters;
586#if !SVC_EXTENSION
587  UInt                  m_maxNuhReservedZeroLayerId;
588#endif
589  std::vector<TComHRD>  m_hrdParameters;
590  std::vector<UInt>     m_hrdOpSetIdx;
591  std::vector<Bool>     m_cprmsPresentFlag;
592#if !SVC_EXTENSION
593  UInt                  m_numOpSets;
594  Bool                  m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1];
595
596  TComPTL               m_pcPTL;
597#endif
598  TimingInfo            m_timingInfo;
599
600#if SVC_EXTENSION
601  Bool                  m_baseLayerInternalFlag;
602  Bool                  m_baseLayerAvailableFlag;
603  TComPTL               m_pcPTLList[MAX_NUM_LAYER_IDS + 1];
604
605  std::vector< std::vector<Int> >     m_layerSetLayerIdList;
606  std::vector<Int>                    m_numLayerInIdList;
607
608  UInt                  m_maxLayerId;
609  UInt                  m_numLayerSets;
610
611  UInt                  m_vpsNumLayerSetsMinus1;
612  Bool                  m_layerIdIncludedFlag[MAX_VPS_LAYER_SETS_PLUS1 + MAX_NUM_ADD_LAYER_SETS][MAX_NUM_LAYER_IDS];
613
614  // ------------------------------------------
615  // Variables related to VPS extensions
616  // ------------------------------------------
617  Bool                  m_nonHEVCBaseLayerFlag; 
618  Bool                  m_splittingFlag;
619  Bool                  m_scalabilityMask[MAX_VPS_NUM_SCALABILITY_TYPES];
620  UInt                  m_dimensionIdLen[MAX_VPS_NUM_SCALABILITY_TYPES];
621  Bool                  m_nuhLayerIdPresentFlag;
622  UInt                  m_layerIdInNuh[MAX_VPS_LAYER_IDX_PLUS1];            // Maps layer ID in the VPS with layer_id_in_nuh
623  UInt                  m_dimensionId[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_NUM_SCALABILITY_TYPES];
624
625  // Below are derived variables
626  UInt                  m_numScalabilityTypes;
627  UInt                  m_layerIdxInVps[MAX_NUM_LAYER_IDS];            // Maps layer_id_in_nuh with the layer ID in the VPS
628  UInt                  m_maxSLInLayerSetMinus1[MAX_VPS_LAYER_SETS_PLUS1 + MAX_NUM_ADD_LAYER_SETS];
629  Bool                  m_ilpSshSignalingEnabledFlag;
630
631  // Profile-tier-level signalling related
632  Bool                  m_profilePresentFlag[MAX_VPS_LAYER_SETS_PLUS1];    // The value with index 0 will not be used.
633
634  // Target output layer signalling related
635  UInt                  m_numOutputLayerSets;
636  UInt                  m_outputLayerSetIdx[MAX_VPS_LAYER_SETS_PLUS1 + 2*MAX_NUM_ADD_LAYER_SETS];
637  Bool                  m_outputLayerFlag[MAX_VPS_LAYER_SETS_PLUS1 + 2*MAX_NUM_ADD_LAYER_SETS][MAX_VPS_LAYER_IDX_PLUS1];
638  Bool                  m_directDependencyFlag[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
639  UInt                  m_numDirectRefLayers[MAX_VPS_LAYER_IDX_PLUS1];
640  UInt                  m_refLayerId[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
641  UInt                  m_directDepTypeLen;
642  Bool                  m_defaultDirectDependencyTypeFlag;
643  UInt                  m_defaultDirectDependencyType;
644  UInt                  m_directDependencyType[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
645
646  UInt                  m_numProfileTierLevel;
647  Int                   m_numAddOutputLayerSets;
648  UInt                  m_defaultTargetOutputLayerIdc;
649  std::vector< std::vector<Int> >  m_profileLevelTierIdx;
650  Bool                  m_maxOneActiveRefLayerFlag;
651  Bool                  m_pocLsbNotPresentFlag[MAX_VPS_LAYER_IDX_PLUS1];
652  Bool                  m_crossLayerPictureTypeAlignFlag;
653  Bool                  m_crossLayerIrapAlignFlag;
654  Bool                  m_crossLayerAlignedIdrOnlyFlag;
655  UInt                  m_maxTidIlRefPicsPlus1[MAX_VPS_LAYER_IDX_PLUS1 - 1][MAX_VPS_LAYER_IDX_PLUS1];
656  Bool                  m_maxTidRefPresentFlag;
657  Bool                  m_maxTSLayersPresentFlag;
658  UInt                  m_maxTSLayerMinus1[MAX_LAYERS];
659  Bool                  m_singleLayerForNonIrapFlag;
660  Bool                  m_higherLayerIrapSkipFlag;
661  Bool                  m_tilesNotInUseFlag;
662  Bool                  m_tilesInUseFlag[MAX_VPS_LAYER_IDX_PLUS1];
663  Bool                  m_loopFilterNotAcrossTilesFlag[MAX_VPS_LAYER_IDX_PLUS1];
664  Bool                  m_tileBoundariesAlignedFlag[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
665  Bool                  m_wppNotInUseFlag;
666  Bool                  m_wppInUseFlag[MAX_VPS_LAYER_IDX_PLUS1];
667
668  Bool                  m_ilpRestrictedRefLayersFlag;
669  Int                   m_minSpatialSegmentOffsetPlus1[MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
670  Bool                  m_ctuBasedOffsetEnabledFlag   [MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
671  Int                   m_minHorizontalCtuOffsetPlus1 [MAX_VPS_LAYER_IDX_PLUS1][MAX_VPS_LAYER_IDX_PLUS1];
672
673  Bool                  m_vidSigPresentVpsFlag;
674  Int                   m_vpsVidSigInfo;
675  Int                   m_vpsVidSigIdx[MAX_VPS_LAYER_IDX_PLUS1];
676  Int                   m_vpsVidFormat[16];
677  Bool                  m_vpsFullRangeFlag[16];
678  Int                   m_vpsColorPrimaries[16];
679  Int                   m_vpsTransChar[16];
680  Int                   m_vpsMatCoeff[16];
681
682  Bool                  m_bitRatePresentVpsFlag;
683  Bool                  m_picRatePresentVpsFlag;
684  Bool                  m_bitRatePresentFlag  [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
685  Bool                  m_picRatePresentFlag  [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
686  Int                   m_avgBitRate          [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
687  Int                   m_maxBitRate          [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
688  Int                   m_constPicRateIdc     [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
689  Int                   m_avgPicRate          [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
690
691  Bool                  m_altOutputLayerFlag[MAX_VPS_LAYER_SETS_PLUS1 + 2*MAX_NUM_ADD_LAYER_SETS];
692
693  Bool                  m_repFormatIdxPresentFlag;
694  Int                   m_vpsNumRepFormats;            // coded as minus1
695  RepFormat             m_vpsRepFormat[16];
696  Int                   m_vpsRepFormatIdx[16];
697
698  Int                   m_viewIdLen;
699  Int                   m_viewIdVal[MAX_LAYERS];
700
701  Int                   m_numberRefLayers[MAX_NUM_LAYER_IDS];  // number of direct and indirect reference layers of a coding layer
702  Bool                  m_recursiveRefLayerFlag[MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];  // flag to indicate if j-th layer is a direct or indirect reference layer of i-th layer
703
704  Int                   m_numAddLayerSets;
705  UInt                  m_highestLayerIdxPlus1[MAX_NUM_ADD_LAYER_SETS][MAX_NUM_LAYER_IDS];
706  UInt                  m_predictedLayerId[MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
707  UInt                  m_numPredictedLayers[MAX_NUM_LAYER_IDS];
708  Int                   m_numIndependentLayers;
709  Int                   m_numLayersInTreePartition[MAX_LAYERS];
710  UInt                  m_treePartitionLayerIdList[MAX_LAYERS][MAX_LAYERS];
711
712  Int                   m_TolsIdx;
713  Bool                  m_subLayerFlagInfoPresentFlag [MAX_VPS_OP_LAYER_SETS_PLUS1];
714  Bool                  m_subLayerDpbInfoPresentFlag  [MAX_VPS_OP_LAYER_SETS_PLUS1][MAX_LAYERS];
715  Int                   m_maxVpsDecPicBufferingMinus1 [MAX_VPS_OP_LAYER_SETS_PLUS1][MAX_LAYERS][MAX_TLAYER];
716  Int                   m_maxVpsNumReorderPics        [MAX_VPS_OP_LAYER_SETS_PLUS1][MAX_LAYERS];
717  Int                   m_maxVpsLatencyIncreasePlus1  [MAX_VPS_OP_LAYER_SETS_PLUS1][MAX_LAYERS];
718  Int                   m_numSubDpbs                  [MAX_VPS_LAYER_SETS_PLUS1 + 2*MAX_NUM_ADD_LAYER_SETS];
719
720  Bool                  m_vpsVuiPresentFlag;
721  Bool                  m_vpsExtensionFlag;
722
723#if O0164_MULTI_LAYER_HRD
724  Bool                  m_vpsVuiBspHrdPresentFlag;
725  Int                   m_vpsNumAddHrdParams;
726  std::vector<Bool>     m_cprmsAddPresentFlag;
727  std::vector<Int>      m_numSubLayerHrdMinus1;
728  std::vector<TComHRD>  m_bspHrd;
729  Int                   m_numSignalledPartitioningSchemes[MAX_VPS_OUTPUT_LAYER_SETS_PLUS1];
730  Int                   m_numPartitionsInSchemeMinus1    [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16];
731  Int                   m_layerIncludedInPartitionFlag   [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_LAYERS][MAX_LAYERS];
732  Int                   m_numBspSchedulesMinus1          [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER];
733  Int                   m_bspHrdIdx                      [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER][31][MAX_LAYERS];
734  Int                   m_bspSchedIdx                    [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER][31][MAX_LAYERS];
735#endif
736  UInt                  m_baseLayerPSCompatibilityFlag[MAX_LAYERS];
737  Int                   m_vpsNonVuiExtLength;
738  Bool                  m_vpsPocLsbAlignedFlag;
739  std::vector< std::vector<Bool> > m_necessaryLayerFlag;
740  std::vector<Int>                 m_numNecessaryLayers;
741#endif //SVC_EXTENSION
742
743public:
744                    TComVPS();
745
746  virtual           ~TComVPS();
747
748  Void              createHrdParamBuffer()
749  {
750    m_hrdParameters.resize(getNumHrdParameters());
751    m_hrdOpSetIdx.resize(getNumHrdParameters());
752    m_cprmsPresentFlag.resize(getNumHrdParameters());
753  }
754
755  TComHRD*          getHrdParameters( UInt i )                           { return &m_hrdParameters[ i ];                                    }
756  const TComHRD*    getHrdParameters( UInt i ) const                     { return &m_hrdParameters[ i ];                                    }
757  UInt              getHrdOpSetIdx( UInt i ) const                       { return m_hrdOpSetIdx[ i ];                                       }
758  Void              setHrdOpSetIdx( UInt val, UInt i )                   { m_hrdOpSetIdx[ i ] = val;                                        }
759  Bool              getCprmsPresentFlag( UInt i ) const                  { return m_cprmsPresentFlag[ i ];                                  }
760  Void              setCprmsPresentFlag( Bool val, UInt i )              { m_cprmsPresentFlag[ i ] = val;                                   }
761
762  Int               getVPSId() const                                     { return m_VPSId;                                                  }
763  Void              setVPSId(Int i)                                      { m_VPSId = i;                                                     }
764
765  UInt              getMaxTLayers() const                                { return m_uiMaxTLayers;                                           }
766  Void              setMaxTLayers(UInt t)                                { m_uiMaxTLayers = t;                                              }
767
768  UInt              getMaxLayers() const                                 { return m_uiMaxLayers;                                            }
769  Void              setMaxLayers(UInt l)                                 { m_uiMaxLayers = l;                                               }
770
771  Bool              getTemporalNestingFlag() const                       { return m_bTemporalIdNestingFlag;                                 }
772  Void              setTemporalNestingFlag(Bool t)                       { m_bTemporalIdNestingFlag = t;                                    }
773
774  Void              setNumReorderPics(UInt v, UInt tLayer)               { m_numReorderPics[tLayer] = v;                                    }
775  UInt              getNumReorderPics(UInt tLayer) const                 { return m_numReorderPics[tLayer];                                 }
776
777  Void              setMaxDecPicBuffering(UInt v, UInt tLayer)           { assert(tLayer < MAX_TLAYER); m_uiMaxDecPicBuffering[tLayer] = v; }
778  UInt              getMaxDecPicBuffering(UInt tLayer) const             { return m_uiMaxDecPicBuffering[tLayer];                           }
779
780  Void              setMaxLatencyIncrease(UInt v, UInt tLayer)           { m_uiMaxLatencyIncrease[tLayer] = v;                              }
781  UInt              getMaxLatencyIncrease(UInt tLayer) const             { return m_uiMaxLatencyIncrease[tLayer];                           }
782
783  UInt              getNumHrdParameters() const                          { return m_numHrdParameters;                                       }
784  Void              setNumHrdParameters(UInt v)                          { m_numHrdParameters = v;                                          }
785 
786#if !SVC_EXTENSION
787  UInt              getMaxNuhReservedZeroLayerId() const                 { return m_maxNuhReservedZeroLayerId;                              }
788  Void              setMaxNuhReservedZeroLayerId(UInt v)                 { m_maxNuhReservedZeroLayerId = v;                                 }
789
790  UInt              getMaxOpSets() const                                 { return m_numOpSets;                                              }
791  Void              setMaxOpSets(UInt v)                                 { m_numOpSets = v;                                                 }
792#endif
793  Bool              getLayerIdIncludedFlag(UInt opsIdx, UInt id) const   { return m_layerIdIncludedFlag[opsIdx][id];                        }
794  Void              setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id) { m_layerIdIncludedFlag[opsIdx][id] = v;                           }
795
796#if !SVC_EXTENSION
797  TComPTL*          getPTL()                                             { return &m_pcPTL;                                                 }
798  const TComPTL*    getPTL() const                                       { return &m_pcPTL;                                                 }
799#endif
800
801  TimingInfo*       getTimingInfo()                                      { return &m_timingInfo;                                            }
802  const TimingInfo* getTimingInfo() const                                { return &m_timingInfo;                                            }
803
804#if SVC_EXTENSION
805  Void              setBaseLayerInternalFlag(Bool x)                     { m_baseLayerInternalFlag = x;                                     }
806  Bool              getBaseLayerInternalFlag() const                     { return m_baseLayerInternalFlag;                                  }
807  Void              setBaseLayerAvailableFlag(Bool x)                    { m_baseLayerAvailableFlag = x;                                    }
808  Bool              getBaseLayerAvailableFlag() const                    { return m_baseLayerAvailableFlag;                                 }
809
810#if O0164_MULTI_LAYER_HRD
811  Void              createBspHrdParamBuffer(UInt numHrds)
812  {
813    m_bspHrd.resize( numHrds );
814    m_cprmsAddPresentFlag.resize( numHrds );
815    m_numSubLayerHrdMinus1.resize( numHrds );
816  }
817#endif
818
819  Int               getBspHrdParamBufferCpbCntMinus1(UInt i, UInt sl)    { return m_bspHrd[i].getCpbCntMinus1(sl);                          }
820
821  TComPTL*          getPTL()                                             { return &m_pcPTLList[0];                                          }
822  const TComPTL*    getPTL() const                                       { return &m_pcPTLList[0];                                          }
823  TComPTL*          getPTL(UInt idx)                                     { return &m_pcPTLList[idx];                                        }
824  const TComPTL*    getPTL(UInt idx) const                               { return &m_pcPTLList[idx];                                        }
825
826  Int               getLayerSetLayerIdList(Int set, Int layerId) const   { return m_layerSetLayerIdList[set][layerId];                      }
827  Void              setLayerSetLayerIdList(Int set, Int layerId, Int x)  { m_layerSetLayerIdList[set][layerId] = x;                         }
828
829  Int               getNumLayersInIdList(Int set) const                  { return m_numLayerInIdList[set];                                  }
830  Void              setNumLayersInIdList(Int set, Int x)                 { m_numLayerInIdList[set] = x;                                     }
831
832  Void              deriveLayerIdListVariables();
833  Void              deriveNumberOfSubDpbs();
834
835  Void              setRefLayersFlags(Int currLayerId);
836  Bool              getRecursiveRefLayerFlag(Int currLayerId, Int refLayerId) const    { return m_recursiveRefLayerFlag[currLayerId][refLayerId];}
837  Void              setRecursiveRefLayerFlag(Int currLayerId, Int refLayerId, Bool x)  { m_recursiveRefLayerFlag[currLayerId][refLayerId] = x;   }
838  Int               getNumRefLayers(Int currLayerId) const                             { return m_numberRefLayers[currLayerId];                  }
839  Void              setNumRefLayers();
840
841  Void              deriveLayerIdListVariablesForAddLayerSets();
842  UInt              getVpsNumLayerSetsMinus1() const                                   { return m_vpsNumLayerSetsMinus1;                      }
843  Void              setVpsNumLayerSetsMinus1(UInt x)                                   { m_vpsNumLayerSetsMinus1 = x;                         }
844  UInt              getNumAddLayerSets() const                                         { return m_numAddLayerSets;                            }
845  Void              setNumAddLayerSets(UInt x)                                         { m_numAddLayerSets = x; }
846  UInt              getHighestLayerIdxPlus1(UInt set, UInt idx) const                  { return m_highestLayerIdxPlus1[set][idx];             }
847  Void              setHighestLayerIdxPlus1(UInt set, UInt idx, UInt layerIdx)         { m_highestLayerIdxPlus1[set][idx] = layerIdx;         }
848  Void              setPredictedLayerIds();
849  UInt              getPredictedLayerId(UInt layerId, UInt predIdx) const              { return m_predictedLayerId[layerId][predIdx];         }
850  Void              setPredictedLayerId(UInt layerId, UInt predIdx, UInt x)            { m_predictedLayerId[layerId][predIdx] = x;            }
851  UInt              getNumPredictedLayers(UInt layerId) const                          { return m_numPredictedLayers[layerId];                }
852  Void              setNumPredictedLayers(UInt layerId, UInt x)                        { m_numPredictedLayers[layerId] = x;                   }
853  Void              setTreePartitionLayerIdList();
854  Int               getNumIndependentLayers() const                                    { return m_numIndependentLayers;                       }
855  Void              setNumIndependentLayers(Int x)                                     { m_numIndependentLayers = x;                          }
856  Int               getNumLayersInTreePartition(Int idx) const                         { return m_numLayersInTreePartition[idx];              }
857  Void              setNumLayersInTreePartition(Int idx, Int x)                        { m_numLayersInTreePartition[idx] = x;                 }
858  UInt              getTreePartitionLayerId(Int idx, Int layerIdx) const               { return m_treePartitionLayerIdList[idx][layerIdx];    }
859  Void              setTreePartitionLayerId(Int idx, Int layerIdx, UInt layerId)       { m_treePartitionLayerIdList[idx][layerIdx] = layerId; }
860
861  UInt              getMaxLayerId() const                                              { return m_maxLayerId;                               }
862  Void              setMaxLayerId(UInt v)                                              { m_maxLayerId = v;                                  }
863  UInt              getNumLayerSets() const                                            { return m_numLayerSets;                             }
864  Void              setNumLayerSets(UInt v)                                            { m_numLayerSets = v;                                }
865
866  Bool              getNonHEVCBaseLayerFlag() const                                    { return m_nonHEVCBaseLayerFlag;                     }
867  Void              setNonHEVCBaseLayerFlag(Bool x)                                    { m_nonHEVCBaseLayerFlag = x;                        }
868
869  Bool              getSplittingFlag() const                                           { return m_splittingFlag;                            }
870  Void              setSplittingFlag(Bool x)                                           { m_splittingFlag = x;                               }
871
872  Bool              getScalabilityMask(Int id) const                                   { return m_scalabilityMask[id];                      }
873  Void              setScalabilityMask(Int id, Bool x)                                 { m_scalabilityMask[id] = x;                         }
874
875  UInt              getDimensionIdLen(Int id) const                                    { return m_dimensionIdLen[id];                       }
876  Void              setDimensionIdLen(Int id, UInt x)                                  { m_dimensionIdLen[id] = x;                          }
877
878  Bool              getNuhLayerIdPresentFlag() const                                   { return m_nuhLayerIdPresentFlag;                    }
879  Void              setNuhLayerIdPresentFlag(Bool x)                                   { m_nuhLayerIdPresentFlag = x;                       }
880
881  UInt              getLayerIdInNuh(Int layerIdx) const                                { return m_layerIdInNuh[layerIdx];                   }
882  Void              setLayerIdInNuh(Int layerIdx, UInt layerId)                        { m_layerIdInNuh[layerIdx] = layerId;                }
883
884  UInt              getDimensionId(Int layerIdx, Int id) const                         { return m_dimensionId[layerIdx][id];                }
885  Void              setDimensionId(Int layerIdx, Int id, UInt x)                       { m_dimensionId[layerIdx][id] = x;                   }
886
887  UInt              getNumScalabilityTypes() const                                     { return m_numScalabilityTypes;                      }
888  Void              setNumScalabilityTypes(UInt x)                                     { m_numScalabilityTypes = x;                         }
889
890  UInt              getLayerIdxInVps(Int layerId) const                                { return m_layerIdxInVps[layerId];                   }
891  Void              setLayerIdxInVps(Int layerId, UInt layerIdx)                       { m_layerIdxInVps[layerId] = layerIdx;               }
892
893  UInt              getMaxSLayersInLayerSetMinus1(Int ls) const                        { return m_maxSLInLayerSetMinus1[ls];                }
894  Void              setMaxSLayersInLayerSetMinus1(Int ls, Int x)                       { m_maxSLInLayerSetMinus1[ls] = x;                   }
895  Bool              getIlpSshSignalingEnabledFlag() const                              { return m_ilpSshSignalingEnabledFlag;               }
896  Void              setIlpSshSignalingEnabledFlag(Bool x)                              { m_ilpSshSignalingEnabledFlag = x;                  }
897
898  Bool              getProfilePresentFlag(Int id) const                                { return m_profilePresentFlag[id];                   }
899  Void              setProfilePresentFlag(Int id, Bool x)                              { m_profilePresentFlag[id] = x;                      }
900
901  // Target output layer signalling related
902  UInt              getNumOutputLayerSets() const                                      { return m_numOutputLayerSets;                       } 
903  Void              setNumOutputLayerSets(Int x)                                       { m_numOutputLayerSets = x;                          }
904 
905  UInt              getOutputLayerSetIdx(Int idx) const                                { return m_outputLayerSetIdx[idx];                   }
906  Void              setOutputLayerSetIdx(Int idx, UInt x)                              { m_outputLayerSetIdx[idx] = x;                      }
907
908  Bool              getOutputLayerFlag(Int layerSet, Int layerIdx) const               { return m_outputLayerFlag[layerSet][layerIdx];      }
909  Void              setOutputLayerFlag(Int layerSet, Int layerIdx, Bool x)             { m_outputLayerFlag[layerSet][layerIdx] = x;         }
910
911  // Direct dependency of layers
912  Bool              getDirectDependencyFlag(Int currLayerIdx, Int refLayerIdx) const   { return m_directDependencyFlag[currLayerIdx][refLayerIdx]; }
913  Void              setDirectDependencyFlag(Int currLayerIdx, Int refLayerIdx, Bool x) { m_directDependencyFlag[currLayerIdx][refLayerIdx] = x;    }
914 
915  UInt              getNumDirectRefLayers(Int layerId) const                           { return m_numDirectRefLayers[layerId];                   }
916  Void              setNumDirectRefLayers(Int layerId, UInt refLayerNum)               { m_numDirectRefLayers[layerId] = refLayerNum;            }
917
918  UInt              getRefLayerId(Int layerId, Int refLayerIdc) const                  { return m_refLayerId[layerId][refLayerIdc];              }
919  Void              setRefLayerId(Int layerId, Int refLayerIdc, UInt refLayerId)       { m_refLayerId[layerId][refLayerIdc] = refLayerId;        }
920
921  UInt              getDirectDepTypeLen() const                                        { return m_directDepTypeLen;                              }
922  Void              setDirectDepTypeLen(UInt x)                                        { m_directDepTypeLen = x;                                 }
923  Bool              getDefaultDirectDependencyTypeFlag() const                         { return m_defaultDirectDependencyTypeFlag;               }
924  Void              setDefaultDirectDependecyTypeFlag(Bool x)                          { m_defaultDirectDependencyTypeFlag = x;                  }
925  UInt              getDefaultDirectDependencyType() const                             { return m_defaultDirectDependencyType;                   }
926  Void              setDefaultDirectDependecyType(UInt x)                              { m_defaultDirectDependencyType = x;                      }
927  UInt              getDirectDependencyType(Int currLayerIdx, Int refLayerIdx) const   { return m_directDependencyType[currLayerIdx][refLayerIdx]; }
928  Void              setDirectDependencyType(Int currLayerIdx, Int refLayerIdx, UInt x) { m_directDependencyType[currLayerIdx][refLayerIdx] = x;    }
929  Bool              isSamplePredictionType(Int currLayerIdx, Int refLayerIdx) const    { assert(currLayerIdx != refLayerIdx); return ( ( m_directDependencyType[currLayerIdx][refLayerIdx] + 1 ) & 1 ) ? true : false; }
930  Bool              isMotionPredictionType(Int currLayerIdx, Int refLayerIdx) const    { assert(currLayerIdx != refLayerIdx); return ( ( ( m_directDependencyType[currLayerIdx][refLayerIdx] + 1 ) & 2 ) >> 1 ) ? true : false; }
931
932  UInt              getNumProfileTierLevel() const                                     { return m_numProfileTierLevel;                           }
933  Void              setNumProfileTierLevel(Int x)                                      { m_numProfileTierLevel = x;                              }
934  Int               getNumAddOutputLayerSets() const                                   { return m_numAddOutputLayerSets;                         }
935  Void              setNumAddOutputLayerSets(Int x)                                    { m_numAddOutputLayerSets = x;                            }
936
937  UInt              getDefaultTargetOutputLayerIdc() const                             { return m_defaultTargetOutputLayerIdc;                   }
938  Void              setDefaultTargetOutputLayerIdc(UInt x)                             { m_defaultTargetOutputLayerIdc = x;                      }
939
940  Bool              getNecessaryLayerFlag(Int const i, Int const j) const              { return m_necessaryLayerFlag[i][j];                      }
941  std::vector< std::vector<Int> >* getProfileLevelTierIdx()                            { return &m_profileLevelTierIdx;                          }
942  std::vector<Int>*                getProfileLevelTierIdx(Int const olsIdx)            { return &m_profileLevelTierIdx[olsIdx];                  }
943  Int               getProfileLevelTierIdx(const Int olsIdx, const Int layerIdx) const { return m_profileLevelTierIdx[olsIdx][layerIdx];               }
944  Void              setProfileLevelTierIdx(const Int olsIdx, const Int layerIdx, const Int ptlIdx) { m_profileLevelTierIdx[olsIdx][layerIdx] = ptlIdx; }
945  Void              addProfileLevelTierIdx(const Int olsIdx, const Int ptlIdx)         { m_profileLevelTierIdx[olsIdx].push_back(ptlIdx);              }
946  Int               calculateLenOfSyntaxElement( const Int numVal ) const;
947
948  Bool              getMaxOneActiveRefLayerFlag() const                                { return m_maxOneActiveRefLayerFlag;                 }
949  Void              setMaxOneActiveRefLayerFlag(Bool x)                                { m_maxOneActiveRefLayerFlag = x;                    }
950  UInt              getPocLsbNotPresentFlag(Int i) const                               { return m_pocLsbNotPresentFlag[i];                  }
951  Void              setPocLsbNotPresentFlag(Int i, Bool x)                             { m_pocLsbNotPresentFlag[i] = x;                     }
952  Bool              getVpsPocLsbAlignedFlag() const                                    { return m_vpsPocLsbAlignedFlag;                     }
953  Void              setVpsPocLsbAlignedFlag(Bool x)                                    { m_vpsPocLsbAlignedFlag = x;                        }
954  Bool              getCrossLayerPictureTypeAlignFlag() const                          { return m_crossLayerPictureTypeAlignFlag;           }
955  Void              setCrossLayerPictureTypeAlignFlag(Bool x)                          { m_crossLayerPictureTypeAlignFlag = x;              }
956  Bool              getCrossLayerAlignedIdrOnlyFlag() const                            { return m_crossLayerAlignedIdrOnlyFlag;             }
957  Void              setCrossLayerAlignedIdrOnlyFlag(Bool x)                            { m_crossLayerAlignedIdrOnlyFlag = x;                }
958  Bool              getCrossLayerIrapAlignFlag() const                                 { return m_crossLayerIrapAlignFlag;                  }
959  Void              setCrossLayerIrapAlignFlag(Bool x)                                 { m_crossLayerIrapAlignFlag = x;                     }
960  UInt              getMaxTidIlRefPicsPlus1(Int refLayerIdx, Int layerIdx) const       { return m_maxTidIlRefPicsPlus1[refLayerIdx][layerIdx];                }
961  Void              setMaxTidIlRefPicsPlus1(Int refLayerIdx, Int layerIdx, UInt maxSublayer)   { m_maxTidIlRefPicsPlus1[refLayerIdx][layerIdx] = maxSublayer; }
962  Bool              getMaxTidRefPresentFlag() const                                    { return m_maxTidRefPresentFlag;                     }
963  Void              setMaxTidRefPresentFlag(Bool x)                                    { m_maxTidRefPresentFlag = x;                        }
964  Bool              getMaxTSLayersPresentFlag() const                                  { return m_maxTSLayersPresentFlag;                   }
965  Void              setMaxTSLayersPresentFlag(Bool x)                                  { m_maxTSLayersPresentFlag = x;                      }
966  UInt              getMaxTSLayersMinus1(Int layerIdx) const                           { return m_maxTSLayerMinus1[layerIdx];               }
967  Void              setMaxTSLayersMinus1(Int layerIdx, UInt maxTSublayer)              { m_maxTSLayerMinus1[layerIdx] = maxTSublayer;       }
968  Bool              getSingleLayerForNonIrapFlag() const                               { return m_singleLayerForNonIrapFlag;                }
969  Void              setSingleLayerForNonIrapFlag(Bool x)                               { m_singleLayerForNonIrapFlag = x;                   }
970  Bool              getHigherLayerIrapSkipFlag() const                                 { return m_higherLayerIrapSkipFlag;                  }
971  Void              setHigherLayerIrapSkipFlag(Bool x)                                 { m_higherLayerIrapSkipFlag = x;                     }
972
973  Bool              getTilesNotInUseFlag() const                                       { return m_tilesNotInUseFlag;                        }
974  Void              setTilesNotInUseFlag(Bool x); 
975  Bool              getTilesInUseFlag(Int currLayerId) const                           { return m_tilesInUseFlag[currLayerId];              }
976  Void              setTilesInUseFlag(Int currLayerId, Bool x)                         { m_tilesInUseFlag[currLayerId] = x; } 
977  Bool              getLoopFilterNotAcrossTilesFlag(Int currLayerId) const             { return m_loopFilterNotAcrossTilesFlag[currLayerId];}
978  Void              setLoopFilterNotAcrossTilesFlag(Int currLayerId, Bool x)           { m_loopFilterNotAcrossTilesFlag[currLayerId] = x;   } 
979  Bool              getTileBoundariesAlignedFlag(Int currLayerId, Int refLayerId) const     { return m_tileBoundariesAlignedFlag[currLayerId][refLayerId]; }
980  Void              setTileBoundariesAlignedFlag(Int currLayerId, Int refLayerId, Bool x)   { m_tileBoundariesAlignedFlag[currLayerId][refLayerId] = x;    } 
981  Bool              getWppNotInUseFlag() const                                         { return m_wppNotInUseFlag;                          }
982  Void              setWppNotInUseFlag(Bool x); 
983  Bool              getWppInUseFlag(Int currLayerId) const                             { return m_wppInUseFlag[currLayerId];                }
984  Void              setWppInUseFlag(Int currLayerId, Bool x)                           { m_wppInUseFlag[currLayerId] = x;                   } 
985
986  Bool              getIlpRestrictedRefLayersFlag  ( ) const                                      { return m_ilpRestrictedRefLayersFlag;}
987  Void              setIlpRestrictedRefLayersFlag  ( Int val )                                    { m_ilpRestrictedRefLayersFlag = val; } 
988  Int               getMinSpatialSegmentOffsetPlus1( Int currLayerId, Int refLayerId ) const      { return m_minSpatialSegmentOffsetPlus1[currLayerId][refLayerId];}
989  Void              setMinSpatialSegmentOffsetPlus1( Int currLayerId, Int refLayerId, Int val )   { m_minSpatialSegmentOffsetPlus1[currLayerId][refLayerId] = val; } 
990  Bool              getCtuBasedOffsetEnabledFlag   ( Int currLayerId, Int refLayerId ) const      { return m_ctuBasedOffsetEnabledFlag[currLayerId][refLayerId];}
991  Void              setCtuBasedOffsetEnabledFlag   ( Int currLayerId, Int refLayerId, Bool flag ) { m_ctuBasedOffsetEnabledFlag[currLayerId][refLayerId] = flag;} 
992  Int               getMinHorizontalCtuOffsetPlus1 ( Int currLayerId, Int refLayerId ) const      { return m_minHorizontalCtuOffsetPlus1[currLayerId][refLayerId];}
993  Void              setMinHorizontalCtuOffsetPlus1 ( Int currLayerId, Int refLayerId, Int val )   { m_minHorizontalCtuOffsetPlus1[currLayerId][refLayerId] = val; } 
994
995  Bool              getVideoSigPresentVpsFlag() const                                  { return m_vidSigPresentVpsFlag;                      }
996  Void              setVideoSigPresentVpsFlag(Bool x)                                  { m_vidSigPresentVpsFlag = x;                         }
997  Int               getNumVideoSignalInfo() const                                      { return m_vpsVidSigInfo;                             }
998  Void              setNumVideoSignalInfo(Int x)                                       { m_vpsVidSigInfo = x;                                }
999  Int               getVideoSignalInfoIdx(Int idx) const                               { return m_vpsVidSigIdx[idx];                         }
1000  Void              setVideoSignalInfoIdx(Int idx, Int x)                              { m_vpsVidSigIdx[idx] = x;                            }
1001  Int               getVideoVPSFormat(Int idx) const                                   { return m_vpsVidFormat[idx];                         }
1002  Void              setVideoVPSFormat(Int idx, Int x)                                  { m_vpsVidFormat[idx] = x;                            }
1003  Bool              getVideoFullRangeVpsFlag(Int idx) const                            { return m_vpsFullRangeFlag[idx];                     }
1004  Void              setVideoFullRangeVpsFlag(Int idx, Bool x)                          { m_vpsFullRangeFlag[idx] = x;                        }
1005  Int               getColorPrimaries(Int idx) const                                   { return m_vpsColorPrimaries[idx];                    }
1006  Void              setColorPrimaries(Int idx, Int x)                                  { m_vpsColorPrimaries[idx] = x;                       }
1007  Int               getTransCharacter(Int idx) const                                   { return m_vpsTransChar[idx];                         }
1008  Void              setTransCharacter(Int idx, Int x)                                  { m_vpsTransChar[idx] = x;                            }
1009  Int               getMaxtrixCoeff(Int idx) const                                     { return m_vpsMatCoeff[idx];                          }
1010  Void              setMaxtrixCoeff(Int idx, Int x)                                    { m_vpsMatCoeff[idx] = x;                             }
1011
1012  Bool              getBitRatePresentVpsFlag() const                                   { return m_bitRatePresentVpsFlag;                     }
1013  Void              setBitRatePresentVpsFlag(Bool x)                                   { m_bitRatePresentVpsFlag = x;                        }
1014  Bool              getPicRatePresentVpsFlag() const                                   { return m_picRatePresentVpsFlag;                     }
1015  Void              setPicRatePresentVpsFlag(Bool x)                                   { m_picRatePresentVpsFlag = x;                        }
1016         
1017  Bool              getBitRatePresentFlag(Int i, Int j) const                          { return m_bitRatePresentFlag[i][j];                  }
1018  Void              setBitRatePresentFlag(Int i, Int j, Bool x)                        { m_bitRatePresentFlag[i][j] = x;                     }
1019  Bool              getPicRatePresentFlag(Int i, Int j) const                          { return m_picRatePresentFlag[i][j];                  }
1020  Void              setPicRatePresentFlag(Int i, Int j, Bool x)                        { m_picRatePresentFlag[i][j] = x;                     }
1021         
1022  Int               getAvgBitRate(Int i, Int j) const                                  { return m_avgBitRate[i][j];                          }
1023  Void              setAvgBitRate(Int i, Int j, Int x)                                 { m_avgBitRate[i][j] = x;                             }
1024  Int               getMaxBitRate(Int i, Int j) const                                  { return m_maxBitRate[i][j];                          }
1025  Void              setMaxBitRate(Int i, Int j, Int x)                                 { m_maxBitRate[i][j] = x;                             }
1026         
1027  Int               getConstPicRateIdc(Int i, Int j) const                             { return m_constPicRateIdc[i][j];                     }
1028  Void              setConstPicRateIdc(Int i, Int j, Int x)                            { m_constPicRateIdc[i][j] = x;                        }
1029  Int               getAvgPicRate(Int i, Int j) const                                  { return m_avgPicRate[i][j];                          }
1030  Void              setAvgPicRate(Int i, Int j, Int x)                                 { m_avgPicRate[i][j] = x;                             }
1031#if O0164_MULTI_LAYER_HRD
1032  Bool              getVpsVuiBspHrdPresentFlag() const                                 { return m_vpsVuiBspHrdPresentFlag;                   }
1033  Void              setVpsVuiBspHrdPresentFlag(Bool x)                                 { m_vpsVuiBspHrdPresentFlag = x;                      }
1034  Int               getVpsNumAddHrdParams() const                                      { return m_vpsNumAddHrdParams;                        }
1035  Void              setVpsNumAddHrdParams(Int  i)                                      { m_vpsNumAddHrdParams = i;                           }
1036
1037  Bool              getCprmsAddPresentFlag(Int i) const                                { return m_cprmsAddPresentFlag[i];                    }
1038  Void              setCprmsAddPresentFlag(Int  i, Bool  val)                          { m_cprmsAddPresentFlag[i] = val;                     }
1039
1040  Int               getNumSubLayerHrdMinus1(Int i) const                               { return m_numSubLayerHrdMinus1[i];                   }
1041  Void              setNumSubLayerHrdMinus1(Int i, Int val)                            { m_numSubLayerHrdMinus1[i] = val;                    }
1042
1043  TComHRD*          getBspHrd(Int i)                                                   { return &m_bspHrd[i];                                }
1044  const TComHRD*    getBspHrd(Int i) const                                             { return &m_bspHrd[i];                                }
1045
1046  Int               getNumSignalledPartitioningSchemes(Int  i) const                   { return m_numSignalledPartitioningSchemes[i];        }
1047  Void              setNumSignalledPartitioningSchemes(Int  i, Int  val)               { m_numSignalledPartitioningSchemes[i] = val;         }
1048
1049  Int               getNumPartitionsInSchemeMinus1(Int  i, Int j) const                { return m_numPartitionsInSchemeMinus1[i][j];         }
1050  Void              setNumPartitionsInSchemeMinus1(Int i, Int j, Int val)              { m_numPartitionsInSchemeMinus1[i][j] = val;          }
1051
1052  Int               getLayerIncludedInPartitionFlag(Int  i, Int j, Int k, Int l) const   { return m_layerIncludedInPartitionFlag[i][j][k][l];}
1053  Void              setLayerIncludedInPartitionFlag(Int i, Int j, Int k, Int l, Int val) { m_layerIncludedInPartitionFlag[i][j][k][l] = val; }
1054
1055  Int               getNumBspSchedulesMinus1(Int  i, Int j, Int k) const               { return m_numBspSchedulesMinus1[i][j][k];            }
1056  Void              setNumBspSchedulesMinus1(Int i, Int j, Int k, Int val)             { m_numBspSchedulesMinus1[i][j][k] = val;             }
1057
1058  Int               getBspSchedIdx(Int  i, Int j, Int k, Int l, Int m) const           { return m_bspSchedIdx[i][j][k][l][m];                }
1059  Void              setBspSchedIdx(Int  i, Int j, Int k, Int l, Int m, Int val)        { m_bspSchedIdx[i][j][k][l][m] = val;                 }
1060
1061  Int               getBspHrdIdx(Int  i, Int j, Int k, Int l, Int m) const             { return m_bspHrdIdx[i][j][k][l][m];                  }
1062  Void              setBspHrdIdx(Int  i, Int j, Int k, Int l, Int m, Int val)          { m_bspHrdIdx[i][j][k][l][m] = val;                   }
1063#endif
1064  Void              setBaseLayerPSCompatibilityFlag (Int layer, Int val)               { m_baseLayerPSCompatibilityFlag[layer] = val;        }
1065  Int               getBaseLayerPSCompatibilityFlag (Int layer) const                  { return m_baseLayerPSCompatibilityFlag[layer];       }
1066  Bool              getAltOuputLayerFlag(Int idx) const                                { return m_altOutputLayerFlag[idx];                   }
1067  Void              setAltOuputLayerFlag(Int idx, Bool x)                              { m_altOutputLayerFlag[idx] = x;                      }
1068
1069  Bool              getRepFormatIdxPresentFlag() const                                 { return m_repFormatIdxPresentFlag;                   }
1070  Void              setRepFormatIdxPresentFlag(Bool x)                                 { m_repFormatIdxPresentFlag = x;                      }
1071
1072  Int               getVpsNumRepFormats() const                                        { return m_vpsNumRepFormats;                          }
1073  Void              setVpsNumRepFormats(Int x)                                         { m_vpsNumRepFormats = x;                             }
1074
1075  RepFormat*        getVpsRepFormat(Int idx)                                           { return &m_vpsRepFormat[idx];                        }
1076  const RepFormat*  getVpsRepFormat(Int idx) const                                     { return &m_vpsRepFormat[idx];                        }
1077
1078  Int               getVpsRepFormatIdx(Int idx) const                                  { return m_vpsRepFormatIdx[idx];                      }
1079  Void              setVpsRepFormatIdx(Int idx, Int x)                                 { m_vpsRepFormatIdx[idx] = x;                         }         
1080
1081  Void              setViewIdLen( Int  val )                                           { m_viewIdLen = val;                                  } 
1082  Int               getViewIdLen() const                                               { return m_viewIdLen;                                 } 
1083
1084  Void              setViewIdVal( Int viewOrderIndex, Int  val )                       { m_viewIdVal[viewOrderIndex] = val;                  } 
1085  Int               getViewIdVal( Int viewOrderIndex ) const                           { return m_viewIdVal[viewOrderIndex];                 } 
1086  Int               getScalabilityId(Int, ScalabilityType scalType ) const;
1087
1088  Int               getViewIndex( Int layerIdInNuh ) const                             { return getScalabilityId( getLayerIdxInVps(layerIdInNuh), VIEW_ORDER_INDEX  ); }   
1089
1090  Int               getNumViews() const;
1091  Int               scalTypeToScalIdx( ScalabilityType scalType ) const;
1092
1093  Bool              getSubLayerFlagInfoPresentFlag(Int olsIdx) const                   { return m_subLayerFlagInfoPresentFlag[olsIdx];       }
1094  Void              setSubLayerFlagInfoPresentFlag(Int olsIdx, Bool x)                 { m_subLayerFlagInfoPresentFlag[olsIdx] = x;          }
1095
1096  Bool              getSubLayerDpbInfoPresentFlag(Int olsIdx, Int subLayerIdx) const   { return m_subLayerDpbInfoPresentFlag[olsIdx][subLayerIdx]; }
1097  Void              setSubLayerDpbInfoPresentFlag(Int olsIdx, Int subLayerIdx, Bool x) { m_subLayerDpbInfoPresentFlag[olsIdx][subLayerIdx] = x;    }
1098
1099  // For the 0-th output layer set, use the date from the active SPS for base layer.
1100  Int               getMaxVpsDecPicBufferingMinus1(Int olsIdx, Int subDpbIdx, Int subLayerIdx) const  { assert(olsIdx != 0); return m_maxVpsDecPicBufferingMinus1[olsIdx][subDpbIdx][subLayerIdx]; }
1101  Void              setMaxVpsDecPicBufferingMinus1(Int olsIdx, Int subDpbIdx, Int subLayerIdx, Int x) { m_maxVpsDecPicBufferingMinus1[olsIdx][subDpbIdx][subLayerIdx] = x;    }
1102  Int               getLayerIdcForOls( Int olsIdx, Int layerId ) const;
1103
1104  Int               getMaxVpsNumReorderPics(Int olsIdx, Int subLayerIdx) const         { assert(olsIdx != 0); return m_maxVpsNumReorderPics[olsIdx][subLayerIdx]; }
1105  Void              setMaxVpsNumReorderPics(Int olsIdx, Int subLayerIdx, Int x)        { m_maxVpsNumReorderPics[olsIdx][subLayerIdx] = x;    }
1106
1107  Int               getMaxVpsLatencyIncreasePlus1(Int olsIdx, Int subLayerIdx) const   { assert(olsIdx != 0); return m_maxVpsLatencyIncreasePlus1[olsIdx][subLayerIdx]; }
1108  Void              setMaxVpsLatencyIncreasePlus1(Int olsIdx, Int subLayerIdx, Int x)  { m_maxVpsLatencyIncreasePlus1[olsIdx][subLayerIdx] = x;    }
1109
1110  Int               getNumSubDpbs(Int olsIdx) const                                    { return m_numSubDpbs[olsIdx];                       }
1111  Void              setNumSubDpbs(Int olsIdx, Int x)                                   { m_numSubDpbs[olsIdx] = x;                          }
1112  Void              determineSubDpbInfoFlags();
1113
1114  Bool              getVpsVuiPresentFlag() const                                       { return m_vpsVuiPresentFlag;                        }
1115  Void              setVpsVuiPresentFlag(Bool x)                                       { m_vpsVuiPresentFlag = x;                           }
1116  Bool              getVpsExtensionFlag() const                                        { return m_vpsExtensionFlag;                         }
1117  Void              setVpsExtensionFlag(Bool x)                                        { m_vpsExtensionFlag = x;                            }
1118  Int               getVpsNonVuiExtLength() const                                      { return m_vpsNonVuiExtLength;                       }
1119  Void              setVpsNonVuiExtLength(Int x)                                       { m_vpsNonVuiExtLength = x;                          }
1120#if O0164_MULTI_LAYER_HRD
1121  Void              setBspHrdParameters( UInt hrdIdx, UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
1122#endif
1123  Void              deriveNecessaryLayerFlag();
1124  Void              deriveNecessaryLayerFlag(Int const olsIdx);
1125  Void              checkNecessaryLayerFlagCondition();
1126  Void              calculateMaxSLInLayerSets();
1127
1128  ChromaFormat      getChromaFormatIdc( const TComSPS* sps, const UInt layerId ) const;
1129  UInt              getPicHeightInLumaSamples( const TComSPS* sps, const UInt layerId ) const;
1130  UInt              getPicWidthInLumaSamples( const TComSPS* sps, const UInt layerId ) const;
1131  UInt              getBitDepth( ChannelType type, const TComSPS* sps, const UInt layerId ) const;
1132  const BitDepths&  getBitDepths( const TComSPS* sps, const UInt layerId ) const;
1133  const Window&     getConformanceWindow( const TComSPS* sps, const UInt layerId ) const;
1134#endif //SVC_EXTENSION
1135};
1136
1137class TComVUI
1138{
1139private:
1140  Bool       m_aspectRatioInfoPresentFlag;
1141  Int        m_aspectRatioIdc;
1142  Int        m_sarWidth;
1143  Int        m_sarHeight;
1144  Bool       m_overscanInfoPresentFlag;
1145  Bool       m_overscanAppropriateFlag;
1146  Bool       m_videoSignalTypePresentFlag;
1147  Int        m_videoFormat;
1148  Bool       m_videoFullRangeFlag;
1149  Bool       m_colourDescriptionPresentFlag;
1150  Int        m_colourPrimaries;
1151  Int        m_transferCharacteristics;
1152  Int        m_matrixCoefficients;
1153  Bool       m_chromaLocInfoPresentFlag;
1154  Int        m_chromaSampleLocTypeTopField;
1155  Int        m_chromaSampleLocTypeBottomField;
1156  Bool       m_neutralChromaIndicationFlag;
1157  Bool       m_fieldSeqFlag;
1158  Window     m_defaultDisplayWindow;
1159  Bool       m_frameFieldInfoPresentFlag;
1160  Bool       m_hrdParametersPresentFlag;
1161  Bool       m_bitstreamRestrictionFlag;
1162  Bool       m_tilesFixedStructureFlag;
1163  Bool       m_motionVectorsOverPicBoundariesFlag;
1164  Bool       m_restrictedRefPicListsFlag;
1165  Int        m_minSpatialSegmentationIdc;
1166  Int        m_maxBytesPerPicDenom;
1167  Int        m_maxBitsPerMinCuDenom;
1168  Int        m_log2MaxMvLengthHorizontal;
1169  Int        m_log2MaxMvLengthVertical;
1170  TComHRD    m_hrdParameters;
1171  TimingInfo m_timingInfo;
1172
1173public:
1174  TComVUI()
1175    : m_aspectRatioInfoPresentFlag        (false) //TODO: This initialiser list contains magic numbers
1176    , m_aspectRatioIdc                    (0)
1177    , m_sarWidth                          (0)
1178    , m_sarHeight                         (0)
1179    , m_overscanInfoPresentFlag           (false)
1180    , m_overscanAppropriateFlag           (false)
1181    , m_videoSignalTypePresentFlag        (false)
1182    , m_videoFormat                       (5)
1183    , m_videoFullRangeFlag                (false)
1184    , m_colourDescriptionPresentFlag      (false)
1185    , m_colourPrimaries                   (2)
1186    , m_transferCharacteristics           (2)
1187    , m_matrixCoefficients                (2)
1188    , m_chromaLocInfoPresentFlag          (false)
1189    , m_chromaSampleLocTypeTopField       (0)
1190    , m_chromaSampleLocTypeBottomField    (0)
1191    , m_neutralChromaIndicationFlag       (false)
1192    , m_fieldSeqFlag                      (false)
1193    , m_frameFieldInfoPresentFlag         (false)
1194    , m_hrdParametersPresentFlag          (false)
1195    , m_bitstreamRestrictionFlag          (false)
1196    , m_tilesFixedStructureFlag           (false)
1197    , m_motionVectorsOverPicBoundariesFlag(true)
1198    , m_restrictedRefPicListsFlag         (1)
1199    , m_minSpatialSegmentationIdc         (0)
1200    , m_maxBytesPerPicDenom               (2)
1201    , m_maxBitsPerMinCuDenom              (1)
1202    , m_log2MaxMvLengthHorizontal         (15)
1203    , m_log2MaxMvLengthVertical           (15)
1204  {}
1205
1206  virtual           ~TComVUI() {}
1207
1208  Bool              getAspectRatioInfoPresentFlag() const                  { return m_aspectRatioInfoPresentFlag;           }
1209  Void              setAspectRatioInfoPresentFlag(Bool i)                  { m_aspectRatioInfoPresentFlag = i;              }
1210
1211  Int               getAspectRatioIdc() const                              { return m_aspectRatioIdc;                       }
1212  Void              setAspectRatioIdc(Int i)                               { m_aspectRatioIdc = i;                          }
1213
1214  Int               getSarWidth() const                                    { return m_sarWidth;                             }
1215  Void              setSarWidth(Int i)                                     { m_sarWidth = i;                                }
1216
1217  Int               getSarHeight() const                                   { return m_sarHeight;                            }
1218  Void              setSarHeight(Int i)                                    { m_sarHeight = i;                               }
1219
1220  Bool              getOverscanInfoPresentFlag() const                     { return m_overscanInfoPresentFlag;              }
1221  Void              setOverscanInfoPresentFlag(Bool i)                     { m_overscanInfoPresentFlag = i;                 }
1222
1223  Bool              getOverscanAppropriateFlag() const                     { return m_overscanAppropriateFlag;              }
1224  Void              setOverscanAppropriateFlag(Bool i)                     { m_overscanAppropriateFlag = i;                 }
1225
1226  Bool              getVideoSignalTypePresentFlag() const                  { return m_videoSignalTypePresentFlag;           }
1227  Void              setVideoSignalTypePresentFlag(Bool i)                  { m_videoSignalTypePresentFlag = i;              }
1228
1229  Int               getVideoFormat() const                                 { return m_videoFormat;                          }
1230  Void              setVideoFormat(Int i)                                  { m_videoFormat = i;                             }
1231
1232  Bool              getVideoFullRangeFlag() const                          { return m_videoFullRangeFlag;                   }
1233  Void              setVideoFullRangeFlag(Bool i)                          { m_videoFullRangeFlag = i;                      }
1234
1235  Bool              getColourDescriptionPresentFlag() const                { return m_colourDescriptionPresentFlag;         }
1236  Void              setColourDescriptionPresentFlag(Bool i)                { m_colourDescriptionPresentFlag = i;            }
1237
1238  Int               getColourPrimaries() const                             { return m_colourPrimaries;                      }
1239  Void              setColourPrimaries(Int i)                              { m_colourPrimaries = i;                         }
1240
1241  Int               getTransferCharacteristics() const                     { return m_transferCharacteristics;              }
1242  Void              setTransferCharacteristics(Int i)                      { m_transferCharacteristics = i;                 }
1243
1244  Int               getMatrixCoefficients() const                          { return m_matrixCoefficients;                   }
1245  Void              setMatrixCoefficients(Int i)                           { m_matrixCoefficients = i;                      }
1246
1247  Bool              getChromaLocInfoPresentFlag() const                    { return m_chromaLocInfoPresentFlag;             }
1248  Void              setChromaLocInfoPresentFlag(Bool i)                    { m_chromaLocInfoPresentFlag = i;                }
1249
1250  Int               getChromaSampleLocTypeTopField() const                 { return m_chromaSampleLocTypeTopField;          }
1251  Void              setChromaSampleLocTypeTopField(Int i)                  { m_chromaSampleLocTypeTopField = i;             }
1252
1253  Int               getChromaSampleLocTypeBottomField() const              { return m_chromaSampleLocTypeBottomField;       }
1254  Void              setChromaSampleLocTypeBottomField(Int i)               { m_chromaSampleLocTypeBottomField = i;          }
1255
1256  Bool              getNeutralChromaIndicationFlag() const                 { return m_neutralChromaIndicationFlag;          }
1257  Void              setNeutralChromaIndicationFlag(Bool i)                 { m_neutralChromaIndicationFlag = i;             }
1258
1259  Bool              getFieldSeqFlag() const                                { return m_fieldSeqFlag;                         }
1260  Void              setFieldSeqFlag(Bool i)                                { m_fieldSeqFlag = i;                            }
1261
1262  Bool              getFrameFieldInfoPresentFlag() const                   { return m_frameFieldInfoPresentFlag;            }
1263  Void              setFrameFieldInfoPresentFlag(Bool i)                   { m_frameFieldInfoPresentFlag = i;               }
1264
1265  Window&           getDefaultDisplayWindow()                              { return m_defaultDisplayWindow;                 }
1266  const Window&     getDefaultDisplayWindow() const                        { return m_defaultDisplayWindow;                 }
1267  Void              setDefaultDisplayWindow(Window& defaultDisplayWindow ) { m_defaultDisplayWindow = defaultDisplayWindow; }
1268
1269  Bool              getHrdParametersPresentFlag() const                    { return m_hrdParametersPresentFlag;             }
1270  Void              setHrdParametersPresentFlag(Bool i)                    { m_hrdParametersPresentFlag = i;                }
1271
1272  Bool              getBitstreamRestrictionFlag() const                    { return m_bitstreamRestrictionFlag;             }
1273  Void              setBitstreamRestrictionFlag(Bool i)                    { m_bitstreamRestrictionFlag = i;                }
1274
1275  Bool              getTilesFixedStructureFlag() const                     { return m_tilesFixedStructureFlag;              }
1276  Void              setTilesFixedStructureFlag(Bool i)                     { m_tilesFixedStructureFlag = i;                 }
1277
1278  Bool              getMotionVectorsOverPicBoundariesFlag() const          { return m_motionVectorsOverPicBoundariesFlag;   }
1279  Void              setMotionVectorsOverPicBoundariesFlag(Bool i)          { m_motionVectorsOverPicBoundariesFlag = i;      }
1280
1281  Bool              getRestrictedRefPicListsFlag() const                   { return m_restrictedRefPicListsFlag;            }
1282  Void              setRestrictedRefPicListsFlag(Bool b)                   { m_restrictedRefPicListsFlag = b;               }
1283
1284  Int               getMinSpatialSegmentationIdc() const                   { return m_minSpatialSegmentationIdc;            }
1285  Void              setMinSpatialSegmentationIdc(Int i)                    { m_minSpatialSegmentationIdc = i;               }
1286
1287  Int               getMaxBytesPerPicDenom() const                         { return m_maxBytesPerPicDenom;                  }
1288  Void              setMaxBytesPerPicDenom(Int i)                          { m_maxBytesPerPicDenom = i;                     }
1289
1290  Int               getMaxBitsPerMinCuDenom() const                        { return m_maxBitsPerMinCuDenom;                 }
1291  Void              setMaxBitsPerMinCuDenom(Int i)                         { m_maxBitsPerMinCuDenom = i;                    }
1292
1293  Int               getLog2MaxMvLengthHorizontal() const                   { return m_log2MaxMvLengthHorizontal;            }
1294  Void              setLog2MaxMvLengthHorizontal(Int i)                    { m_log2MaxMvLengthHorizontal = i;               }
1295
1296  Int               getLog2MaxMvLengthVertical() const                     { return m_log2MaxMvLengthVertical;              }
1297  Void              setLog2MaxMvLengthVertical(Int i)                      { m_log2MaxMvLengthVertical = i;                 }
1298
1299  TComHRD*          getHrdParameters()                                     { return &m_hrdParameters;                       }
1300  const TComHRD*    getHrdParameters()  const                              { return &m_hrdParameters;                       }
1301
1302  TimingInfo*       getTimingInfo()                                        { return &m_timingInfo;                          }
1303  const TimingInfo* getTimingInfo() const                                  { return &m_timingInfo;                          }
1304};
1305
1306
1307/// SPS class
1308class TComSPS
1309{
1310private:
1311  Int              m_SPSId;
1312  Int              m_VPSId;
1313  ChromaFormat     m_chromaFormatIdc;
1314
1315  UInt             m_uiMaxTLayers;           // maximum number of temporal layers
1316
1317  // Structure
1318  UInt             m_picWidthInLumaSamples;
1319  UInt             m_picHeightInLumaSamples;
1320
1321  Int              m_log2MinCodingBlockSize;
1322  Int              m_log2DiffMaxMinCodingBlockSize;
1323  UInt             m_uiMaxCUWidth;
1324  UInt             m_uiMaxCUHeight;
1325  UInt             m_uiMaxTotalCUDepth; ///< Total CU depth, relative to the smallest possible transform block size.
1326
1327  Window           m_conformanceWindow;
1328
1329  TComRPSList      m_RPSList;
1330  Bool             m_bLongTermRefsPresent;
1331  Bool             m_TMVPFlagsPresent;
1332  Int              m_numReorderPics[MAX_TLAYER];
1333
1334  // Tool list
1335  UInt             m_uiQuadtreeTULog2MaxSize;
1336  UInt             m_uiQuadtreeTULog2MinSize;
1337  UInt             m_uiQuadtreeTUMaxDepthInter;
1338  UInt             m_uiQuadtreeTUMaxDepthIntra;
1339  Bool             m_usePCM;
1340  UInt             m_pcmLog2MaxSize;
1341  UInt             m_uiPCMLog2MinSize;
1342  Bool             m_useAMP;
1343
1344  // Parameter
1345  BitDepths        m_bitDepths;
1346  Int              m_qpBDOffset[MAX_NUM_CHANNEL_TYPE];
1347  Bool             m_useExtendedPrecision;
1348  Bool             m_useHighPrecisionPredictionWeighting;
1349  Bool             m_useResidualRotation;
1350  Bool             m_useSingleSignificanceMapContext;
1351  Bool             m_useGolombRiceParameterAdaptation;
1352  Bool             m_alignCABACBeforeBypass;
1353  Bool             m_useResidualDPCM[NUMBER_OF_RDPCM_SIGNALLING_MODES];
1354  Int              m_pcmBitDepths[MAX_NUM_CHANNEL_TYPE];
1355  Bool             m_bPCMFilterDisableFlag;
1356  Bool             m_disableIntraReferenceSmoothing;
1357
1358  UInt             m_uiBitsForPOC;
1359  UInt             m_numLongTermRefPicSPS;
1360  UInt             m_ltRefPicPocLsbSps[MAX_NUM_LONG_TERM_REF_PICS];
1361  Bool             m_usedByCurrPicLtSPSFlag[MAX_NUM_LONG_TERM_REF_PICS];
1362  // Max physical transform size
1363  UInt             m_uiMaxTrSize;
1364
1365  Bool             m_bUseSAO;
1366
1367  Bool             m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
1368
1369  Bool             m_scalingListEnabledFlag;
1370  Bool             m_scalingListPresentFlag;
1371  TComScalingList  m_scalingList;
1372  UInt             m_uiMaxDecPicBuffering[MAX_TLAYER];
1373  UInt             m_uiMaxLatencyIncrease[MAX_TLAYER];  // Really max latency increase plus 1 (value 0 expresses no limit)
1374
1375  Bool             m_useStrongIntraSmoothing;
1376
1377  Bool             m_vuiParametersPresentFlag;
1378  TComVUI          m_vuiParameters;
1379
1380  static const Int m_winUnitX[MAX_CHROMA_FORMAT_IDC+1];
1381  static const Int m_winUnitY[MAX_CHROMA_FORMAT_IDC+1];
1382  TComPTL          m_pcPTL;
1383
1384#if O0043_BEST_EFFORT_DECODING
1385  UInt             m_forceDecodeBitDepth; // 0 = do not force the decoder's bit depth, other = force the decoder's bit depth to this value (best effort decoding)
1386#endif
1387
1388#if SVC_EXTENSION
1389  UInt             m_layerId;
1390  Bool             m_extensionFlag;
1391  Bool             m_bV1CompatibleSPSFlag;
1392  UInt             m_numScaledRefLayerOffsets;
1393  Bool             m_multiLayerExtSpsFlag;
1394  Int              m_NumDirectRefLayers;
1395  Bool             m_updateRepFormatFlag;
1396  UInt             m_updateRepFormatIndex;
1397  Bool             m_inferScalingListFlag;
1398  UInt             m_scalingListRefLayerId;
1399#endif //SVC_EXTENSION
1400
1401public:
1402                         TComSPS();
1403  virtual                ~TComSPS();
1404#if O0043_BEST_EFFORT_DECODING
1405  Void                   setForceDecodeBitDepth(UInt bitDepth)                                           { m_forceDecodeBitDepth = bitDepth;                                    }
1406  UInt                   getForceDecodeBitDepth()        const                                           { return m_forceDecodeBitDepth;                                        }
1407#endif
1408
1409  Int                    getVPSId() const                                                                { return m_VPSId;                                                      }
1410  Void                   setVPSId(Int i)                                                                 { m_VPSId = i;                                                         }
1411  Int                    getSPSId() const                                                                { return m_SPSId;                                                      }
1412  Void                   setSPSId(Int i)                                                                 { m_SPSId = i;                                                         }
1413  ChromaFormat           getChromaFormatIdc () const                                                     { return m_chromaFormatIdc;                                            }
1414  Void                   setChromaFormatIdc (ChromaFormat i)                                             { m_chromaFormatIdc = i;                                               }
1415
1416  static Int             getWinUnitX (Int chromaFormatIdc)                                               { assert (chromaFormatIdc >= 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitX[chromaFormatIdc]; }
1417  static Int             getWinUnitY (Int chromaFormatIdc)                                               { assert (chromaFormatIdc >= 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitY[chromaFormatIdc]; }
1418
1419  // structure
1420  Void                   setPicWidthInLumaSamples( UInt u )                                              { m_picWidthInLumaSamples = u;                                         }
1421  UInt                   getPicWidthInLumaSamples() const                                                { return  m_picWidthInLumaSamples;                                     }
1422  Void                   setPicHeightInLumaSamples( UInt u )                                             { m_picHeightInLumaSamples = u;                                        }
1423  UInt                   getPicHeightInLumaSamples() const                                               { return  m_picHeightInLumaSamples;                                    }
1424
1425  Window&                getConformanceWindow()                                                          { return  m_conformanceWindow;                                         }
1426  const Window&          getConformanceWindow() const                                                    { return  m_conformanceWindow;                                         }
1427  Void                   setConformanceWindow(Window& conformanceWindow )                                { m_conformanceWindow = conformanceWindow;                             }
1428
1429  UInt                   getNumLongTermRefPicSPS() const                                                 { return m_numLongTermRefPicSPS;                                       }
1430  Void                   setNumLongTermRefPicSPS(UInt val)                                               { m_numLongTermRefPicSPS = val;                                        }
1431
1432  UInt                   getLtRefPicPocLsbSps(UInt index) const                                          { assert( index < MAX_NUM_LONG_TERM_REF_PICS ); return m_ltRefPicPocLsbSps[index]; }
1433  Void                   setLtRefPicPocLsbSps(UInt index, UInt val)                                      { assert( index < MAX_NUM_LONG_TERM_REF_PICS ); m_ltRefPicPocLsbSps[index] = val;  }
1434
1435  Bool                   getUsedByCurrPicLtSPSFlag(Int i) const                                          { assert( i < MAX_NUM_LONG_TERM_REF_PICS ); return m_usedByCurrPicLtSPSFlag[i];    }
1436  Void                   setUsedByCurrPicLtSPSFlag(Int i, Bool x)                                        { assert( i < MAX_NUM_LONG_TERM_REF_PICS ); m_usedByCurrPicLtSPSFlag[i] = x;       }
1437
1438  Int                    getLog2MinCodingBlockSize() const                                               { return m_log2MinCodingBlockSize;                                     }
1439  Void                   setLog2MinCodingBlockSize(Int val)                                              { m_log2MinCodingBlockSize = val;                                      }
1440  Int                    getLog2DiffMaxMinCodingBlockSize() const                                        { return m_log2DiffMaxMinCodingBlockSize;                              }
1441  Void                   setLog2DiffMaxMinCodingBlockSize(Int val)                                       { m_log2DiffMaxMinCodingBlockSize = val;                               }
1442
1443  Void                   setMaxCUWidth( UInt u )                                                         { m_uiMaxCUWidth = u;                                                  }
1444  UInt                   getMaxCUWidth() const                                                           { return  m_uiMaxCUWidth;                                              }
1445  Void                   setMaxCUHeight( UInt u )                                                        { m_uiMaxCUHeight = u;                                                 }
1446  UInt                   getMaxCUHeight() const                                                          { return  m_uiMaxCUHeight;                                             }
1447  Void                   setMaxTotalCUDepth( UInt u )                                                    { m_uiMaxTotalCUDepth = u;                                             }
1448  UInt                   getMaxTotalCUDepth() const                                                      { return  m_uiMaxTotalCUDepth;                                         }
1449  Void                   setUsePCM( Bool b )                                                             { m_usePCM = b;                                                        }
1450  Bool                   getUsePCM() const                                                               { return m_usePCM;                                                     }
1451  Void                   setPCMLog2MaxSize( UInt u )                                                     { m_pcmLog2MaxSize = u;                                                }
1452  UInt                   getPCMLog2MaxSize() const                                                       { return  m_pcmLog2MaxSize;                                            }
1453  Void                   setPCMLog2MinSize( UInt u )                                                     { m_uiPCMLog2MinSize = u;                                              }
1454  UInt                   getPCMLog2MinSize() const                                                       { return  m_uiPCMLog2MinSize;                                          }
1455  Void                   setBitsForPOC( UInt u )                                                         { m_uiBitsForPOC = u;                                                  }
1456  UInt                   getBitsForPOC() const                                                           { return m_uiBitsForPOC;                                               }
1457  Bool                   getUseAMP() const                                                               { return m_useAMP;                                                     }
1458  Void                   setUseAMP( Bool b )                                                             { m_useAMP = b;                                                        }
1459  Void                   setQuadtreeTULog2MaxSize( UInt u )                                              { m_uiQuadtreeTULog2MaxSize = u;                                       }
1460  UInt                   getQuadtreeTULog2MaxSize() const                                                { return m_uiQuadtreeTULog2MaxSize;                                    }
1461  Void                   setQuadtreeTULog2MinSize( UInt u )                                              { m_uiQuadtreeTULog2MinSize = u;                                       }
1462  UInt                   getQuadtreeTULog2MinSize() const                                                { return m_uiQuadtreeTULog2MinSize;                                    }
1463  Void                   setQuadtreeTUMaxDepthInter( UInt u )                                            { m_uiQuadtreeTUMaxDepthInter = u;                                     }
1464  Void                   setQuadtreeTUMaxDepthIntra( UInt u )                                            { m_uiQuadtreeTUMaxDepthIntra = u;                                     }
1465  UInt                   getQuadtreeTUMaxDepthInter() const                                              { return m_uiQuadtreeTUMaxDepthInter;                                  }
1466  UInt                   getQuadtreeTUMaxDepthIntra() const                                              { return m_uiQuadtreeTUMaxDepthIntra;                                  }
1467  Void                   setNumReorderPics(Int i, UInt tlayer)                                           { m_numReorderPics[tlayer] = i;                                        }
1468  Int                    getNumReorderPics(UInt tlayer) const                                            { return m_numReorderPics[tlayer];                                     }
1469  Void                   createRPSList( Int numRPS );
1470  const TComRPSList*     getRPSList() const                                                              { return &m_RPSList;                                                   }
1471  TComRPSList*           getRPSList()                                                                    { return &m_RPSList;                                                   }
1472  Bool                   getLongTermRefsPresent() const                                                  { return m_bLongTermRefsPresent;                                       }
1473  Void                   setLongTermRefsPresent(Bool b)                                                  { m_bLongTermRefsPresent=b;                                            }
1474  Bool                   getTMVPFlagsPresent() const                                                     { return m_TMVPFlagsPresent;                                           }
1475  Void                   setTMVPFlagsPresent(Bool b)                                                     { m_TMVPFlagsPresent=b;                                                }
1476  // physical transform
1477  Void                   setMaxTrSize( UInt u )                                                          { m_uiMaxTrSize = u;                                                   }
1478  UInt                   getMaxTrSize() const                                                            { return  m_uiMaxTrSize;                                               }
1479
1480  // Bit-depth
1481  Int                    getBitDepth(ChannelType type) const                                             { return m_bitDepths.recon[type];                                      }
1482  Void                   setBitDepth(ChannelType type, Int u )                                           { m_bitDepths.recon[type] = u;                                         }
1483#if O0043_BEST_EFFORT_DECODING
1484  Int                    getStreamBitDepth(ChannelType type) const                                       { return m_bitDepths.stream[type];                                     }
1485  Void                   setStreamBitDepth(ChannelType type, Int u )                                     { m_bitDepths.stream[type] = u;                                        }
1486#endif
1487  const BitDepths&       getBitDepths() const                                                            { return m_bitDepths;                                                  }
1488  Int                    getMaxLog2TrDynamicRange(ChannelType channelType) const                         { return getUseExtendedPrecision() ? std::max<Int>(15, Int(m_bitDepths.recon[channelType] + 6)) : 15; }
1489
1490  Int                    getDifferentialLumaChromaBitDepth() const                                       { return Int(m_bitDepths.recon[CHANNEL_TYPE_LUMA]) - Int(m_bitDepths.recon[CHANNEL_TYPE_CHROMA]); }
1491  Int                    getQpBDOffset(ChannelType type) const                                           { return m_qpBDOffset[type];                                           }
1492  Void                   setQpBDOffset(ChannelType type, Int i)                                          { m_qpBDOffset[type] = i;                                              }
1493  Bool                   getUseExtendedPrecision() const                                                 { return m_useExtendedPrecision;                                       }
1494  Void                   setUseExtendedPrecision(Bool value)                                             { m_useExtendedPrecision = value;                                      }
1495  Bool                   getUseHighPrecisionPredictionWeighting() const                                  { return m_useHighPrecisionPredictionWeighting;                        }
1496  Void                   setUseHighPrecisionPredictionWeighting(Bool value)                              { m_useHighPrecisionPredictionWeighting = value;                       }
1497
1498  Void                   setUseSAO(Bool bVal)                                                            { m_bUseSAO = bVal;                                                    }
1499  Bool                   getUseSAO() const                                                               { return m_bUseSAO;                                                    }
1500
1501  Bool                   getUseResidualRotation() const                                                  { return m_useResidualRotation;                                        }
1502  Void                   setUseResidualRotation(const Bool value)                                        { m_useResidualRotation = value;                                       }
1503
1504  Bool                   getUseSingleSignificanceMapContext()                 const                      { return m_useSingleSignificanceMapContext;                            }
1505  Void                   setUseSingleSignificanceMapContext(const Bool value)                            { m_useSingleSignificanceMapContext = value;                           }
1506
1507  Bool                   getUseGolombRiceParameterAdaptation()                 const                     { return m_useGolombRiceParameterAdaptation;                           }
1508  Void                   setUseGolombRiceParameterAdaptation(const Bool value)                           { m_useGolombRiceParameterAdaptation = value;                          }
1509
1510  Bool                   getAlignCABACBeforeBypass()                 const                               { return m_alignCABACBeforeBypass;                                     }
1511  Void                   setAlignCABACBeforeBypass(const Bool value)                                     { m_alignCABACBeforeBypass = value;                                    }
1512
1513  Bool                   getUseResidualDPCM(const RDPCMSignallingMode signallingMode) const              { return m_useResidualDPCM[signallingMode];                            }
1514  Void                   setUseResidualDPCM(const RDPCMSignallingMode signallingMode, const Bool value)  { m_useResidualDPCM[signallingMode] = value;                           }
1515
1516  UInt                   getMaxTLayers() const                                                           { return m_uiMaxTLayers; }
1517  Void                   setMaxTLayers( UInt uiMaxTLayers )                                              { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
1518
1519  Bool                   getTemporalIdNestingFlag() const                                                { return m_bTemporalIdNestingFlag;                                     }
1520  Void                   setTemporalIdNestingFlag( Bool bValue )                                         { m_bTemporalIdNestingFlag = bValue;                                   }
1521  UInt                   getPCMBitDepth(ChannelType type) const                                          { return m_pcmBitDepths[type];                                         }
1522  Void                   setPCMBitDepth(ChannelType type, UInt u)                                        { m_pcmBitDepths[type] = u;                                            }
1523  Void                   setPCMFilterDisableFlag( Bool bValue )                                          { m_bPCMFilterDisableFlag = bValue;                                    }
1524  Bool                   getPCMFilterDisableFlag() const                                                 { return m_bPCMFilterDisableFlag;                                      }
1525  Void                   setDisableIntraReferenceSmoothing(Bool bValue)                                  { m_disableIntraReferenceSmoothing=bValue;                             }
1526  Bool                   getDisableIntraReferenceSmoothing() const                                       { return m_disableIntraReferenceSmoothing;                             }
1527
1528  Bool                   getScalingListFlag() const                                                      { return m_scalingListEnabledFlag;                                     }
1529  Void                   setScalingListFlag( Bool b )                                                    { m_scalingListEnabledFlag  = b;                                       }
1530  Bool                   getScalingListPresentFlag() const                                               { return m_scalingListPresentFlag;                                     }
1531  Void                   setScalingListPresentFlag( Bool b )                                             { m_scalingListPresentFlag  = b;                                       }
1532  Void                   setScalingList( TComScalingList *scalingList);
1533  TComScalingList&       getScalingList()                                                                { return m_scalingList;                                                }
1534  const TComScalingList& getScalingList() const                                                          { return m_scalingList;                                                }
1535  UInt                   getMaxDecPicBuffering(UInt tlayer) const                                        { return m_uiMaxDecPicBuffering[tlayer];                               }
1536  Void                   setMaxDecPicBuffering( UInt ui, UInt tlayer )                                   { assert(tlayer < MAX_TLAYER); m_uiMaxDecPicBuffering[tlayer] = ui;    }
1537  UInt                   getMaxLatencyIncrease(UInt tlayer) const                                        { return m_uiMaxLatencyIncrease[tlayer];                               }
1538  Void                   setMaxLatencyIncrease( UInt ui , UInt tlayer)                                   { m_uiMaxLatencyIncrease[tlayer] = ui;                                 }
1539
1540  Void                   setUseStrongIntraSmoothing(Bool bVal)                                           { m_useStrongIntraSmoothing = bVal;                                    }
1541  Bool                   getUseStrongIntraSmoothing() const                                              { return m_useStrongIntraSmoothing;                                    }
1542
1543  Bool                   getVuiParametersPresentFlag() const                                             { return m_vuiParametersPresentFlag;                                   }
1544  Void                   setVuiParametersPresentFlag(Bool b)                                             { m_vuiParametersPresentFlag = b;                                      }
1545  TComVUI*               getVuiParameters()                                                              { return &m_vuiParameters;                                             }
1546  const TComVUI*         getVuiParameters() const                                                        { return &m_vuiParameters;                                             }
1547  Void                   setHrdParameters( UInt frameRate, Bool useSubCpbParams, UInt bitRate, Bool randomAccess );
1548  const TComPTL*         getPTL() const                                                                  { return &m_pcPTL;                                                     }
1549  TComPTL*               getPTL()                                                                        { return &m_pcPTL;                                                     }
1550
1551#if SVC_EXTENSION
1552  Void                   setLayerId(UInt layerId)                                                        { m_layerId = layerId;                                                 }
1553  UInt                   getLayerId() const                                                              { return m_layerId;                                                    }
1554  Int                    getExtensionFlag() const                                                        { return m_extensionFlag;                                              }
1555  Void                   setExtensionFlag(Int n)                                                         { m_extensionFlag = n;                                                 }
1556  Bool                   getMultiLayerExtSpsFlag() const                                                 { return m_multiLayerExtSpsFlag;                                       }
1557  Void                   setMultiLayerExtSpsFlag(Bool flag)                                              { m_multiLayerExtSpsFlag = flag;                                       }
1558
1559  //These two functions shall be used / called when the syntax element sps_ext_or_max_sub_layers_minus1 and V1CompatibleSPSFlag are implemented
1560  Bool                   getV1CompatibleSPSFlag() const                                                  { return m_bV1CompatibleSPSFlag;                                       }
1561  Void                   setV1CompatibleSPSFlag(Bool x)                                                  { m_bV1CompatibleSPSFlag = x;                                          }
1562
1563  Int                    getNumDirectRefLayers() const                                                   { return  m_NumDirectRefLayers;                                        }
1564  Void                   setNumDirectRefLayers(Int n)                                                    {  m_NumDirectRefLayers = n;                                           }
1565  Bool                   getUpdateRepFormatFlag() const                                                  { return m_updateRepFormatFlag;                                        }
1566  Void                   setUpdateRepFormatFlag(Bool x)                                                  { m_updateRepFormatFlag = x;                                           }
1567  Int                    getUpdateRepFormatIndex() const                                                 { return m_updateRepFormatIndex;                                       }
1568  Void                   setUpdateRepFormatIndex(UInt index)                                             { m_updateRepFormatIndex = index;                                      }
1569  Bool                   getInferScalingListFlag() const                                                 { return m_inferScalingListFlag;                                       }
1570  UInt                   getScalingListRefLayerId() const                                                { return m_scalingListRefLayerId;                                      }
1571  Void                   setInferScalingListFlag( Bool flag )                                            { m_inferScalingListFlag = flag;                                       }
1572  Void                   setScalingListRefLayerId( UInt layerId )                                        { m_scalingListRefLayerId = layerId;                                   }
1573#endif //SVC_EXTENSION
1574};
1575
1576
1577/// Reference Picture Lists class
1578
1579class TComRefPicListModification
1580{
1581private:
1582  Bool m_refPicListModificationFlagL0;
1583  Bool m_refPicListModificationFlagL1;
1584  UInt m_RefPicSetIdxL0[REF_PIC_LIST_NUM_IDX];
1585  UInt m_RefPicSetIdxL1[REF_PIC_LIST_NUM_IDX];
1586
1587public:
1588          TComRefPicListModification();
1589  virtual ~TComRefPicListModification();
1590
1591  Void    create();
1592  Void    destroy();
1593
1594  Bool    getRefPicListModificationFlagL0() const        { return m_refPicListModificationFlagL0;                                  }
1595  Void    setRefPicListModificationFlagL0(Bool flag)     { m_refPicListModificationFlagL0 = flag;                                  }
1596  Bool    getRefPicListModificationFlagL1() const        { return m_refPicListModificationFlagL1;                                  }
1597  Void    setRefPicListModificationFlagL1(Bool flag)     { m_refPicListModificationFlagL1 = flag;                                  }
1598  UInt    getRefPicSetIdxL0(UInt idx) const              { assert(idx<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL0[idx];         }
1599  Void    setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { assert(idx<REF_PIC_LIST_NUM_IDX); m_RefPicSetIdxL0[idx] = refPicSetIdx; }
1600  UInt    getRefPicSetIdxL1(UInt idx) const              { assert(idx<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL1[idx];         }
1601  Void    setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { assert(idx<REF_PIC_LIST_NUM_IDX); m_RefPicSetIdxL1[idx] = refPicSetIdx; }
1602};
1603
1604/// PPS class
1605class TComPPS
1606{
1607private:
1608  Int              m_PPSId;                    // pic_parameter_set_id
1609  Int              m_SPSId;                    // seq_parameter_set_id
1610  Int              m_picInitQPMinus26;
1611  Bool             m_useDQP;
1612  Bool             m_bConstrainedIntraPred;    // constrained_intra_pred_flag
1613  Bool             m_bSliceChromaQpFlag;       // slicelevel_chroma_qp_flag
1614
1615  // access channel
1616  UInt             m_uiMaxCuDQPDepth;
1617
1618  // Chroma QP Adjustments
1619  Int              m_MaxCuChromaQpAdjDepth;
1620  Int              m_ChromaQpAdjTableSize; // size (excludes the null entry used in the following array).
1621  ChromaQpAdj      m_ChromaQpAdjTableIncludingNullEntry[1+MAX_QP_OFFSET_LIST_SIZE]; //!< Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
1622
1623  Int              m_chromaCbQpOffset;
1624  Int              m_chromaCrQpOffset;
1625
1626  UInt             m_numRefIdxL0DefaultActive;
1627  UInt             m_numRefIdxL1DefaultActive;
1628
1629  Bool             m_bUseWeightPred;                    //!< Use of Weighting Prediction (P_SLICE)
1630  Bool             m_useWeightedBiPred;                 //!< Use of Weighting Bi-Prediction (B_SLICE)
1631  Bool             m_OutputFlagPresentFlag;             //!< Indicates the presence of output_flag in slice header
1632  Bool             m_useCrossComponentPrediction;
1633  UInt             m_saoOffsetBitShift[MAX_NUM_CHANNEL_TYPE];
1634  Bool             m_TransquantBypassEnableFlag;        //!< Indicates presence of cu_transquant_bypass_flag in CUs.
1635  Bool             m_useTransformSkip;
1636  Int              m_transformSkipLog2MaxSize;
1637  Bool             m_dependentSliceSegmentsEnabledFlag; //!< Indicates the presence of dependent slices
1638  Bool             m_tilesEnabledFlag;                  //!< Indicates the presence of tiles
1639  Bool             m_entropyCodingSyncEnabledFlag;      //!< Indicates the presence of wavefronts
1640
1641  Bool             m_loopFilterAcrossTilesEnabledFlag;
1642  Bool             m_uniformSpacingFlag;
1643  Int              m_numTileColumnsMinus1;
1644  Int              m_numTileRowsMinus1;
1645  std::vector<Int> m_tileColumnWidth;
1646  std::vector<Int> m_tileRowHeight;
1647
1648  Bool             m_signHideFlag;
1649
1650  Bool             m_cabacInitPresentFlag;
1651
1652  Bool             m_sliceHeaderExtensionPresentFlag;
1653  Bool             m_loopFilterAcrossSlicesEnabledFlag;
1654  Bool             m_deblockingFilterControlPresentFlag;
1655  Bool             m_deblockingFilterOverrideEnabledFlag;
1656  Bool             m_picDisableDeblockingFilterFlag;
1657  Int              m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
1658  Int              m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
1659  Bool             m_scalingListPresentFlag;
1660  TComScalingList  m_scalingList;                       //!< ScalingList class
1661  Bool             m_listsModificationPresentFlag;
1662  UInt             m_log2ParallelMergeLevelMinus2;
1663  Int              m_numExtraSliceHeaderBits;
1664
1665#if SVC_EXTENSION
1666  Bool             m_extensionFlag;
1667  UInt             m_layerId;
1668  Bool             m_inferScalingListFlag;
1669  UInt             m_scalingListRefLayerId;
1670  Bool             m_pocResetInfoPresentFlag;
1671  UInt             m_numRefLayerLocationOffsets;
1672  UInt             m_refLocationOffsetLayerId[MAX_LAYERS];
1673  Window           m_scaledRefLayerWindow[MAX_LAYERS];
1674  Window           m_refLayerWindow[MAX_LAYERS];
1675  Bool             m_scaledRefLayerOffsetPresentFlag[MAX_LAYERS];
1676  Bool             m_refRegionOffsetPresentFlag[MAX_LAYERS];
1677  ResamplingPhase  m_resamplingPhase[MAX_LAYERS];
1678#if CGS_3D_ASYMLUT
1679  Int              m_nCGSFlag;
1680  Int              m_nCGSOutputBitDepthY; // not for syntax
1681  Int              m_nCGSOutputBitDepthC; // not for syntax
1682#endif
1683#endif
1684
1685public:
1686                         TComPPS();
1687  virtual                ~TComPPS();
1688
1689  Int                    getPPSId() const                                                 { return m_PPSId;                               }
1690  Void                   setPPSId(Int i)                                                  { m_PPSId = i;                                  }
1691  Int                    getSPSId() const                                                 { return m_SPSId;                               }
1692  Void                   setSPSId(Int i)                                                  { m_SPSId = i;                                  }
1693
1694  Int                    getPicInitQPMinus26() const                                      { return  m_picInitQPMinus26;                   }
1695  Void                   setPicInitQPMinus26( Int i )                                     { m_picInitQPMinus26 = i;                       }
1696  Bool                   getUseDQP() const                                                { return m_useDQP;                              }
1697  Void                   setUseDQP( Bool b )                                              { m_useDQP   = b;                               }
1698  Bool                   getConstrainedIntraPred() const                                  { return  m_bConstrainedIntraPred;              }
1699  Void                   setConstrainedIntraPred( Bool b )                                { m_bConstrainedIntraPred = b;                  }
1700  Bool                   getSliceChromaQpFlag() const                                     { return  m_bSliceChromaQpFlag;                 }
1701  Void                   setSliceChromaQpFlag( Bool b )                                   { m_bSliceChromaQpFlag = b;                     }
1702
1703  Void                   setMaxCuDQPDepth( UInt u )                                       { m_uiMaxCuDQPDepth = u;                        }
1704  UInt                   getMaxCuDQPDepth() const                                         { return m_uiMaxCuDQPDepth;                     }
1705
1706  Void                   setQpOffset(ComponentID compID, Int i )
1707  {
1708    if      (compID==COMPONENT_Cb)
1709    {
1710      m_chromaCbQpOffset = i;
1711    }
1712    else if (compID==COMPONENT_Cr)
1713    {
1714      m_chromaCrQpOffset = i;
1715    }
1716    else
1717    {
1718      assert(0);
1719    }
1720  }
1721  Int                    getQpOffset(ComponentID compID) const
1722  {
1723    return (compID==COMPONENT_Y) ? 0 : (compID==COMPONENT_Cb ? m_chromaCbQpOffset : m_chromaCrQpOffset );
1724  }
1725
1726  Void                   setMaxCuChromaQpAdjDepth ( UInt u )                              { m_MaxCuChromaQpAdjDepth = u;                  }
1727  UInt                   getMaxCuChromaQpAdjDepth () const                                { return m_MaxCuChromaQpAdjDepth;               }
1728  Void                   clearChromaQpAdjTable()                                          { m_ChromaQpAdjTableSize = 0;                   }
1729  Int                    getChromaQpAdjTableSize() const                                  { return m_ChromaQpAdjTableSize;                }
1730
1731  const ChromaQpAdj&     getChromaQpAdjTableAt( Int cuChromaQpOffsetIdxPlus1 ) const
1732  {
1733    assert(cuChromaQpOffsetIdxPlus1 < m_ChromaQpAdjTableSize+1);
1734    return m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1]; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
1735  }
1736
1737  Void                   setChromaQpAdjTableAt( Int cuChromaQpOffsetIdxPlus1, Int cbOffset, Int crOffset )
1738  {
1739    assert (cuChromaQpOffsetIdxPlus1 != 0 && cuChromaQpOffsetIdxPlus1 <= MAX_QP_OFFSET_LIST_SIZE);
1740    m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CbOffset = cbOffset; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
1741    m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CrOffset = crOffset;
1742    m_ChromaQpAdjTableSize = max(m_ChromaQpAdjTableSize, cuChromaQpOffsetIdxPlus1);
1743  }
1744
1745  Void                   setNumRefIdxL0DefaultActive(UInt ui)                             { m_numRefIdxL0DefaultActive=ui;                }
1746  UInt                   getNumRefIdxL0DefaultActive() const                              { return m_numRefIdxL0DefaultActive;            }
1747  Void                   setNumRefIdxL1DefaultActive(UInt ui)                             { m_numRefIdxL1DefaultActive=ui;                }
1748  UInt                   getNumRefIdxL1DefaultActive() const                              { return m_numRefIdxL1DefaultActive;            }
1749
1750  Bool                   getUseWP() const                                                 { return m_bUseWeightPred;                      }
1751  Bool                   getWPBiPred() const                                              { return m_useWeightedBiPred;                   }
1752  Void                   setUseWP( Bool b )                                               { m_bUseWeightPred = b;                         }
1753  Void                   setWPBiPred( Bool b )                                            { m_useWeightedBiPred = b;                      }
1754
1755  Bool                   getUseCrossComponentPrediction() const                           { return m_useCrossComponentPrediction;         }
1756  Void                   setUseCrossComponentPrediction(Bool value)                       { m_useCrossComponentPrediction = value;        }
1757
1758  UInt                   getSaoOffsetBitShift(ChannelType type) const                     { return m_saoOffsetBitShift[type];             }
1759  Void                   setSaoOffsetBitShift(ChannelType type, UInt uiBitShift)          { m_saoOffsetBitShift[type] = uiBitShift;       }
1760
1761  Void                   setOutputFlagPresentFlag( Bool b )                               { m_OutputFlagPresentFlag = b;                  }
1762  Bool                   getOutputFlagPresentFlag() const                                 { return m_OutputFlagPresentFlag;               }
1763  Void                   setTransquantBypassEnableFlag( Bool b )                          { m_TransquantBypassEnableFlag = b;             }
1764  Bool                   getTransquantBypassEnableFlag() const                            { return m_TransquantBypassEnableFlag;          }
1765
1766  Bool                   getUseTransformSkip() const                                      { return m_useTransformSkip;                    }
1767  Void                   setUseTransformSkip( Bool b )                                    { m_useTransformSkip  = b;                      }
1768  UInt                   getTransformSkipLog2MaxSize() const                              { return m_transformSkipLog2MaxSize;            }
1769  Void                   setTransformSkipLog2MaxSize( UInt u )                            { m_transformSkipLog2MaxSize  = u;              }
1770
1771  Void                   setLoopFilterAcrossTilesEnabledFlag(Bool b)                      { m_loopFilterAcrossTilesEnabledFlag = b;       }
1772  Bool                   getLoopFilterAcrossTilesEnabledFlag() const                      { return m_loopFilterAcrossTilesEnabledFlag;    }
1773  Bool                   getDependentSliceSegmentsEnabledFlag() const                     { return m_dependentSliceSegmentsEnabledFlag;   }
1774  Void                   setDependentSliceSegmentsEnabledFlag(Bool val)                   { m_dependentSliceSegmentsEnabledFlag = val;    }
1775  Bool                   getEntropyCodingSyncEnabledFlag() const                          { return m_entropyCodingSyncEnabledFlag;        }
1776  Void                   setEntropyCodingSyncEnabledFlag(Bool val)                        { m_entropyCodingSyncEnabledFlag = val;         }
1777
1778  Void                   setTilesEnabledFlag(Bool val)                                    { m_tilesEnabledFlag = val;                     }
1779  Bool                   getTilesEnabledFlag() const                                      { return m_tilesEnabledFlag;                    }
1780  Void                   setTileUniformSpacingFlag(Bool b)                                { m_uniformSpacingFlag = b;                     }
1781  Bool                   getTileUniformSpacingFlag() const                                { return m_uniformSpacingFlag;                  }
1782  Void                   setNumTileColumnsMinus1(Int i)                                   { m_numTileColumnsMinus1 = i;                   }
1783  Int                    getNumTileColumnsMinus1() const                                  { return m_numTileColumnsMinus1;                }
1784  Void                   setTileColumnWidth(const std::vector<Int>& columnWidth )         { m_tileColumnWidth = columnWidth;              }
1785  UInt                   getTileColumnWidth(UInt columnIdx) const                         { return  m_tileColumnWidth[columnIdx];         }
1786  Void                   setNumTileRowsMinus1(Int i)                                      { m_numTileRowsMinus1 = i;                      }
1787  Int                    getNumTileRowsMinus1() const                                     { return m_numTileRowsMinus1;                   }
1788  Void                   setTileRowHeight(const std::vector<Int>& rowHeight)              { m_tileRowHeight = rowHeight;                  }
1789  UInt                   getTileRowHeight(UInt rowIdx) const                              { return m_tileRowHeight[rowIdx];               }
1790
1791  Void                   setSignHideFlag( Bool signHideFlag )                             { m_signHideFlag = signHideFlag;                }
1792  Bool                   getSignHideFlag() const                                          { return m_signHideFlag;                        }
1793
1794  Void                   setCabacInitPresentFlag( Bool flag )                             { m_cabacInitPresentFlag = flag;                }
1795  Bool                   getCabacInitPresentFlag() const                                  { return m_cabacInitPresentFlag;                }
1796  Void                   setDeblockingFilterControlPresentFlag( Bool val )                { m_deblockingFilterControlPresentFlag = val;   }
1797  Bool                   getDeblockingFilterControlPresentFlag() const                    { return m_deblockingFilterControlPresentFlag;  }
1798  Void                   setDeblockingFilterOverrideEnabledFlag( Bool val )               { m_deblockingFilterOverrideEnabledFlag = val;  }
1799  Bool                   getDeblockingFilterOverrideEnabledFlag() const                   { return m_deblockingFilterOverrideEnabledFlag; }
1800  Void                   setPicDisableDeblockingFilterFlag(Bool val)                      { m_picDisableDeblockingFilterFlag = val;       } //!< set offset for deblocking filter disabled
1801  Bool                   getPicDisableDeblockingFilterFlag() const                        { return m_picDisableDeblockingFilterFlag;      } //!< get offset for deblocking filter disabled
1802  Void                   setDeblockingFilterBetaOffsetDiv2(Int val)                       { m_deblockingFilterBetaOffsetDiv2 = val;       } //!< set beta offset for deblocking filter
1803  Int                    getDeblockingFilterBetaOffsetDiv2() const                        { return m_deblockingFilterBetaOffsetDiv2;      } //!< get beta offset for deblocking filter
1804  Void                   setDeblockingFilterTcOffsetDiv2(Int val)                         { m_deblockingFilterTcOffsetDiv2 = val;         } //!< set tc offset for deblocking filter
1805  Int                    getDeblockingFilterTcOffsetDiv2() const                          { return m_deblockingFilterTcOffsetDiv2;        } //!< get tc offset for deblocking filter
1806  Bool                   getScalingListPresentFlag() const                                { return m_scalingListPresentFlag;              }
1807  Void                   setScalingListPresentFlag( Bool b )                              { m_scalingListPresentFlag  = b;                }
1808  TComScalingList&       getScalingList()                                                 { return m_scalingList;                         }
1809  const TComScalingList& getScalingList() const                                           { return m_scalingList;                         }
1810  Bool                   getListsModificationPresentFlag() const                          { return m_listsModificationPresentFlag;        }
1811  Void                   setListsModificationPresentFlag( Bool b )                        { m_listsModificationPresentFlag = b;           }
1812  UInt                   getLog2ParallelMergeLevelMinus2() const                          { return m_log2ParallelMergeLevelMinus2;        }
1813  Void                   setLog2ParallelMergeLevelMinus2(UInt mrgLevel)                   { m_log2ParallelMergeLevelMinus2 = mrgLevel;    }
1814  Int                    getNumExtraSliceHeaderBits() const                               { return m_numExtraSliceHeaderBits;             }
1815  Void                   setNumExtraSliceHeaderBits(Int i)                                { m_numExtraSliceHeaderBits = i;                }
1816  Void                   setLoopFilterAcrossSlicesEnabledFlag( Bool bValue )              { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
1817  Bool                   getLoopFilterAcrossSlicesEnabledFlag() const                     { return m_loopFilterAcrossSlicesEnabledFlag;   }
1818  Bool                   getSliceHeaderExtensionPresentFlag() const                       { return m_sliceHeaderExtensionPresentFlag;     }
1819  Void                   setSliceHeaderExtensionPresentFlag(Bool val)                     { m_sliceHeaderExtensionPresentFlag = val;      }
1820#if SVC_EXTENSION
1821  Int                    getExtensionFlag() const                                         { return m_extensionFlag;                       }
1822  Void                   setExtensionFlag(Int n)                                          { m_extensionFlag = n;                          }
1823  UInt                   getLayerId() const                                               { return m_layerId;                             }
1824  Void                   setLayerId( UInt layerId )                                       { m_layerId = layerId;                          }
1825  Bool                   getInferScalingListFlag() const                                  { return m_inferScalingListFlag;                }
1826  UInt                   getScalingListRefLayerId() const                                 { return m_scalingListRefLayerId;               }
1827  Void                   setInferScalingListFlag( Bool flag )                             { m_inferScalingListFlag = flag;                }
1828  Void                   setScalingListRefLayerId( UInt layerId )                         { m_scalingListRefLayerId = layerId;            }
1829  Bool                   getPocResetInfoPresentFlag() const                               { return m_pocResetInfoPresentFlag;             }
1830  Void                   setPocResetInfoPresentFlag(const Bool val)                       { m_pocResetInfoPresentFlag = val;              }
1831  UInt                   getNumRefLayerLocationOffsets() const                            { return m_numRefLayerLocationOffsets;          }
1832  Void                   setNumRefLayerLocationOffsets(Int x)                             { m_numRefLayerLocationOffsets = x;             }
1833
1834  UInt                   getRefLocationOffsetLayerId(Int x) const                         { return m_refLocationOffsetLayerId[x];         }
1835  Void                   setRefLocationOffsetLayerId(Int x, UInt id)                      { m_refLocationOffsetLayerId[x] = id;           }
1836  const Window&          getScaledRefLayerWindowForLayer( Int layerId ) const;
1837
1838  Window&                getScaledRefLayerWindow( Int x )                                 { return m_scaledRefLayerWindow[x];             }
1839  const Window&          getScaledRefLayerWindow( Int x ) const                           { return m_scaledRefLayerWindow[x];             }
1840  const Window&          getRefLayerWindowForLayer( Int layerId ) const;
1841  Window&                getRefLayerWindow( Int x )                                       { return m_refLayerWindow[x];                   }
1842  const Window&          getRefLayerWindow( Int x ) const                                 { return m_refLayerWindow[x];                   }
1843  Bool                   getScaledRefLayerOffsetPresentFlag(Int x) const                  { return m_scaledRefLayerOffsetPresentFlag[x];  }
1844  Void                   setScaledRefLayerOffsetPresentFlag(Int x, Bool b)                { m_scaledRefLayerOffsetPresentFlag[x] = b;     }
1845  Bool                   getRefRegionOffsetPresentFlag(Int x) const                       { return m_refRegionOffsetPresentFlag[x];       }
1846  Void                   setRefRegionOffsetPresentFlag(Int x, Bool b)                     { m_refRegionOffsetPresentFlag[x] = b;          }
1847
1848  Int                    getPhaseHorLuma(Int x) const                                     { return m_resamplingPhase[x].phaseHorLuma;     }
1849  Int                    getPhaseVerLuma(Int x) const                                     { return m_resamplingPhase[x].phaseVerLuma;     }
1850  Int                    getPhaseHorChroma(Int x) const                                   { return m_resamplingPhase[x].phaseHorChroma;   }
1851  Int                    getPhaseVerChroma(Int x) const                                   { return m_resamplingPhase[x].phaseVerChroma;   }
1852  Void                   setPhaseHorLuma(Int x, Int val)                                  { m_resamplingPhase[x].phaseHorLuma = val;      }
1853  Void                   setPhaseVerLuma(Int x, Int val)                                  { m_resamplingPhase[x].phaseVerLuma = val;      }
1854  Void                   setPhaseHorChroma(Int x, Int val)                                { m_resamplingPhase[x].phaseHorChroma = val;    }
1855  Void                   setPhaseVerChroma(Int x, Int val)                                { m_resamplingPhase[x].phaseVerChroma = val;    }
1856  Bool                   getResamplePhaseSetPresentFlag(Int x) const                      { return m_resamplingPhase[x].phasePresentFlag; }
1857  Void                   setResamplePhaseSetPresentFlag(Int x, Bool b)                    { m_resamplingPhase[x].phasePresentFlag = b;    }
1858
1859  Bool                   hasZeroResamplingPhase(Int refLayerId) const;
1860  const ResamplingPhase& getResamplingPhase(Int refLayerId) const;
1861#if CGS_3D_ASYMLUT
1862  Int                    getCGSFlag() const                                               { return m_nCGSFlag;                            }
1863  Void                   setCGSFlag(Int n)                                                { m_nCGSFlag = n;                               }
1864  Int                    getCGSOutputBitDepthY() const                                    { return m_nCGSOutputBitDepthY;                 }
1865  Void                   setCGSOutputBitDepthY(Int n)                                     { m_nCGSOutputBitDepthY = n;                    }
1866  Int                    getCGSOutputBitDepthC() const                                    { return m_nCGSOutputBitDepthC;                 }
1867  Void                   setCGSOutputBitDepthC(Int n)                                     { m_nCGSOutputBitDepthC = n;                    }
1868#endif
1869#endif //SVC_EXTENSION
1870};
1871
1872struct WPScalingParam
1873{
1874  // Explicit weighted prediction parameters parsed in slice header,
1875  // or Implicit weighted prediction parameters (8 bits depth values).
1876  Bool bPresentFlag;
1877  UInt uiLog2WeightDenom;
1878  Int  iWeight;
1879  Int  iOffset;
1880
1881  // Weighted prediction scaling values built from above parameters (bitdepth scaled):
1882  Int  w;
1883  Int  o;
1884  Int  offset;
1885  Int  shift;
1886  Int  round;
1887};
1888
1889struct WPACDCParam
1890{
1891  Int64 iAC;
1892  Int64 iDC;
1893#if SVC_EXTENSION
1894  Int iSamples;
1895#endif
1896};
1897
1898/// slice header class
1899class TComSlice
1900{
1901
1902private:
1903  //  Bitstream writing
1904  Bool                       m_saoEnabledFlag[MAX_NUM_CHANNEL_TYPE];
1905  Int                        m_iPPSId;               ///< picture parameter set ID
1906  Bool                       m_PicOutputFlag;        ///< pic_output_flag
1907  Int                        m_iPOC;
1908  Int                        m_iLastIDR;
1909  Int                        m_iAssociatedIRAP;
1910  NalUnitType                m_iAssociatedIRAPType;
1911  TComReferencePictureSet*   m_pcRPS;
1912  TComReferencePictureSet    m_LocalRPS;
1913  Int                        m_iBDidx;
1914  TComRefPicListModification m_RefPicListModification;
1915  NalUnitType                m_eNalUnitType;         ///< Nal unit type for the slice
1916  SliceType                  m_eSliceType;
1917  Int                        m_iSliceQp;
1918  Bool                       m_dependentSliceSegmentFlag;
1919#if ADAPTIVE_QP_SELECTION
1920  Int                        m_iSliceQpBase;
1921#endif
1922  Bool                       m_ChromaQpAdjEnabled;
1923  Bool                       m_deblockingFilterDisable;
1924  Bool                       m_deblockingFilterOverrideFlag;      //< offsets for deblocking filter inherit from PPS
1925  Int                        m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
1926  Int                        m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
1927  Int                        m_list1IdxToList0Idx[MAX_NUM_REF];
1928  Int                        m_aiNumRefIdx   [NUM_REF_PIC_LIST_01];    //  for multiple reference of current slice
1929
1930  Bool                       m_bCheckLDC;
1931
1932  //  Data
1933  Int                        m_iSliceQpDelta;
1934  Int                        m_iSliceChromaQpDelta[MAX_NUM_COMPONENT];
1935  TComPic*                   m_apcRefPicList [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
1936  Int                        m_aiRefPOCList  [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
1937  Bool                       m_bIsUsedAsLongTerm[NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
1938  Int                        m_iDepth;
1939
1940  // referenced slice?
1941  Bool                       m_bRefenced;
1942
1943  // access channel
1944  const TComVPS*             m_pcVPS;
1945  const TComSPS*             m_pcSPS;
1946  const TComPPS*             m_pcPPS;
1947  TComPic*                   m_pcPic;
1948#if ADAPTIVE_QP_SELECTION
1949  TComTrQuant*               m_pcTrQuant;
1950#endif
1951  Bool                       m_colFromL0Flag;  // collocated picture from List0 flag
1952
1953  Bool                       m_noOutputPriorPicsFlag;
1954  Bool                       m_noRaslOutputFlag;
1955  Bool                       m_handleCraAsBlaFlag;
1956
1957  UInt                       m_colRefIdx;
1958  UInt                       m_maxNumMergeCand;
1959
1960  Double                     m_lambdas[MAX_NUM_COMPONENT];
1961
1962  Bool                       m_abEqualRef  [NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_REF];
1963  UInt                       m_uiTLayer;
1964  Bool                       m_bTLayerSwitchingFlag;
1965
1966  SliceConstraint            m_sliceMode;
1967  UInt                       m_sliceArgument;
1968  UInt                       m_sliceCurStartCtuTsAddr;
1969  UInt                       m_sliceCurEndCtuTsAddr;
1970  UInt                       m_sliceIdx;
1971  SliceConstraint            m_sliceSegmentMode;
1972  UInt                       m_sliceSegmentArgument;
1973  UInt                       m_sliceSegmentCurStartCtuTsAddr;
1974  UInt                       m_sliceSegmentCurEndCtuTsAddr;
1975  Bool                       m_nextSlice;
1976  Bool                       m_nextSliceSegment;
1977  UInt                       m_sliceBits;
1978  UInt                       m_sliceSegmentBits;
1979  Bool                       m_bFinalized;
1980
1981  Bool                       m_bTestWeightPred;
1982  Bool                       m_bTestWeightBiPred;
1983  WPScalingParam             m_weightPredTable[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
1984  WPACDCParam                m_weightACDCParam[MAX_NUM_COMPONENT];
1985
1986  std::vector<UInt>          m_substreamSizes;
1987
1988  Bool                       m_cabacInitFlag;
1989
1990  Bool                       m_bLMvdL1Zero;
1991  Bool                       m_temporalLayerNonReferenceFlag;
1992  Bool                       m_LFCrossSliceBoundaryFlag;
1993
1994  Bool                       m_enableTMVPFlag;
1995
1996  SliceType                  m_encCABACTableIdx;           // Used to transmit table selection across slices.
1997
1998#if SVC_EXTENSION
1999  Int                        m_associatedIrapPocBeforeReset;
2000  Bool                       m_firstSliceInPic;
2001  Bool                       m_availableForTMVPRefFlag;
2002  UInt                       m_layerId;
2003  TComPic*                   m_pcBaseColPic[MAX_LAYERS];
2004  TComPicYuv*                m_pcFullPelBaseRec[MAX_LAYERS];
2005  Int                        m_numMotionPredRefLayers;
2006  Bool                       m_bMFMEnabledFlag;
2007  Int                        m_colRefLayerIdx;
2008  Bool                       m_altColIndicationFlag;
2009  TComPic*                   m_pcIlpPic;
2010
2011  Bool                       m_interLayerPredEnabledFlag;
2012  Int                        m_activeNumILRRefIdx;        //< Active inter-layer reference pictures
2013  Int                        m_interLayerPredLayerIdc  [MAX_VPS_LAYER_IDX_PLUS1];
2014  Bool                       m_bDiscardableFlag;
2015  Bool                       m_bCrossLayerBLAFlag;
2016  Int                        m_pocResetIdc;
2017  Int                        m_pocResetPeriodId;
2018  Bool                       m_fullPocResetFlag;
2019  Int                        m_pocLsbVal;
2020  Int                        m_pocMsbVal;
2021  Bool                       m_pocMsbValRequiredFlag;
2022  Bool                       m_pocMsbValPresentFlag;
2023  Bool                       m_pocMsbValNeeded;
2024  Int                        m_pocResetDeltaPoc;
2025  Int                        m_pocValueBeforeReset;
2026  Int                        m_picOrderCntLsb;
2027#if CGS_3D_ASYMLUT
2028  Int                        m_nCGSOverWritePPS;  // for optimization, not output to bitstream
2029#endif
2030#endif //SVC_EXTENSION
2031
2032public:
2033                              TComSlice();
2034  virtual                     ~TComSlice();
2035#if SVC_EXTENSION
2036  Void                        initSlice( UInt layerId );
2037  Void                        setVPS( const TComVPS* pcVPS )                         { m_pcVPS = pcVPS;                                              }
2038#else
2039  Void                        initSlice();
2040#endif
2041
2042  Void                        setVPS( TComVPS* pcVPS )                               { m_pcVPS = pcVPS;                                              }
2043  const TComVPS*              getVPS() const                                         { return m_pcVPS;                                               }
2044  Void                        setSPS( const TComSPS* pcSPS )                         { m_pcSPS = pcSPS;                                              }
2045  const TComSPS*              getSPS() const                                         { return m_pcSPS;                                               }
2046
2047  Void                        setPPS( const TComPPS* pcPPS )                         { m_pcPPS = pcPPS; m_iPPSId = (pcPPS) ? pcPPS->getPPSId() : -1; }
2048  const TComPPS*              getPPS() const                                         { return m_pcPPS;                                               }
2049
2050  Void                        setPPSId( Int PPSId )                                  { m_iPPSId = PPSId;                                             }
2051  Int                         getPPSId() const                                       { return m_iPPSId;                                              }
2052  Void                        setPicOutputFlag( Bool b   )                           { m_PicOutputFlag = b;                                          }
2053  Bool                        getPicOutputFlag() const                               { return m_PicOutputFlag;                                       }
2054  Void                        setSaoEnabledFlag(ChannelType chType, Bool s)          {m_saoEnabledFlag[chType] =s;                                   }
2055  Bool                        getSaoEnabledFlag(ChannelType chType) const            { return m_saoEnabledFlag[chType];                              }
2056  Void                        setRPS( TComReferencePictureSet *pcRPS )               { m_pcRPS = pcRPS;                                              }
2057  TComReferencePictureSet*    getRPS()                                               { return m_pcRPS;                                               }
2058  TComReferencePictureSet*    getLocalRPS()                                          { return &m_LocalRPS;                                           }
2059
2060  Void                        setRPSidx( Int iBDidx )                                { m_iBDidx = iBDidx;                                            }
2061  Int                         getRPSidx() const                                      { return m_iBDidx;                                              }
2062  TComRefPicListModification* getRefPicListModification()                            { return &m_RefPicListModification;                             }
2063  Void                        setLastIDR(Int iIDRPOC)                                { m_iLastIDR = iIDRPOC;                                         }
2064  Int                         getLastIDR() const                                     { return m_iLastIDR;                                            }
2065  Void                        setAssociatedIRAPPOC(Int iAssociatedIRAPPOC)           { m_iAssociatedIRAP = iAssociatedIRAPPOC;                       }
2066  Int                         getAssociatedIRAPPOC() const                           { return m_iAssociatedIRAP;                                     }
2067  Void                        setAssociatedIRAPType(NalUnitType associatedIRAPType)  { m_iAssociatedIRAPType = associatedIRAPType;                   }
2068  NalUnitType                 getAssociatedIRAPType() const                          { return m_iAssociatedIRAPType;                                 }
2069  SliceType                   getSliceType() const                                   { return m_eSliceType;                                          }
2070  Int                         getPOC() const                                         { return m_iPOC;                                                }
2071  Int                         getSliceQp() const                                     { return m_iSliceQp;                                            }
2072  Bool                        getDependentSliceSegmentFlag() const                   { return m_dependentSliceSegmentFlag;                           }
2073  Void                        setDependentSliceSegmentFlag(Bool val)                 { m_dependentSliceSegmentFlag = val;                            }
2074#if ADAPTIVE_QP_SELECTION
2075  Int                         getSliceQpBase() const                                 { return m_iSliceQpBase;                                        }
2076#endif
2077  Int                         getSliceQpDelta() const                                { return m_iSliceQpDelta;                                       }
2078  Int                         getSliceChromaQpDelta(ComponentID compID) const        { return isLuma(compID) ? 0 : m_iSliceChromaQpDelta[compID];    }
2079  Bool                        getUseChromaQpAdj() const                              { return m_ChromaQpAdjEnabled;                                  }
2080  Bool                        getDeblockingFilterDisable() const                     { return m_deblockingFilterDisable;                             }
2081  Bool                        getDeblockingFilterOverrideFlag() const                { return m_deblockingFilterOverrideFlag;                        }
2082  Int                         getDeblockingFilterBetaOffsetDiv2()const               { return m_deblockingFilterBetaOffsetDiv2;                      }
2083  Int                         getDeblockingFilterTcOffsetDiv2() const                { return m_deblockingFilterTcOffsetDiv2;                        }
2084
2085  Int                         getNumRefIdx( RefPicList e ) const                     { return m_aiNumRefIdx[e];                                      }
2086  TComPic*                    getPic()                                               { return m_pcPic;                                               }
2087  TComPic*                    getRefPic( RefPicList e, Int iRefIdx)                  { return m_apcRefPicList[e][iRefIdx];                           }
2088  Int                         getRefPOC( RefPicList e, Int iRefIdx)                  { return m_aiRefPOCList[e][iRefIdx];                            }
2089  Int                         getDepth() const                                       { return m_iDepth;                                              }
2090  Bool                        getColFromL0Flag() const                               { return m_colFromL0Flag;                                       }
2091  UInt                        getColRefIdx() const                                   { return m_colRefIdx;                                           }
2092  Void                        checkColRefIdx(UInt curSliceIdx, TComPic* pic);
2093  Bool                        getIsUsedAsLongTerm(Int i, Int j) const                { return m_bIsUsedAsLongTerm[i][j];                             }
2094  Void                        setIsUsedAsLongTerm(Int i, Int j, Bool value)          { m_bIsUsedAsLongTerm[i][j] = value;                            }
2095  Bool                        getCheckLDC() const                                    { return m_bCheckLDC;                                           }
2096  Bool                        getMvdL1ZeroFlag() const                               { return m_bLMvdL1Zero;                                         }
2097  Int                         getNumRpsCurrTempList() const;
2098  Int                         getList1IdxToList0Idx( Int list1Idx ) const            { return m_list1IdxToList0Idx[list1Idx];                        }
2099  Void                        setReferenced(Bool b)                                  { m_bRefenced = b;                                              }
2100  Bool                        isReferenced() const                                   { return m_bRefenced;                                           }
2101  Bool                        isReferenceNalu() const                                { return ((getNalUnitType() <= NAL_UNIT_RESERVED_VCL_R15) && (getNalUnitType()%2 != 0)) || ((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_RESERVED_IRAP_VCL23) ); }
2102  Void                        setPOC( Int i )                                        { m_iPOC              = i; }
2103  Void                        setNalUnitType( NalUnitType e )                        { m_eNalUnitType      = e;                                      }
2104  NalUnitType                 getNalUnitType() const                                 { return m_eNalUnitType;                                        }
2105  Bool                        getRapPicFlag() const;
2106  Bool                        getIdrPicFlag() const                                  { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
2107  Bool                        isIRAP() const                                         { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23);  }
2108  Void                        checkCRA(const TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic);
2109#if NO_CLRAS_OUTPUT_FLAG
2110  Void                        decodingRefreshMarking( TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag, UInt smallestLayerId = 0 );
2111  Void                        decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag);
2112#else
2113  Void                        decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
2114#endif
2115  Void                        setSliceType( SliceType e )                            { m_eSliceType        = e;                                      }
2116  Void                        setSliceQp( Int i )                                    { m_iSliceQp          = i;                                      }
2117#if ADAPTIVE_QP_SELECTION
2118  Void                        setSliceQpBase( Int i )                                { m_iSliceQpBase      = i;                                      }
2119#endif
2120  Void                        setSliceQpDelta( Int i )                               { m_iSliceQpDelta     = i;                                      }
2121  Void                        setSliceChromaQpDelta( ComponentID compID, Int i )     { m_iSliceChromaQpDelta[compID] = isLuma(compID) ? 0 : i;       }
2122  Void                        setUseChromaQpAdj( Bool b )                            { m_ChromaQpAdjEnabled = b;                                     }
2123  Void                        setDeblockingFilterDisable( Bool b )                   { m_deblockingFilterDisable= b;                                 }
2124  Void                        setDeblockingFilterOverrideFlag( Bool b )              { m_deblockingFilterOverrideFlag = b;                           }
2125  Void                        setDeblockingFilterBetaOffsetDiv2( Int i )             { m_deblockingFilterBetaOffsetDiv2 = i;                         }
2126  Void                        setDeblockingFilterTcOffsetDiv2( Int i )               { m_deblockingFilterTcOffsetDiv2 = i;                           }
2127
2128  Void                        setRefPic( TComPic* p, RefPicList e, Int iRefIdx )     { m_apcRefPicList[e][iRefIdx] = p;                              }
2129  Void                        setRefPOC( Int i, RefPicList e, Int iRefIdx )          { m_aiRefPOCList[e][iRefIdx] = i;                               }
2130  Void                        setNumRefIdx( RefPicList e, Int i )                    { m_aiNumRefIdx[e]    = i;                                      }
2131  Void                        setPic( TComPic* p )                                   { m_pcPic             = p;                                      }
2132  Void                        setDepth( Int iDepth )                                 { m_iDepth            = iDepth;                                 }
2133
2134#if SVC_EXTENSION
2135  Void                        setAssociatedIrapPocBeforeReset(Int x)                 { m_associatedIrapPocBeforeReset = x;                           }
2136  Int                         getAssociatedIrapPocBeforeReset(     )                 { return m_associatedIrapPocBeforeReset;                        }
2137
2138  Void                        setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false, TComPic** ilpPic = NULL );
2139#if CGS_3D_ASYMLUT
2140  Int                         getCGSOverWritePPS()              { return m_nCGSOverWritePPS;    }
2141  Void                        setCGSOverWritePPS(Int n)         { m_nCGSOverWritePPS = n;       }
2142#endif
2143#else
2144  Void                        setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
2145#endif
2146  Void                        setRefPOCList();
2147  Void                        setColFromL0Flag( Bool colFromL0 )                     { m_colFromL0Flag = colFromL0;                                  }
2148  Void                        setColRefIdx( UInt refIdx)                             { m_colRefIdx = refIdx;                                         }
2149  Void                        setCheckLDC( Bool b )                                  { m_bCheckLDC = b;                                              }
2150  Void                        setMvdL1ZeroFlag( Bool b)                              { m_bLMvdL1Zero = b;                                            }
2151
2152  Bool                        isIntra() const                                        { return m_eSliceType == I_SLICE;                               }
2153  Bool                        isInterB() const                                       { return m_eSliceType == B_SLICE;                               }
2154  Bool                        isInterP() const                                       { return m_eSliceType == P_SLICE;                               }
2155
2156  Void                        setLambdas( const Double lambdas[MAX_NUM_COMPONENT] )  { for (Int component = 0; component < MAX_NUM_COMPONENT; component++) m_lambdas[component] = lambdas[component]; }
2157  const Double*               getLambdas() const                                     { return m_lambdas;                                             }
2158
2159  Void                        initEqualRef();
2160  Bool                        isEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
2161  {
2162    assert(e<NUM_REF_PIC_LIST_01);
2163    if (iRefIdx1 < 0 || iRefIdx2 < 0)
2164    {
2165      return false;
2166    }
2167    else
2168    {
2169      return m_abEqualRef[e][iRefIdx1][iRefIdx2];
2170    }
2171  }
2172
2173  Void                        setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
2174  {
2175    assert(e<NUM_REF_PIC_LIST_01);
2176    m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
2177  }
2178
2179  static Void                 sortPicList( TComList<TComPic*>& rcListPic );
2180  Void                        setList1IdxToList0Idx();
2181
2182  UInt                        getTLayer() const                                      { return m_uiTLayer;                                            }
2183  Void                        setTLayer( UInt uiTLayer )                             { m_uiTLayer = uiTLayer;                                        }
2184
2185  Void                        setTLayerInfo( UInt uiTLayer );
2186  Void                        decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
2187
2188#if SVC_POC
2189  Void                        checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic, Bool usePocBeforeReset = false);
2190#else
2191  Void                        checkLeadingPictureRestrictions( TComList<TComPic*>& rcListPic );
2192#endif
2193  Void                        applyReferencePictureSet( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *RPSList);
2194  Bool                        isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
2195  Bool                        isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
2196#if ALLOW_RECOVERY_POINT_AS_RAP
2197  Int                         checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0, Bool bUseRecoveryPoint = false);
2198  Void                        createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool isRAP, Int pocRandomAccess = 0, Bool bUseRecoveryPoint = false);
2199#else
2200  Int                         checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
2201  Void                        createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, const TComReferencePictureSet *pReferencePictureSet, Bool isRAP);
2202#endif
2203  Void                        setMaxNumMergeCand(UInt val )                          { m_maxNumMergeCand = val;                                      }
2204  UInt                        getMaxNumMergeCand() const                             { return m_maxNumMergeCand;                                     }
2205
2206  Void                        setNoOutputPriorPicsFlag( Bool val )                   { m_noOutputPriorPicsFlag = val;                                }
2207  Bool                        getNoOutputPriorPicsFlag() const                       { return m_noOutputPriorPicsFlag;                               }
2208
2209  Void                        setNoRaslOutputFlag( Bool val )                        { m_noRaslOutputFlag = val;                                     }
2210  Bool                        getNoRaslOutputFlag() const                            { return m_noRaslOutputFlag;                                    }
2211
2212  Void                        setHandleCraAsBlaFlag( Bool val )                      { m_handleCraAsBlaFlag = val;                                   }
2213  Bool                        getHandleCraAsBlaFlag() const                          { return m_handleCraAsBlaFlag;                                  }
2214
2215  Void                        setSliceMode( SliceConstraint mode )                   { m_sliceMode = mode;                                           }
2216  SliceConstraint             getSliceMode() const                                   { return m_sliceMode;                                           }
2217  Void                        setSliceArgument( UInt uiArgument )                    { m_sliceArgument = uiArgument;                                 }
2218  UInt                        getSliceArgument() const                               { return m_sliceArgument;                                       }
2219  Void                        setSliceCurStartCtuTsAddr( UInt ctuTsAddr )            { m_sliceCurStartCtuTsAddr = ctuTsAddr;                         } // CTU Tile-scan address (as opposed to raster-scan)
2220  UInt                        getSliceCurStartCtuTsAddr() const                      { return m_sliceCurStartCtuTsAddr;                              } // CTU Tile-scan address (as opposed to raster-scan)
2221  Void                        setSliceCurEndCtuTsAddr( UInt ctuTsAddr )              { m_sliceCurEndCtuTsAddr = ctuTsAddr;                           } // CTU Tile-scan address (as opposed to raster-scan)
2222  UInt                        getSliceCurEndCtuTsAddr() const                        { return m_sliceCurEndCtuTsAddr;                                } // CTU Tile-scan address (as opposed to raster-scan)
2223  Void                        setSliceIdx( UInt i)                                   { m_sliceIdx = i;                                               }
2224  UInt                        getSliceIdx() const                                    { return  m_sliceIdx;                                           }
2225  Void                        copySliceInfo(TComSlice *pcSliceSrc);
2226  Void                        setSliceSegmentMode( SliceConstraint mode )            { m_sliceSegmentMode = mode;                                    }
2227  SliceConstraint             getSliceSegmentMode() const                            { return m_sliceSegmentMode;                                    }
2228  Void                        setSliceSegmentArgument( UInt uiArgument )             { m_sliceSegmentArgument = uiArgument;                          }
2229  UInt                        getSliceSegmentArgument() const                        { return m_sliceSegmentArgument;                                }
2230  Void                        setSliceSegmentCurStartCtuTsAddr( UInt ctuTsAddr )     { m_sliceSegmentCurStartCtuTsAddr = ctuTsAddr;                  } // CTU Tile-scan address (as opposed to raster-scan)
2231  UInt                        getSliceSegmentCurStartCtuTsAddr() const               { return m_sliceSegmentCurStartCtuTsAddr;                       } // CTU Tile-scan address (as opposed to raster-scan)
2232  Void                        setSliceSegmentCurEndCtuTsAddr( UInt ctuTsAddr )       { m_sliceSegmentCurEndCtuTsAddr = ctuTsAddr;                    } // CTU Tile-scan address (as opposed to raster-scan)
2233  UInt                        getSliceSegmentCurEndCtuTsAddr() const                 { return m_sliceSegmentCurEndCtuTsAddr;                         } // CTU Tile-scan address (as opposed to raster-scan)
2234  Void                        setSliceBits( UInt uiVal )                             { m_sliceBits = uiVal;                                          }
2235  UInt                        getSliceBits() const                                   { return m_sliceBits;                                           }
2236  Void                        setSliceSegmentBits( UInt uiVal )                      { m_sliceSegmentBits = uiVal;                                   }
2237  UInt                        getSliceSegmentBits() const                            { return m_sliceSegmentBits;                                    }
2238  Void                        setFinalized( Bool uiVal )                             { m_bFinalized = uiVal;                                         }
2239  Bool                        getFinalized() const                                   { return m_bFinalized;                                          }
2240  Bool                        testWeightPred( ) const                                { return m_bTestWeightPred;                                     }
2241  Void                        setTestWeightPred( Bool bValue )                       { m_bTestWeightPred = bValue;                                   }
2242  Bool                        testWeightBiPred( ) const                              { return m_bTestWeightBiPred;                                   }
2243  Void                        setTestWeightBiPred( Bool bValue )                     { m_bTestWeightBiPred = bValue;                                 }
2244  Void                        setWpScaling( WPScalingParam  wp[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT] )
2245  {
2246    memcpy(m_weightPredTable, wp, sizeof(WPScalingParam)*NUM_REF_PIC_LIST_01*MAX_NUM_REF*MAX_NUM_COMPONENT);
2247  }
2248
2249  Void                        getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp);
2250
2251  Void                        resetWpScaling();
2252  Void                        initWpScaling(const TComSPS *sps);
2253
2254  Void                        setWpAcDcParam( WPACDCParam wp[MAX_NUM_COMPONENT] )
2255  {
2256    memcpy(m_weightACDCParam, wp, sizeof(WPACDCParam)*MAX_NUM_COMPONENT);
2257  }
2258
2259  WPACDCParam*                getWpAcDcParam()                                       { return &m_weightACDCParam[0]; }
2260
2261  Void                        initWpAcDcParam();
2262
2263  Void                        clearSubstreamSizes( )                                 { return m_substreamSizes.clear();                              }
2264  UInt                        getNumberOfSubstreamSizes( )                           { return (UInt) m_substreamSizes.size();                        }
2265  Void                        addSubstreamSize( UInt size )                          { m_substreamSizes.push_back(size);                             }
2266  UInt                        getSubstreamSize( Int idx )                            { assert(idx<getNumberOfSubstreamSizes()); return m_substreamSizes[idx]; }
2267
2268  Void                        setCabacInitFlag( Bool val )                           { m_cabacInitFlag = val;                                        } //!< set CABAC initial flag
2269  Bool                        getCabacInitFlag()                                     { return m_cabacInitFlag;                                       } //!< get CABAC initial flag
2270  Bool                        getTemporalLayerNonReferenceFlag()                     { return m_temporalLayerNonReferenceFlag;                       }
2271  Void                        setTemporalLayerNonReferenceFlag(Bool x)               { m_temporalLayerNonReferenceFlag = x;                          }
2272  Void                        setLFCrossSliceBoundaryFlag( Bool   val )              { m_LFCrossSliceBoundaryFlag = val;                             }
2273  Bool                        getLFCrossSliceBoundaryFlag()                          { return m_LFCrossSliceBoundaryFlag;                            }
2274
2275  Void                        setEnableTMVPFlag( Bool   b )                          { m_enableTMVPFlag = b;                                         }
2276  Bool                        getEnableTMVPFlag()                                    { return m_enableTMVPFlag;                                      }
2277
2278  Void                        setEncCABACTableIdx( SliceType idx )                   { m_encCABACTableIdx = idx;                                     }
2279  SliceType                   getEncCABACTableIdx() const                            { return m_encCABACTableIdx;                                    }
2280
2281#if SVC_EXTENSION
2282  Void                        setFirstSliceInPic( Bool val )                         { m_firstSliceInPic = val;                                      }
2283  Bool                        getFirstSliceInPic()                                   { return m_firstSliceInPic;                                     }
2284  Void                        setAvailableForTMVPRefFlag( Bool   b )                 { m_availableForTMVPRefFlag = b;                                }
2285  Bool                        getAvailableForTMVPRefFlag()                           { return m_availableForTMVPRefFlag;                             }
2286  Bool                        setBaseColPic( TComList<TComPic*>& rcListPic , UInt refLayerIdc );
2287  Void                        setBaseColPic(UInt refLayerIdc, TComPic* p)            { m_pcBaseColPic[refLayerIdc] = p;                              }
2288  TComPic*                    getBaseColPic(UInt refLayerIdc)                        { return m_pcBaseColPic[refLayerIdc];                           }
2289  TComPic**                   getBaseColPic()                                        { return &m_pcBaseColPic[0];                                    }
2290  TComPic*                    getBaseColPic( TComList<TComPic*>& rcListPic );
2291
2292  Void                        setLayerId(UInt layerId)                               { m_layerId = layerId;                                          }
2293  UInt                        getLayerId() const                                     { return m_layerId;                                             }
2294  UInt                        getLayerIdx()                                          { return m_pcVPS->getLayerIdxInVps(m_layerId);                  }
2295
2296  Void                        setFullPelBaseRec( UInt refLayerIdc, TComPicYuv* p)    { m_pcFullPelBaseRec[refLayerIdc] = p;                          }
2297  TComPicYuv*                 getFullPelBaseRec( UInt refLayerIdc)                   { return  m_pcFullPelBaseRec[refLayerIdc];                      }
2298
2299  Void                        setRefPicListModificationSvc();
2300  Int                         getNumILRRefIdx()                                      { return  m_pcVPS->getNumDirectRefLayers( m_layerId );          }
2301
2302  Int                         getActiveNumILRRefIdx()                                { return  m_activeNumILRRefIdx;                                 }
2303  Void                        setActiveNumILRRefIdx( Int i )                         { m_activeNumILRRefIdx = i;                                     } 
2304   
2305  Int                         getInterLayerPredLayerIdc(UInt layerIdc)                        { return  m_interLayerPredLayerIdc[layerIdc];          }
2306  Void                        setInterLayerPredLayerIdc(UInt refLayerIdc, UInt layerIdc)      { m_interLayerPredLayerIdc[layerIdc] = refLayerIdc;    }
2307
2308  Void                        setInterLayerPredEnabledFlag( Bool   val )             { m_interLayerPredEnabledFlag = val;                            }
2309  Bool                        getInterLayerPredEnabledFlag()                         { return m_interLayerPredEnabledFlag;                           }
2310
2311  Void                        setNumMotionPredRefLayers(Int i)                       { m_numMotionPredRefLayers = i;                                 }
2312  Int                         getNumMotionPredRefLayers()                            { return m_numMotionPredRefLayers;                              }
2313
2314  Void                        setMFMEnabledFlag(Bool flag)                           { m_bMFMEnabledFlag = flag;                                     }
2315  Bool                        getMFMEnabledFlag()                                    { return m_bMFMEnabledFlag;                                     }
2316
2317  TComPic*                    getRefPic(TComList<TComPic*>& rcListPic, Int poc)      { return xGetRefPic( rcListPic, poc );                          } 
2318
2319  Bool                        isRADL()                                               { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_RADL_N || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RADL_R); }
2320  Bool                        isRASL()                                               { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_N || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_R); }
2321
2322  Bool                        isIDR()                                                { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP); }
2323  Bool                        isCRA()                                                { return m_eNalUnitType == NAL_UNIT_CODED_SLICE_CRA; }
2324  Bool                        isBLA()                                                { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP || m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL || m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP ); }
2325  Bool                        isSLNR()
2326  { 
2327    return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N
2328         || m_eNalUnitType == NAL_UNIT_CODED_SLICE_TSA_N
2329         || m_eNalUnitType == NAL_UNIT_CODED_SLICE_STSA_N
2330         || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RADL_N
2331         || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_N
2332         || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N10
2333         || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N12
2334         || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N14 );
2335  }
2336
2337  Bool                        getDiscardableFlag  ()                                 { return m_bDiscardableFlag;                                    }
2338  Void                        setDiscardableFlag  (Bool b)                           { m_bDiscardableFlag = b;                                       }
2339  Bool                        getCrossLayerBLAFlag  ()                               { return m_bCrossLayerBLAFlag;                                  }
2340  Void                        setCrossLayerBLAFlag  (Bool b)                         { m_bCrossLayerBLAFlag = b;                                     }
2341
2342  Int                         getNumNegativeRpsCurrTempList();
2343
2344  UInt                        getPicWidthInLumaSamples();
2345  UInt                        getPicHeightInLumaSamples();
2346  ChromaFormat                getChromaFormatIdc();
2347  UInt                        getBitDepth(ChannelType type) const;
2348  BitDepths&                  getBitDepths();
2349  Int                         getQpBDOffset(ChannelType type) const                  { return (getBitDepth(type) - 8) * 6;                           }
2350
2351  const Window&               getConformanceWindow() const;
2352
2353  Void                        setILRPic(TComPic **pcIlpPic);
2354
2355  Int                         getPocResetIdc()                                       { return m_pocResetIdc;                                         }
2356  Void                        setPocResetIdc(Int b)                                  { m_pocResetIdc = b;                                            }
2357  Int                         getPocResetPeriodId()                                  { return m_pocResetPeriodId;                                    }
2358  Void                        setPocResetPeriodId(Int b)                             { m_pocResetPeriodId = b;                                       }
2359  Bool                        getFullPocResetFlag()                                  { return m_fullPocResetFlag;                                    }
2360  Void                        setFullPocResetFlag(Bool b)                            { m_fullPocResetFlag = b;                                       }
2361  Int                         getPocLsbVal()                                         { return m_pocLsbVal;                                           }
2362  Void                        setPocLsbVal(Int b)                                    { m_pocLsbVal = b;                                              }
2363  Void                        setPocMsbNeeded(Bool x)                                { m_pocMsbValNeeded = x;                                        }
2364  Bool                        getPocMsbNeeded()                                      { return m_pocMsbValNeeded;                                     }
2365  Int                         getPocResetDeltaPoc()                                  { return m_pocResetDeltaPoc;                                    }
2366  Void                        setPocResetDeltaPoc(Int x)                             { m_pocResetDeltaPoc = x;                                       }
2367  Int                         getPocMsbVal()                                         { return m_pocMsbVal;                                           }
2368  Void                        setPocMsbVal(Int b)                                    { m_pocMsbVal = b;                                              }
2369  Bool                        getPocMsbValPresentFlag()                              { return m_pocMsbValPresentFlag;                                }
2370  Void                        setPocMsbValPresentFlag(Bool x)                        { m_pocMsbValPresentFlag = x;                                   }
2371  Bool                        getPocMsbValRequiredFlag()                             { return m_pocMsbValRequiredFlag;                               }
2372  Void                        setPocMsbValRequiredFlag(Bool x)                       { m_pocMsbValRequiredFlag = x;                                  }
2373
2374  Bool                        getBlaPicFlag();
2375  Bool                        getCraPicFlag();
2376  Bool                        getRaslPicFlag();
2377  Bool                        getRadlPicFlag();
2378  Int                         getPicOrderCntLsb()                                    { return m_picOrderCntLsb;                                      }
2379  Void                        setPicOrderCntLsb(Int x)                               { m_picOrderCntLsb = x;                                         }
2380
2381  Int                         getPocValueBeforeReset()                               { return m_pocValueBeforeReset;                                 }
2382  Void                        setPocValueBeforeReset(Int x)                          { m_pocValueBeforeReset = x ;                                   }
2383  Void                        decrementRefPocValues(Int const decrementValue);
2384  Int                         getCurrMsb( Int currLsb, Int prevLsb, Int prevMsb, Int maxLsbVal );
2385
2386  Int                         getReferenceLayerIdc( UInt refLayerId );
2387#endif //SVC_EXTENSION
2388
2389protected:
2390  TComPic*                    xGetRefPic        (TComList<TComPic*>& rcListPic, Int poc);
2391  TComPic*                    xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
2392};// END CLASS DEFINITION TComSlice
2393
2394
2395Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> *pNewData);
2396
2397template <class T> class ParameterSetMap
2398{
2399public:
2400  template <class Tm>
2401  struct MapData
2402  {
2403    Bool                  bChanged;
2404    std::vector<UChar>   *pNaluData; // Can be null
2405    Tm*                   parameterSet;
2406  };
2407
2408  ParameterSetMap(Int maxId)
2409  :m_maxId (maxId)
2410  {}
2411
2412  ~ParameterSetMap()
2413  {
2414    for (typename std::map<Int,MapData<T> >::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
2415    {
2416      delete (*i).second.pNaluData;
2417      delete (*i).second.parameterSet;
2418    }
2419  }
2420
2421  Void storePS(Int psId, T *ps, const std::vector<UChar> *pNaluData)
2422  {
2423    assert ( psId < m_maxId );
2424    if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
2425    {
2426      MapData<T> &mapData=m_paramsetMap[psId];
2427
2428      // work out changed flag
2429      calculateParameterSetChangedFlag(mapData.bChanged, mapData.pNaluData, pNaluData);
2430      delete m_paramsetMap[psId].pNaluData;
2431      delete m_paramsetMap[psId].parameterSet;
2432
2433      m_paramsetMap[psId].parameterSet = ps;
2434    }
2435    else
2436    {
2437      m_paramsetMap[psId].parameterSet = ps;
2438      m_paramsetMap[psId].bChanged = false;
2439    }
2440    if (pNaluData)
2441    {
2442      m_paramsetMap[psId].pNaluData=new std::vector<UChar>;
2443      *(m_paramsetMap[psId].pNaluData) = *pNaluData;
2444    }
2445    else
2446    {
2447      m_paramsetMap[psId].pNaluData=0;
2448    }
2449  }
2450
2451  Void clearChangedFlag(Int psId)
2452  {
2453    if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
2454    {
2455      m_paramsetMap[psId].bChanged=false;
2456    }
2457  }
2458
2459  Bool getChangedFlag(Int psId) const
2460  {
2461    const typename std::map<Int,MapData<T> >::const_iterator constit=m_paramsetMap.find(psId);
2462    if ( constit != m_paramsetMap.end() )
2463    {
2464      return constit->second.bChanged;
2465    }
2466    return false;
2467  }
2468
2469  T* getPS(Int psId)
2470  {
2471    return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId].parameterSet;
2472  }
2473
2474  T* getFirstPS()
2475  {
2476    return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second.parameterSet;
2477  }
2478
2479private:
2480  std::map<Int,MapData<T> > m_paramsetMap;
2481  Int                       m_maxId;
2482};
2483
2484class ParameterSetManager
2485{
2486public:
2487                 ParameterSetManager();
2488  virtual        ~ParameterSetManager();
2489
2490  //! store sequence parameter set and take ownership of it
2491  Void           storeVPS(TComVPS *vps, const std::vector<UChar> *pNaluData) { m_vpsMap.storePS( vps->getVPSId(), vps, pNaluData); };
2492  //! get pointer to existing video parameter set
2493  TComVPS*       getVPS(Int vpsId)                                           { return m_vpsMap.getPS(vpsId); };
2494  Bool           getVPSChangedFlag(Int vpsId) const                          { return m_vpsMap.getChangedFlag(vpsId); }
2495  Void           clearVPSChangedFlag(Int vpsId)                              { m_vpsMap.clearChangedFlag(vpsId); }
2496  TComVPS*       getFirstVPS()                                               { return m_vpsMap.getFirstPS(); };
2497
2498  //! store sequence parameter set and take ownership of it
2499  Void           storeSPS(TComSPS *sps, const std::vector<UChar> *pNaluData) { m_spsMap.storePS( sps->getSPSId(), sps, pNaluData); };
2500  //! get pointer to existing sequence parameter set
2501  TComSPS*       getSPS(Int spsId)                                           { return m_spsMap.getPS(spsId); };
2502  Bool           getSPSChangedFlag(Int spsId) const                          { return m_spsMap.getChangedFlag(spsId); }
2503  Void           clearSPSChangedFlag(Int spsId)                              { m_spsMap.clearChangedFlag(spsId); }
2504  TComSPS*       getFirstSPS()                                               { return m_spsMap.getFirstPS(); };
2505
2506  //! store picture parameter set and take ownership of it
2507  Void           storePPS(TComPPS *pps, const std::vector<UChar> *pNaluData) { m_ppsMap.storePS( pps->getPPSId(), pps, pNaluData); };
2508  //! get pointer to existing picture parameter set
2509  TComPPS*       getPPS(Int ppsId)                                           { return m_ppsMap.getPS(ppsId); };
2510  Bool           getPPSChangedFlag(Int ppsId) const                          { return m_ppsMap.getChangedFlag(ppsId); }
2511  Void           clearPPSChangedFlag(Int ppsId)                              { m_ppsMap.clearChangedFlag(ppsId); }
2512  TComPPS*       getFirstPPS()                                               { return m_ppsMap.getFirstPS(); };
2513
2514  //! activate a SPS from a active parameter sets SEI message
2515  //! \returns true, if activation is successful
2516  Bool           activateSPSWithSEI(Int SPSId);
2517
2518  //! activate a PPS and depending on isIDR parameter also SPS and VPS
2519  //! \returns true, if activation is successful
2520  Bool           activatePPS(Int ppsId, Bool isIRAP);
2521
2522  const TComVPS* getActiveVPS()const { return &m_activeVPS; };
2523  const TComSPS* getActiveSPS()const { return &m_activeSPS; };
2524
2525#if SVC_EXTENSION
2526  const TComPPS* getActivePPS()const { return &m_activePPS; };
2527#endif
2528
2529protected:
2530
2531#if SVC_EXTENSION
2532  static ParameterSetMap<TComVPS> m_vpsMap;
2533  static ParameterSetMap<TComSPS> m_spsMap; 
2534  static ParameterSetMap<TComPPS> m_ppsMap;
2535
2536  TComPPS                  m_activePPS;
2537  static TComVPS           m_activeVPS;
2538#else
2539  ParameterSetMap<TComVPS> m_vpsMap;
2540  ParameterSetMap<TComSPS> m_spsMap;
2541  ParameterSetMap<TComPPS> m_ppsMap;
2542
2543  TComVPS                  m_activeVPS; // used for SEI message
2544#endif
2545
2546  TComSPS                  m_activeSPS; // used for SEI message
2547};
2548
2549//! \}
2550
2551#endif // __TCOMSLICE__
Note: See TracBrowser for help on using the repository browser.