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

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