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

Last change on this file since 758 was 738, checked in by tech, 10 years ago

Merged HTM-9.0-dev0@731. (MV-HEVC 6 HLS)

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