source: 3DVCSoftware/branches/HTM-8.2-dev3-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp @ 697

Last change on this file since 697 was 697, checked in by samsung-htm, 11 years ago

Integration of F0147: DMM simplification and signalling

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