source: 3DVCSoftware/branches/HTM-11.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 969

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

Cleanup part 3.

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