source: 3DVCSoftware/branches/HTM-8.2-dev2-Qualcomm/source/App/TAppEncoder/TAppEncCfg.cpp @ 669

Last change on this file since 669 was 669, checked in by zhang, 11 years ago

JCT3V-F0125

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