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

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

Merged 8.0-dev0@621 (MV-HEVC 5 HLS).

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