source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 833

Last change on this file since 833 was 833, checked in by tech, 10 years ago

Merged 9.3-dev0@831.

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