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

Last change on this file since 630 was 630, checked in by chang, 11 years ago

Fixed macro news to H_3D_FCO_E0163 with document number.

  • 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 !H_3D_FCO_E0163
1375     if ( numDiff  == 1 ) 
1376     {
1377       Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ]; 
1378#if H_MV5
1379       Bool shallBeButIsNotIncreasing = ( !inc  ) ; 
1380#else
1381       Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ; 
1382#endif
1383       if ( shallBeButIsNotIncreasing )
1384       {       
1385         printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
1386       }
1387#if H_MV5
1388       xConfirmPara( shallBeButIsNotIncreasing,  "DimensionIds shall be increasing within one dimension. " );
1389#else
1390       xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ),  "DimensionIds shall be increasing within one dimension. " );
1391#endif
1392     }
1393#endif
1394   }
1395 }
1396
1397#if H_MV5
1398 /// ViewId
1399 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." ); 
1400
1401  /// Layer sets
1402  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ; 
1403#else
1404  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ; 
1405#endif
1406  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1407  {
1408    if (lsIdx == 0)
1409    {
1410      xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 || m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1411    }
1412    for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1413    {
1414      xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 || m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than 64" ); 
1415    }
1416  }
1417
1418  // Output layer sets
1419  xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1420  for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1421  {   
1422    Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ]; 
1423    xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1424
1425    for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1426    {
1427      Bool isAlsoInLayerSet = false; 
1428      for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1429      {
1430        if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1431        {
1432          isAlsoInLayerSet = true; 
1433          break; 
1434        }       
1435      }
1436      xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1437    }
1438  }
1439  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" );
1440
1441  // Layer Dependencies 
1442  for (Int i = 0; i < m_numberOfLayers; i++ )
1443  {
1444    xConfirmPara( (i == 0)  && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." ); 
1445    xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." ); 
1446    for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1447    {
1448      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"); 
1449      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"); 
1450    }       
1451  } 
1452#endif
1453  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
1454  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1455  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1456  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
1457#if H_MV
1458  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1459  {
1460    xConfirmPara( m_iQP[layer] <  -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51,      "QP exceeds supported range (-QpBDOffsety to 51)" );
1461  }
1462#else
1463  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
1464#endif
1465  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6,          "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1466  xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6,              "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1467  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
1468  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
1469  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
1470  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
1471  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1472
1473  xConfirmPara( m_cbQpOffset < -12,   "Min. Chroma Cb QP Offset is -12" );
1474  xConfirmPara( m_cbQpOffset >  12,   "Max. Chroma Cb QP Offset is  12" );
1475  xConfirmPara( m_crQpOffset < -12,   "Min. Chroma Cr QP Offset is -12" );
1476  xConfirmPara( m_crQpOffset >  12,   "Max. Chroma Cr QP Offset is  12" );
1477
1478  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
1479  if (m_iDecodingRefreshType == 2)
1480  {
1481    xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
1482  }
1483  xConfirmPara( (m_uiMaxCUWidth  >> m_uiMaxCUDepth) < 4,                                    "Minimum partition width size should be larger than or equal to 8");
1484  xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4,                                    "Minimum partition height size should be larger than or equal to 8");
1485  xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
1486  xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
1487  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
1488  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
1489 
1490  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
1491  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
1492  xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth,                                        "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1493 
1494  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1495  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1496  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1497  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth  >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1498  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1499  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1500  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" );
1501  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1502  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" );
1503 
1504  xConfirmPara(  m_maxNumMergeCand < 1,  "MaxNumMergeCand must be 1 or greater.");
1505  xConfirmPara(  m_maxNumMergeCand > 5,  "MaxNumMergeCand must be 5 or smaller.");
1506
1507#if H_3D_ARP
1508  xConfirmPara( ( 0 != m_uiUseAdvResPred ) &&  ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1509#endif
1510#if ADAPTIVE_QP_SELECTION
1511#if H_MV
1512  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1513  {
1514    xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0,                                     "AdaptiveQpSelection must be disabled when QP < 0.");
1515  }
1516#else
1517  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
1518#endif
1519  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1520#endif
1521
1522  if( m_usePCM)
1523  {
1524    xConfirmPara(  m_uiPCMLog2MinSize < 3,                                      "PCMLog2MinSize must be 3 or greater.");
1525    xConfirmPara(  m_uiPCMLog2MinSize > 5,                                      "PCMLog2MinSize must be 5 or smaller.");
1526    xConfirmPara(  m_pcmLog2MaxSize > 5,                                        "PCMLog2MaxSize must be 5 or smaller.");
1527    xConfirmPara(  m_pcmLog2MaxSize < m_uiPCMLog2MinSize,                       "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1528  }
1529
1530  xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1531  if (m_sliceMode!=0)
1532  {
1533    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
1534  }
1535  xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1536  if (m_sliceSegmentMode!=0)
1537  {
1538    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
1539  }
1540 
1541  Bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
1542  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
1543
1544  //TODO:ChromaFmt assumes 4:2:0 below
1545  xConfirmPara( m_iSourceWidth  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1546  xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1547
1548  xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1549  xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1550
1551  xConfirmPara( m_confLeft   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1552  xConfirmPara( m_confRight  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1553  xConfirmPara( m_confTop    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1554  xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1555
1556#if H_3D
1557  xConfirmPara( m_pchCameraParameterFile    == 0                ,   "CameraParameterFile must be given");
1558  xConfirmPara( m_pchBaseViewCameraNumbers  == 0                ,   "BaseViewCameraNumbers must be given" );
1559  xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1560  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
1561#if H_3D_VSO
1562    if( m_bUseVSO )
1563    {
1564      xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
1565      xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
1566    }
1567#endif
1568#endif
1569  // max CU width and height should be power of 2
1570  UInt ui = m_uiMaxCUWidth;
1571  while(ui)
1572  {
1573    ui >>= 1;
1574    if( (ui & 1) == 1)
1575      xConfirmPara( ui != 1 , "Width should be 2^n");
1576  }
1577  ui = m_uiMaxCUHeight;
1578  while(ui)
1579  {
1580    ui >>= 1;
1581    if( (ui & 1) == 1)
1582      xConfirmPara( ui != 1 , "Height should be 2^n");
1583  }
1584
1585#if H_MV
1586  // validate that POC of same frame is identical across multiple layers
1587  Bool bErrorMvePoc = false;
1588  if( m_numberOfLayers > 1 )
1589  {
1590    for( Int k = 1; k < m_numberOfLayers; k++ )
1591    {
1592      for( Int i = 0; i < MAX_GOP; i++ )
1593      {
1594        if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1595        {
1596          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 );
1597          bErrorMvePoc = true;
1598        }
1599      }
1600    }
1601  }
1602  xConfirmPara( bErrorMvePoc,  "Invalid inter-layer POC structure given" );
1603
1604  // validate that baseview has no inter-view refs
1605  Bool bErrorIvpBase = false;
1606  for( Int i = 0; i < MAX_GOP; i++ )
1607  {
1608    if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1609    {
1610      printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1611      bErrorIvpBase = true;
1612    }
1613  }
1614  xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1615
1616  // validate inter-view refs
1617  Bool bErrorIvpEnhV = false;
1618  if( m_numberOfLayers > 1 )
1619  {
1620    for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1621    {
1622      for( Int i = 0; i < MAX_GOP+1; i++ )
1623      {
1624        GOPEntry gopEntry = m_GOPListMvc[layer][i]; 
1625        for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1626        {
1627          Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1628          if( ilPredLayerIdc < 0 || ilPredLayerIdc >= m_directRefLayers[layer].size() )
1629          {
1630            printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1631            bErrorIvpEnhV = true;
1632          }
1633          if( gopEntry.m_interViewRefPosL[0][j] < -1 || gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1634          {
1635            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 );
1636            bErrorIvpEnhV = true;
1637          }
1638          if( gopEntry.m_interViewRefPosL[1][j] < -1  || gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1639          {
1640            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 );
1641            bErrorIvpEnhV = true;
1642          }
1643        }
1644        if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1645        {
1646          if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1647          {
1648            printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1649            bErrorIvpEnhV = true;
1650          }
1651
1652          if( gopEntry.m_POC != 0 )
1653          {
1654            printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1655            bErrorIvpEnhV = true;
1656          }
1657
1658          if( gopEntry.m_temporalId != 0 )
1659          {
1660            printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1661            gopEntry.m_temporalId = 0;
1662          }
1663
1664          if( gopEntry.m_numRefPics != 0 )
1665          {
1666            printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1667            for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1668            {
1669              gopEntry.m_referencePics[j] = 0;
1670            }
1671            gopEntry.m_numRefPics = 0;
1672          }
1673
1674          if( gopEntry.m_interRPSPrediction )
1675          {
1676            printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1677            bErrorIvpEnhV = true;
1678          }
1679
1680          if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1681          {
1682            printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1683            bErrorIvpEnhV = true;
1684          }
1685
1686          if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1687          {
1688            gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1689          }
1690
1691          if( gopEntry.m_sliceType == 'P' )
1692          {
1693            if( gopEntry.m_numActiveRefLayerPics < 1 )
1694            {
1695              printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1696              bErrorIvpEnhV = true;
1697            }
1698            else
1699            {
1700              for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1701              {
1702                if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1703                {
1704                  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 );
1705                  bErrorIvpEnhV = true;
1706                }
1707              }
1708            }
1709          }
1710
1711          if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1712          {
1713            printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1714            bErrorIvpEnhV = true;
1715          }
1716        }
1717      }
1718    }
1719  }
1720  xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1721
1722  // validate temporal coding structure
1723  if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1724  {
1725    for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1726    {
1727      GOPEntry* m_GOPList            = m_GOPListMvc           [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1728      Int&      m_extraRPSs          = m_extraRPSsMvc         [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1729      Int&      m_maxTempLayer       = m_maxTempLayerMvc      [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1730      Int*      m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1731      Int*      m_numReorderPics     = m_numReorderPicsMvc    [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1732#endif
1733  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1734   * This permits the ability to omit a GOP structure specification */
1735  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1736    m_GOPList[0] = GOPEntry();
1737    m_GOPList[0].m_QPFactor = 1;
1738    m_GOPList[0].m_betaOffsetDiv2 = 0;
1739    m_GOPList[0].m_tcOffsetDiv2 = 0;
1740    m_GOPList[0].m_POC = 1;
1741    m_GOPList[0].m_numRefPicsActive = 4;
1742  }
1743 
1744  Bool verifiedGOP=false;
1745  Bool errorGOP=false;
1746  Int checkGOP=1;
1747  Int numRefs = 1;
1748  Int refList[MAX_NUM_REF_PICS+1];
1749  refList[0]=0;
1750  Bool isOK[MAX_GOP];
1751  for(Int i=0; i<MAX_GOP; i++) 
1752  {
1753    isOK[i]=false;
1754  }
1755  Int numOK=0;
1756  xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1757
1758  for(Int i=0; i<m_iGOPSize; i++)
1759  {
1760    if(m_GOPList[i].m_POC==m_iGOPSize)
1761    {
1762      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1763    }
1764  }
1765 
1766#if H_MV
1767  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1768#else
1769  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1770#endif
1771  {
1772    for(Int i=0; i<m_iGOPSize; i++)
1773    {
1774      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)" );
1775      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)" );
1776    }
1777  }
1778  m_extraRPSs=0;
1779  //start looping through frames in coding order until we can verify that the GOP structure is correct.
1780  while(!verifiedGOP&&!errorGOP) 
1781  {
1782    Int curGOP = (checkGOP-1)%m_iGOPSize;
1783    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
1784    if(m_GOPList[curGOP].m_POC<0) 
1785    {
1786#if H_MV
1787      printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1788#else
1789      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1790#endif
1791      errorGOP=true;
1792    }
1793    else 
1794    {
1795      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1796      Bool beforeI = false;
1797      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1798      {
1799        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1800        if(absPOC < 0)
1801        {
1802          beforeI=true;
1803        }
1804        else 
1805        {
1806          Bool found=false;
1807          for(Int j=0; j<numRefs; j++) 
1808          {
1809            if(refList[j]==absPOC) 
1810            {
1811              found=true;
1812              for(Int k=0; k<m_iGOPSize; k++)
1813              {
1814                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1815                {
1816                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1817                  {
1818                    m_GOPList[k].m_refPic = true;
1819                  }
1820                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1821                }
1822              }
1823            }
1824          }
1825          if(!found)
1826          {
1827#if H_MV
1828            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);
1829#else
1830            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1831#endif
1832            errorGOP=true;
1833          }
1834        }
1835      }
1836      if(!beforeI&&!errorGOP)
1837      {
1838        //all ref frames were present
1839        if(!isOK[curGOP]) 
1840        {
1841          numOK++;
1842          isOK[curGOP]=true;
1843          if(numOK==m_iGOPSize)
1844          {
1845            verifiedGOP=true;
1846          }
1847        }
1848      }
1849      else 
1850      {
1851        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1852        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1853        Int newRefs=0;
1854        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1855        {
1856          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1857          if(absPOC>=0)
1858          {
1859            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1860            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1861            newRefs++;
1862          }
1863        }
1864        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1865       
1866        for(Int offset = -1; offset>-checkGOP; offset--)
1867        {
1868          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1869          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1870          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1871          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1872          {
1873            Bool newRef=false;
1874            for(Int i=0; i<numRefs; i++)
1875            {
1876              if(refList[i]==offPOC)
1877              {
1878                newRef=true;
1879              }
1880            }
1881            for(Int i=0; i<newRefs; i++) 
1882            {
1883              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1884              {
1885                newRef=false;
1886              }
1887            }
1888            if(newRef) 
1889            {
1890              Int insertPoint=newRefs;
1891              //this picture can be added, find appropriate place in list and insert it.
1892              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1893              {
1894                m_GOPList[offGOP].m_refPic = true;
1895              }
1896              for(Int j=0; j<newRefs; j++)
1897              {
1898                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1899                {
1900                  insertPoint = j;
1901                  break;
1902                }
1903              }
1904              Int prev = offPOC-curPOC;
1905              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1906              for(Int j=insertPoint; j<newRefs+1; j++)
1907              {
1908                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1909                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1910                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1911                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1912                prevUsed=newUsed;
1913                prev=newPrev;
1914              }
1915              newRefs++;
1916            }
1917          }
1918          if(newRefs>=numPrefRefs)
1919          {
1920            break;
1921          }
1922        }
1923        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1924        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1925        if (m_extraRPSs == 0)
1926        {
1927          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1928          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1929        }
1930        else
1931        {
1932          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
1933          Int refPOC = m_GOPList[rIdx].m_POC;
1934          Int refPics = m_GOPList[rIdx].m_numRefPics;
1935          Int newIdc=0;
1936          for(Int i = 0; i<= refPics; i++) 
1937          {
1938            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
1939            Int absPOCref = refPOC+deltaPOC;
1940            Int refIdc = 0;
1941            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1942            {
1943              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1944              {
1945                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1946                {
1947                  refIdc = 1;
1948                }
1949                else
1950                {
1951                  refIdc = 2;
1952                }
1953              }
1954            }
1955            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1956            newIdc++;
1957          }
1958          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
1959          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1960          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 
1961        }
1962        curGOP=m_iGOPSize+m_extraRPSs;
1963        m_extraRPSs++;
1964      }
1965      numRefs=0;
1966      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1967      {
1968        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1969        if(absPOC >= 0) 
1970        {
1971          refList[numRefs]=absPOC;
1972          numRefs++;
1973        }
1974      }
1975      refList[numRefs]=curPOC;
1976      numRefs++;
1977    }
1978    checkGOP++;
1979  }
1980  xConfirmPara(errorGOP,"Invalid GOP structure given");
1981  m_maxTempLayer = 1;
1982  for(Int i=0; i<m_iGOPSize; i++) 
1983  {
1984    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
1985    {
1986      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
1987    }
1988    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
1989  }
1990  for(Int i=0; i<MAX_TLAYER; i++)
1991  {
1992    m_numReorderPics[i] = 0;
1993    m_maxDecPicBuffering[i] = 1;
1994  }
1995  for(Int i=0; i<m_iGOPSize; i++) 
1996  {
1997    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1998    {
1999      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2000    }
2001    Int highestDecodingNumberWithLowerPOC = 0; 
2002    for(Int j=0; j<m_iGOPSize; j++)
2003    {
2004      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2005      {
2006        highestDecodingNumberWithLowerPOC = j;
2007      }
2008    }
2009    Int numReorder = 0;
2010    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2011    {
2012      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 
2013        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2014      {
2015        numReorder++;
2016      }
2017    }   
2018    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2019    {
2020      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2021    }
2022  }
2023  for(Int i=0; i<MAX_TLAYER-1; i++) 
2024  {
2025    // a lower layer can not have higher value of m_numReorderPics than a higher layer
2026    if(m_numReorderPics[i+1] < m_numReorderPics[i])
2027    {
2028      m_numReorderPics[i+1] = m_numReorderPics[i];
2029    }
2030    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2031    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2032    {
2033      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2034    }
2035    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2036    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2037    {
2038      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2039    }
2040  }
2041
2042
2043  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
2044  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2045  {
2046    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2047  }
2048
2049  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2050  { 
2051    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
2052    if(tileFlag)
2053    {
2054      Int maxTileWidth = 0;
2055      Int maxTileHeight = 0;
2056      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2057      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2058      if(m_iUniformSpacingIdr)
2059      {
2060        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2061        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2062        // if only the last tile-row is one treeblock higher than the others
2063        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2064        if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2065        {
2066          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2067        }     
2068        // if only the last tile-column is one treeblock wider than the others
2069        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
2070        if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2071        {
2072          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2073        }
2074      }
2075      else // not uniform spacing
2076      {
2077        if(m_iNumColumnsMinus1<1)
2078        {
2079          maxTileWidth = m_iSourceWidth;
2080        }
2081        else
2082        {
2083          Int accColumnWidth = 0;
2084          for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2085          {
2086            maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2087            accColumnWidth += m_pColumnWidth[col];
2088          }
2089          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
2090        }
2091        if(m_iNumRowsMinus1<1)
2092        {
2093          maxTileHeight = m_iSourceHeight;
2094        }
2095        else
2096        {
2097          Int accRowHeight = 0;
2098          for(Int row=0; row<(m_iNumRowsMinus1); row++)
2099          {
2100            maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2101            accRowHeight += m_pRowHeight[row];
2102          }
2103          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
2104        }
2105      }
2106      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2107      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2108    }
2109    else if(m_iWaveFrontSynchro)
2110    {
2111      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2112    }
2113    else if(m_sliceMode == 1)
2114    {
2115      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2116    }
2117    else
2118    {
2119      m_minSpatialSegmentationIdc = 0;
2120    }
2121  }
2122  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2123  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2124  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2125
2126  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2127
2128  if (m_toneMappingInfoSEIEnabled)
2129  {
2130    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2131    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2132    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2133    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2134    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2135    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2136    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2137  }
2138
2139#if RATE_CONTROL_LAMBDA_DOMAIN
2140  if ( m_RCEnableRateControl )
2141  {
2142    if ( m_RCForceIntraQP )
2143    {
2144      if ( m_RCInitialQP == 0 )
2145      {
2146        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2147        m_RCForceIntraQP = false;
2148      }
2149    }
2150    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2151  }
2152#else
2153  if(m_enableRateCtrl)
2154  {
2155    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
2156    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
2157    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
2158
2159    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2160
2161    m_iMaxDeltaQP       = MAX_DELTA_QP;
2162    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
2163  }
2164#endif
2165#if H_MV5
2166#if H_MV
2167  // VPS VUI
2168  for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2169  { 
2170    for (Int j = 0; j < MAX_TLAYER; j++)
2171    {   
2172      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" );
2173      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" );
2174      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" );
2175      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" );
2176    }
2177  }
2178  // todo: replace value of 100 with requirement in spec
2179  for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2180  { 
2181    for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2182    {   
2183      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" );
2184      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" );
2185    }
2186  }
2187#endif
2188#endif
2189
2190  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2191
2192  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2193  if (m_framePackingSEIEnabled)
2194  {
2195    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2196  }
2197
2198#if H_MV
2199  }
2200  }
2201#endif
2202#undef xConfirmPara
2203  if (check_failed)
2204  {
2205    exit(EXIT_FAILURE);
2206  }
2207}
2208
2209/** \todo use of global variables should be removed later
2210 */
2211Void TAppEncCfg::xSetGlobal()
2212{
2213  // set max CU width & height
2214  g_uiMaxCUWidth  = m_uiMaxCUWidth;
2215  g_uiMaxCUHeight = m_uiMaxCUHeight;
2216 
2217  // compute actual CU depth with respect to config depth and max transform size
2218  g_uiAddCUDepth  = 0;
2219  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
2220 
2221  m_uiMaxCUDepth += g_uiAddCUDepth;
2222  g_uiAddCUDepth++;
2223  g_uiMaxCUDepth = m_uiMaxCUDepth;
2224 
2225  // set internal bit-depth and constants
2226  g_bitDepthY = m_internalBitDepthY;
2227  g_bitDepthC = m_internalBitDepthC;
2228 
2229  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2230  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2231}
2232
2233Void TAppEncCfg::xPrintParameter()
2234{
2235  printf("\n");
2236#if H_MV
2237  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2238  {
2239    printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
2240  }
2241#else
2242  printf("Input          File          : %s\n", m_pchInputFile          );
2243#endif
2244  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
2245#if H_MV
2246  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2247  {
2248    printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
2249  }
2250#else
2251  printf("Reconstruction File          : %s\n", m_pchReconFile          );
2252#endif
2253#if H_MV
2254#if H_MV5
2255  xPrintParaVector( "ViewIdVal"     , m_viewId ); 
2256  xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex ); 
2257#else
2258  xPrintParaVector( "ViewId", m_viewId ); 
2259#endif
2260#endif
2261#if H_3D
2262  xPrintParaVector( "DepthFlag", m_depthFlag ); 
2263  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2264#endif
2265#if H_MV 
2266  xPrintParaVector( "QP"               , m_fQP                ); 
2267  xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable ); 
2268  xPrintParaVector( "SAO"              , m_bUseSAO            ); 
2269#endif
2270  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2271  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2272  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2273  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2274  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2275  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
2276  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2277  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
2278  printf("Motion search range          : %d\n", m_iSearchRange );
2279  printf("Intra period                 : %d\n", m_iIntraPeriod );
2280  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
2281#if !H_MV
2282  printf("QP                           : %5.2f\n", m_fQP );
2283#endif
2284  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
2285
2286  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
2287  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
2288
2289  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2290  printf("GOP size                     : %d\n", m_iGOPSize );
2291  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2292  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2293#if RATE_CONTROL_LAMBDA_DOMAIN
2294  printf("RateControl                  : %d\n", m_RCEnableRateControl );
2295  if(m_RCEnableRateControl)
2296  {
2297    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2298    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
2299    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
2300    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
2301    printf("InitialQP                    : %d\n", m_RCInitialQP );
2302    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
2303  }
2304#else
2305  printf("RateControl                  : %d\n", m_enableRateCtrl);
2306  if(m_enableRateCtrl)
2307  {
2308    printf("TargetBitrate                : %d\n", m_targetBitrate);
2309    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
2310  }
2311#endif
2312  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
2313#if H_3D
2314  printf("BaseViewCameraNumbers        : %s\n", m_pchBaseViewCameraNumbers ); 
2315  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2316#if H_3D_VSO
2317  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
2318
2319  if ( m_bUseVSO )
2320  {   
2321    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
2322    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
2323    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
2324    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
2325    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);
2326    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);
2327    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
2328    if ( m_bUseWVSO )
2329    printf("Dist. Weights (VSO/VSD/SAD)  : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2330  }
2331#endif //HHI_VSO
2332#endif //H_3D
2333  printf("\n");
2334#if H_MV
2335  printf("TOOL CFG General: ");
2336#else
2337  printf("TOOL CFG: ");
2338#endif
2339  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
2340  printf("HAD:%d ", m_bUseHADME           );
2341  printf("SRD:%d ", m_bUseSBACRD          );
2342  printf("RDQ:%d ", m_useRDOQ            );
2343  printf("RDQTS:%d ", m_useRDOQTS        );
2344  printf("RDpenalty:%d ", m_rdPenalty  );
2345  printf("SQP:%d ", m_uiDeltaQpRD         );
2346  printf("ASR:%d ", m_bUseASR             );
2347  printf("FEN:%d ", m_bUseFastEnc         );
2348  printf("ECU:%d ", m_bUseEarlyCU         );
2349  printf("FDM:%d ", m_useFastDecisionForMerge );
2350  printf("CFM:%d ", m_bUseCbfFastMode         );
2351  printf("ESD:%d ", m_useEarlySkipDetection  );
2352  printf("RQT:%d ", 1     );
2353  printf("TransformSkip:%d ",     m_useTransformSkip              );
2354  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
2355  printf("Slice: M=%d ", m_sliceMode);
2356  if (m_sliceMode!=0)
2357  {
2358    printf("A=%d ", m_sliceArgument);
2359  }
2360  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2361  if (m_sliceSegmentMode!=0)
2362  {
2363    printf("A=%d ", m_sliceSegmentArgument);
2364  }
2365  printf("CIP:%d ", m_bUseConstrainedIntraPred);
2366#if !H_MV
2367  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2368#endif
2369  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2370  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2371
2372  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2373  printf("WPP:%d ", (Int)m_useWeightedPred);
2374  printf("WPB:%d ", (Int)m_useWeightedBiPred);
2375  printf("PME:%d ", m_log2ParallelMergeLevel);
2376  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2377          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2378  printf(" ScalingList:%d ", m_useScalingListId );
2379  printf("TMVPMode:%d ", m_TMVPModeId     );
2380#if ADAPTIVE_QP_SELECTION
2381  printf("AQpS:%d ", m_bUseAdaptQpSelect   );
2382#endif
2383
2384  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2385  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2386#if H_3D_VSO
2387  printf("VSO:%d ", m_bUseVSO   );
2388  printf("WVSO:%d ", m_bUseWVSO ); 
2389#endif
2390#if H_3D_QTLPC
2391  printf("QTL:%d ", m_bUseQTL);
2392  printf("PC:%d " , m_bUsePC );
2393#endif
2394#if H_3D_IV_MERGE
2395  printf("IvMvPred:%d ", m_ivMvPredFlag );
2396#endif
2397#if H_3D_ARP
2398  printf(" ARP:%d  ", m_uiUseAdvResPred  );
2399#endif
2400#if H_3D_IC
2401  printf( "IlluCompEnable: %d %d ", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0 );
2402#endif
2403#if H_3D_NBDV_REF
2404  printf("DepthRefinement:%d ", m_depthRefinementFlag ); 
2405#endif
2406#if H_3D_VSP
2407  printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2408#endif
2409#if H_3D
2410  printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0  );
2411#endif
2412#if H_3D_DIM
2413  printf("DMM:%d ", m_useDMM );
2414  printf("RBC:%d ", m_useRBC );
2415  printf("SDC:%d ", m_useSDC );
2416  printf("DLT:%d ", m_useDLT );
2417#endif
2418#if LGE_INTER_SDC_E0156
2419  printf( "interSDC: %d ", m_bDepthInterSDCFlag ? 1 : 0 );
2420#endif
2421  printf("\n\n"); 
2422
2423  fflush(stdout);
2424}
2425
2426Bool confirmPara(Bool bflag, const Char* message)
2427{
2428  if (!bflag)
2429    return false;
2430 
2431  printf("Error: %s\n",message);
2432  return true;
2433}
2434
2435//! \}
Note: See TracBrowser for help on using the repository browser.