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

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

Merged 11.2-dev0@1038.

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