source: 3DVCSoftware/branches/HTM-DEV-2.0-dev1-Fix/source/App/TAppEncoder/TAppEncCfg.cpp @ 713

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

Further removal of unused macros.

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