source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 1179

Last change on this file since 1179 was 1179, checked in by tech, 9 years ago

Merged branch 13.1-dev0@1178.

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