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

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

Merged DEV3 ( branch HTM-8.2-dev3-Samsung@699 )

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