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

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

Cleanup part 3

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