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

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

Cleanup part 1

  • Property svn:eol-style set to native
File size: 117.4 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 MTK_SPIVMP_F0110
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 SEC_MPI_ENABLING_MERGE_F0150
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#if QC_DEPTH_IV_MRG_F0125 
783  ("IvMvPred",                        m_ivMvPredFlag            , std::vector<Bool>(2, true)            , "inter view motion prediction " )
784#else
785  ("IvMvPred",                        m_ivMvPredFlag,           true            , "inter view motion prediction " ) 
786#endif
787#endif
788#if H_3D_NBDV_REF
789  ("DepthRefinement",                 m_depthRefinementFlag,    true           , "depth refinement by DoNBDV" ) 
790#endif
791#if H_3D_VSP
792  ("ViewSynthesisPred",               m_viewSynthesisPredFlag,  true           , "view synthesis prediction " ) 
793#endif
794#if H_3D
795  ("IvMvScaling",                     m_ivMvScalingFlag      ,  true            , "inter view motion vector scaling" )   
796#endif
797#endif //H_3D
798  ;
799  #if H_MV
800  // parse coding structure
801  for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
802  {
803    m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
804    if( k == 0 )
805    {
806      m_GOPListMvc[0][0].m_sliceType = 'I'; 
807      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
808      {
809        std::ostringstream cOSS;
810        cOSS<<"Frame"<<i;
811        opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
812        if ( i != 1 )
813        {
814          opts.opt_list.back()->opt->opt_duplicate = true; 
815        }       
816      }
817    }
818    else
819    {
820      std::ostringstream cOSS1;
821      cOSS1<<"FrameI"<<"_l"<<k;
822
823      opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
824      if ( k > 1 )
825      {
826        opts.opt_list.back()->opt->opt_duplicate = true; 
827      }       
828
829
830      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
831      {
832        std::ostringstream cOSS2;
833        cOSS2<<"Frame"<<i<<"_l"<<k;
834        opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
835        if ( i != 1 || k > 0 )
836        {
837          opts.opt_list.back()->opt->opt_duplicate = true; 
838        }       
839      }
840    }
841  }
842#else
843  for(Int i=1; i<MAX_GOP+1; i++) {
844    std::ostringstream cOSS;
845    cOSS<<"Frame"<<i;
846    opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
847  }
848#endif
849  po::setDefaults(opts);
850  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
851
852  if(m_isField)
853  {
854    //Frame height
855    m_iSourceHeightOrg = m_iSourceHeight;
856    //Field height
857    m_iSourceHeight = m_iSourceHeight >> 1;
858    //number of fields to encode
859    m_framesToBeEncoded *= 2;
860  }
861 
862  for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
863  {
864    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
865  }
866 
867  if (argc == 1 || do_help)
868  {
869    /* argc == 1: no options have been specified */
870    po::doHelp(cout, opts);
871    return false;
872  }
873 
874  /*
875   * Set any derived parameters
876   */
877  /* convert std::string to c string for compatability */
878#if !H_MV
879  m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
880#endif
881  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
882#if !H_MV
883  m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
884#endif
885  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
886 
887  Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
888  Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
889  if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
890  {
891    char *columnWidth;
892    int  i=0;
893    m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
894    columnWidth = strtok(pColumnWidth, " ,-");
895    while(columnWidth!=NULL)
896    {
897      if( i>=m_iNumColumnsMinus1 )
898      {
899        printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
900        exit( EXIT_FAILURE );
901      }
902      *( m_pColumnWidth + i ) = atoi( columnWidth );
903      columnWidth = strtok(NULL, " ,-");
904      i++;
905    }
906    if( i<m_iNumColumnsMinus1 )
907    {
908      printf( "The width of some columns is not defined.\n" );
909      exit( EXIT_FAILURE );
910    }
911  }
912  else
913  {
914    m_pColumnWidth = NULL;
915  }
916
917  if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
918  {
919    char *rowHeight;
920    int  i=0;
921    m_pRowHeight = new UInt[m_iNumRowsMinus1];
922    rowHeight = strtok(pRowHeight, " ,-");
923    while(rowHeight!=NULL)
924    {
925      if( i>=m_iNumRowsMinus1 )
926      {
927        printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
928        exit( EXIT_FAILURE );
929      }
930      *( m_pRowHeight + i ) = atoi( rowHeight );
931      rowHeight = strtok(NULL, " ,-");
932      i++;
933    }
934    if( i<m_iNumRowsMinus1 )
935    {
936      printf( "The height of some rows is not defined.\n" );
937      exit( EXIT_FAILURE );
938   }
939  }
940  else
941  {
942    m_pRowHeight = NULL;
943  }
944#if H_MV
945  free ( pColumnWidth );
946  free ( pRowHeight   ); 
947#endif
948  m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
949 
950  /* rules for input, output and internal bitdepths as per help text */
951  if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
952  if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
953  if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
954  if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
955  if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
956
957  // TODO:ChromaFmt assumes 4:2:0 below
958  switch (m_conformanceMode)
959  {
960  case 0:
961    {
962      // no conformance or padding
963      m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
964      m_aiPad[1] = m_aiPad[0] = 0;
965      break;
966    }
967  case 1:
968    {
969      // automatic padding to minimum CU size
970      Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
971      if (m_iSourceWidth % minCuSize)
972      {
973        m_aiPad[0] = m_confRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
974        m_iSourceWidth  += m_confRight;
975      }
976      if (m_iSourceHeight % minCuSize)
977      {
978        m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
979        m_iSourceHeight += m_confBottom;
980        if ( m_isField )
981        {
982          m_iSourceHeightOrg += m_confBottom << 1;
983          m_aiPad[1] = m_confBottom << 1;
984        }
985      }
986      if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
987      {
988        fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
989        exit(EXIT_FAILURE);
990      }
991      if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
992      {
993        fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
994        exit(EXIT_FAILURE);
995      }
996      break;
997    }
998  case 2:
999    {
1000      //padding
1001      m_iSourceWidth  += m_aiPad[0];
1002      m_iSourceHeight += m_aiPad[1];
1003      m_confRight  = m_aiPad[0];
1004      m_confBottom = m_aiPad[1];
1005      break;
1006    }
1007  case 3:
1008    {
1009      // conformance
1010      if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
1011      {
1012        fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
1013      }
1014      if ((m_aiPad[1] != 0) || (m_aiPad[0]!=0))
1015      {
1016        fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
1017      }
1018      m_aiPad[1] = m_aiPad[0] = 0;
1019      break;
1020    }
1021  }
1022 
1023  // allocate slice-based dQP values
1024#if H_MV
1025  xResizeVector( m_viewOrderIndex    ); 
1026
1027  std::vector<Int> uniqueViewOrderIndices; 
1028  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1029  {   
1030    Bool isIn = false; 
1031    for ( Int i = 0 ; i < uniqueViewOrderIndices.size(); i++ )
1032    {
1033      isIn = isIn || ( m_viewOrderIndex[ layer ] == uniqueViewOrderIndices[ i ] ); 
1034    }
1035    if ( !isIn ) 
1036    {
1037      uniqueViewOrderIndices.push_back( m_viewOrderIndex[ layer ] ); 
1038    } 
1039  }
1040  m_iNumberOfViews = (Int) uniqueViewOrderIndices.size(); 
1041
1042#if H_3D
1043  xResizeVector( m_depthFlag ); 
1044#endif
1045  xResizeVector( m_fQP ); 
1046
1047  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1048  {
1049    m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
1050    ::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1051
1052    // handling of floating-point QP values
1053    // if QP is not integer, sequence is split into two sections having QP and QP+1
1054    m_iQP.push_back((Int)( m_fQP[layer] ));
1055    if ( m_iQP[layer] < m_fQP[layer] )
1056    {
1057      Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
1058
1059      iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1060      for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1061      {
1062        m_aidQP[layer][i] = 1;
1063      }
1064    }
1065  }
1066
1067  xResizeVector( m_bLoopFilterDisable ); 
1068  xResizeVector( m_bUseSAO ); 
1069#if H_MV_LAYER_WISE_STARTUP
1070  xResizeVector( m_iIntraPeriod ); 
1071#endif
1072#if H_MV_6_O0226_37
1073  xResizeVector( m_tilesInUseFlag ); 
1074  xResizeVector( m_loopFilterNotAcrossTilesFlag ); 
1075  xResizeVector( m_wppInUseFlag ); 
1076#endif
1077#else
1078  m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1079  ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1080 
1081  // handling of floating-point QP values
1082  // if QP is not integer, sequence is split into two sections having QP and QP+1
1083  m_iQP = (Int)( m_fQP );
1084  if ( m_iQP < m_fQP )
1085  {
1086    Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1087   
1088    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1089    for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1090    {
1091      m_aidQP[i] = 1;
1092    }
1093  }
1094#endif
1095 
1096  // reading external dQP description from file
1097  if ( m_pchdQPFile )
1098  {
1099    FILE* fpt=fopen( m_pchdQPFile, "r" );
1100    if ( fpt )
1101    {
1102#if H_MV
1103      for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1104      {
1105#endif
1106      Int iValue;
1107      Int iPOC = 0;
1108      while ( iPOC < m_framesToBeEncoded )
1109      {
1110        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1111#if H_MV
1112        m_aidQP[layer][ iPOC ] = iValue;
1113        iPOC++;
1114      }
1115#else
1116        m_aidQP[ iPOC ] = iValue;
1117        iPOC++;
1118#endif
1119      }
1120      fclose(fpt);
1121    }
1122  }
1123  m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1124
1125  if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1126  {
1127    Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1128    Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1129    Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1130    if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1131    {
1132      char *startOfCodedInterval;
1133      UInt num = 1u<< m_toneMapTargetBitDepth;
1134      m_startOfCodedInterval = new Int[num];
1135      ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1136      startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1137      int i = 0;
1138      while( startOfCodedInterval && ( i < num ) )
1139      {
1140        m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1141        startOfCodedInterval = strtok(NULL, " .");
1142        i++;
1143      }
1144    } 
1145    else
1146    {
1147      m_startOfCodedInterval = NULL;
1148    }
1149    if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1150    {
1151      if( pcCodedPivotValue && pcTargetPivotValue )
1152      {
1153        char *codedPivotValue;
1154        char *targetPivotValue;
1155        m_codedPivotValue = new Int[m_numPivots];
1156        m_targetPivotValue = new Int[m_numPivots];
1157        ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1158        ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1159        codedPivotValue = strtok(pcCodedPivotValue, " .");
1160        int i=0;
1161        while(codedPivotValue&&i<m_numPivots)
1162        {
1163          m_codedPivotValue[i] = atoi( codedPivotValue );
1164          codedPivotValue = strtok(NULL, " .");
1165          i++;
1166        }
1167        i=0;
1168        targetPivotValue = strtok(pcTargetPivotValue, " .");
1169        while(targetPivotValue&&i<m_numPivots)
1170        {
1171          m_targetPivotValue[i]= atoi( targetPivotValue );
1172          targetPivotValue = strtok(NULL, " .");
1173          i++;
1174        }
1175      }
1176    }
1177    else
1178    {
1179      m_codedPivotValue = NULL;
1180      m_targetPivotValue = NULL;
1181    }
1182  }
1183#if H_3D
1184  // set global varibles
1185  xSetGlobal();
1186#if H_3D_VSO
1187// Table base optimization
1188  // Q&D
1189  Double adLambdaScaleTable[] = 
1190  {  0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755, 
1191     0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648, 
1192     0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542, 
1193     0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388, 
1194     0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100, 
1195     0.753550, 0.800000 
1196  }; 
1197  if ( m_bUseVSO && m_bVSOLSTable )
1198  {
1199    Int firstDepthLayer = -1; 
1200    for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1201    {
1202      if ( m_depthFlag[ layer ])
1203      {
1204        firstDepthLayer = layer;
1205        break; 
1206      }
1207    }
1208    AOT( firstDepthLayer == -1 );
1209    AOT( (m_iQP[firstDepthLayer] < 0) || (m_iQP[firstDepthLayer] > 51));
1210    m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]]; 
1211  }
1212#endif
1213#if H_3D_VSO
1214if ( m_bUseVSO && m_uiVSOMode == 4)
1215{
1216  m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1217  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1218                                      g_bitDepthY,
1219                                (UInt)m_iCodedCamParPrecision,
1220                                      m_FrameSkip,
1221                                (UInt)m_framesToBeEncoded,
1222                                      m_pchCameraParameterFile,
1223                                      m_pchBaseViewCameraNumbers,
1224                                      NULL,
1225                                      m_cRenModStrParser.getSynthViews(),
1226                                      LOG2_DISP_PREC_LUT );
1227}
1228else if ( m_bUseVSO && m_uiVSOMode != 4 )
1229{
1230  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1231                                      g_bitDepthY,
1232                                (UInt)m_iCodedCamParPrecision,
1233                                      m_FrameSkip,
1234                                (UInt)m_framesToBeEncoded,
1235                                      m_pchCameraParameterFile,
1236                                      m_pchBaseViewCameraNumbers,
1237                                      m_pchVSOConfig,
1238                                      NULL,
1239                                      LOG2_DISP_PREC_LUT );
1240}
1241else
1242{
1243  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1244    g_bitDepthY,
1245    (UInt) m_iCodedCamParPrecision,
1246    m_FrameSkip,
1247    (UInt) m_framesToBeEncoded,
1248    m_pchCameraParameterFile,
1249    m_pchBaseViewCameraNumbers,
1250    NULL,
1251    NULL,
1252    LOG2_DISP_PREC_LUT );
1253}
1254#else
1255  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ), 
1256    g_bitDepthY,
1257    (UInt) m_iCodedCamParPrecision,
1258    m_FrameSkip,
1259    (UInt) m_framesToBeEncoded,
1260    m_pchCameraParameterFile,
1261    m_pchBaseViewCameraNumbers,
1262    NULL,
1263    NULL,
1264    LOG2_DISP_PREC_LUT );
1265#endif
1266  m_cCameraData.check( false, true );
1267#endif
1268  // check validity of input parameters
1269  xCheckParameter();
1270
1271#if !H_3D
1272  // set global varibles
1273  xSetGlobal();
1274#endif
1275 
1276  // print-out parameters
1277  xPrintParameter();
1278 
1279  return true;
1280}
1281// ====================================================================================================================
1282// Private member functions
1283// ====================================================================================================================
1284
1285Bool confirmPara(Bool bflag, const Char* message);
1286
1287Void TAppEncCfg::xCheckParameter()
1288{
1289  if (!m_decodedPictureHashSEIEnabled)
1290  {
1291    fprintf(stderr, "******************************************************************\n");
1292    fprintf(stderr, "** WARNING: --SEIDecodedPictureHash is now disabled by default. **\n");
1293    fprintf(stderr, "**          Automatic verification of decoded pictures by a     **\n");
1294    fprintf(stderr, "**          decoder requires this option to be enabled.         **\n");
1295    fprintf(stderr, "******************************************************************\n");
1296  }
1297  if( m_profile==Profile::NONE )
1298  {
1299    fprintf(stderr, "***************************************************************************\n");
1300    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Profile value must be set! **\n");
1301    fprintf(stderr, "***************************************************************************\n");
1302  }
1303  if( m_level==Level::NONE )
1304  {
1305    fprintf(stderr, "***************************************************************************\n");
1306    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Level value must be set!   **\n");
1307    fprintf(stderr, "***************************************************************************\n");
1308  }
1309
1310  Bool check_failed = false; /* abort if there is a fatal configuration problem */
1311#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
1312  // check range of parameters
1313  xConfirmPara( m_inputBitDepthY < 8,                                                     "InputBitDepth must be at least 8" );
1314  xConfirmPara( m_inputBitDepthC < 8,                                                     "InputBitDepthC must be at least 8" );
1315  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
1316  xConfirmPara( m_framesToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
1317#if H_MV
1318  xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS ,                                      "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1319
1320
1321  xConfirmPara( m_layerIdInNuh[0] != 0      , "LayerIdInNuh must be 0 for the first layer. ");
1322  xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1323 
1324#if H_3D
1325  xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
1326#else
1327  xConfirmPara( m_scalabilityMask != 2 , "Scalability Mask must be equal to 2. ");
1328#endif
1329
1330#if H_3D
1331  if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1332  {
1333    m_dimIds.push_back( m_depthFlag ); 
1334  }
1335#endif
1336
1337  m_dimIds.push_back( m_viewOrderIndex );   
1338  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1]; 
1339
1340  dimBitOffset[ 0 ] = 0; 
1341  for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1342 {
1343    dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1]; 
1344  }
1345
1346  if ( m_splittingFlag )
1347  {
1348    dimBitOffset[ (Int) m_dimIds.size() ] = 6; 
1349  }
1350 
1351  for( Int j = 0; j < m_dimIds.size(); j++ )
1352  {   
1353    xConfirmPara( m_dimIds[j].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");   
1354    xConfirmPara( (m_dimIds[j][0] != 0)                 , "DimensionId of layer 0 must be 0. " );
1355    xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " ); 
1356     
1357
1358   for( Int i = 1; i < m_numberOfLayers; i++ )
1359   {     
1360      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. " );
1361      if ( m_splittingFlag )
1362      {
1363        Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] :  i; 
1364        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. "); 
1365      }
1366   }
1367 }
1368
1369 for( Int i = 0; i < m_numberOfLayers; i++ )
1370 {
1371   for( Int j = 0; j < i; j++ )
1372   {     
1373     Int numDiff  = 0; 
1374     Int lastDiff = -1; 
1375     for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1376     {
1377       if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1378       {
1379         numDiff ++; 
1380         lastDiff = dim; 
1381       }
1382     }
1383
1384     Bool allEqual = ( numDiff == 0 ); 
1385
1386     if ( allEqual ) 
1387     {
1388       printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1389     }
1390
1391     xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1392
1393#if !H_3D_FCO
1394     if ( numDiff  == 1 ) 
1395     {
1396       Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ]; 
1397       Bool shallBeButIsNotIncreasing = ( !inc  ) ; 
1398       if ( shallBeButIsNotIncreasing )
1399       {       
1400         printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
1401       }
1402       xConfirmPara( shallBeButIsNotIncreasing,  "DimensionIds shall be increasing within one dimension. " );
1403     }
1404#endif
1405   }
1406 }
1407
1408 /// ViewId
1409 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." ); 
1410
1411  /// Layer sets
1412  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ; 
1413  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1414  {
1415    if (lsIdx == 0)
1416    {
1417      xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 || m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1418    }
1419    for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1420    {
1421#if H_MV_6_LAYER_ID_32
1422      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" ); 
1423#else
1424      xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 || m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than 64" ); 
1425#endif
1426    }
1427  }
1428
1429  // Output layer sets
1430  xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1431  for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1432  {   
1433    Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ]; 
1434    xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1435
1436    for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1437    {
1438      Bool isAlsoInLayerSet = false; 
1439      for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1440      {
1441        if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1442        {
1443          isAlsoInLayerSet = true; 
1444          break; 
1445        }       
1446      }
1447      xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1448    }
1449  }
1450
1451#if H_MV_6_PS_0109_25
1452  xConfirmPara( m_defaultOneTargetOutputLayerIdc < 0 || m_defaultOneTargetOutputLayerIdc > 1, "Default one target output layer idc must be equal to 0 or equal to 1" );
1453#endif
1454  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" );
1455
1456  // Layer Dependencies 
1457  for (Int i = 0; i < m_numberOfLayers; i++ )
1458  {
1459    xConfirmPara( (i == 0)  && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." ); 
1460    xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." ); 
1461    for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1462    {
1463      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"); 
1464      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"); 
1465    }       
1466  } 
1467#endif
1468  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
1469  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1470#if H_MV_LAYER_WISE_STARTUP
1471  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1472  {
1473    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" );
1474  }
1475#else
1476  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1477#endif
1478  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
1479#if H_MV
1480  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1481  {
1482    xConfirmPara( m_iQP[layer] <  -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51,      "QP exceeds supported range (-QpBDOffsety to 51)" );
1483  }
1484#else
1485  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
1486#endif
1487  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6,          "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1488  xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6,              "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1489  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
1490  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
1491  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
1492  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
1493  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1494
1495  xConfirmPara( m_cbQpOffset < -12,   "Min. Chroma Cb QP Offset is -12" );
1496  xConfirmPara( m_cbQpOffset >  12,   "Max. Chroma Cb QP Offset is  12" );
1497  xConfirmPara( m_crQpOffset < -12,   "Min. Chroma Cr QP Offset is -12" );
1498  xConfirmPara( m_crQpOffset >  12,   "Max. Chroma Cr QP Offset is  12" );
1499
1500  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
1501  if (m_iDecodingRefreshType == 2)
1502  {
1503#if H_MV_LAYER_WISE_STARTUP
1504    for (Int i = 0; i < m_numberOfLayers; i++ )
1505    {
1506      xConfirmPara( m_iIntraPeriod[i] > 0 && m_iIntraPeriod[i] <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
1507    }
1508#else
1509    xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
1510#endif
1511  }
1512  xConfirmPara( (m_uiMaxCUWidth  >> m_uiMaxCUDepth) < 4,                                    "Minimum partition width size should be larger than or equal to 8");
1513  xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4,                                    "Minimum partition height size should be larger than or equal to 8");
1514  xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
1515  xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
1516  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
1517  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
1518 
1519  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
1520  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
1521  xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth,                                        "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1522 
1523  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1524  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1525  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1526  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth  >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1527  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1528  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1529  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" );
1530  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1531  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" );
1532 
1533  xConfirmPara(  m_maxNumMergeCand < 1,  "MaxNumMergeCand must be 1 or greater.");
1534  xConfirmPara(  m_maxNumMergeCand > 5,  "MaxNumMergeCand must be 5 or smaller.");
1535
1536#if H_3D_ARP
1537  xConfirmPara( ( 0 != m_uiUseAdvResPred ) &&  ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1538#endif
1539#if MTK_SPIVMP_F0110
1540  xConfirmPara( m_iSubPULog2Size < 2,                                        "SubPULog2Size must be 2 or greater.");
1541  xConfirmPara( m_iSubPULog2Size > 6,                                        "SubPULog2Size must be 6 or smaller.");
1542  xConfirmPara( (1<<m_iSubPULog2Size) > m_uiMaxCUWidth,                      "SubPULog2Size must be log2(maxCUSize) or smaller.");
1543#endif
1544#if ADAPTIVE_QP_SELECTION
1545#if H_MV
1546  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1547  {
1548    xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0,                                     "AdaptiveQpSelection must be disabled when QP < 0.");
1549  }
1550#else
1551  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
1552#endif
1553  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1554#endif
1555
1556  if( m_usePCM)
1557  {
1558    xConfirmPara(  m_uiPCMLog2MinSize < 3,                                      "PCMLog2MinSize must be 3 or greater.");
1559    xConfirmPara(  m_uiPCMLog2MinSize > 5,                                      "PCMLog2MinSize must be 5 or smaller.");
1560    xConfirmPara(  m_pcmLog2MaxSize > 5,                                        "PCMLog2MaxSize must be 5 or smaller.");
1561    xConfirmPara(  m_pcmLog2MaxSize < m_uiPCMLog2MinSize,                       "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1562  }
1563
1564  xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1565  if (m_sliceMode!=0)
1566  {
1567    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
1568  }
1569  xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1570  if (m_sliceSegmentMode!=0)
1571  {
1572    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
1573  }
1574 
1575  Bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
1576  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
1577
1578  //TODO:ChromaFmt assumes 4:2:0 below
1579  xConfirmPara( m_iSourceWidth  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1580  xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1581
1582  xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1583  xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1584
1585  xConfirmPara( m_confLeft   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1586  xConfirmPara( m_confRight  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1587  xConfirmPara( m_confTop    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1588  xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1589
1590#if H_3D
1591  xConfirmPara( m_pchCameraParameterFile    == 0                ,   "CameraParameterFile must be given");
1592  xConfirmPara( m_pchBaseViewCameraNumbers  == 0                ,   "BaseViewCameraNumbers must be given" );
1593  xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1594  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
1595#if H_3D_VSO
1596    if( m_bUseVSO )
1597    {
1598      xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
1599      xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
1600    }
1601#endif
1602#endif
1603  // max CU width and height should be power of 2
1604  UInt ui = m_uiMaxCUWidth;
1605  while(ui)
1606  {
1607    ui >>= 1;
1608    if( (ui & 1) == 1)
1609      xConfirmPara( ui != 1 , "Width should be 2^n");
1610  }
1611  ui = m_uiMaxCUHeight;
1612  while(ui)
1613  {
1614    ui >>= 1;
1615    if( (ui & 1) == 1)
1616      xConfirmPara( ui != 1 , "Height should be 2^n");
1617  }
1618
1619#if H_MV
1620  // validate that POC of same frame is identical across multiple layers
1621  Bool bErrorMvePoc = false;
1622  if( m_numberOfLayers > 1 )
1623  {
1624    for( Int k = 1; k < m_numberOfLayers; k++ )
1625    {
1626      for( Int i = 0; i < MAX_GOP; i++ )
1627      {
1628        if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1629        {
1630          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 );
1631          bErrorMvePoc = true;
1632        }
1633      }
1634    }
1635  }
1636  xConfirmPara( bErrorMvePoc,  "Invalid inter-layer POC structure given" );
1637
1638  // validate that baseview has no inter-view refs
1639  Bool bErrorIvpBase = false;
1640  for( Int i = 0; i < MAX_GOP; i++ )
1641  {
1642    if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1643    {
1644      printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1645      bErrorIvpBase = true;
1646    }
1647  }
1648  xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1649
1650  // validate inter-view refs
1651  Bool bErrorIvpEnhV = false;
1652  if( m_numberOfLayers > 1 )
1653  {
1654    for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1655    {
1656      for( Int i = 0; i < MAX_GOP+1; i++ )
1657      {
1658        GOPEntry gopEntry = m_GOPListMvc[layer][i]; 
1659        for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1660        {
1661          Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1662          if( ilPredLayerIdc < 0 || ilPredLayerIdc >= m_directRefLayers[layer].size() )
1663          {
1664            printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1665            bErrorIvpEnhV = true;
1666          }
1667          if( gopEntry.m_interViewRefPosL[0][j] < -1 || gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1668          {
1669            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 );
1670            bErrorIvpEnhV = true;
1671          }
1672          if( gopEntry.m_interViewRefPosL[1][j] < -1  || gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1673          {
1674            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 );
1675            bErrorIvpEnhV = true;
1676          }
1677        }
1678        if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1679        {
1680          if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1681          {
1682            printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1683            bErrorIvpEnhV = true;
1684          }
1685
1686          if( gopEntry.m_POC != 0 )
1687          {
1688            printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1689            bErrorIvpEnhV = true;
1690          }
1691
1692          if( gopEntry.m_temporalId != 0 )
1693          {
1694            printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1695            gopEntry.m_temporalId = 0;
1696          }
1697
1698          if( gopEntry.m_numRefPics != 0 )
1699          {
1700            printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1701            for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1702            {
1703              gopEntry.m_referencePics[j] = 0;
1704            }
1705            gopEntry.m_numRefPics = 0;
1706          }
1707
1708          if( gopEntry.m_interRPSPrediction )
1709          {
1710            printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1711            bErrorIvpEnhV = true;
1712          }
1713
1714          if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1715          {
1716            printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1717            bErrorIvpEnhV = true;
1718          }
1719
1720          if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1721          {
1722            gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1723          }
1724
1725          if( gopEntry.m_sliceType == 'P' )
1726          {
1727            if( gopEntry.m_numActiveRefLayerPics < 1 )
1728            {
1729              printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1730              bErrorIvpEnhV = true;
1731            }
1732            else
1733            {
1734              for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1735              {
1736                if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1737                {
1738                  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 );
1739                  bErrorIvpEnhV = true;
1740                }
1741              }
1742            }
1743          }
1744
1745          if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1746          {
1747            printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1748            bErrorIvpEnhV = true;
1749          }
1750        }
1751      }
1752    }
1753  }
1754  xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1755
1756  // validate temporal coding structure
1757  if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1758  {
1759    for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1760    {
1761      GOPEntry* m_GOPList            = m_GOPListMvc           [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1762      Int&      m_extraRPSs          = m_extraRPSsMvc         [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1763      Int&      m_maxTempLayer       = m_maxTempLayerMvc      [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1764      Int*      m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1765      Int*      m_numReorderPics     = m_numReorderPicsMvc    [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1766#endif
1767  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1768   * This permits the ability to omit a GOP structure specification */
1769#if H_MV_LAYER_WISE_STARTUP
1770  if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {
1771#else
1772  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1773#endif
1774    m_GOPList[0] = GOPEntry();
1775    m_GOPList[0].m_QPFactor = 1;
1776    m_GOPList[0].m_betaOffsetDiv2 = 0;
1777    m_GOPList[0].m_tcOffsetDiv2 = 0;
1778    m_GOPList[0].m_POC = 1;
1779    m_GOPList[0].m_numRefPicsActive = 4;
1780  }
1781 
1782  Bool verifiedGOP=false;
1783  Bool errorGOP=false;
1784  Int checkGOP=1;
1785  Int numRefs = m_isField ? 2 : 1;
1786  Int refList[MAX_NUM_REF_PICS+1];
1787  refList[0]=0;
1788  if(m_isField)
1789  {
1790    refList[1] = 1;
1791  }
1792  Bool isOK[MAX_GOP];
1793  for(Int i=0; i<MAX_GOP; i++) 
1794  {
1795    isOK[i]=false;
1796  }
1797  Int numOK=0;
1798#if H_MV_LAYER_WISE_STARTUP
1799  xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" ); 
1800#else
1801  xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1802#endif
1803
1804  for(Int i=0; i<m_iGOPSize; i++)
1805  {
1806    if(m_GOPList[i].m_POC==m_iGOPSize)
1807    {
1808      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1809    }
1810  }
1811 
1812#if H_MV
1813#if H_MV_LAYER_WISE_STARTUP
1814  if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1815#else
1816  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1817#endif
1818#else
1819  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1820#endif
1821  {
1822    for(Int i=0; i<m_iGOPSize; i++)
1823    {
1824      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)" );
1825      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)" );
1826    }
1827  }
1828  m_extraRPSs=0;
1829  //start looping through frames in coding order until we can verify that the GOP structure is correct.
1830  while(!verifiedGOP&&!errorGOP) 
1831  {
1832    Int curGOP = (checkGOP-1)%m_iGOPSize;
1833    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
1834    if(m_GOPList[curGOP].m_POC<0) 
1835    {
1836#if H_MV
1837      printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1838#else
1839      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1840#endif
1841      errorGOP=true;
1842    }
1843    else 
1844    {
1845      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1846      Bool beforeI = false;
1847      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1848      {
1849        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1850        if(absPOC < 0)
1851        {
1852          beforeI=true;
1853        }
1854        else 
1855        {
1856          Bool found=false;
1857          for(Int j=0; j<numRefs; j++) 
1858          {
1859            if(refList[j]==absPOC) 
1860            {
1861              found=true;
1862              for(Int k=0; k<m_iGOPSize; k++)
1863              {
1864                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1865                {
1866                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1867                  {
1868                    m_GOPList[k].m_refPic = true;
1869                  }
1870                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1871                }
1872              }
1873            }
1874          }
1875          if(!found)
1876          {
1877#if H_MV
1878            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);
1879#else
1880            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1881#endif
1882            errorGOP=true;
1883          }
1884        }
1885      }
1886      if(!beforeI&&!errorGOP)
1887      {
1888        //all ref frames were present
1889        if(!isOK[curGOP]) 
1890        {
1891          numOK++;
1892          isOK[curGOP]=true;
1893          if(numOK==m_iGOPSize)
1894          {
1895            verifiedGOP=true;
1896          }
1897        }
1898      }
1899      else 
1900      {
1901        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1902        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1903        Int newRefs=0;
1904        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1905        {
1906          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1907          if(absPOC>=0)
1908          {
1909            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1910            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1911            newRefs++;
1912          }
1913        }
1914        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1915       
1916        for(Int offset = -1; offset>-checkGOP; offset--)
1917        {
1918          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1919          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1920          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1921          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1922          {
1923            Bool newRef=false;
1924            for(Int i=0; i<numRefs; i++)
1925            {
1926              if(refList[i]==offPOC)
1927              {
1928                newRef=true;
1929              }
1930            }
1931            for(Int i=0; i<newRefs; i++) 
1932            {
1933              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1934              {
1935                newRef=false;
1936              }
1937            }
1938            if(newRef) 
1939            {
1940              Int insertPoint=newRefs;
1941              //this picture can be added, find appropriate place in list and insert it.
1942              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1943              {
1944                m_GOPList[offGOP].m_refPic = true;
1945              }
1946              for(Int j=0; j<newRefs; j++)
1947              {
1948                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1949                {
1950                  insertPoint = j;
1951                  break;
1952                }
1953              }
1954              Int prev = offPOC-curPOC;
1955              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1956              for(Int j=insertPoint; j<newRefs+1; j++)
1957              {
1958                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1959                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1960                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1961                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1962                prevUsed=newUsed;
1963                prev=newPrev;
1964              }
1965              newRefs++;
1966            }
1967          }
1968          if(newRefs>=numPrefRefs)
1969          {
1970            break;
1971          }
1972        }
1973        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1974        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1975        if (m_extraRPSs == 0)
1976        {
1977          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1978          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1979        }
1980        else
1981        {
1982          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
1983          Int refPOC = m_GOPList[rIdx].m_POC;
1984          Int refPics = m_GOPList[rIdx].m_numRefPics;
1985          Int newIdc=0;
1986          for(Int i = 0; i<= refPics; i++) 
1987          {
1988            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
1989            Int absPOCref = refPOC+deltaPOC;
1990            Int refIdc = 0;
1991            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1992            {
1993              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1994              {
1995                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1996                {
1997                  refIdc = 1;
1998                }
1999                else
2000                {
2001                  refIdc = 2;
2002                }
2003              }
2004            }
2005            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2006            newIdc++;
2007          }
2008          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
2009          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
2010          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 
2011        }
2012        curGOP=m_iGOPSize+m_extraRPSs;
2013        m_extraRPSs++;
2014      }
2015      numRefs=0;
2016      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
2017      {
2018        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2019        if(absPOC >= 0) 
2020        {
2021          refList[numRefs]=absPOC;
2022          numRefs++;
2023        }
2024      }
2025      refList[numRefs]=curPOC;
2026      numRefs++;
2027    }
2028    checkGOP++;
2029  }
2030  xConfirmPara(errorGOP,"Invalid GOP structure given");
2031  m_maxTempLayer = 1;
2032  for(Int i=0; i<m_iGOPSize; i++) 
2033  {
2034    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2035    {
2036      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2037    }
2038    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
2039  }
2040  for(Int i=0; i<MAX_TLAYER; i++)
2041  {
2042    m_numReorderPics[i] = 0;
2043    m_maxDecPicBuffering[i] = 1;
2044  }
2045  for(Int i=0; i<m_iGOPSize; i++) 
2046  {
2047    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2048    {
2049      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2050    }
2051    Int highestDecodingNumberWithLowerPOC = 0; 
2052    for(Int j=0; j<m_iGOPSize; j++)
2053    {
2054      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2055      {
2056        highestDecodingNumberWithLowerPOC = j;
2057      }
2058    }
2059    Int numReorder = 0;
2060    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2061    {
2062      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 
2063        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2064      {
2065        numReorder++;
2066      }
2067    }   
2068    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2069    {
2070      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2071    }
2072  }
2073  for(Int i=0; i<MAX_TLAYER-1; i++) 
2074  {
2075    // a lower layer can not have higher value of m_numReorderPics than a higher layer
2076    if(m_numReorderPics[i+1] < m_numReorderPics[i])
2077    {
2078      m_numReorderPics[i+1] = m_numReorderPics[i];
2079    }
2080    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2081    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2082    {
2083      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2084    }
2085    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2086    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2087    {
2088      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2089    }
2090  }
2091
2092
2093  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
2094  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2095  {
2096    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2097  }
2098
2099  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2100  { 
2101    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
2102    if(tileFlag)
2103    {
2104      Int maxTileWidth = 0;
2105      Int maxTileHeight = 0;
2106      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2107      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2108      if(m_iUniformSpacingIdr)
2109      {
2110        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2111        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2112        // if only the last tile-row is one treeblock higher than the others
2113        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2114        if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2115        {
2116          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2117        }     
2118        // if only the last tile-column is one treeblock wider than the others
2119        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
2120        if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2121        {
2122          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2123        }
2124      }
2125      else // not uniform spacing
2126      {
2127        if(m_iNumColumnsMinus1<1)
2128        {
2129          maxTileWidth = m_iSourceWidth;
2130        }
2131        else
2132        {
2133          Int accColumnWidth = 0;
2134          for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2135          {
2136            maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2137            accColumnWidth += m_pColumnWidth[col];
2138          }
2139          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
2140        }
2141        if(m_iNumRowsMinus1<1)
2142        {
2143          maxTileHeight = m_iSourceHeight;
2144        }
2145        else
2146        {
2147          Int accRowHeight = 0;
2148          for(Int row=0; row<(m_iNumRowsMinus1); row++)
2149          {
2150            maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2151            accRowHeight += m_pRowHeight[row];
2152          }
2153          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
2154        }
2155      }
2156      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2157      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2158    }
2159    else if(m_iWaveFrontSynchro)
2160    {
2161      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2162    }
2163    else if(m_sliceMode == 1)
2164    {
2165      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2166    }
2167    else
2168    {
2169      m_minSpatialSegmentationIdc = 0;
2170    }
2171  }
2172  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2173  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2174  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2175
2176  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2177
2178  if (m_toneMappingInfoSEIEnabled)
2179  {
2180    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2181    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2182    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2183    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2184    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2185    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2186    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2187  }
2188
2189#if RATE_CONTROL_LAMBDA_DOMAIN
2190  if ( m_RCEnableRateControl )
2191  {
2192    if ( m_RCForceIntraQP )
2193    {
2194      if ( m_RCInitialQP == 0 )
2195      {
2196        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2197        m_RCForceIntraQP = false;
2198      }
2199    }
2200    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2201  }
2202#else
2203  if(m_enableRateCtrl)
2204  {
2205    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
2206    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
2207    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
2208
2209    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2210
2211#if !KWU_FIX_URQ
2212    m_iMaxDeltaQP       = MAX_DELTA_QP;
2213#endif
2214    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
2215  }
2216#endif
2217#if H_MV
2218  // VPS VUI
2219  for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2220  { 
2221    for (Int j = 0; j < MAX_TLAYER; j++)
2222    {   
2223      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" );
2224      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" );
2225      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" );
2226      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" );
2227    }
2228  }
2229  // todo: replace value of 100 with requirement in spec
2230  for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2231  { 
2232    for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2233    {   
2234      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" );
2235      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" );
2236    }
2237  }
2238#endif
2239
2240  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2241
2242  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2243  if (m_framePackingSEIEnabled)
2244  {
2245    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2246  }
2247
2248#if H_MV
2249  }
2250  }
2251#endif
2252#undef xConfirmPara
2253  if (check_failed)
2254  {
2255    exit(EXIT_FAILURE);
2256  }
2257}
2258
2259/** \todo use of global variables should be removed later
2260 */
2261Void TAppEncCfg::xSetGlobal()
2262{
2263  // set max CU width & height
2264  g_uiMaxCUWidth  = m_uiMaxCUWidth;
2265  g_uiMaxCUHeight = m_uiMaxCUHeight;
2266 
2267  // compute actual CU depth with respect to config depth and max transform size
2268  g_uiAddCUDepth  = 0;
2269  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
2270 
2271  m_uiMaxCUDepth += g_uiAddCUDepth;
2272  g_uiAddCUDepth++;
2273  g_uiMaxCUDepth = m_uiMaxCUDepth;
2274 
2275  // set internal bit-depth and constants
2276  g_bitDepthY = m_internalBitDepthY;
2277  g_bitDepthC = m_internalBitDepthC;
2278 
2279  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2280  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2281}
2282
2283Void TAppEncCfg::xPrintParameter()
2284{
2285  printf("\n");
2286#if H_MV
2287  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2288  {
2289    printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
2290  }
2291#else
2292  printf("Input          File          : %s\n", m_pchInputFile          );
2293#endif
2294  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
2295#if H_MV
2296  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2297  {
2298    printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
2299  }
2300#else
2301  printf("Reconstruction File          : %s\n", m_pchReconFile          );
2302#endif
2303#if H_MV
2304  xPrintParaVector( "ViewIdVal"     , m_viewId ); 
2305  xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex ); 
2306#endif
2307#if H_3D
2308  xPrintParaVector( "DepthFlag", m_depthFlag ); 
2309  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2310#endif
2311#if H_MV 
2312  xPrintParaVector( "QP"               , m_fQP                ); 
2313  xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable ); 
2314  xPrintParaVector( "SAO"              , m_bUseSAO            ); 
2315#endif
2316  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2317  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2318  if (m_isField)
2319  {
2320    printf("Frame/Field          : Field based coding\n");
2321    printf("Field index          : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2322    if (m_isTopFieldFirst)
2323    {
2324      printf("Field Order            : Top field first\n");
2325    }
2326    else
2327    {
2328      printf("Field Order            : Bottom field first\n");
2329    }
2330  }
2331  else
2332  {
2333    printf("Frame/Field                  : Frame based coding\n");
2334  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2335  }
2336  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2337  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2338  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
2339  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2340  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
2341  printf("Motion search range          : %d\n", m_iSearchRange );
2342#if H_MV_LAYER_WISE_STARTUP
2343  xPrintParaVector( "Intra period", m_iIntraPeriod );
2344#else
2345  printf("Intra period                 : %d\n", m_iIntraPeriod );
2346#endif
2347  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
2348#if !H_MV
2349  printf("QP                           : %5.2f\n", m_fQP );
2350#endif
2351  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
2352
2353  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
2354  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
2355
2356  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2357  printf("GOP size                     : %d\n", m_iGOPSize );
2358  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2359  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2360#if RATE_CONTROL_LAMBDA_DOMAIN
2361  printf("RateControl                  : %d\n", m_RCEnableRateControl );
2362  if(m_RCEnableRateControl)
2363  {
2364    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2365    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
2366    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
2367    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
2368    printf("InitialQP                    : %d\n", m_RCInitialQP );
2369    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
2370
2371#if KWU_RC_MADPRED_E0227
2372    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
2373#endif
2374#if KWU_RC_VIEWRC_E0227
2375    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
2376    if(m_viewWiseRateCtrl)
2377    {
2378
2379      printf("ViewWiseTargetBits           : ");
2380      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2381        printf("%d ", m_viewTargetBits[i]);
2382      printf("\n");
2383    }
2384    else
2385    {
2386      printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2387    }
2388#endif
2389  }
2390#else
2391  printf("RateControl                  : %d\n", m_enableRateCtrl);
2392  if(m_enableRateCtrl)
2393  {
2394    printf("TargetBitrate                : %d\n", m_targetBitrate);
2395    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
2396
2397#if KWU_RC_MADPRED_E0227
2398    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
2399#endif
2400#if KWU_RC_VIEWRC_E0227
2401    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
2402    if(m_viewWiseRateCtrl)
2403    {
2404
2405      printf("ViewWiseTargetBits           : ");
2406      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2407        printf("%d ", m_viewTargetBits[i]);
2408      printf("\n");
2409    }
2410    else
2411    {
2412      printf("TargetBitrate                : %d\n", m_targetBitrate );
2413    }
2414#endif
2415  }
2416#endif
2417  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
2418#if H_3D
2419  printf("BaseViewCameraNumbers        : %s\n", m_pchBaseViewCameraNumbers ); 
2420  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2421#if H_3D_VSO
2422  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
2423
2424  if ( m_bUseVSO )
2425  {   
2426    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
2427    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
2428    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
2429    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
2430    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);
2431    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);
2432    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
2433    if ( m_bUseWVSO )
2434    printf("Dist. Weights (VSO/VSD/SAD)  : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2435  }
2436#endif //HHI_VSO
2437#endif //H_3D
2438  printf("\n");
2439#if H_MV
2440  printf("TOOL CFG General: ");
2441#else
2442  printf("TOOL CFG: ");
2443#endif
2444  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
2445  printf("HAD:%d ", m_bUseHADME           );
2446  printf("SRD:%d ", m_bUseSBACRD          );
2447  printf("RDQ:%d ", m_useRDOQ            );
2448  printf("RDQTS:%d ", m_useRDOQTS        );
2449  printf("RDpenalty:%d ", m_rdPenalty  );
2450  printf("SQP:%d ", m_uiDeltaQpRD         );
2451  printf("ASR:%d ", m_bUseASR             );
2452  printf("FEN:%d ", m_bUseFastEnc         );
2453  printf("ECU:%d ", m_bUseEarlyCU         );
2454  printf("FDM:%d ", m_useFastDecisionForMerge );
2455  printf("CFM:%d ", m_bUseCbfFastMode         );
2456  printf("ESD:%d ", m_useEarlySkipDetection  );
2457  printf("RQT:%d ", 1     );
2458  printf("TransformSkip:%d ",     m_useTransformSkip              );
2459  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
2460  printf("Slice: M=%d ", m_sliceMode);
2461  if (m_sliceMode!=0)
2462  {
2463    printf("A=%d ", m_sliceArgument);
2464  }
2465  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2466  if (m_sliceSegmentMode!=0)
2467  {
2468    printf("A=%d ", m_sliceSegmentArgument);
2469  }
2470  printf("CIP:%d ", m_bUseConstrainedIntraPred);
2471#if !H_MV
2472  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2473#endif
2474  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2475  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2476
2477  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2478  printf("WPP:%d ", (Int)m_useWeightedPred);
2479  printf("WPB:%d ", (Int)m_useWeightedBiPred);
2480  printf("PME:%d ", m_log2ParallelMergeLevel);
2481  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2482          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2483  printf(" ScalingList:%d ", m_useScalingListId );
2484  printf("TMVPMode:%d ", m_TMVPModeId     );
2485#if ADAPTIVE_QP_SELECTION
2486  printf("AQpS:%d ", m_bUseAdaptQpSelect   );
2487#endif
2488
2489  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2490  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2491#if H_3D_VSO
2492  printf("VSO:%d ", m_bUseVSO   );
2493  printf("WVSO:%d ", m_bUseWVSO ); 
2494#endif
2495#if H_3D_QTLPC
2496  printf("QTL:%d ", m_bUseQTL);
2497  printf("PC:%d " , m_bUsePC );
2498#endif
2499#if H_3D_IV_MERGE
2500#if QC_DEPTH_IV_MRG_F0125
2501  printf("IvMvPred:%d %d", m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2502#else
2503  printf("IvMvPred:%d ", m_ivMvPredFlag );
2504#endif
2505#if MTK_SPIVMP_F0110
2506  printf(" SubPULog2Size:%d  " , m_iSubPULog2Size  );
2507#endif
2508#endif
2509#if H_3D_ARP
2510  printf(" ARP:%d  ", m_uiUseAdvResPred  );
2511#endif
2512#if H_3D_IC
2513  printf( "IlluCompEnable: %d ", m_abUseIC);
2514#endif
2515#if H_3D_NBDV_REF
2516  printf("DepthRefinement:%d ", m_depthRefinementFlag ); 
2517#endif
2518#if H_3D_VSP
2519  printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2520#endif
2521#if H_3D
2522  printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0  );
2523#endif
2524#if H_3D_DIM
2525  printf("DMM:%d ", m_useDMM );
2526  printf("SDC:%d ", m_useSDC );
2527  printf("DLT:%d ", m_useDLT );
2528#endif
2529#if H_3D_INTER_SDC
2530  printf( "interSDC: %d ", m_bDepthInterSDCFlag ? 1 : 0 );
2531#endif
2532#if SEC_MPI_ENABLING_MERGE_F0150
2533  printf( "MPI: %d ", m_bMPIFlag ? 1 : 0 );
2534#endif
2535  printf("\n\n"); 
2536
2537  fflush(stdout);
2538}
2539
2540Bool confirmPara(Bool bflag, const Char* message)
2541{
2542  if (!bflag)
2543    return false;
2544 
2545  printf("Error: %s\n",message);
2546  return true;
2547}
2548
2549//! \}
Note: See TracBrowser for help on using the repository browser.