source: 3DVCSoftware/branches/HTM-8.2-dev2-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp @ 696

Last change on this file since 696 was 696, checked in by samsung-htm, 11 years ago

Integration of F0150: MPI candidate in depth merge mode list construction

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