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

Last change on this file since 483 was 446, checked in by tech, 12 years ago

Added missing parts.

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