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

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

Merged HTM-DEV-0.3-dev1 Rev. 520.

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