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

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

Merged branch/9.2-dev0@722.

  • 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#else
1747  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1748#endif
1749    m_GOPList[0] = GOPEntry();
1750    m_GOPList[0].m_QPFactor = 1;
1751    m_GOPList[0].m_betaOffsetDiv2 = 0;
1752    m_GOPList[0].m_tcOffsetDiv2 = 0;
1753    m_GOPList[0].m_POC = 1;
1754    m_GOPList[0].m_numRefPicsActive = 4;
1755  }
1756 
1757  Bool verifiedGOP=false;
1758  Bool errorGOP=false;
1759  Int checkGOP=1;
1760  Int numRefs = m_isField ? 2 : 1;
1761  Int refList[MAX_NUM_REF_PICS+1];
1762  refList[0]=0;
1763  if(m_isField)
1764  {
1765    refList[1] = 1;
1766  }
1767  Bool isOK[MAX_GOP];
1768  for(Int i=0; i<MAX_GOP; i++) 
1769  {
1770    isOK[i]=false;
1771  }
1772  Int numOK=0;
1773#if H_MV
1774  xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" ); 
1775#else
1776xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1777#endif
1778
1779  for(Int i=0; i<m_iGOPSize; i++)
1780  {
1781    if(m_GOPList[i].m_POC==m_iGOPSize)
1782    {
1783      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1784    }
1785  }
1786 
1787#if H_MV
1788  if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1789#else
1790  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1791#endif
1792  {
1793    for(Int i=0; i<m_iGOPSize; i++)
1794    {
1795      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)" );
1796      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)" );
1797    }
1798  }
1799  m_extraRPSs=0;
1800  //start looping through frames in coding order until we can verify that the GOP structure is correct.
1801  while(!verifiedGOP&&!errorGOP) 
1802  {
1803    Int curGOP = (checkGOP-1)%m_iGOPSize;
1804    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
1805    if(m_GOPList[curGOP].m_POC<0) 
1806    {
1807#if H_MV
1808      printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1809#else
1810      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1811#endif
1812      errorGOP=true;
1813    }
1814    else 
1815    {
1816      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1817      Bool beforeI = false;
1818      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1819      {
1820        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1821        if(absPOC < 0)
1822        {
1823          beforeI=true;
1824        }
1825        else 
1826        {
1827          Bool found=false;
1828          for(Int j=0; j<numRefs; j++) 
1829          {
1830            if(refList[j]==absPOC) 
1831            {
1832              found=true;
1833              for(Int k=0; k<m_iGOPSize; k++)
1834              {
1835                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1836                {
1837                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1838                  {
1839                    m_GOPList[k].m_refPic = true;
1840                  }
1841                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1842                }
1843              }
1844            }
1845          }
1846          if(!found)
1847          {
1848#if H_MV
1849            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);
1850#else
1851            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1852#endif
1853            errorGOP=true;
1854          }
1855        }
1856      }
1857      if(!beforeI&&!errorGOP)
1858      {
1859        //all ref frames were present
1860        if(!isOK[curGOP]) 
1861        {
1862          numOK++;
1863          isOK[curGOP]=true;
1864          if(numOK==m_iGOPSize)
1865          {
1866            verifiedGOP=true;
1867          }
1868        }
1869      }
1870      else 
1871      {
1872        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1873        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1874        Int newRefs=0;
1875        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1876        {
1877          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1878          if(absPOC>=0)
1879          {
1880            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1881            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1882            newRefs++;
1883          }
1884        }
1885        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1886       
1887        for(Int offset = -1; offset>-checkGOP; offset--)
1888        {
1889          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1890          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1891          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1892          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1893          {
1894            Bool newRef=false;
1895            for(Int i=0; i<numRefs; i++)
1896            {
1897              if(refList[i]==offPOC)
1898              {
1899                newRef=true;
1900              }
1901            }
1902            for(Int i=0; i<newRefs; i++) 
1903            {
1904              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1905              {
1906                newRef=false;
1907              }
1908            }
1909            if(newRef) 
1910            {
1911              Int insertPoint=newRefs;
1912              //this picture can be added, find appropriate place in list and insert it.
1913              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1914              {
1915                m_GOPList[offGOP].m_refPic = true;
1916              }
1917              for(Int j=0; j<newRefs; j++)
1918              {
1919                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1920                {
1921                  insertPoint = j;
1922                  break;
1923                }
1924              }
1925              Int prev = offPOC-curPOC;
1926              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1927              for(Int j=insertPoint; j<newRefs+1; j++)
1928              {
1929                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1930                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1931                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1932                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1933                prevUsed=newUsed;
1934                prev=newPrev;
1935              }
1936              newRefs++;
1937            }
1938          }
1939          if(newRefs>=numPrefRefs)
1940          {
1941            break;
1942          }
1943        }
1944        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1945        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1946        if (m_extraRPSs == 0)
1947        {
1948          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1949          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1950        }
1951        else
1952        {
1953          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
1954          Int refPOC = m_GOPList[rIdx].m_POC;
1955          Int refPics = m_GOPList[rIdx].m_numRefPics;
1956          Int newIdc=0;
1957          for(Int i = 0; i<= refPics; i++) 
1958          {
1959            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
1960            Int absPOCref = refPOC+deltaPOC;
1961            Int refIdc = 0;
1962            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1963            {
1964              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1965              {
1966                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1967                {
1968                  refIdc = 1;
1969                }
1970                else
1971                {
1972                  refIdc = 2;
1973                }
1974              }
1975            }
1976            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1977            newIdc++;
1978          }
1979          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
1980          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1981          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 
1982        }
1983        curGOP=m_iGOPSize+m_extraRPSs;
1984        m_extraRPSs++;
1985      }
1986      numRefs=0;
1987      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
1988      {
1989        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1990        if(absPOC >= 0) 
1991        {
1992          refList[numRefs]=absPOC;
1993          numRefs++;
1994        }
1995      }
1996      refList[numRefs]=curPOC;
1997      numRefs++;
1998    }
1999    checkGOP++;
2000  }
2001  xConfirmPara(errorGOP,"Invalid GOP structure given");
2002  m_maxTempLayer = 1;
2003  for(Int i=0; i<m_iGOPSize; i++) 
2004  {
2005    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2006    {
2007      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2008    }
2009    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
2010  }
2011  for(Int i=0; i<MAX_TLAYER; i++)
2012  {
2013    m_numReorderPics[i] = 0;
2014    m_maxDecPicBuffering[i] = 1;
2015  }
2016  for(Int i=0; i<m_iGOPSize; i++) 
2017  {
2018    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2019    {
2020      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2021    }
2022    Int highestDecodingNumberWithLowerPOC = 0; 
2023    for(Int j=0; j<m_iGOPSize; j++)
2024    {
2025      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2026      {
2027        highestDecodingNumberWithLowerPOC = j;
2028      }
2029    }
2030    Int numReorder = 0;
2031    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2032    {
2033      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 
2034        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2035      {
2036        numReorder++;
2037      }
2038    }   
2039    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2040    {
2041      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2042    }
2043  }
2044  for(Int i=0; i<MAX_TLAYER-1; i++) 
2045  {
2046    // a lower layer can not have higher value of m_numReorderPics than a higher layer
2047    if(m_numReorderPics[i+1] < m_numReorderPics[i])
2048    {
2049      m_numReorderPics[i+1] = m_numReorderPics[i];
2050    }
2051    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2052    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2053    {
2054      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2055    }
2056    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2057    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2058    {
2059      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2060    }
2061  }
2062
2063
2064  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
2065  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2066  {
2067    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2068  }
2069
2070  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2071  { 
2072    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
2073    if(tileFlag)
2074    {
2075      Int maxTileWidth = 0;
2076      Int maxTileHeight = 0;
2077      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2078      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2079      if(m_iUniformSpacingIdr)
2080      {
2081        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2082        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2083        // if only the last tile-row is one treeblock higher than the others
2084        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2085        if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2086        {
2087          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2088        }     
2089        // if only the last tile-column is one treeblock wider than the others
2090        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
2091        if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2092        {
2093          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2094        }
2095      }
2096      else // not uniform spacing
2097      {
2098        if(m_iNumColumnsMinus1<1)
2099        {
2100          maxTileWidth = m_iSourceWidth;
2101        }
2102        else
2103        {
2104          Int accColumnWidth = 0;
2105          for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2106          {
2107            maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2108            accColumnWidth += m_pColumnWidth[col];
2109          }
2110          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
2111        }
2112        if(m_iNumRowsMinus1<1)
2113        {
2114          maxTileHeight = m_iSourceHeight;
2115        }
2116        else
2117        {
2118          Int accRowHeight = 0;
2119          for(Int row=0; row<(m_iNumRowsMinus1); row++)
2120          {
2121            maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2122            accRowHeight += m_pRowHeight[row];
2123          }
2124          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
2125        }
2126      }
2127      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2128      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2129    }
2130    else if(m_iWaveFrontSynchro)
2131    {
2132      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2133    }
2134    else if(m_sliceMode == 1)
2135    {
2136      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2137    }
2138    else
2139    {
2140      m_minSpatialSegmentationIdc = 0;
2141    }
2142  }
2143  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2144  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2145  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2146
2147  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2148
2149  if (m_toneMappingInfoSEIEnabled)
2150  {
2151    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2152    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2153    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2154    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2155    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2156    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2157    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2158  }
2159
2160#if RATE_CONTROL_LAMBDA_DOMAIN
2161  if ( m_RCEnableRateControl )
2162  {
2163    if ( m_RCForceIntraQP )
2164    {
2165      if ( m_RCInitialQP == 0 )
2166      {
2167        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2168        m_RCForceIntraQP = false;
2169      }
2170    }
2171    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2172  }
2173#else
2174  if(m_enableRateCtrl)
2175  {
2176    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
2177    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
2178    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
2179
2180    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2181
2182#if !KWU_FIX_URQ
2183    m_iMaxDeltaQP       = MAX_DELTA_QP;
2184#endif
2185    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
2186  }
2187#endif
2188#if H_MV
2189  // VPS VUI
2190  for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2191  { 
2192    for (Int j = 0; j < MAX_TLAYER; j++)
2193    {   
2194      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" );
2195      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" );
2196      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" );
2197      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" );
2198    }
2199  }
2200  // todo: replace value of 100 with requirement in spec
2201  for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2202  { 
2203    for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2204    {   
2205      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" );
2206      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" );
2207    }
2208  }
2209#endif
2210
2211  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2212
2213  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2214  if (m_framePackingSEIEnabled)
2215  {
2216    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2217  }
2218
2219#if H_MV
2220  }
2221  }
2222#endif
2223#undef xConfirmPara
2224  if (check_failed)
2225  {
2226    exit(EXIT_FAILURE);
2227  }
2228}
2229
2230/** \todo use of global variables should be removed later
2231 */
2232Void TAppEncCfg::xSetGlobal()
2233{
2234  // set max CU width & height
2235  g_uiMaxCUWidth  = m_uiMaxCUWidth;
2236  g_uiMaxCUHeight = m_uiMaxCUHeight;
2237 
2238  // compute actual CU depth with respect to config depth and max transform size
2239  g_uiAddCUDepth  = 0;
2240  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
2241 
2242  m_uiMaxCUDepth += g_uiAddCUDepth;
2243  g_uiAddCUDepth++;
2244  g_uiMaxCUDepth = m_uiMaxCUDepth;
2245 
2246  // set internal bit-depth and constants
2247  g_bitDepthY = m_internalBitDepthY;
2248  g_bitDepthC = m_internalBitDepthC;
2249 
2250  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2251  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2252}
2253
2254Void TAppEncCfg::xPrintParameter()
2255{
2256  printf("\n");
2257#if H_MV
2258  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2259  {
2260    printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
2261  }
2262#else
2263  printf("Input          File          : %s\n", m_pchInputFile          );
2264#endif
2265  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
2266#if H_MV
2267  for( Int layer = 0; layer < m_numberOfLayers; layer++)
2268  {
2269    printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
2270  }
2271#else
2272  printf("Reconstruction File          : %s\n", m_pchReconFile          );
2273#endif
2274#if H_MV
2275  xPrintParaVector( "ViewIdVal"     , m_viewId ); 
2276  xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex ); 
2277#endif
2278#if H_3D
2279  xPrintParaVector( "DepthFlag", m_depthFlag ); 
2280  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2281#endif
2282#if H_MV 
2283  xPrintParaVector( "QP"               , m_fQP                ); 
2284  xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable ); 
2285  xPrintParaVector( "SAO"              , m_bUseSAO            ); 
2286#endif
2287  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2288  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2289  if (m_isField)
2290  {
2291    printf("Frame/Field          : Field based coding\n");
2292    printf("Field index          : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2293    if (m_isTopFieldFirst)
2294    {
2295      printf("Field Order            : Top field first\n");
2296    }
2297    else
2298    {
2299      printf("Field Order            : Bottom field first\n");
2300    }
2301  }
2302  else
2303  {
2304    printf("Frame/Field                  : Frame based coding\n");
2305  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2306  }
2307  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2308  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2309  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
2310  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2311  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
2312  printf("Motion search range          : %d\n", m_iSearchRange );
2313#if H_MV
2314  xPrintParaVector( "Intra period", m_iIntraPeriod );
2315#else
2316  printf("Intra period                 : %d\n", m_iIntraPeriod );
2317#endif
2318  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
2319#if !H_MV
2320  printf("QP                           : %5.2f\n", m_fQP );
2321#endif
2322  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
2323
2324  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
2325  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
2326
2327  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2328  printf("GOP size                     : %d\n", m_iGOPSize );
2329  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2330  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2331#if RATE_CONTROL_LAMBDA_DOMAIN
2332  printf("RateControl                  : %d\n", m_RCEnableRateControl );
2333  if(m_RCEnableRateControl)
2334  {
2335    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2336    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
2337    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
2338    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
2339    printf("InitialQP                    : %d\n", m_RCInitialQP );
2340    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
2341
2342#if KWU_RC_MADPRED_E0227
2343    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
2344#endif
2345#if KWU_RC_VIEWRC_E0227
2346    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
2347    if(m_viewWiseRateCtrl)
2348    {
2349
2350      printf("ViewWiseTargetBits           : ");
2351      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2352        printf("%d ", m_viewTargetBits[i]);
2353      printf("\n");
2354    }
2355    else
2356    {
2357      printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
2358    }
2359#endif
2360  }
2361#else
2362  printf("RateControl                  : %d\n", m_enableRateCtrl);
2363  if(m_enableRateCtrl)
2364  {
2365    printf("TargetBitrate                : %d\n", m_targetBitrate);
2366    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
2367
2368#if KWU_RC_MADPRED_E0227
2369    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
2370#endif
2371#if KWU_RC_VIEWRC_E0227
2372    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
2373    if(m_viewWiseRateCtrl)
2374    {
2375
2376      printf("ViewWiseTargetBits           : ");
2377      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2378        printf("%d ", m_viewTargetBits[i]);
2379      printf("\n");
2380    }
2381    else
2382    {
2383      printf("TargetBitrate                : %d\n", m_targetBitrate );
2384    }
2385#endif
2386  }
2387#endif
2388  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
2389#if H_3D
2390  printf("BaseViewCameraNumbers        : %s\n", m_pchBaseViewCameraNumbers ); 
2391  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2392#if H_3D_VSO
2393  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
2394
2395  if ( m_bUseVSO )
2396  {   
2397    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
2398    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
2399    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
2400    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
2401    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);
2402    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);
2403    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
2404    if ( m_bUseWVSO )
2405    printf("Dist. Weights (VSO/VSD/SAD)  : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2406  }
2407#endif //HHI_VSO
2408#endif //H_3D
2409  printf("\n");
2410#if H_MV
2411  printf("TOOL CFG General: ");
2412#else
2413  printf("TOOL CFG: ");
2414#endif
2415  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
2416  printf("HAD:%d ", m_bUseHADME           );
2417  printf("SRD:%d ", m_bUseSBACRD          );
2418  printf("RDQ:%d ", m_useRDOQ            );
2419  printf("RDQTS:%d ", m_useRDOQTS        );
2420  printf("RDpenalty:%d ", m_rdPenalty  );
2421  printf("SQP:%d ", m_uiDeltaQpRD         );
2422  printf("ASR:%d ", m_bUseASR             );
2423  printf("FEN:%d ", m_bUseFastEnc         );
2424  printf("ECU:%d ", m_bUseEarlyCU         );
2425  printf("FDM:%d ", m_useFastDecisionForMerge );
2426  printf("CFM:%d ", m_bUseCbfFastMode         );
2427  printf("ESD:%d ", m_useEarlySkipDetection  );
2428  printf("RQT:%d ", 1     );
2429  printf("TransformSkip:%d ",     m_useTransformSkip              );
2430  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
2431  printf("Slice: M=%d ", m_sliceMode);
2432  if (m_sliceMode!=0)
2433  {
2434    printf("A=%d ", m_sliceArgument);
2435  }
2436  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2437  if (m_sliceSegmentMode!=0)
2438  {
2439    printf("A=%d ", m_sliceSegmentArgument);
2440  }
2441  printf("CIP:%d ", m_bUseConstrainedIntraPred);
2442#if !H_MV
2443  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2444#endif
2445  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2446  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2447
2448  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2449  printf("WPP:%d ", (Int)m_useWeightedPred);
2450  printf("WPB:%d ", (Int)m_useWeightedBiPred);
2451  printf("PME:%d ", m_log2ParallelMergeLevel);
2452  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2453          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2454  printf(" ScalingList:%d ", m_useScalingListId );
2455  printf("TMVPMode:%d ", m_TMVPModeId     );
2456#if ADAPTIVE_QP_SELECTION
2457  printf("AQpS:%d ", m_bUseAdaptQpSelect   );
2458#endif
2459
2460  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2461  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2462#if H_3D_VSO
2463  printf("VSO:%d ", m_bUseVSO   );
2464  printf("WVSO:%d ", m_bUseWVSO ); 
2465#endif
2466#if H_3D_QTLPC
2467  printf("QTL:%d ", m_bUseQTL);
2468  printf("PC:%d " , m_bUsePC );
2469#endif
2470#if H_3D_IV_MERGE
2471  printf("IvMvPred:%d %d", m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2472#if H_3D_SPIVMP
2473  printf(" SubPULog2Size:%d  " , m_iSubPULog2Size  );
2474#endif
2475#endif
2476#if H_3D_ARP
2477  printf(" ARP:%d  ", m_uiUseAdvResPred  );
2478#endif
2479#if H_3D_IC
2480  printf( "IlluCompEnable: %d ", m_abUseIC);
2481#endif
2482#if H_3D_NBDV_REF
2483  printf("DepthRefinement:%d ", m_depthRefinementFlag ); 
2484#endif
2485#if H_3D_VSP
2486  printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2487#endif
2488#if H_3D
2489  printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0  );
2490#endif
2491#if H_3D_DIM
2492  printf("DMM:%d ", m_useDMM );
2493  printf("SDC:%d ", m_useSDC );
2494  printf("DLT:%d ", m_useDLT );
2495#endif
2496#if H_3D_INTER_SDC
2497  printf( "interSDC: %d ", m_bDepthInterSDCFlag ? 1 : 0 );
2498#endif
2499#if H_3D_IV_MERGE
2500  printf( "MPI: %d ", m_bMPIFlag ? 1 : 0 );
2501#endif
2502  printf("\n\n"); 
2503
2504  fflush(stdout);
2505}
2506
2507Bool confirmPara(Bool bflag, const Char* message)
2508{
2509  if (!bflag)
2510    return false;
2511 
2512  printf("Error: %s\n",message);
2513  return true;
2514}
2515
2516//! \}
Note: See TracBrowser for help on using the repository browser.