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

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

Macro enclosed and cleaned-up

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