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

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

Merged HTM-10.0-dev0@871. (MV-HEVC 7 HLS)

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