source: 3DVCSoftware/branches/HTM-9.2-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 765

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

Cleanup part 2

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