source: 3DVCSoftware/branches/HTM-9.2-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 768

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

Further fixes.

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