source: 3DVCSoftware/branches/HTM-DEV-0.3-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 500

Last change on this file since 500 was 500, checked in by tech, 11 years ago

Further fixes.

  • Property svn:eol-style set to native
File size: 109.5 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-2013, 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     TAppEncCfg.cpp
35    \brief    Handle encoder configuration parameters
36*/
37
38#include <stdlib.h>
39#include <cassert>
40#include <cstring>
41#include <string>
42#include "TLibCommon/TComRom.h"
43#include "TAppEncCfg.h"
44
45static istream& operator>>(istream &, Level::Name &);
46static istream& operator>>(istream &, Level::Tier &);
47static istream& operator>>(istream &, Profile::Name &);
48
49#include "TAppCommon/program_options_lite.h"
50#include "TLibEncoder/TEncRateCtrl.h"
51#ifdef WIN32
52#define strdup _strdup
53#endif
54
55using namespace std;
56namespace po = df::program_options_lite;
57
58//! \ingroup TAppEncoder
59//! \{
60
61// ====================================================================================================================
62// Constructor / destructor / initialization / destroy
63// ====================================================================================================================
64
65TAppEncCfg::TAppEncCfg()
66#if H_MV
67: m_pchBitstreamFile()
68#else
69: m_pchInputFile()
70, m_pchBitstreamFile()
71, m_pchReconFile()
72#endif
73, m_pchdQPFile()
74, m_pColumnWidth()
75, m_pRowHeight()
76, m_scalingListFile()
77{
78#if !H_MV
79  m_aidQP = NULL;
80#endif
81#if J0149_TONE_MAPPING_SEI
82  m_startOfCodedInterval = NULL;
83  m_codedPivotValue = NULL;
84  m_targetPivotValue = NULL;
85#endif
86}
87
88TAppEncCfg::~TAppEncCfg()
89{
90#if H_MV
91  for( Int layer = 0; layer < m_aidQP.size(); layer++ )
92  {
93    if ( m_aidQP[layer] != NULL )
94    {
95      delete[] m_aidQP[layer];
96      m_aidQP[layer] = NULL;
97    }
98  }
99  for(Int i = 0; i< m_pchInputFileList.size(); i++ )
100  {
101    if ( m_pchInputFileList[i] != NULL )
102      free (m_pchInputFileList[i]);
103  }
104#else
105  if ( m_aidQP )
106  {
107    delete[] m_aidQP;
108  }
109#endif
110#if J0149_TONE_MAPPING_SEI
111  if ( m_startOfCodedInterval )
112  {
113    delete[] m_startOfCodedInterval;
114    m_startOfCodedInterval = NULL;
115  }
116   if ( m_codedPivotValue )
117  {
118    delete[] m_codedPivotValue;
119    m_codedPivotValue = NULL;
120  }
121  if ( m_targetPivotValue )
122  {
123    delete[] m_targetPivotValue;
124    m_targetPivotValue = NULL;
125  }
126#endif
127#if !H_MV
128  free(m_pchInputFile);
129#endif
130  free(m_pchBitstreamFile);
131#if H_MV
132  for(Int i = 0; i< m_pchReconFileList.size(); i++ )
133  {
134    if ( m_pchReconFileList[i] != NULL )
135      free (m_pchReconFileList[i]);
136  }
137#else
138  free(m_pchReconFile);
139#endif
140  free(m_pchdQPFile);
141  free(m_pColumnWidth);
142  free(m_pRowHeight);
143  free(m_scalingListFile);
144#if H_MV
145  for( Int i = 0; i < m_GOPListMvc.size(); i++ )
146  {
147    if( m_GOPListMvc[i] )
148    {
149      delete[] m_GOPListMvc[i];
150      m_GOPListMvc[i] = NULL;
151    }
152  }
153#endif
154#if H_3D
155#if H_3D_VSO
156  if (  m_pchVSOConfig != NULL)
157    free (  m_pchVSOConfig );
158#endif
159  if ( m_pchCameraParameterFile != NULL )
160    free ( m_pchCameraParameterFile ); 
161
162  if ( m_pchBaseViewCameraNumbers != NULL )
163    free ( m_pchBaseViewCameraNumbers ); 
164#endif
165}
166
167Void TAppEncCfg::create()
168{
169}
170
171Void TAppEncCfg::destroy()
172{
173}
174
175std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry)     //input
176{
177  in>>entry.m_sliceType;
178  in>>entry.m_POC;
179  in>>entry.m_QPOffset;
180  in>>entry.m_QPFactor;
181  in>>entry.m_tcOffsetDiv2;
182  in>>entry.m_betaOffsetDiv2;
183  in>>entry.m_temporalId;
184  in>>entry.m_numRefPicsActive;
185  in>>entry.m_numRefPics;
186  for ( Int i = 0; i < entry.m_numRefPics; i++ )
187  {
188    in>>entry.m_referencePics[i];
189  }
190  in>>entry.m_interRPSPrediction;
191#if AUTO_INTER_RPS
192  if (entry.m_interRPSPrediction==1)
193  {
194    in>>entry.m_deltaRPS;
195    in>>entry.m_numRefIdc;
196    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
197    {
198      in>>entry.m_refIdc[i];
199    }
200  }
201  else if (entry.m_interRPSPrediction==2)
202  {
203    in>>entry.m_deltaRPS;
204  }
205#else
206  if (entry.m_interRPSPrediction)
207  {
208    in>>entry.m_deltaRPS;
209    in>>entry.m_numRefIdc;
210    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
211    {
212      in>>entry.m_refIdc[i];
213    }
214  }
215#endif
216#if H_MV
217  in>>entry.m_numActiveRefLayerPics;
218  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
219  {
220    in>>entry.m_interLayerPredLayerIdc[i];
221  }
222  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
223  {
224    in>>entry.m_interViewRefPosL[0][i];
225  }
226  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
227  {
228    in>>entry.m_interViewRefPosL[1][i];
229  }
230  if (entry.m_numActiveRefLayerPics > 0 )
231  {
232    in>>entry.m_collocatedRefLayerIdx; 
233  }
234#endif
235  return in;
236}
237
238static const struct MapStrToProfile {
239  const Char* str;
240  Profile::Name value;
241} strToProfile[] = {
242  {"none", Profile::NONE},
243  {"main", Profile::MAIN},
244  {"main10", Profile::MAIN10},
245  {"main-still-picture", Profile::MAINSTILLPICTURE},
246#if H_MV
247  {"main-stereo",    Profile::MAINSTEREO},
248  {"main-multiview", Profile::MAINMULTIVIEW},
249#if H_3D
250  {"main-3d"    , Profile::MAIN3D},
251#endif
252#endif
253};
254
255static const struct MapStrToTier {
256  const Char* str;
257  Level::Tier value;
258} strToTier[] = {
259  {"main", Level::MAIN},
260  {"high", Level::HIGH},
261};
262
263static const struct MapStrToLevel {
264  const Char* str;
265  Level::Name value;
266} strToLevel[] = {
267  {"none",Level::NONE},
268  {"1",   Level::LEVEL1},
269  {"2",   Level::LEVEL2},
270  {"2.1", Level::LEVEL2_1},
271  {"3",   Level::LEVEL3},
272  {"3.1", Level::LEVEL3_1},
273  {"4",   Level::LEVEL4},
274  {"4.1", Level::LEVEL4_1},
275  {"5",   Level::LEVEL5},
276  {"5.1", Level::LEVEL5_1},
277  {"5.2", Level::LEVEL5_2},
278  {"6",   Level::LEVEL6},
279  {"6.1", Level::LEVEL6_1},
280  {"6.2", Level::LEVEL6_2},
281};
282
283template<typename T, typename P>
284static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
285{
286  string str;
287  in >> str;
288
289  for (Int i = 0; i < mapLen; i++)
290  {
291    if (str == map[i].str)
292    {
293      val = map[i].value;
294      goto found;
295    }
296  }
297  /* not found */
298  in.setstate(ios::failbit);
299found:
300  return in;
301}
302
303static istream& operator>>(istream &in, Profile::Name &profile)
304{
305  return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
306}
307
308static istream& operator>>(istream &in, Level::Tier &tier)
309{
310  return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
311}
312
313static istream& operator>>(istream &in, Level::Name &level)
314{
315  return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
316}
317
318#if SIGNAL_BITRATE_PICRATE_IN_VPS
319Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName);
320Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName);
321#endif
322// ====================================================================================================================
323// Public member functions
324// ====================================================================================================================
325
326/** \param  argc        number of arguments
327    \param  argv        array of arguments
328    \retval             true when success
329 */
330Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
331{
332  Bool do_help = false;
333 
334#if !H_MV
335  string cfg_InputFile;
336#endif
337  string cfg_BitstreamFile;
338#if !H_MV
339  string cfg_ReconFile;
340#endif
341#if H_MV
342  vector<Int>   cfg_dimensionLength; 
343#if H_3D
344  cfg_dimensionLength.push_back( 2  );  // depth
345  cfg_dimensionLength.push_back( 32 );  // texture
346#else
347  cfg_dimensionLength.push_back( 64 ); 
348#endif
349#endif
350  string cfg_dQPFile;
351  string cfg_ColumnWidth;
352  string cfg_RowHeight;
353  string cfg_ScalingListFile;
354#if J0149_TONE_MAPPING_SEI
355  string cfg_startOfCodedInterval;
356  string cfg_codedPivotValue;
357  string cfg_targetPivotValue;
358#endif
359#if SIGNAL_BITRATE_PICRATE_IN_VPS
360  string cfg_bitRateInfoPresentFlag;
361  string cfg_picRateInfoPresentFlag;
362  string cfg_avgBitRate;
363  string cfg_maxBitRate;
364  string cfg_avgPicRate;
365  string cfg_constantPicRateIdc;
366#endif
367  po::Options opts;
368  opts.addOptions()
369  ("help", do_help, false, "this help text")
370  ("c", po::parseConfigFile, "configuration file name")
371 
372  // File, I/O and source parameters
373#if H_MV
374  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
375#else
376  ("InputFile,i",           cfg_InputFile,     string(""), "Original YUV input file name")
377#endif
378  ("BitstreamFile,b",       cfg_BitstreamFile, string(""), "Bitstream output file name")
379#if H_MV
380  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
381#else
382  ("ReconFile,o",           cfg_ReconFile,     string(""), "Reconstructed YUV output file name")
383#endif
384#if H_MV
385  ("NumberOfLayers",        m_numberOfLayers     , 1,                     "Number of layers")
386#if !H_3D
387  ("ScalabilityMask",       m_scalabilityMask    , 1                    , "Scalability Mask")   
388#else
389  ("ScalabilityMask",       m_scalabilityMask    , 3                    , "Scalability Mask, 1: Texture 3: Texture + Depth ")   
390#endif 
391  ("DimensionIdLen",        m_dimensionIdLen     , cfg_dimensionLength  , "Number of bits used to store dimensions Id")
392  ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id")
393#if H_3D
394  ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
395#endif
396  ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")
397  ("SplittingFlag",         m_splittingFlag      , false                , "Splitting Flag")   
398
399  // Layer Sets + Output Layer Sets + Profile Tier Level
400  ("VpsNumLayerSets",       m_vpsNumLayerSets    , 1                    , "Number of layer sets")   
401  ("LayerIdsInSet_%d",      m_layerIdsInSets     , std::vector<Int>(1,0), MAX_VPS_OP_SETS_PLUS1 ,"LayerIds of Layer set") 
402  ("DefaultOneTargetOutputLayerFlag", m_defaultOneTargetOutputLayerFlag,  false , "Output highest layer of layer sets by default")     
403  ("OutputLayerSetIdx",     m_outputLayerSetIdx  , std::vector<Int>(0,0), "Indices of layer sets used as additional output layer sets") 
404  ("LayerIdsInAddOutputLayerSet_%d", m_layerIdsInAddOutputLayerSet      , std::vector<Int>(1,0), MAX_VPS_ADD_OUTPUT_LAYER_SETS, "LayerIds of additional output layers") 
405  ("ProfileLevelTierIdx",   m_profileLevelTierIdx, std::vector<Int>(1,0), "Indices to profile level tier")
406 
407  // Layer dependencies
408  ("DirectRefLayers_%d",    m_directRefLayers    , std::vector<Int>(0,0), MAX_NUM_LAYERS, "LayerIds of direct reference layers")
409  ("DependencyTypes_%d",    m_dependencyTypes    , std::vector<Int>(0,0), MAX_NUM_LAYERS, "Dependency types of direct reference layers, 0: Sample 1: Motion 2: Sample+Motion")
410#endif
411  ("SourceWidth,-wdt",      m_iSourceWidth,        0, "Source picture width")
412  ("SourceHeight,-hgt",     m_iSourceHeight,       0, "Source picture height")
413  ("InputBitDepth",         m_inputBitDepthY,    8, "Bit-depth of input file")
414  ("OutputBitDepth",        m_outputBitDepthY,   0, "Bit-depth of output file (default:InternalBitDepth)")
415  ("InternalBitDepth",      m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
416                                                       "If different to InputBitDepth, source data will be converted")
417  ("InputBitDepthC",        m_inputBitDepthC,    0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
418  ("OutputBitDepthC",       m_outputBitDepthC,   0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
419  ("InternalBitDepthC",     m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
420  ("ConformanceMode",       m_conformanceMode,     0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
421  ("HorizontalPadding,-pdx",m_aiPad[0],            0, "Horizontal source padding for conformance window mode 2")
422  ("VerticalPadding,-pdy",  m_aiPad[1],            0, "Vertical source padding for conformance window mode 2")
423  ("ConfLeft",              m_confLeft,            0, "Left offset for window conformance mode 3")
424  ("ConfRight",             m_confRight,           0, "Right offset for window conformance mode 3")
425  ("ConfTop",               m_confTop,             0, "Top offset for window conformance mode 3")
426  ("ConfBottom",            m_confBottom,          0, "Bottom offset for window conformance mode 3")
427  ("FrameRate,-fr",         m_iFrameRate,          0, "Frame rate")
428  ("FrameSkip,-fs",         m_FrameSkip,          0u, "Number of frames to skip at start of input YUV")
429  ("FramesToBeEncoded,f",   m_framesToBeEncoded,   0, "Number of frames to be encoded (default=all)")
430
431  // Profile and level
432  ("Profile", m_profile,   Profile::NONE, "Profile to be used when encoding (Incomplete)")
433  ("Level",   m_level,     Level::NONE,   "Level limit to be used, eg 5.1 (Incomplete)")
434  ("Tier",    m_levelTier, Level::MAIN,   "Tier to use for interpretation of --Level")
435
436#if L0046_CONSTRAINT_FLAGS
437  ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
438  ("InterlacedSource",  m_interlacedSourceFlag,  false, "Indicate that source is interlaced")
439  ("NonPackedSource",   m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
440  ("FrameOnly",         m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
441#endif
442 
443  // Unit definition parameters
444  ("MaxCUWidth",              m_uiMaxCUWidth,             64u)
445  ("MaxCUHeight",             m_uiMaxCUHeight,            64u)
446  // todo: remove defaults from MaxCUSize
447  ("MaxCUSize,s",             m_uiMaxCUWidth,             64u, "Maximum CU size")
448  ("MaxCUSize,s",             m_uiMaxCUHeight,            64u, "Maximum CU size")
449  ("MaxPartitionDepth,h",     m_uiMaxCUDepth,              4u, "CU depth")
450 
451  ("QuadtreeTULog2MaxSize",   m_uiQuadtreeTULog2MaxSize,   6u, "Maximum TU size in logarithm base 2")
452  ("QuadtreeTULog2MinSize",   m_uiQuadtreeTULog2MinSize,   2u, "Minimum TU size in logarithm base 2")
453 
454  ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
455  ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
456 
457  // Coding structure paramters
458  ("IntraPeriod,-ip",         m_iIntraPeriod,              -1, "Intra period in frames, (-1: only first frame)")
459  ("DecodingRefreshType,-dr", m_iDecodingRefreshType,       0, "Intra refresh type (0:none 1:CRA 2:IDR)")
460  ("GOPSize,g",               m_iGOPSize,                   1, "GOP size of temporal structure")
461#if !L0034_COMBINED_LIST_CLEANUP
462  ("ListCombination,-lc",     m_bUseLComb,               true, "Combined reference list for uni-prediction estimation in B-slices")
463#endif
464  // motion options
465  ("FastSearch",              m_iFastSearch,                1, "0:Full search  1:Diamond  2:PMVFAST")
466  ("SearchRange,-sr",         m_iSearchRange,              96, "Motion search range")
467  ("BipredSearchRange",       m_bipredSearchRange,          4, "Motion search range for bipred refinement")
468  ("HadamardME",              m_bUseHADME,               true, "Hadamard ME for fractional-pel")
469  ("ASR",                     m_bUseASR,                false, "Adaptive motion search range")
470
471  // Mode decision parameters
472  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
473  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
474  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
475  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
476  ("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
477  ("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
478  ("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
479  ("LambdaModifier7,-LM7", m_adLambdaModifier[ 7 ], ( Double )1.0, "Lambda modifier for temporal layer 7")
480
481  /* Quantization parameters */
482#if H_MV
483  ("QP,q",          m_fQP, std::vector<double>(1,30.0), "Qp values for each layer, if value is float, QP is switched once during encoding")
484#else
485  ("QP,q",          m_fQP,             30.0, "Qp value, if value is float, QP is switched once during encoding")
486#endif
487  ("DeltaQpRD,-dqr",m_uiDeltaQpRD,       0u, "max dQp offset for slice")
488  ("MaxDeltaQP,d",  m_iMaxDeltaQP,        0, "max dQp offset for block")
489  ("MaxCuDQPDepth,-dqd",  m_iMaxCuDQPDepth,        0, "max depth for a minimum CuDQP")
490
491  ("CbQpOffset,-cbqpofs",  m_cbQpOffset,        0, "Chroma Cb QP Offset")
492  ("CrQpOffset,-crqpofs",  m_crQpOffset,        0, "Chroma Cr QP Offset")
493
494#if ADAPTIVE_QP_SELECTION
495  ("AdaptiveQpSelection,-aqps",   m_bUseAdaptQpSelect,           false, "AdaptiveQpSelection")
496#endif
497
498  ("AdaptiveQP,-aq",                m_bUseAdaptiveQP,           false, "QP adaptation based on a psycho-visual model")
499  ("MaxQPAdaptationRange,-aqr",     m_iQPAdaptationRange,           6, "QP adaptation range")
500  ("dQPFile,m",                     cfg_dQPFile,           string(""), "dQP file name")
501  ("RDOQ",                          m_useRDOQ,                  true )
502  ("RDOQTS",                        m_useRDOQTS,                true )
503#if L0232_RD_PENALTY
504  ("RDpenalty",                     m_rdPenalty,                0,  "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled  1:RD-penalty  2:maximum RD-penalty")
505#endif
506  // Entropy coding parameters
507  ("SBACRD",                         m_bUseSBACRD,                      true, "SBAC based RD estimation")
508 
509  // Deblocking filter parameters
510#if H_MV
511  ("LoopFilterDisable",              m_bLoopFilterDisable,             std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )
512#else
513  ("LoopFilterDisable",              m_bLoopFilterDisable,             false )
514#endif
515  ("LoopFilterOffsetInPPS",          m_loopFilterOffsetInPPS,          false )
516  ("LoopFilterBetaOffset_div2",      m_loopFilterBetaOffsetDiv2,           0 )
517  ("LoopFilterTcOffset_div2",        m_loopFilterTcOffsetDiv2,             0 )
518  ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
519#if L0386_DB_METRIC
520  ("DeblockingFilterMetric",         m_DeblockingFilterMetric,         false )
521#endif
522
523  // Coding tools
524  ("AMP",                      m_enableAMP,                 true,  "Enable asymmetric motion partitions")
525  ("TransformSkip",            m_useTransformSkip,          false, "Intra transform skipping")
526  ("TransformSkipFast",        m_useTransformSkipFast,      false, "Fast intra transform skipping")
527#if H_MV
528  ("SAO",                      m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer")
529#else
530  ("SAO",                      m_bUseSAO,                   true,  "Enable Sample Adaptive Offset")
531#endif
532  ("MaxNumOffsetsPerPic",      m_maxNumOffsetsPerPic,       2048,  "Max number of SAO offset per picture (Default: 2048)")   
533  ("SAOLcuBoundary",           m_saoLcuBoundary,            false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
534  ("SAOLcuBasedOptimization",  m_saoLcuBasedOptimization,   true,  "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
535  ("SliceMode",                m_sliceMode,                0,     "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
536  ("SliceArgument",            m_sliceArgument,            0,     "Depending on SliceMode being:"
537                                                                   "\t1: max number of CTUs per slice"
538                                                                   "\t2: max number of bytes per slice"
539                                                                   "\t3: max number of tiles per slice")
540  ("SliceSegmentMode",         m_sliceSegmentMode,       0,     "0: Disable all slice segment limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
541  ("SliceSegmentArgument",     m_sliceSegmentArgument,   0,     "Depending on SliceSegmentMode being:"
542                                                                   "\t1: max number of CTUs per slice segment"
543                                                                   "\t2: max number of bytes per slice segment"
544                                                                   "\t3: max number of tiles per slice segment")
545  ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
546
547  ("ConstrainedIntraPred",     m_bUseConstrainedIntraPred,  false, "Constrained Intra Prediction")
548
549  ("PCMEnabledFlag",           m_usePCM,                    false)
550  ("PCMLog2MaxSize",           m_pcmLog2MaxSize,            5u)
551  ("PCMLog2MinSize",           m_uiPCMLog2MinSize,          3u)
552  ("PCMInputBitDepthFlag",     m_bPCMInputBitDepthFlag,     true)
553  ("PCMFilterDisableFlag",     m_bPCMFilterDisableFlag,    false)
554
555  ("LosslessCuEnabled",        m_useLossless, false)
556
557  ("WeightedPredP,-wpP",          m_useWeightedPred,               false,      "Use weighted prediction in P slices")
558  ("WeightedPredB,-wpB",          m_useWeightedBiPred,             false,      "Use weighted (bidirectional) prediction in B slices")
559  ("Log2ParallelMergeLevel",      m_log2ParallelMergeLevel,     2u,          "Parallel merge estimation region")
560  ("UniformSpacingIdc",           m_iUniformSpacingIdr,            0,          "Indicates if the column and row boundaries are distributed uniformly")
561  ("NumTileColumnsMinus1",        m_iNumColumnsMinus1,             0,          "Number of columns in a picture minus 1")
562  ("ColumnWidthArray",            cfg_ColumnWidth,                 string(""), "Array containing ColumnWidth values in units of LCU")
563  ("NumTileRowsMinus1",           m_iNumRowsMinus1,                0,          "Number of rows in a picture minus 1")
564  ("RowHeightArray",              cfg_RowHeight,                   string(""), "Array containing RowHeight values in units of LCU")
565  ("LFCrossTileBoundaryFlag",      m_bLFCrossTileBoundaryFlag,             true,          "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
566  ("WaveFrontSynchro",            m_iWaveFrontSynchro,             0,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
567  ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
568  ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
569  ("SignHideFlag,-SBH",                m_signHideFlag, 1)
570  ("MaxNumMergeCand",             m_maxNumMergeCand,             5u,         "Maximum number of merge candidates")
571
572  /* Misc. */
573  ("SEIDecodedPictureHash",       m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
574                                                                    "\t3: checksum\n"
575                                                                    "\t2: CRC\n"
576                                                                    "\t1: use MD5\n"
577                                                                    "\t0: disable")
578  ("SEIpictureDigest",            m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
579  ("TMVPMode", m_TMVPModeId, 1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only")
580  ("FEN", m_bUseFastEnc, false, "fast encoder setting")
581  ("ECU", m_bUseEarlyCU, false, "Early CU setting") 
582  ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost") 
583  ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
584  ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
585#if RATE_CONTROL_LAMBDA_DOMAIN
586  ( "RateControl",         m_RCEnableRateControl,   false, "Rate control: enable rate control" )
587  ( "TargetBitrate",       m_RCTargetBitrate,           0, "Rate control: target bitrate" )
588  ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, false, "Rate control: keep hierarchical bit allocation in rate control algorithm" )
589  ( "LCULevelRateControl", m_RCLCULevelRC,           true, "Rate control: true: LCU level RC; false: picture level RC" )
590  ( "RCLCUSeparateModel",  m_RCUseLCUSeparateModel,  true, "Rate control: use LCU level separate R-lambda model" )
591  ( "InitialQP",           m_RCInitialQP,               0, "Rate control: initial QP" )
592  ( "RCForceIntraQP",      m_RCForceIntraQP,        false, "Rate control: force intra QP to be equal to initial QP" )
593#else
594  ("RateCtrl,-rc", m_enableRateCtrl, false, "Rate control on/off")
595  ("TargetBitrate,-tbr", m_targetBitrate, 0, "Input target bitrate")
596  ("NumLCUInUnit,-nu", m_numLCUInUnit, 0, "Number of LCUs in an Unit")
597#endif
598
599  ("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
600  ("CUTransquantBypassFlagValue", m_CUTransquantBypassFlagValue, false, "Fixed cu_transquant_bypass_flag value, when transquant_bypass_enable_flag is enabled")
601  ("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
602  ("StrongIntraSmoothing,-sis",      m_useStrongIntraSmoothing,           true, "Enable strong intra smoothing for 32x32 blocks")
603  ("SEIActiveParameterSets",         m_activeParameterSetsSEIEnabled,          0, "Enable generation of active parameter sets SEI messages")
604  ("VuiParametersPresent,-vui",      m_vuiParametersPresentFlag,           false, "Enable generation of vui_parameters()")
605  ("AspectRatioInfoPresent",         m_aspectRatioInfoPresentFlag,         false, "Signals whether aspect_ratio_idc is present")
606  ("AspectRatioIdc",                 m_aspectRatioIdc,                         0, "aspect_ratio_idc")
607  ("SarWidth",                       m_sarWidth,                               0, "horizontal size of the sample aspect ratio")
608  ("SarHeight",                      m_sarHeight,                              0, "vertical size of the sample aspect ratio")
609  ("OverscanInfoPresent",            m_overscanInfoPresentFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
610  ("OverscanAppropriate",            m_overscanAppropriateFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
611  ("VideoSignalTypePresent",         m_videoSignalTypePresentFlag,         false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
612  ("VideoFormat",                    m_videoFormat,                            5, "Indicates representation of pictures")
613  ("VideoFullRange",                 m_videoFullRangeFlag,                 false, "Indicates the black level and range of luma and chroma signals")
614  ("ColourDescriptionPresent",       m_colourDescriptionPresentFlag,       false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
615  ("ColourPrimaries",                m_colourPrimaries,                        2, "Indicates chromaticity coordinates of the source primaries")
616  ("TransferCharateristics",         m_transferCharacteristics,                2, "Indicates the opto-electronic transfer characteristics of the source")
617  ("MatrixCoefficients",             m_matrixCoefficients,                     2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
618  ("ChromaLocInfoPresent",           m_chromaLocInfoPresentFlag,           false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
619  ("ChromaSampleLocTypeTopField",    m_chromaSampleLocTypeTopField,            0, "Specifies the location of chroma samples for top field")
620  ("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField,         0, "Specifies the location of chroma samples for bottom field")
621  ("NeutralChromaIndication",        m_neutralChromaIndicationFlag,        false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
622  ("DefaultDisplayWindowFlag",       m_defaultDisplayWindowFlag,           false, "Indicates the presence of the Default Window parameters")
623  ("DefDispWinLeftOffset",           m_defDispWinLeftOffset,                   0, "Specifies the left offset of the default display window from the conformance window")
624  ("DefDispWinRightOffset",          m_defDispWinRightOffset,                  0, "Specifies the right offset of the default display window from the conformance window")
625  ("DefDispWinTopOffset",            m_defDispWinTopOffset,                    0, "Specifies the top offset of the default display window from the conformance window")
626  ("DefDispWinBottomOffset",         m_defDispWinBottomOffset,                 0, "Specifies the bottom offset of the default display window from the conformance window")
627  ("FrameFieldInfoPresentFlag",      m_frameFieldInfoPresentFlag,               false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
628  ("PocProportionalToTimingFlag",   m_pocProportionalToTimingFlag,         false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
629  ("NumTicksPocDiffOneMinus1",      m_numTicksPocDiffOneMinus1,                0, "Number of ticks minus 1 that for a POC difference of one")
630  ("BitstreamRestriction",           m_bitstreamRestrictionFlag,           false, "Signals whether bitstream restriction parameters are present")
631  ("TilesFixedStructure",            m_tilesFixedStructureFlag,            false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
632  ("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
633  ("MaxBytesPerPicDenom",            m_maxBytesPerPicDenom,                    2, "Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture")
634  ("MaxBitsPerMinCuDenom",           m_maxBitsPerMinCuDenom,                   1, "Indicates an upper bound for the number of bits of coding_unit() data")
635  ("Log2MaxMvLengthHorizontal",      m_log2MaxMvLengthHorizontal,             15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
636  ("Log2MaxMvLengthVertical",        m_log2MaxMvLengthVertical,               15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
637  ("SEIRecoveryPoint",               m_recoveryPointSEIEnabled,                0, "Control generation of recovery point SEI messages")
638  ("SEIBufferingPeriod",             m_bufferingPeriodSEIEnabled,              0, "Control generation of buffering period SEI messages")
639  ("SEIPictureTiming",               m_pictureTimingSEIEnabled,                0, "Control generation of picture timing SEI messages")
640#if J0149_TONE_MAPPING_SEI
641  ("SEIToneMappingInfo",                       m_toneMappingInfoSEIEnabled,    false, "Control generation of Tone Mapping SEI messages")
642  ("SEIToneMapId",                             m_toneMapId,                        0, "Specifies Id of Tone Mapping SEI message for a given session")
643  ("SEIToneMapCancelFlag",                     m_toneMapCancelFlag,            false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
644  ("SEIToneMapPersistenceFlag",                m_toneMapPersistenceFlag,        true, "Specifies the persistence of the Tone Mapping SEI message")
645  ("SEIToneMapCodedDataBitDepth",              m_toneMapCodedDataBitDepth,         8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
646  ("SEIToneMapTargetBitDepth",                 m_toneMapTargetBitDepth,            8, "Specifies Output BitDepth of Tome mapping function")
647  ("SEIToneMapModelId",                        m_toneMapModelId,                   0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
648                                                                                      "\t0:  linear mapping with clipping\n"
649                                                                                      "\t1:  sigmoidal mapping\n"
650                                                                                      "\t2:  user-defined table mapping\n"
651                                                                                      "\t3:  piece-wise linear mapping\n"
652                                                                                      "\t4:  luminance dynamic range information ")
653  ("SEIToneMapMinValue",                              m_toneMapMinValue,                          0, "Specifies the minimum value in mode 0")
654  ("SEIToneMapMaxValue",                              m_toneMapMaxValue,                       1023, "Specifies the maxmum value in mode 0")
655  ("SEIToneMapSigmoidMidpoint",                       m_sigmoidMidpoint,                        512, "Specifies the centre point in mode 1")
656  ("SEIToneMapSigmoidWidth",                          m_sigmoidWidth,                           960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
657  ("SEIToneMapStartOfCodedInterval",                  cfg_startOfCodedInterval,          string(""), "Array of user-defined mapping table")
658  ("SEIToneMapNumPivots",                             m_numPivots,                                0, "Specifies the number of pivot points in mode 3")
659  ("SEIToneMapCodedPivotValue",                       cfg_codedPivotValue,               string(""), "Array of pivot point")
660  ("SEIToneMapTargetPivotValue",                      cfg_targetPivotValue,              string(""), "Array of pivot point")
661  ("SEIToneMapCameraIsoSpeedIdc",                     m_cameraIsoSpeedIdc,                        0, "Indicates the camera ISO speed for daylight illumination")
662  ("SEIToneMapCameraIsoSpeedValue",                   m_cameraIsoSpeedValue,                    400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
663  ("SEIToneMapExposureCompensationValueSignFlag",     m_exposureCompensationValueSignFlag,        0, "Specifies the sign of ExposureCompensationValue")
664  ("SEIToneMapExposureCompensationValueNumerator",    m_exposureCompensationValueNumerator,       0, "Specifies the numerator of ExposureCompensationValue")
665  ("SEIToneMapExposureCompensationValueDenomIdc",     m_exposureCompensationValueDenomIdc,        2, "Specifies the denominator of ExposureCompensationValue")
666  ("SEIToneMapRefScreenLuminanceWhite",               m_refScreenLuminanceWhite,                350, "Specifies reference screen brightness setting in units of candela per square metre")
667  ("SEIToneMapExtendedRangeWhiteLevel",               m_extendedRangeWhiteLevel,                800, "Indicates the luminance dynamic range")
668  ("SEIToneMapNominalBlackLevelLumaCodeValue",        m_nominalBlackLevelLumaCodeValue,          16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
669  ("SEIToneMapNominalWhiteLevelLumaCodeValue",        m_nominalWhiteLevelLumaCodeValue,         235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
670  ("SEIToneMapExtendedWhiteLevelLumaCodeValue",       m_extendedWhiteLevelLumaCodeValue,        300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
671#endif
672  ("SEIFramePacking",                m_framePackingSEIEnabled,                 0, "Control generation of frame packing SEI messages")
673  ("SEIFramePackingType",            m_framePackingSEIType,                    0, "Define frame packing arrangement\n"
674                                                                                  "\t0: checkerboard - pixels alternatively represent either frames\n"
675                                                                                  "\t1: column alternation - frames are interlaced by column\n"
676                                                                                  "\t2: row alternation - frames are interlaced by row\n"
677                                                                                  "\t3: side by side - frames are displayed horizontally\n"
678                                                                                  "\t4: top bottom - frames are displayed vertically\n"
679                                                                                  "\t5: frame alternation - one frame is alternated with the other")
680  ("SEIFramePackingId",              m_framePackingSEIId,                      0, "Id of frame packing SEI message for a given session")
681  ("SEIFramePackingQuincunx",        m_framePackingSEIQuincunx,                0, "Indicate the presence of a Quincunx type video frame")
682  ("SEIFramePackingInterpretation",  m_framePackingSEIInterpretation,          0, "Indicate the interpretation of the frame pair\n"
683                                                                                  "\t0: unspecified\n"
684                                                                                  "\t1: stereo pair, frame0 represents left view\n"
685                                                                                  "\t2: stereo pair, frame0 represents right view")
686  ("SEIDisplayOrientation",          m_displayOrientationSEIAngle,             0, "Control generation of display orientation SEI messages\n"
687                                                              "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
688                                                              "\t0: disable")
689  ("SEITemporalLevel0Index",         m_temporalLevel0IndexSEIEnabled,          0, "Control generation of temporal level 0 index SEI messages")
690  ("SEIGradualDecodingRefreshInfo",  m_gradualDecodingRefreshInfoEnabled,      0, "Control generation of gradual decoding refresh information SEI message")
691  ("SEIDecodingUnitInfo",             m_decodingUnitInfoSEIEnabled,                       0, "Control generation of decoding unit information SEI message.")
692#if L0208_SOP_DESCRIPTION_SEI
693  ("SEISOPDescription",              m_SOPDescriptionSEIEnabled,              0, "Control generation of SOP description SEI messages")
694#endif
695#if K0180_SCALABLE_NESTING_SEI
696  ("SEIScalableNesting",             m_scalableNestingSEIEnabled,              0, "Control generation of scalable nesting SEI messages")
697#endif
698#if SIGNAL_BITRATE_PICRATE_IN_VPS
699  ("BitRatePicRateMaxTLayers",   m_bitRatePicRateMaxTLayers,           0, "Maximum number of sub-layers signalled; can be inferred otherwise; here for easy parsing of config. file")
700  ("BitRateInfoPresent",         cfg_bitRateInfoPresentFlag,          string(""), "Control signalling of bit rate information of avg. bit rate and max. bit rate in VPS\n"
701                                                                          "\t0: Do not sent bit rate info\n"
702                                                                          "\tN (N > 0): Send bit rate info for N sub-layers. N should equal maxTempLayers.")                                                                     
703  ("PicRateInfoPresent",         cfg_picRateInfoPresentFlag,          string(""), "Control signalling of picture rate information of avg. bit rate and max. bit rate in VPS\n"
704                                                                          "\t0: Do not sent picture rate info\n"
705                                                                          "\tN (N > 0): Send picture rate info for N sub-layers. N should equal maxTempLayers.")                                                                     
706  ("AvgBitRate",                   cfg_avgBitRate,                    string(""), "List of avg. bit rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
707  ("MaxBitRate",                   cfg_maxBitRate,                    string(""), "List of max. bit rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
708  ("AvgPicRate",                   cfg_avgPicRate,                    string(""), "List of avg. picture rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
709  ("ConstantPicRateIdc",           cfg_constantPicRateIdc,            string(""), "List of constant picture rate IDCs; include non-negative number even if corresponding flag is 0")
710#endif
711#if H_3D
712  ("CameraParameterFile,cpf", m_pchCameraParameterFile,    (Char *) 0, "Camera Parameter File Name")
713  ("BaseViewCameraNumbers" ,  m_pchBaseViewCameraNumbers,  (Char *) 0, "Numbers of base views")
714  ("CodedCamParsPrecision",   m_iCodedCamParPrecision,  STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
715/* View Synthesis Optimization */
716
717#if H_3D_VSO
718  ("VSOConfig",                       m_pchVSOConfig            , (Char *) 0    , "VSO configuration")
719  ("VSO",                             m_bUseVSO                 , false         , "Use VSO" )   
720  ("VSOMode",                         m_uiVSOMode               , (UInt)   4    , "VSO Mode")
721  ("LambdaScaleVSO",                  m_dLambdaScaleVSO         , (Double) 1    , "Lambda Scaling for VSO")
722  ("VSOLSTable",                      m_bVSOLSTable             , true          , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )     
723  ("ForceLambdaScaleVSO",             m_bForceLambdaScaleVSO    , false         , "Force using Lambda Scale VSO also in non-VSO-Mode")
724  ("AllowNegDist",                    m_bAllowNegDist           , true          , "Allow negative Distortion in VSO")
725 
726  ("UseEstimatedVSD",                 m_bUseEstimatedVSD        , true          , "Model based VSD estimation instead of rendering based for some encoder decisions" )     
727  ("VSOEarlySkip",                    m_bVSOEarlySkip           , true          , "Early skip of VSO computation if synthesis error assumed to be zero" )     
728 
729  ("WVSO",                            m_bUseWVSO                , true          , "Use depth fidelity term for VSO" )
730  ("VSOWeight",                       m_iVSOWeight              , 10            , "Synthesized View Distortion Change weight" )
731  ("VSDWeight",                       m_iVSDWeight              , 1             , "View Synthesis Distortion estimate weight" )
732  ("DWeight",                         m_iDWeight                , 1             , "Depth Distortion weight" )
733
734#endif //HHI_VSO
735#endif //H_3D
736  ;
737 
738#if H_MV
739  // parse coding structure
740  for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
741  {
742    m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
743    if( k == 0 )
744    {
745      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
746      {
747        std::ostringstream cOSS;
748        cOSS<<"Frame"<<i;
749        opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
750        if ( i != 1 )
751        {
752          opts.opt_list.back()->opt->opt_duplicate = true; 
753        }       
754      }
755    }
756    else
757    {
758      std::ostringstream cOSS1;
759      cOSS1<<"FrameI"<<"_l"<<k;
760
761      opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
762      if ( k > 1 )
763      {
764        opts.opt_list.back()->opt->opt_duplicate = true; 
765      }       
766
767
768      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
769      {
770        std::ostringstream cOSS2;
771        cOSS2<<"Frame"<<i<<"_l"<<k;
772        opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
773        if ( i != 1 || k > 0 )
774        {
775          opts.opt_list.back()->opt->opt_duplicate = true; 
776        }       
777      }
778    }
779  }
780#else
781  for(Int i=1; i<MAX_GOP+1; i++) {
782    std::ostringstream cOSS;
783    cOSS<<"Frame"<<i;
784    opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
785  }
786#endif
787  po::setDefaults(opts);
788  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
789
790  for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
791  {
792    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
793  }
794 
795  if (argc == 1 || do_help)
796  {
797    /* argc == 1: no options have been specified */
798    po::doHelp(cout, opts);
799    return false;
800  }
801 
802  /*
803   * Set any derived parameters
804   */
805  /* convert std::string to c string for compatability */
806#if !H_MV
807  m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
808#endif
809  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
810#if !H_MV
811  m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
812#endif
813  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
814 
815  Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
816  Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
817  if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
818  {
819    char *columnWidth;
820    int  i=0;
821    m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
822    columnWidth = strtok(pColumnWidth, " ,-");
823    while(columnWidth!=NULL)
824    {
825      if( i>=m_iNumColumnsMinus1 )
826      {
827        printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
828        exit( EXIT_FAILURE );
829      }
830      *( m_pColumnWidth + i ) = atoi( columnWidth );
831      columnWidth = strtok(NULL, " ,-");
832      i++;
833    }
834    if( i<m_iNumColumnsMinus1 )
835    {
836      printf( "The width of some columns is not defined.\n" );
837      exit( EXIT_FAILURE );
838    }
839  }
840  else
841  {
842    m_pColumnWidth = NULL;
843  }
844
845  if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
846  {
847    char *rowHeight;
848    int  i=0;
849    m_pRowHeight = new UInt[m_iNumRowsMinus1];
850    rowHeight = strtok(pRowHeight, " ,-");
851    while(rowHeight!=NULL)
852    {
853      if( i>=m_iNumRowsMinus1 )
854      {
855        printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
856        exit( EXIT_FAILURE );
857      }
858      *( m_pRowHeight + i ) = atoi( rowHeight );
859      rowHeight = strtok(NULL, " ,-");
860      i++;
861    }
862    if( i<m_iNumRowsMinus1 )
863    {
864      printf( "The height of some rows is not defined.\n" );
865      exit( EXIT_FAILURE );
866   }
867  }
868  else
869  {
870    m_pRowHeight = NULL;
871  }
872#if H_MV
873  free ( pColumnWidth );
874  free ( pRowHeight   ); 
875#endif
876#if SIGNAL_BITRATE_PICRATE_IN_VPS
877  readBoolString(cfg_bitRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_bitRateInfoPresentFlag, "bit rate info. present flag" );
878  readIntString (cfg_avgBitRate,             m_bitRatePicRateMaxTLayers, m_avgBitRate,             "avg. bit rate"               );
879  readIntString (cfg_maxBitRate,             m_bitRatePicRateMaxTLayers, m_maxBitRate,             "max. bit rate"               );
880  readBoolString(cfg_picRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_picRateInfoPresentFlag, "bit rate info. present flag" );
881  readIntString (cfg_avgPicRate,             m_bitRatePicRateMaxTLayers, m_avgPicRate,             "avg. pic rate"               );
882  readIntString (cfg_constantPicRateIdc,     m_bitRatePicRateMaxTLayers, m_constantPicRateIdc,     "constant pic rate Idc"       );
883#endif
884  m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
885 
886  /* rules for input, output and internal bitdepths as per help text */
887  if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
888  if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
889  if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
890  if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
891  if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
892
893  // TODO:ChromaFmt assumes 4:2:0 below
894  switch (m_conformanceMode)
895  {
896  case 0:
897    {
898      // no conformance or padding
899      m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
900      m_aiPad[1] = m_aiPad[0] = 0;
901      break;
902    }
903  case 1:
904    {
905      // automatic padding to minimum CU size
906      Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
907      if (m_iSourceWidth % minCuSize)
908      {
909        m_aiPad[0] = m_confRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
910        m_iSourceWidth  += m_confRight;
911      }
912      if (m_iSourceHeight % minCuSize)
913      {
914        m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
915        m_iSourceHeight += m_confBottom;
916      }
917      if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
918      {
919        fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
920        exit(EXIT_FAILURE);
921      }
922      if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
923      {
924        fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
925        exit(EXIT_FAILURE);
926      }
927      break;
928    }
929  case 2:
930    {
931      //padding
932      m_iSourceWidth  += m_aiPad[0];
933      m_iSourceHeight += m_aiPad[1];
934      m_confRight  = m_aiPad[0];
935      m_confBottom = m_aiPad[1];
936      break;
937    }
938  case 3:
939    {
940      // conformance
941      if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
942      {
943        fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
944      }
945      if ((m_aiPad[1] != 0) || (m_aiPad[0]!=0))
946      {
947        fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
948      }
949      m_aiPad[1] = m_aiPad[0] = 0;
950      break;
951    }
952  }
953 
954  // allocate slice-based dQP values
955#if H_MV
956  xResizeVector( m_viewId    ); 
957#if H_3D
958  xResizeVector( m_depthFlag ); 
959
960  std::vector<Int> uniqueViewIds; 
961  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
962  {   
963    Bool isIn = false; 
964    for ( Int i = 0 ; i < uniqueViewIds.size(); i++ )
965    {
966      isIn = isIn || ( m_viewId[ layer ] == uniqueViewIds[ i ] ); 
967    }
968    if ( !isIn ) 
969    {
970      uniqueViewIds.push_back( m_viewId[ layer ] ); 
971    } 
972  }
973  m_iNumberOfViews = (Int) uniqueViewIds.size(); 
974#endif
975
976  xResizeVector( m_fQP ); 
977
978  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
979  {
980    m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
981    ::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
982
983    // handling of floating-point QP values
984    // if QP is not integer, sequence is split into two sections having QP and QP+1
985    m_iQP.push_back((Int)( m_fQP[layer] ));
986    if ( m_iQP[layer] < m_fQP[layer] )
987    {
988      Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
989
990      iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
991      for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
992      {
993        m_aidQP[layer][i] = 1;
994      }
995    }
996  }
997
998  xResizeVector( m_bLoopFilterDisable ); 
999  xResizeVector( m_bUseSAO );   
1000
1001#else
1002  m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1003  ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1004 
1005  // handling of floating-point QP values
1006  // if QP is not integer, sequence is split into two sections having QP and QP+1
1007  m_iQP = (Int)( m_fQP );
1008  if ( m_iQP < m_fQP )
1009  {
1010    Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1011   
1012    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1013    for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1014    {
1015      m_aidQP[i] = 1;
1016    }
1017  }
1018#endif
1019 
1020  // reading external dQP description from file
1021  if ( m_pchdQPFile )
1022  {
1023    FILE* fpt=fopen( m_pchdQPFile, "r" );
1024    if ( fpt )
1025    {
1026#if H_MV
1027      for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1028      {
1029#endif
1030      Int iValue;
1031      Int iPOC = 0;
1032      while ( iPOC < m_framesToBeEncoded )
1033      {
1034        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1035#if H_MV
1036        m_aidQP[layer][ iPOC ] = iValue;
1037        iPOC++;
1038      }
1039#else
1040        m_aidQP[ iPOC ] = iValue;
1041        iPOC++;
1042#endif
1043      }
1044      fclose(fpt);
1045    }
1046  }
1047  m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1048
1049#if J0149_TONE_MAPPING_SEI
1050  if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1051  {
1052    Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1053    Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1054    Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1055    if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1056    {
1057      char *startOfCodedInterval;
1058      UInt num = 1u<< m_toneMapTargetBitDepth;
1059      m_startOfCodedInterval = new Int[num];
1060      ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1061      startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1062      int i = 0;
1063      while( startOfCodedInterval && ( i < num ) )
1064      {
1065        m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1066        startOfCodedInterval = strtok(NULL, " .");
1067        i++;
1068      }
1069    } 
1070    else
1071    {
1072      m_startOfCodedInterval = NULL;
1073    }
1074    if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1075    {
1076      if( pcCodedPivotValue && pcTargetPivotValue )
1077      {
1078        char *codedPivotValue;
1079        char *targetPivotValue;
1080        m_codedPivotValue = new Int[m_numPivots];
1081        m_targetPivotValue = new Int[m_numPivots];
1082        ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1083        ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1084        codedPivotValue = strtok(pcCodedPivotValue, " .");
1085        int i=0;
1086        while(codedPivotValue&&i<m_numPivots)
1087        {
1088          m_codedPivotValue[i] = atoi( codedPivotValue );
1089          codedPivotValue = strtok(NULL, " .");
1090          i++;
1091        }
1092        i=0;
1093        targetPivotValue = strtok(pcTargetPivotValue, " .");
1094        while(targetPivotValue&&i<m_numPivots)
1095        {
1096          m_targetPivotValue[i]= atoi( targetPivotValue );
1097          targetPivotValue = strtok(NULL, " .");
1098          i++;
1099        }
1100      }
1101    }
1102    else
1103    {
1104      m_codedPivotValue = NULL;
1105      m_targetPivotValue = NULL;
1106    }
1107  }
1108#endif
1109#if H_3D
1110  // set global varibles
1111  xSetGlobal();
1112#if H_3D_VSO
1113// Table base optimization
1114  // Q&D
1115  Double adLambdaScaleTable[] = 
1116  {  0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755, 
1117     0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648, 
1118     0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542, 
1119     0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388, 
1120     0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100, 
1121     0.753550, 0.800000 
1122  }; 
1123  if ( m_bVSOLSTable )
1124  {
1125    Int firstDepthLayer = -1; 
1126    for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1127    {
1128      if ( m_depthFlag[ layer ])
1129      {
1130        firstDepthLayer = layer;
1131        break; 
1132      }
1133    }
1134    AOT( firstDepthLayer == -1 );
1135    AOT( (m_iQP[firstDepthLayer] < 0) || (m_iQP[firstDepthLayer] > 51));
1136    m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]]; 
1137  }
1138#endif
1139#if H_3D_VSO
1140if ( m_bUseVSO && m_uiVSOMode == 4)
1141{
1142  m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1143  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1144                                      g_bitDepthY,
1145                                (UInt)m_iCodedCamParPrecision,
1146                                      m_FrameSkip,
1147                                (UInt)m_framesToBeEncoded,
1148                                      m_pchCameraParameterFile,
1149                                      m_pchBaseViewCameraNumbers,
1150                                      NULL,
1151                                      m_cRenModStrParser.getSynthViews(),
1152                                      LOG2_DISP_PREC_LUT );
1153}
1154else if ( m_bUseVSO && m_uiVSOMode != 4 )
1155{
1156  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1157                                      g_bitDepthY,
1158                                (UInt)m_iCodedCamParPrecision,
1159                                      m_FrameSkip,
1160                                (UInt)m_framesToBeEncoded,
1161                                      m_pchCameraParameterFile,
1162                                      m_pchBaseViewCameraNumbers,
1163                                      m_pchVSOConfig,
1164                                      NULL,
1165                                      LOG2_DISP_PREC_LUT );
1166}
1167else
1168{
1169  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1170    g_bitDepthY,
1171    (UInt) m_iCodedCamParPrecision,
1172    m_FrameSkip,
1173    (UInt) m_framesToBeEncoded,
1174    m_pchCameraParameterFile,
1175    m_pchBaseViewCameraNumbers,
1176    NULL,
1177    NULL,
1178    LOG2_DISP_PREC_LUT );
1179}
1180#else
1181  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1182    g_bitDepthY,
1183    (UInt) m_iCodedCamParPrecision,
1184    m_FrameSkip,
1185    (UInt) m_framesToBeEncoded,
1186    m_pchCameraParameterFile,
1187    m_pchBaseViewCameraNumbers,
1188    NULL,
1189    NULL,
1190    LOG2_DISP_PREC_LUT );
1191#endif
1192  m_cCameraData.check( false, true );
1193#endif
1194  // check validity of input parameters
1195  xCheckParameter();
1196
1197#if !H_3D
1198  // set global varibles
1199  xSetGlobal();
1200#endif
1201 
1202  // print-out parameters
1203  xPrintParameter();
1204 
1205  return true;
1206}
1207#if SIGNAL_BITRATE_PICRATE_IN_VPS
1208Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName)
1209{
1210  Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1211  Int i = 0;
1212  if(numEntries)
1213  {
1214    Char* tempArray = strtok(inpArray, " ,-");
1215    memberArray = new Bool[numEntries];
1216    while( tempArray != NULL )
1217    {
1218      if( i >= numEntries )
1219      {
1220        printf( "The number of %s defined is larger than the allowed number\n", elementName );
1221        exit( EXIT_FAILURE );
1222      }
1223      assert( (atoi(tempArray) == 0) || (atoi(tempArray) == 1) );
1224      *( memberArray + i ) = atoi(tempArray);
1225      tempArray = strtok(NULL, " ,-");
1226      i++;
1227    }
1228    if( i < numEntries )
1229    {
1230      printf( "Some %s are not defined\n", elementName );
1231      exit( EXIT_FAILURE );
1232    }
1233  }
1234  else
1235  {
1236    memberArray = NULL;
1237  }
1238}
1239
1240Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName)
1241{
1242  Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1243  Int i = 0;
1244  if(numEntries)
1245  {
1246    Char* tempArray = strtok(inpArray, " ,-");
1247    memberArray = new Int[numEntries];
1248    while( tempArray != NULL )
1249    {
1250      if( i >= numEntries )
1251      {
1252        printf( "The number of %s defined is larger than the allowed number\n", elementName );
1253        exit( EXIT_FAILURE );
1254      }
1255      *( memberArray + i ) = atoi(tempArray);
1256      tempArray = strtok(NULL, " ,-");
1257      i++;
1258    }
1259    if( i < numEntries )
1260    {
1261      printf( "Some %s are not defined\n", elementName );
1262      exit( EXIT_FAILURE );
1263    }
1264  }
1265  else
1266  {
1267    memberArray = NULL;
1268  }
1269}
1270#endif
1271// ====================================================================================================================
1272// Private member functions
1273// ====================================================================================================================
1274
1275Bool confirmPara(Bool bflag, const Char* message);
1276
1277Void TAppEncCfg::xCheckParameter()
1278{
1279  if (!m_decodedPictureHashSEIEnabled)
1280  {
1281    fprintf(stderr, "******************************************************************\n");
1282    fprintf(stderr, "** WARNING: --SEIDecodedPictureHash is now disabled by default. **\n");
1283    fprintf(stderr, "**          Automatic verification of decoded pictures by a     **\n");
1284    fprintf(stderr, "**          decoder requires this option to be enabled.         **\n");
1285    fprintf(stderr, "******************************************************************\n");
1286  }
1287
1288  Bool check_failed = false; /* abort if there is a fatal configuration problem */
1289#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
1290  // check range of parameters
1291  xConfirmPara( m_inputBitDepthY < 8,                                                     "InputBitDepth must be at least 8" );
1292  xConfirmPara( m_inputBitDepthC < 8,                                                     "InputBitDepthC must be at least 8" );
1293  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
1294  xConfirmPara( m_framesToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
1295#if H_MV
1296  xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS ,                                      "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1297
1298
1299  xConfirmPara( m_layerIdInNuh[0] != 0      , "LayerIdInNuh must be 0 for the first layer. ");
1300  xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1301
1302#if H_3D
1303  xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
1304#else
1305  xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
1306#endif
1307
1308  m_dimIds.push_back( m_viewId ); 
1309  const Int viewDimPosition = 0; 
1310#if H_3D
1311  if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1312    m_dimIds.push_back( m_depthFlag ); 
1313#endif
1314
1315  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1]; 
1316
1317  dimBitOffset[ 0 ] = 0; 
1318  for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1319  {
1320    dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1]; 
1321  }
1322
1323  if ( m_splittingFlag )
1324  {
1325    dimBitOffset[ (Int) m_dimIds.size() ] = 6; 
1326  }
1327 
1328  for( Int j = 0; j < m_dimIds.size(); j++ )
1329  {   
1330    xConfirmPara( m_dimIds[j].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");   
1331    xConfirmPara( ( j != viewDimPosition ) &&  (m_dimIds[j][0] != 0), "DimensionId of layer 0 must be 0. " );
1332    xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " ); 
1333     
1334
1335    for( Int i = 1; i < m_numberOfLayers; i++ )
1336    {     
1337      xConfirmPara(  ( m_dimIds[j][i] < 0 ) || ( m_dimIds[j][i] > ( ( 1 << m_dimensionIdLen[j] ) - 1 ) )   , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " );
1338      if ( m_splittingFlag )
1339      {
1340        Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] :  i; 
1341        xConfirmPara( ( ( layerIdInNuh & ( (1 << dimBitOffset[ j + 1 ] ) - 1) ) >> dimBitOffset[ j ] )  != m_dimIds[j][ i ]  , "When Splitting Flag is equal to 1 dimension ids shall match values derived from layer ids. "); 
1342      }
1343    }
1344  }
1345
1346  for( Int i = 0; i < m_numberOfLayers; i++ )
1347  {
1348    for( Int j = 0; j < i; j++ )
1349    {     
1350      Int numDiff  = 0; 
1351      Int lastDiff = -1; 
1352      for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1353      {
1354        if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1355        {
1356          numDiff ++; 
1357          lastDiff = dim; 
1358        }
1359      }
1360
1361      Bool allEqual = ( numDiff == 0 ); 
1362
1363      if ( allEqual ) 
1364      {
1365        printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1366      }
1367
1368      xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1369
1370      if ( numDiff  == 1 ) 
1371      {
1372        Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ]; 
1373        Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ; 
1374        if ( shallBeButIsNotIncreasing )
1375        {       
1376          printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
1377        }
1378        xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ),  "DimensionIds shall be increasing within one dimension. " );
1379      }
1380    }
1381  }
1382
1383  /// Layer sets
1384  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ; 
1385  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1386  {
1387    if (lsIdx == 0)
1388    {
1389      xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 || m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1390    }
1391    for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1392    {
1393      xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 || m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than 64" ); 
1394    }
1395  }
1396
1397  // Output layer sets
1398  xConfirmPara( m_outputLayerSetIdx.size() < 0 || m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1399  for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1400  {   
1401    Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ]; 
1402    xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1403
1404    for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1405    {
1406      Bool isAlsoInLayerSet = false; 
1407      for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1408      {
1409        if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1410        {
1411          isAlsoInLayerSet = true; 
1412          break; 
1413        }       
1414      }
1415      xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1416    }
1417  }
1418  xConfirmPara( m_profileLevelTierIdx.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
1419
1420  // Layer Dependencies 
1421  for (Int i = 0; i < m_numberOfLayers; i++ )
1422  {
1423    xConfirmPara( (i == 0)  && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." ); 
1424    xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." ); 
1425    for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1426    {
1427      xConfirmPara( m_directRefLayers[i][j] < 0 || m_directRefLayers[i][j] >= i , "Reference layer id shall be greater than or equal to 0 and less than dependent layer id"); 
1428      xConfirmPara( m_dependencyTypes[i][j] < 0 || m_dependencyTypes[i][j] >  2 , "Dependency type shall be greater than or equal to 0 and less than 3"); 
1429    }       
1430  } 
1431#endif
1432  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
1433  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1434  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1435  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
1436#if H_MV
1437  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1438  {
1439    xConfirmPara( m_iQP[layer] <  -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51,      "QP exceeds supported range (-QpBDOffsety to 51)" );
1440  }
1441#else
1442  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
1443#endif
1444  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 || m_loopFilterBetaOffsetDiv2 > 13,          "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
1445  xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 || m_loopFilterTcOffsetDiv2 > 13,              "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
1446  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
1447  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
1448  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
1449  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
1450  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1451
1452  xConfirmPara( m_cbQpOffset < -12,   "Min. Chroma Cb QP Offset is -12" );
1453  xConfirmPara( m_cbQpOffset >  12,   "Max. Chroma Cb QP Offset is  12" );
1454  xConfirmPara( m_crQpOffset < -12,   "Min. Chroma Cr QP Offset is -12" );
1455  xConfirmPara( m_crQpOffset >  12,   "Max. Chroma Cr QP Offset is  12" );
1456
1457  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
1458  if (m_iDecodingRefreshType == 2)
1459  {
1460    xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
1461  }
1462  xConfirmPara( (m_uiMaxCUWidth  >> m_uiMaxCUDepth) < 4,                                    "Minimum partition width size should be larger than or equal to 8");
1463  xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4,                                    "Minimum partition height size should be larger than or equal to 8");
1464  xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
1465  xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
1466  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
1467  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
1468 
1469  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
1470  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
1471  xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth,                                        "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1472 
1473  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1474  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1475  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1476  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth  >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1477  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1478  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1479  xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthInter - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
1480  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1481  xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthIntra - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
1482 
1483  xConfirmPara(  m_maxNumMergeCand < 1,  "MaxNumMergeCand must be 1 or greater.");
1484  xConfirmPara(  m_maxNumMergeCand > 5,  "MaxNumMergeCand must be 5 or smaller.");
1485
1486#if ADAPTIVE_QP_SELECTION
1487#if H_MV
1488  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1489  {
1490    xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0,                                     "AdaptiveQpSelection must be disabled when QP < 0.");
1491  }
1492#else
1493  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
1494#endif
1495  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1496#endif
1497
1498  if( m_usePCM)
1499  {
1500    xConfirmPara(  m_uiPCMLog2MinSize < 3,                                      "PCMLog2MinSize must be 3 or greater.");
1501    xConfirmPara(  m_uiPCMLog2MinSize > 5,                                      "PCMLog2MinSize must be 5 or smaller.");
1502    xConfirmPara(  m_pcmLog2MaxSize > 5,                                        "PCMLog2MaxSize must be 5 or smaller.");
1503    xConfirmPara(  m_pcmLog2MaxSize < m_uiPCMLog2MinSize,                       "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1504  }
1505
1506  xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1507  if (m_sliceMode!=0)
1508  {
1509    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
1510  }
1511  xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1512  if (m_sliceSegmentMode!=0)
1513  {
1514    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
1515  }
1516 
1517  Bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
1518  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
1519
1520  //TODO:ChromaFmt assumes 4:2:0 below
1521  xConfirmPara( m_iSourceWidth  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1522  xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1523
1524  xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1525  xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1526
1527  xConfirmPara( m_confLeft   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1528  xConfirmPara( m_confRight  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1529  xConfirmPara( m_confTop    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1530  xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1531
1532#if H_3D
1533  xConfirmPara( m_pchCameraParameterFile    == 0                ,   "CameraParameterFile must be given");
1534  xConfirmPara( m_pchBaseViewCameraNumbers  == 0                ,   "BaseViewCameraNumbers must be given" );
1535  xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1536  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
1537#if H_3D_VSO
1538    if( m_bUseVSO )
1539    {
1540      xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
1541      xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
1542    }
1543#endif
1544#endif
1545  // max CU width and height should be power of 2
1546  UInt ui = m_uiMaxCUWidth;
1547  while(ui)
1548  {
1549    ui >>= 1;
1550    if( (ui & 1) == 1)
1551      xConfirmPara( ui != 1 , "Width should be 2^n");
1552  }
1553  ui = m_uiMaxCUHeight;
1554  while(ui)
1555  {
1556    ui >>= 1;
1557    if( (ui & 1) == 1)
1558      xConfirmPara( ui != 1 , "Height should be 2^n");
1559  }
1560
1561#if H_MV
1562  // validate that POC of same frame is identical across multiple layers
1563  Bool bErrorMvePoc = false;
1564  if( m_numberOfLayers > 1 )
1565  {
1566    for( Int k = 1; k < m_numberOfLayers; k++ )
1567    {
1568      for( Int i = 0; i < MAX_GOP; i++ )
1569      {
1570        if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1571        {
1572          printf( "\nError: Frame%d_l%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListMvc[k][i].m_POC, i );
1573          bErrorMvePoc = true;
1574        }
1575      }
1576    }
1577  }
1578  xConfirmPara( bErrorMvePoc,  "Invalid inter-layer POC structure given" );
1579
1580  // validate that baseview has no inter-view refs
1581  Bool bErrorIvpBase = false;
1582  for( Int i = 0; i < MAX_GOP; i++ )
1583  {
1584    if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1585    {
1586      printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1587      bErrorIvpBase = true;
1588    }
1589  }
1590  xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1591
1592  // validate inter-view refs
1593  Bool bErrorIvpEnhV = false;
1594  if( m_numberOfLayers > 1 )
1595  {
1596    for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1597    {
1598      for( Int i = 0; i < MAX_GOP+1; i++ )
1599      {
1600        GOPEntry gopEntry = m_GOPListMvc[layer][i]; 
1601        for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1602        {
1603          Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1604          if( ilPredLayerIdc < 0 || ilPredLayerIdc >= m_directRefLayers[layer].size() )
1605          {
1606            printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1607            bErrorIvpEnhV = true;
1608          }
1609          if( gopEntry.m_interViewRefPosL[0][j] < -1 || gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1610          {
1611            printf( "\nError: inter-layer ref pos %d on L0 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[0][j], i, layer );
1612            bErrorIvpEnhV = true;
1613          }
1614          if( gopEntry.m_interViewRefPosL[1][j] < -1  || gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1615          {
1616            printf( "\nError: inter-layer ref pos %d on L1 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[1][j], i, layer );
1617            bErrorIvpEnhV = true;
1618          }
1619        }
1620        if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1621        {
1622          if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1623          {
1624            printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1625            bErrorIvpEnhV = true;
1626          }
1627
1628          if( gopEntry.m_POC != 0 )
1629          {
1630            printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1631            bErrorIvpEnhV = true;
1632          }
1633
1634          if( gopEntry.m_temporalId != 0 )
1635          {
1636            printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1637            gopEntry.m_temporalId = 0;
1638          }
1639
1640          if( gopEntry.m_numRefPics != 0 )
1641          {
1642            printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1643            for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1644            {
1645              gopEntry.m_referencePics[j] = 0;
1646            }
1647            gopEntry.m_numRefPics = 0;
1648          }
1649
1650          if( gopEntry.m_interRPSPrediction )
1651          {
1652            printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1653            bErrorIvpEnhV = true;
1654          }
1655
1656          if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1657          {
1658            printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1659            bErrorIvpEnhV = true;
1660          }
1661
1662          if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1663          {
1664            gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1665          }
1666
1667          if( gopEntry.m_sliceType == 'P' )
1668          {
1669            if( gopEntry.m_numActiveRefLayerPics < 1 )
1670            {
1671              printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1672              bErrorIvpEnhV = true;
1673            }
1674            else
1675            {
1676              for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1677              {
1678                if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1679                {
1680                  printf( "\nError: inter-layer ref pos %d on L1 not possible for FrameI_l%d with slice type P\n", gopEntry.m_interViewRefPosL[1][j], layer );
1681                  bErrorIvpEnhV = true;
1682                }
1683              }
1684            }
1685          }
1686
1687          if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1688          {
1689            printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1690            bErrorIvpEnhV = true;
1691          }
1692        }
1693      }
1694    }
1695  }
1696  xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1697
1698  // validate temporal coding structure
1699  if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1700  {
1701    for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1702    {
1703      GOPEntry* m_GOPList            = m_GOPListMvc           [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1704      Int&      m_extraRPSs          = m_extraRPSsMvc         [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1705      Int&      m_maxTempLayer       = m_maxTempLayerMvc      [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1706      Int*      m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1707      Int*      m_numReorderPics     = m_numReorderPicsMvc    [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1708#endif
1709  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1710   * This permits the ability to omit a GOP structure specification */
1711  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1712    m_GOPList[0] = GOPEntry();
1713    m_GOPList[0].m_QPFactor = 1;
1714    m_GOPList[0].m_betaOffsetDiv2 = 0;
1715    m_GOPList[0].m_tcOffsetDiv2 = 0;
1716    m_GOPList[0].m_POC = 1;
1717    m_GOPList[0].m_numRefPicsActive = 4;
1718  }
1719 
1720  Bool verifiedGOP=false;
1721  Bool errorGOP=false;
1722  Int checkGOP=1;
1723  Int numRefs = 1;
1724  Int refList[MAX_NUM_REF_PICS+1];
1725  refList[0]=0;
1726  Bool isOK[MAX_GOP];
1727  for(Int i=0; i<MAX_GOP; i++) 
1728  {
1729    isOK[i]=false;
1730  }
1731  Int numOK=0;
1732  xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1733
1734  for(Int i=0; i<m_iGOPSize; i++)
1735  {
1736    if(m_GOPList[i].m_POC==m_iGOPSize)
1737    {
1738      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1739    }
1740  }
1741 
1742#if H_MV
1743  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1744#else
1745  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1746#endif
1747  {
1748    for(Int i=0; i<m_iGOPSize; i++)
1749    {
1750      xConfirmPara( (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) < -6 || (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) > 6, "Loop Filter Beta Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
1751      xConfirmPara( (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) < -6 || (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) > 6, "Loop Filter Tc Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
1752    }
1753  }
1754  m_extraRPSs=0;
1755  //start looping through frames in coding order until we can verify that the GOP structure is correct.
1756  while(!verifiedGOP&&!errorGOP) 
1757  {
1758    Int curGOP = (checkGOP-1)%m_iGOPSize;
1759    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
1760    if(m_GOPList[curGOP].m_POC<0) 
1761    {
1762#if H_MV
1763      printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1764#else
1765      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1766#endif
1767      errorGOP=true;
1768    }
1769    else 
1770    {
1771      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1772      Bool beforeI = false;
1773      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1774      {
1775        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1776        if(absPOC < 0)
1777        {
1778          beforeI=true;
1779        }
1780        else 
1781        {
1782          Bool found=false;
1783          for(Int j=0; j<numRefs; j++) 
1784          {
1785            if(refList[j]==absPOC) 
1786            {
1787              found=true;
1788              for(Int k=0; k<m_iGOPSize; k++)
1789              {
1790                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1791                {
1792                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1793                  {
1794                    m_GOPList[k].m_refPic = true;
1795                  }
1796                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1797                }
1798              }
1799            }
1800          }
1801          if(!found)
1802          {
1803#if H_MV
1804            printf("\nError: ref pic %d is not available for GOP frame %d of layer %d\n", m_GOPList[curGOP].m_referencePics[i], curGOP+1, layer);
1805#else
1806            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1807#endif
1808            errorGOP=true;
1809          }
1810        }
1811      }
1812      if(!beforeI&&!errorGOP)
1813      {
1814        //all ref frames were present
1815        if(!isOK[curGOP]) 
1816        {
1817          numOK++;
1818          isOK[curGOP]=true;
1819          if(numOK==m_iGOPSize)
1820          {
1821            verifiedGOP=true;
1822          }
1823        }
1824      }
1825      else 
1826      {
1827        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1828        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1829        Int newRefs=0;
1830        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1831        {
1832          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1833          if(absPOC>=0)
1834          {
1835            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1836            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1837            newRefs++;
1838          }
1839        }
1840        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1841       
1842        for(Int offset = -1; offset>-checkGOP; offset--)
1843        {
1844          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1845          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1846          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1847          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1848          {
1849            Bool newRef=false;
1850            for(Int i=0; i<numRefs; i++)
1851            {
1852              if(refList[i]==offPOC)
1853              {
1854                newRef=true;
1855              }
1856            }
1857            for(Int i=0; i<newRefs; i++) 
1858            {
1859              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1860              {
1861                newRef=false;
1862              }
1863            }
1864            if(newRef) 
1865            {
1866              Int insertPoint=newRefs;
1867              //this picture can be added, find appropriate place in list and insert it.
1868              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1869              {
1870                m_GOPList[offGOP].m_refPic = true;
1871              }
1872              for(Int j=0; j<newRefs; j++)
1873              {
1874                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1875                {
1876                  insertPoint = j;
1877                  break;
1878                }
1879              }
1880              Int prev = offPOC-curPOC;
1881              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1882              for(Int j=insertPoint; j<newRefs+1; j++)
1883              {
1884                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1885                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1886                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1887                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1888                prevUsed=newUsed;
1889                prev=newPrev;
1890              }
1891              newRefs++;
1892            }
1893          }
1894          if(newRefs>=numPrefRefs)
1895          {
1896            break;
1897          }
1898        }
1899        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1900        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1901        if (m_extraRPSs == 0)
1902        {
1903          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1904          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1905        }
1906        else
1907        {
1908          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
1909          Int refPOC = m_GOPList[rIdx].m_POC;
1910          Int refPics = m_GOPList[rIdx].m_numRefPics;
1911          Int newIdc=0;
1912          for(Int i = 0; i<= refPics; i++) 
1913          {
1914            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
1915            Int absPOCref = refPOC+deltaPOC;
1916            Int refIdc = 0;
1917            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1918            {
1919              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1920              {
1921                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1922                {
1923                  refIdc = 1;
1924                }
1925                else
1926                {
1927                  refIdc = 2;
1928                }
1929              }
1930            }
1931            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1932            newIdc++;
1933          }
1934          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
1935          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1936          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 
1937        }
1938        curGOP=m_iGOPSize+m_extraRPSs;
1939        m_extraRPSs++;
1940      }
1941      numRefs=0;
1942      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1943      {
1944        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1945        if(absPOC >= 0) 
1946        {
1947          refList[numRefs]=absPOC;
1948          numRefs++;
1949        }
1950      }
1951      refList[numRefs]=curPOC;
1952      numRefs++;
1953    }
1954    checkGOP++;
1955  }
1956  xConfirmPara(errorGOP,"Invalid GOP structure given");
1957  m_maxTempLayer = 1;
1958  for(Int i=0; i<m_iGOPSize; i++) 
1959  {
1960    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
1961    {
1962      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
1963    }
1964    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
1965  }
1966  for(Int i=0; i<MAX_TLAYER; i++)
1967  {
1968    m_numReorderPics[i] = 0;
1969#if L0323_DPB
1970    m_maxDecPicBuffering[i] = 1;
1971#else
1972    m_maxDecPicBuffering[i] = 0;
1973#endif
1974  }
1975  for(Int i=0; i<m_iGOPSize; i++) 
1976  {
1977#if L0323_DPB
1978    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1979#else
1980    if(m_GOPList[i].m_numRefPics > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1981#endif
1982    {
1983#if L0323_DPB
1984      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
1985#else
1986      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics;
1987#endif
1988    }
1989    Int highestDecodingNumberWithLowerPOC = 0; 
1990    for(Int j=0; j<m_iGOPSize; j++)
1991    {
1992      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
1993      {
1994        highestDecodingNumberWithLowerPOC = j;
1995      }
1996    }
1997    Int numReorder = 0;
1998    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
1999    {
2000      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 
2001        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2002      {
2003        numReorder++;
2004      }
2005    }   
2006    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2007    {
2008      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2009    }
2010  }
2011  for(Int i=0; i<MAX_TLAYER-1; i++) 
2012  {
2013    // a lower layer can not have higher value of m_numReorderPics than a higher layer
2014    if(m_numReorderPics[i+1] < m_numReorderPics[i])
2015    {
2016      m_numReorderPics[i+1] = m_numReorderPics[i];
2017    }
2018#if L0323_DPB
2019    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2020    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2021    {
2022      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2023    }
2024#else
2025    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
2026    if(m_numReorderPics[i] > m_maxDecPicBuffering[i])
2027    {
2028      m_maxDecPicBuffering[i] = m_numReorderPics[i];
2029    }
2030#endif
2031    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2032    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2033    {
2034      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2035    }
2036  }
2037
2038
2039#if L0323_DPB
2040  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
2041  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2042  {
2043    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2044  }
2045#else
2046  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
2047  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1])
2048  {
2049    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1];
2050  }
2051#endif
2052
2053  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2054  { 
2055    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
2056    if(tileFlag)
2057    {
2058      Int maxTileWidth = 0;
2059      Int maxTileHeight = 0;
2060      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2061      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2062      if(m_iUniformSpacingIdr)
2063      {
2064        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2065        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2066        // if only the last tile-row is one treeblock higher than the others
2067        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2068        if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2069        {
2070          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2071        }     
2072        // if only the last tile-column is one treeblock wider than the others
2073        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
2074        if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2075        {
2076          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2077        }
2078      }
2079      else // not uniform spacing
2080      {
2081        if(m_iNumColumnsMinus1<1)
2082        {
2083          maxTileWidth = m_iSourceWidth;
2084        }
2085        else
2086        {
2087          Int accColumnWidth = 0;
2088          for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2089          {
2090            maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2091            accColumnWidth += m_pColumnWidth[col];
2092          }
2093          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
2094        }
2095        if(m_iNumRowsMinus1<1)
2096        {
2097          maxTileHeight = m_iSourceHeight;
2098        }
2099        else
2100        {
2101          Int accRowHeight = 0;
2102          for(Int row=0; row<(m_iNumRowsMinus1); row++)
2103          {
2104            maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2105            accRowHeight += m_pRowHeight[row];
2106          }
2107          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
2108        }
2109      }
2110      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2111      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2112    }
2113    else if(m_iWaveFrontSynchro)
2114    {
2115      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2116    }
2117    else if(m_sliceMode == 1)
2118    {
2119      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2120    }
2121    else
2122    {
2123      m_minSpatialSegmentationIdc = 0;
2124    }
2125  }
2126#if !L0034_COMBINED_LIST_CLEANUP
2127  xConfirmPara( m_bUseLComb==false && m_numReorderPics[MAX_TLAYER-1]!=0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" );  // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
2128#endif
2129  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2130  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2131  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2132
2133  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2134
2135#if J0149_TONE_MAPPING_SEI
2136  if (m_toneMappingInfoSEIEnabled)
2137  {
2138    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2139    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2140    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2141    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2142    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2143    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2144    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2145  }
2146#endif
2147
2148#if RATE_CONTROL_LAMBDA_DOMAIN
2149  if ( m_RCEnableRateControl )
2150  {
2151    if ( m_RCForceIntraQP )
2152    {
2153      if ( m_RCInitialQP == 0 )
2154      {
2155        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2156        m_RCForceIntraQP = false;
2157      }
2158    }
2159    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2160  }
2161#else
2162  if(m_enableRateCtrl)
2163  {
2164    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
2165    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
2166    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
2167
2168    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2169
2170    m_iMaxDeltaQP       = MAX_DELTA_QP;
2171    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
2172  }
2173#endif
2174
2175  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2176
2177  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2178#if L0444_FPA_TYPE
2179  if (m_framePackingSEIEnabled)
2180  {
2181    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2182  }
2183#endif
2184#if H_MV
2185  }
2186  }
2187#endif
2188
2189#undef xConfirmPara
2190  if (check_failed)
2191  {
2192    exit(EXIT_FAILURE);
2193  }
2194}
2195
2196/** \todo use of global variables should be removed later
2197 */
2198Void TAppEncCfg::xSetGlobal()
2199{
2200  // set max CU width & height
2201  g_uiMaxCUWidth  = m_uiMaxCUWidth;
2202  g_uiMaxCUHeight = m_uiMaxCUHeight;
2203 
2204  // compute actual CU depth with respect to config depth and max transform size
2205  g_uiAddCUDepth  = 0;
2206  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
2207 
2208  m_uiMaxCUDepth += g_uiAddCUDepth;
2209  g_uiAddCUDepth++;
2210  g_uiMaxCUDepth = m_uiMaxCUDepth;
2211 
2212  // set internal bit-depth and constants
2213  g_bitDepthY = m_internalBitDepthY;
2214  g_bitDepthC = m_internalBitDepthC;
2215 
2216  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2217  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2218}
2219
2220Void TAppEncCfg::xPrintParameter()
2221{
2222  printf("\n");
2223#if H_MV
2224  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2225  {
2226    printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
2227  }
2228#else
2229  printf("Input          File          : %s\n", m_pchInputFile          );
2230#endif
2231  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
2232#if H_MV
2233  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2234  {
2235    printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
2236  }
2237#else
2238  printf("Reconstruction File          : %s\n", m_pchReconFile          );
2239#endif
2240#if H_MV
2241  xPrintParaVector( "ViewId", m_viewId ); 
2242#endif
2243#if H_3D
2244  xPrintParaVector( "DepthFlag", m_depthFlag ); 
2245  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2246#endif
2247#if H_MV 
2248  xPrintParaVector( "QP"               , m_fQP                ); 
2249  xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable ); 
2250  xPrintParaVector( "SAO"              , m_bUseSAO            ); 
2251#endif
2252  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2253  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2254  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2255  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2256  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2257  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
2258  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2259  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
2260  printf("Motion search range          : %d\n", m_iSearchRange );
2261  printf("Intra period                 : %d\n", m_iIntraPeriod );
2262  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
2263#if !H_MV
2264  printf("QP                           : %5.2f\n", m_fQP );
2265#endif
2266  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
2267
2268  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
2269  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
2270
2271  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2272  printf("GOP size                     : %d\n", m_iGOPSize );
2273  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2274  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2275#if RATE_CONTROL_LAMBDA_DOMAIN
2276  printf("RateControl                  : %d\n", m_RCEnableRateControl );
2277  if(m_RCEnableRateControl)
2278  {
2279    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2280    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
2281    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
2282    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
2283    printf("InitialQP                    : %d\n", m_RCInitialQP );
2284    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
2285  }
2286#else
2287  printf("RateControl                  : %d\n", m_enableRateCtrl);
2288  if(m_enableRateCtrl)
2289  {
2290    printf("TargetBitrate                : %d\n", m_targetBitrate);
2291    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
2292  }
2293#endif
2294  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
2295#if H_3D
2296  printf("BaseViewCameraNumbers        : %s\n", m_pchBaseViewCameraNumbers ); 
2297  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2298#if H_3D_VSO
2299  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
2300
2301  if ( m_bUseVSO )
2302  {   
2303    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
2304    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
2305    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
2306    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
2307    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);
2308    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);
2309    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
2310    if ( m_bUseWVSO )
2311    printf("Dist. Weights (VSO/VSD/SAD)  : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2312  }
2313#endif //HHI_VSO
2314#endif //H_3D
2315  printf("\n");
2316#if H_MV
2317  printf("TOOL CFG General: ");
2318#else
2319  printf("TOOL CFG: ");
2320#endif
2321  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
2322  printf("HAD:%d ", m_bUseHADME           );
2323  printf("SRD:%d ", m_bUseSBACRD          );
2324  printf("RDQ:%d ", m_useRDOQ            );
2325  printf("RDQTS:%d ", m_useRDOQTS        );
2326#if L0232_RD_PENALTY
2327  printf("RDpenalty:%d ", m_rdPenalty  );
2328#endif
2329  printf("SQP:%d ", m_uiDeltaQpRD         );
2330  printf("ASR:%d ", m_bUseASR             );
2331#if !L0034_COMBINED_LIST_CLEANUP
2332  printf("LComb:%d ", m_bUseLComb         );
2333#endif
2334  printf("FEN:%d ", m_bUseFastEnc         );
2335  printf("ECU:%d ", m_bUseEarlyCU         );
2336  printf("FDM:%d ", m_useFastDecisionForMerge );
2337  printf("CFM:%d ", m_bUseCbfFastMode         );
2338  printf("ESD:%d ", m_useEarlySkipDetection  );
2339  printf("RQT:%d ", 1     );
2340  printf("TransformSkip:%d ",     m_useTransformSkip              );
2341  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
2342  printf("Slice: M=%d ", m_sliceMode);
2343  if (m_sliceMode!=0)
2344  {
2345    printf("A=%d ", m_sliceArgument);
2346  }
2347  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2348  if (m_sliceSegmentMode!=0)
2349  {
2350    printf("A=%d ", m_sliceSegmentArgument);
2351  }
2352  printf("CIP:%d ", m_bUseConstrainedIntraPred);
2353#if !H_MV
2354  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2355#endif
2356  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2357  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2358
2359  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2360  printf("WPP:%d ", (Int)m_useWeightedPred);
2361  printf("WPB:%d ", (Int)m_useWeightedBiPred);
2362  printf("PME:%d ", m_log2ParallelMergeLevel);
2363  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2364          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2365  printf(" ScalingList:%d ", m_useScalingListId );
2366  printf("TMVPMode:%d ", m_TMVPModeId     );
2367#if ADAPTIVE_QP_SELECTION
2368  printf("AQpS:%d ", m_bUseAdaptQpSelect   );
2369#endif
2370
2371  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2372  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2373#if H_3D_VSO
2374  printf("VSO:%d ", m_bUseVSO   );
2375  printf("WVSO:%d ", m_bUseWVSO ); 
2376#endif
2377  printf("\n\n"); 
2378
2379  fflush(stdout);
2380}
2381
2382Bool confirmPara(Bool bflag, const Char* message)
2383{
2384  if (!bflag)
2385    return false;
2386 
2387  printf("Error: %s\n",message);
2388  return true;
2389}
2390
2391//! \}
Note: See TracBrowser for help on using the repository browser.