source: 3DVCSoftware/branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncCfg.cpp @ 648

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

Macro removal part H_MV5.

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