source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncCfg.cpp @ 504

Last change on this file since 504 was 504, checked in by zhang, 11 years ago

Merge Dev2.a to Dev2 and simulation results updated

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