source: 3DVCSoftware/branches/HTM-9.3-dev1-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp @ 786

Last change on this file since 786 was 786, checked in by samsung-htm, 10 years ago

Integration of JCT3V-G0077: MCP Size (Only enabling SPIVMP with 2Nx2N PU & Change name of syntax element "log2_sub_pb_size_minus2" to "log2_sub_pb_size_minus3")

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