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

Last change on this file since 608 was 608, checked in by tech, 11 years ago

Merged DEV-2.0-dev0@604.

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