source: 3DVCSoftware/tags/HTM-14.1/source/App/TAppEncoder/TAppEncCfg.cpp

Last change on this file was 1196, checked in by tech, 10 years ago

Merged 14.0-dev0@1187.

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