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

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

Merged 8.1-Cleanup@654

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