Changeset 608 in 3DVCSoftware for trunk/source/App/TAppEncoder


Ignore:
Timestamp:
1 Sep 2013, 22:47:26 (11 years ago)
Author:
tech
Message:

Merged DEV-2.0-dev0@604.

Location:
trunk/source/App/TAppEncoder
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/App/TAppEncoder/TAppEncCfg.cpp

    r443 r608  
    44 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4242#include "TLibCommon/TComRom.h"
    4343#include "TAppEncCfg.h"
     44
     45static istream& operator>>(istream &, Level::Name &);
     46static istream& operator>>(istream &, Level::Tier &);
     47static istream& operator>>(istream &, Profile::Name &);
     48
    4449#include "TAppCommon/program_options_lite.h"
    45 
     50#include "TLibEncoder/TEncRateCtrl.h"
    4651#ifdef WIN32
    4752#define strdup _strdup
     
    5358//! \ingroup TAppEncoder
    5459//! \{
    55 
    56 /* configuration helper funcs */
    57 void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg);
    58 void doOldStyleCmdlineOff(po::Options& opts, const std::string& arg);
    59 
    60 // ====================================================================================================================
    61 // Local constants
    62 // ====================================================================================================================
    63 
    64 /// max value of source padding size
    65 /** \todo replace it by command line option
    66  */
    67 #define MAX_PAD_SIZE                16
    6860
    6961// ====================================================================================================================
     
    7264
    7365TAppEncCfg::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()
    7477{
     78#if !H_MV
    7579  m_aidQP = NULL;
    76   m_aidQPdepth = NULL;
     80#endif
     81  m_startOfCodedInterval = NULL;
     82  m_codedPivotValue = NULL;
     83  m_targetPivotValue = NULL;
    7784}
    7885
    7986TAppEncCfg::~TAppEncCfg()
    8087{
    81   if ( m_aidQP )
    82   {
    83     delete[] m_aidQP; m_aidQP = NULL;
    84   }
    85 
    86   if ( m_aidQPdepth )
    87   {
    88     delete[] m_aidQPdepth; m_aidQPdepth = NULL;
    89   }
    90 
     88#if H_MV
     89  for( Int layer = 0; layer < m_aidQP.size(); layer++ )
     90  {
     91    if ( m_aidQP[layer] != NULL )
     92    {
     93      delete[] m_aidQP[layer];
     94      m_aidQP[layer] = NULL;
     95    }
     96  }
    9197  for(Int i = 0; i< m_pchInputFileList.size(); i++ )
    9298  {
     
    94100      free (m_pchInputFileList[i]);
    95101  }
    96   for(Int i = 0; i< m_pchDepthInputFileList.size(); i++ )
    97   {
    98     if ( m_pchDepthInputFileList[i] != NULL )
    99       free (m_pchDepthInputFileList[i]);
    100   }
     102#else
     103  if ( m_aidQP )
     104  {
     105    delete[] m_aidQP;
     106  }
     107#endif
     108  if ( m_startOfCodedInterval )
     109  {
     110    delete[] m_startOfCodedInterval;
     111    m_startOfCodedInterval = NULL;
     112  }
     113   if ( m_codedPivotValue )
     114  {
     115    delete[] m_codedPivotValue;
     116    m_codedPivotValue = NULL;
     117  }
     118  if ( m_targetPivotValue )
     119  {
     120    delete[] m_targetPivotValue;
     121    m_targetPivotValue = NULL;
     122  }
     123#if !H_MV
     124  free(m_pchInputFile);
     125#endif
     126  free(m_pchBitstreamFile);
     127#if H_MV
    101128  for(Int i = 0; i< m_pchReconFileList.size(); i++ )
    102129  {
     
    104131      free (m_pchReconFileList[i]);
    105132  }
    106   for(Int i = 0; i< m_pchDepthReconFileList.size(); i++ )
    107   {
    108     if ( m_pchDepthReconFileList[i] != NULL )
    109       free (m_pchDepthReconFileList[i]);
    110   }
    111   if (m_pchBitstreamFile != NULL)
    112     free (m_pchBitstreamFile) ;
    113 #if FLEX_CODING_ORDER_M23723
    114   if (m_pchMVCJointCodingOrder != NULL)
    115   {
    116     free(m_pchMVCJointCodingOrder) ;
    117   }
    118 #endif
    119 #if HHI_VSO
     133#else
     134  free(m_pchReconFile);
     135#endif
     136  free(m_pchdQPFile);
     137  free(m_pColumnWidth);
     138  free(m_pRowHeight);
     139  free(m_scalingListFile);
     140#if H_MV
     141  for( Int i = 0; i < m_GOPListMvc.size(); i++ )
     142  {
     143    if( m_GOPListMvc[i] )
     144    {
     145      delete[] m_GOPListMvc[i];
     146      m_GOPListMvc[i] = NULL;
     147    }
     148  }
     149#endif
     150#if H_3D
     151#if H_3D_VSO
    120152  if (  m_pchVSOConfig != NULL)
    121153    free (  m_pchVSOConfig );
    122154#endif
    123 
    124  if ( m_pchCameraParameterFile != NULL )
    125    free ( m_pchCameraParameterFile );
    126 
    127  if ( m_pchBaseViewCameraNumbers != NULL )
    128    free ( m_pchBaseViewCameraNumbers );
    129 
    130  if ( m_pchdQPFile      != NULL )
    131    free ( m_pchdQPFile      );
    132 
    133  if ( m_pchColumnWidth  != NULL )
    134    free ( m_pchColumnWidth  );
    135 
    136  if ( m_pchRowHeight    != NULL )
    137    free ( m_pchRowHeight    );
    138 
    139  if ( m_scalingListFile != NULL )
    140    free ( m_scalingListFile );
    141 
    142 
     155  if ( m_pchCameraParameterFile != NULL )
     156    free ( m_pchCameraParameterFile );
     157
     158  if ( m_pchBaseViewCameraNumbers != NULL )
     159    free ( m_pchBaseViewCameraNumbers );
     160#endif
    143161}
    144162
     
    151169}
    152170
    153 std::istringstream &operator>>( std::istringstream &in, GOPEntryMvc &entry )     //input
     171std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry)     //input
    154172{
    155173  in>>entry.m_sliceType;
     
    157175  in>>entry.m_QPOffset;
    158176  in>>entry.m_QPFactor;
     177  in>>entry.m_tcOffsetDiv2;
     178  in>>entry.m_betaOffsetDiv2;
    159179  in>>entry.m_temporalId;
    160180  in>>entry.m_numRefPicsActive;
    161   in>>entry.m_refPic;
    162181  in>>entry.m_numRefPics;
    163182  for ( Int i = 0; i < entry.m_numRefPics; i++ )
     
    166185  }
    167186  in>>entry.m_interRPSPrediction;
    168   if (entry.m_interRPSPrediction)
    169   {
    170     in>>entry.m_deltaRIdxMinus1;
     187#if AUTO_INTER_RPS
     188  if (entry.m_interRPSPrediction==1)
     189  {
    171190    in>>entry.m_deltaRPS;
    172191    in>>entry.m_numRefIdc;
     
    176195    }
    177196  }
    178   in>>entry.m_numInterViewRefPics;
    179   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    180   {
    181     in>>entry.m_interViewRefs[i];
    182   }
    183   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    184   {
    185     in>>entry.m_interViewRefPosL0[i];
    186   }
    187   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    188   {
    189     in>>entry.m_interViewRefPosL1[i];
    190   }
     197  else if (entry.m_interRPSPrediction==2)
     198  {
     199    in>>entry.m_deltaRPS;
     200  }
     201#else
     202  if (entry.m_interRPSPrediction)
     203  {
     204    in>>entry.m_deltaRPS;
     205    in>>entry.m_numRefIdc;
     206    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
     207    {
     208      in>>entry.m_refIdc[i];
     209    }
     210  }
     211#endif
     212#if H_MV
     213  in>>entry.m_numActiveRefLayerPics;
     214  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
     215  {
     216    in>>entry.m_interLayerPredLayerIdc[i];
     217  }
     218  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
     219  {
     220    in>>entry.m_interViewRefPosL[0][i];
     221  }
     222  for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
     223  {
     224    in>>entry.m_interViewRefPosL[1][i];
     225  }
     226  if (entry.m_numActiveRefLayerPics > 0 )
     227  {
     228    in>>entry.m_collocatedRefLayerIdx;
     229  }
     230#endif
    191231  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);
    192312}
    193313
     
    202322Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
    203323{
    204   bool do_help = false;
    205  
     324  Bool do_help = false;
     325 
     326#if !H_MV
     327  string cfg_InputFile;
     328#endif
    206329  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
    207342  string cfg_dQPFile;
    208343  string cfg_ColumnWidth;
    209344  string cfg_RowHeight;
    210345  string cfg_ScalingListFile;
    211 
    212  #if FLEX_CODING_ORDER_M23723
    213   string cfg_JointCodingOrdering;
    214 #endif
    215 
     346  string cfg_startOfCodedInterval;
     347  string cfg_codedPivotValue;
     348  string cfg_targetPivotValue;
    216349  po::Options opts;
    217350  opts.addOptions()
     
    219352  ("c", po::parseConfigFile, "configuration file name")
    220353 
    221   /* File, I/O and source parameters */
    222   ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM ,   "original Yuv input file name %d")
    223   ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM ,   "original Yuv depth input file name %d")
    224   ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv output file name %d")
    225   ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM ,   "reconstructed Yuv depth output file name %d")
    226   ("BitstreamFile,b",         cfg_BitstreamFile,        string(""),                   "bitstream output file name")
    227   ("CodeDepthMaps",           m_bUsingDepthMaps,        false,                        "Encode depth maps" )
    228   ("CodedCamParsPrecision",   m_iCodedCamParPrecision,  STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
    229   ("LambdaModifier0,-LM0",    m_adLambdaModifier[ 0 ],  ( double )1.0,                "Lambda modifier for temporal layer 0")
    230   ("LambdaModifier1,-LM1",    m_adLambdaModifier[ 1 ],  ( double )1.0,                "Lambda modifier for temporal layer 1")
    231   ("LambdaModifier2,-LM2",    m_adLambdaModifier[ 2 ],  ( double )1.0,                "Lambda modifier for temporal layer 2")
    232   ("LambdaModifier3,-LM3",    m_adLambdaModifier[ 3 ],  ( double )1.0,                "Lambda modifier for temporal layer 3")
    233   ("SourceWidth,-wdt",        m_iSourceWidth,           0,                            "Source picture width")
    234   ("SourceHeight,-hgt",       m_iSourceHeight,          0,                            "Source picture height")
    235   ("CroppingMode",            m_croppingMode,           0,                            "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
    236   ("CropLeft",                m_cropLeft,               0,                            "Left cropping/padding for cropping mode 3")
    237   ("CropRight",               m_cropRight,              0,                            "Right cropping/padding for cropping mode 3")
    238   ("CropTop",                 m_cropTop,                0,                            "Top cropping/padding for cropping mode 3")
    239   ("CropBottom",              m_cropBottom,             0,                            "Bottom cropping/padding for cropping mode 3")
    240   ("HorizontalPadding,-pdx",  m_aiPad[0],               0,                            "horizontal source padding for cropping mode 2")
    241   ("VerticalPadding,-pdy",    m_aiPad[1],               0,                            "vertical source padding for cropping mode 2")
    242   ("InputBitDepth",         m_uiInputBitDepth, 8u, "bit-depth of input file")
    243   ("BitDepth",              m_uiInputBitDepth, 8u, "deprecated alias of InputBitDepth")
    244   ("OutputBitDepth",        m_uiOutputBitDepth, 0u, "bit-depth of output file")
    245   ("InternalBitDepth",      m_uiInternalBitDepth, 0u, "Internal bit-depth (BitDepth+BitIncrement)")
    246   ("FrameRate,-fr",         m_iFrameRate,        0, "Frame rate")
    247   ("FrameSkip,-fs",         m_FrameSkip,         0u, "Number of frames to skip at start of input YUV")
    248   ("FramesToBeEncoded,f",   m_iFrameToBeEncoded, 0, "number of frames to be encoded (default=all)")
    249   ("FrameToBeEncoded",      m_iFrameToBeEncoded, 0, "deprecated alias of FramesToBeEncoded")
    250  
    251   ("NumberOfViews",         m_iNumberOfViews,    0, "Number of views")
    252 #if FLEX_CODING_ORDER_M23723
    253   ("FCO",               m_b3DVFlexOrder,   false, "flexible coding order flag" )
    254   ("FCOCodingOrder",   cfg_JointCodingOrdering,  string(""), "The coding order for joint texture-depth coding")
    255 #endif
    256   /* Unit definition parameters */
    257   ("MaxCUWidth",          m_uiMaxCUWidth,  64u)
    258   ("MaxCUHeight",         m_uiMaxCUHeight, 64u)
    259   /* todo: remove defaults from MaxCUSize */
    260   ("MaxCUSize,s",         m_uiMaxCUWidth,  64u, "max CU size")
    261   ("MaxCUSize,s",         m_uiMaxCUHeight, 64u, "max CU size")
    262   ("MaxPartitionDepth,h", m_uiMaxCUDepth,   4u, "CU depth")
    263  
    264   ("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u)
    265   ("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u)
    266  
    267   ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u)
    268   ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u)
    269  
    270   /* Coding structure paramters */
    271   ("IntraPeriod,-ip",m_iIntraPeriod, -1, "intra period in frames, (-1: only first frame)")
    272   ("DecodingRefreshType,-dr",m_iDecodingRefreshType, 0, "intra refresh, (0:none 1:CRA 2:IDR)")
    273   ("GOPSize,g",      m_iGOPSize,      1, "GOP size of temporal structure")
    274   ("ListCombination,-lc", m_bUseLComb, true, "combined reference list flag for uni-prediction in B-slices")
    275   ("LCModification", m_bLCMod, false, "enables signalling of combined reference list derivation")
    276   ("DisableInter4x4", m_bDisInter4x4, true, "Disable Inter 4x4")
    277   ("NSQT", m_enableNSQT, true, "Enable non-square transforms")
    278   ("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
    279   /* motion options */
    280   ("FastSearch", m_iFastSearch, 1, "0:Full search  1:Diamond  2:PMVFAST")
    281   ("SearchRange,-sr",m_iSearchRange, 96, "motion search range")
    282 #if DV_V_RESTRICTION_B0037
    283   ("DisparitySearchRangeRestriction",m_bUseDisparitySearchRangeRestriction, false, "restrict disparity search range")
    284   ("VerticalDisparitySearchRange",m_iVerticalDisparitySearchRange, 56, "vertical disparity search range")
    285 #endif
    286   ("BipredSearchRange", m_bipredSearchRange, 4, "motion search range for bipred refinement")
    287   ("HadamardME", m_bUseHADME, true, "hadamard ME for fractional-pel")
    288   ("ASR", m_bUseASR, false, "adaptive motion search range")
    289  
     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    , 1                    , "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  ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id")
     375#if H_3D
     376  ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
     377#if H_3D_DIM
     378  ("DMM",                   m_useDMM,           true,  "Depth intra model modes")
     379  ("RBC",                   m_useRBC,           true,  "Region boundary chain mode")
     380  ("SDC",                   m_useSDC,           true,  "Simplified depth coding")
     381  ("DLT",                   m_useDLT,           true,  "Depth lookup table")
     382#endif
     383#endif
     384  ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")
     385  ("SplittingFlag",         m_splittingFlag      , false                , "Splitting Flag")   
     386
     387  // Layer Sets + Output Layer Sets + Profile Tier Level
     388  ("VpsNumLayerSets",       m_vpsNumLayerSets    , 1                    , "Number of layer sets")   
     389  ("LayerIdsInSet_%d",      m_layerIdsInSets     , std::vector<Int>(1,0), MAX_VPS_OP_SETS_PLUS1 ,"LayerIds of Layer set") 
     390  ("DefaultOneTargetOutputLayerFlag", m_defaultOneTargetOutputLayerFlag,  false , "Output highest layer of layer sets by default")     
     391  ("OutputLayerSetIdx",     m_outputLayerSetIdx  , std::vector<Int>(0,0), "Indices of layer sets used as additional output layer sets") 
     392  ("LayerIdsInAddOutputLayerSet_%d", m_layerIdsInAddOutputLayerSet      , std::vector<Int>(1,0), MAX_VPS_ADD_OUTPUT_LAYER_SETS, "LayerIds of additional output layers") 
     393  ("ProfileLevelTierIdx",   m_profileLevelTierIdx, std::vector<Int>(1,0), "Indices to profile level tier")
     394 
     395  // Layer dependencies
     396  ("DirectRefLayers_%d",    m_directRefLayers    , std::vector<Int>(0,0), MAX_NUM_LAYERS, "LayerIds of direct reference layers")
     397  ("DependencyTypes_%d",    m_dependencyTypes    , std::vector<Int>(0,0), MAX_NUM_LAYERS, "Dependency types of direct reference layers, 0: Sample 1: Motion 2: Sample+Motion")
     398#endif
     399  ("SourceWidth,-wdt",      m_iSourceWidth,        0, "Source picture width")
     400  ("SourceHeight,-hgt",     m_iSourceHeight,       0, "Source picture height")
     401  ("InputBitDepth",         m_inputBitDepthY,    8, "Bit-depth of input file")
     402  ("OutputBitDepth",        m_outputBitDepthY,   0, "Bit-depth of output file (default:InternalBitDepth)")
     403  ("InternalBitDepth",      m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
     404                                                       "If different to InputBitDepth, source data will be converted")
     405  ("InputBitDepthC",        m_inputBitDepthC,    0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
     406  ("OutputBitDepthC",       m_outputBitDepthC,   0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
     407  ("InternalBitDepthC",     m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
     408  ("ConformanceMode",       m_conformanceMode,     0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
     409  ("HorizontalPadding,-pdx",m_aiPad[0],            0, "Horizontal source padding for conformance window mode 2")
     410  ("VerticalPadding,-pdy",  m_aiPad[1],            0, "Vertical source padding for conformance window mode 2")
     411  ("ConfLeft",              m_confLeft,            0, "Left offset for window conformance mode 3")
     412  ("ConfRight",             m_confRight,           0, "Right offset for window conformance mode 3")
     413  ("ConfTop",               m_confTop,             0, "Top offset for window conformance mode 3")
     414  ("ConfBottom",            m_confBottom,          0, "Bottom offset for window conformance mode 3")
     415  ("FrameRate,-fr",         m_iFrameRate,          0, "Frame rate")
     416  ("FrameSkip,-fs",         m_FrameSkip,          0u, "Number of frames to skip at start of input YUV")
     417  ("FramesToBeEncoded,f",   m_framesToBeEncoded,   0, "Number of frames to be encoded (default=all)")
     418
     419  // Profile and level
     420  ("Profile", m_profile,   Profile::NONE, "Profile to be used when encoding (Incomplete)")
     421  ("Level",   m_level,     Level::NONE,   "Level limit to be used, eg 5.1 (Incomplete)")
     422  ("Tier",    m_levelTier, Level::MAIN,   "Tier to use for interpretation of --Level")
     423
     424  ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
     425  ("InterlacedSource",  m_interlacedSourceFlag,  false, "Indicate that source is interlaced")
     426  ("NonPackedSource",   m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
     427  ("FrameOnly",         m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
     428 
     429  // Unit definition parameters
     430  ("MaxCUWidth",              m_uiMaxCUWidth,             64u)
     431  ("MaxCUHeight",             m_uiMaxCUHeight,            64u)
     432  // todo: remove defaults from MaxCUSize
     433  ("MaxCUSize,s",             m_uiMaxCUWidth,             64u, "Maximum CU size")
     434  ("MaxCUSize,s",             m_uiMaxCUHeight,            64u, "Maximum CU size")
     435  ("MaxPartitionDepth,h",     m_uiMaxCUDepth,              4u, "CU depth")
     436 
     437  ("QuadtreeTULog2MaxSize",   m_uiQuadtreeTULog2MaxSize,   6u, "Maximum TU size in logarithm base 2")
     438  ("QuadtreeTULog2MinSize",   m_uiQuadtreeTULog2MinSize,   2u, "Minimum TU size in logarithm base 2")
     439 
     440  ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
     441  ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
     442 
     443  // Coding structure paramters
     444  ("IntraPeriod,-ip",         m_iIntraPeriod,              -1, "Intra period in frames, (-1: only first frame)")
     445  ("DecodingRefreshType,-dr", m_iDecodingRefreshType,       0, "Intra refresh type (0:none 1:CRA 2:IDR)")
     446  ("GOPSize,g",               m_iGOPSize,                   1, "GOP size of temporal structure")
     447  // motion options
     448  ("FastSearch",              m_iFastSearch,                1, "0:Full search  1:Diamond  2:PMVFAST")
     449  ("SearchRange,-sr",         m_iSearchRange,              96, "Motion search range")
     450  ("BipredSearchRange",       m_bipredSearchRange,          4, "Motion search range for bipred refinement")
     451  ("HadamardME",              m_bUseHADME,               true, "Hadamard ME for fractional-pel")
     452  ("ASR",                     m_bUseASR,                false, "Adaptive motion search range")
     453
     454  // Mode decision parameters
     455  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
     456  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
     457  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
     458  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
     459  ("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
     460  ("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
     461  ("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
     462  ("LambdaModifier7,-LM7", m_adLambdaModifier[ 7 ], ( Double )1.0, "Lambda modifier for temporal layer 7")
     463
    290464  /* Quantization parameters */
    291   ("QP,q",          m_adQP,     std::vector<double>(1,32), "Qp value, if value is float, QP is switched once during encoding, if two values are given the second is used for depth")
     465#if H_MV
     466  ("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")
     467#else
     468  ("QP,q",          m_fQP,             30.0, "Qp value, if value is float, QP is switched once during encoding")
     469#endif
    292470  ("DeltaQpRD,-dqr",m_uiDeltaQpRD,       0u, "max dQp offset for slice")
    293471  ("MaxDeltaQP,d",  m_iMaxDeltaQP,        0, "max dQp offset for block")
    294472  ("MaxCuDQPDepth,-dqd",  m_iMaxCuDQPDepth,        0, "max depth for a minimum CuDQP")
    295473
    296     ("ChromaQpOffset,   -cqo",   m_iChromaQpOffset,           0, "ChromaQpOffset")
    297     ("ChromaQpOffset2nd,-cqo2",  m_iChromaQpOffset2nd,        0, "ChromaQpOffset2nd")
     474  ("CbQpOffset,-cbqpofs",  m_cbQpOffset,        0, "Chroma Cb QP Offset")
     475  ("CrQpOffset,-crqpofs",  m_crQpOffset,        0, "Chroma Cr QP Offset")
    298476
    299477#if ADAPTIVE_QP_SELECTION
    300     ("AdaptiveQpSelection,-aqps",   m_bUseAdaptQpSelect,           false, "AdaptiveQpSelection")
    301 #endif
    302 
    303   ("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
    304   ("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
    305   ("dQPFile,m",     cfg_dQPFile, string(""), "dQP file name")
    306   ("RDOQ",          m_abUseRDOQ, std::vector<Bool>(1,true), "Enable RDOQ")
    307   ("TemporalLayerQPOffset_L0,-tq0", m_aiTLayerQPOffset[0], MAX_QP + 1, "QP offset of temporal layer 0")
    308   ("TemporalLayerQPOffset_L1,-tq1", m_aiTLayerQPOffset[1], MAX_QP + 1, "QP offset of temporal layer 1")
    309   ("TemporalLayerQPOffset_L2,-tq2", m_aiTLayerQPOffset[2], MAX_QP + 1, "QP offset of temporal layer 2")
    310   ("TemporalLayerQPOffset_L3,-tq3", m_aiTLayerQPOffset[3], MAX_QP + 1, "QP offset of temporal layer 3")
    311  
    312 
    313   /* Entropy coding parameters */
    314   ("SBACRD", m_bUseSBACRD, true, "SBAC based RD estimation")
    315  
    316   /* Deblocking filter parameters */
    317   ("LoopFilterDisable", m_abLoopFilterDisable, std::vector<Bool>(1,false), "Disables LoopFilter")
    318 
    319   ("LoopFilterOffsetInAPS", m_loopFilterOffsetInAPS, false)
    320   ("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
    321   ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
    322 #if LGE_ILLUCOMP_B0045
    323 #if LGE_ILLUCOMP_DEPTH_C0046
    324   ("IlluCompEnable", m_abUseIC, std::vector<Bool>(2, true), "Enable illumination compensation for inter-view prediction")
    325 #else
    326   ("IlluCompEnable",                  m_bUseIC                  , true         , "Use illumination compensation for inter-view prediction" )
    327 #endif
    328 #endif
    329 #if INTER_VIEW_VECTOR_SCALING_C0115
    330   ("IVSEnable",                       m_bUseIVS                 , true         , "Use inter-view vector scaling" )
    331 #endif
    332   ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, true)
    333 
    334   /* Camera Paremetes */
     478  ("AdaptiveQpSelection,-aqps",   m_bUseAdaptQpSelect,           false, "AdaptiveQpSelection")
     479#endif
     480
     481  ("AdaptiveQP,-aq",                m_bUseAdaptiveQP,           false, "QP adaptation based on a psycho-visual model")
     482  ("MaxQPAdaptationRange,-aqr",     m_iQPAdaptationRange,           6, "QP adaptation range")
     483  ("dQPFile,m",                     cfg_dQPFile,           string(""), "dQP file name")
     484  ("RDOQ",                          m_useRDOQ,                  true )
     485  ("RDOQTS",                        m_useRDOQTS,                true )
     486  ("RDpenalty",                     m_rdPenalty,                0,  "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled  1:RD-penalty  2:maximum RD-penalty")
     487  // Entropy coding parameters
     488  ("SBACRD",                         m_bUseSBACRD,                      true, "SBAC based RD estimation")
     489 
     490  // Deblocking filter parameters
     491#if H_MV
     492  ("LoopFilterDisable",              m_bLoopFilterDisable,             std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )
     493#else
     494  ("LoopFilterDisable",              m_bLoopFilterDisable,             false )
     495#endif
     496  ("LoopFilterOffsetInPPS",          m_loopFilterOffsetInPPS,          false )
     497  ("LoopFilterBetaOffset_div2",      m_loopFilterBetaOffsetDiv2,           0 )
     498  ("LoopFilterTcOffset_div2",        m_loopFilterTcOffsetDiv2,             0 )
     499  ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
     500  ("DeblockingFilterMetric",         m_DeblockingFilterMetric,         false )
     501
     502#if H_3D_ARP
     503  ("AdvMultiviewResPred",      m_uiUseAdvResPred,           (UInt)1, "Usage of Advanced Residual Prediction" )
     504#endif
     505#if H_3D_IC
     506  ("IlluCompEnable",           m_abUseIC, std::vector<Bool>(2, true), "Enable illumination compensation")
     507#endif
     508#if LGE_INTER_SDC_E0156
     509  ("InterSDC",                 m_bDepthInterSDCFlag,        true, "Enable depth inter SDC")
     510#endif
     511  // Coding tools
     512  ("AMP",                      m_enableAMP,                 true,  "Enable asymmetric motion partitions")
     513  ("TransformSkip",            m_useTransformSkip,          false, "Intra transform skipping")
     514  ("TransformSkipFast",        m_useTransformSkipFast,      false, "Fast intra transform skipping")
     515#if H_MV
     516  ("SAO",                      m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer")
     517#else
     518  ("SAO",                      m_bUseSAO,                   true,  "Enable Sample Adaptive Offset")
     519#endif
     520  ("MaxNumOffsetsPerPic",      m_maxNumOffsetsPerPic,       2048,  "Max number of SAO offset per picture (Default: 2048)")   
     521  ("SAOLcuBoundary",           m_saoLcuBoundary,            false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
     522  ("SAOLcuBasedOptimization",  m_saoLcuBasedOptimization,   true,  "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
     523  ("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")
     524  ("SliceArgument",            m_sliceArgument,            0,     "Depending on SliceMode being:"
     525                                                                   "\t1: max number of CTUs per slice"
     526                                                                   "\t2: max number of bytes per slice"
     527                                                                   "\t3: max number of tiles per slice")
     528  ("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")
     529  ("SliceSegmentArgument",     m_sliceSegmentArgument,   0,     "Depending on SliceSegmentMode being:"
     530                                                                   "\t1: max number of CTUs per slice segment"
     531                                                                   "\t2: max number of bytes per slice segment"
     532                                                                   "\t3: max number of tiles per slice segment")
     533  ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
     534
     535  ("ConstrainedIntraPred",     m_bUseConstrainedIntraPred,  false, "Constrained Intra Prediction")
     536
     537  ("PCMEnabledFlag",           m_usePCM,                    false)
     538  ("PCMLog2MaxSize",           m_pcmLog2MaxSize,            5u)
     539  ("PCMLog2MinSize",           m_uiPCMLog2MinSize,          3u)
     540  ("PCMInputBitDepthFlag",     m_bPCMInputBitDepthFlag,     true)
     541  ("PCMFilterDisableFlag",     m_bPCMFilterDisableFlag,    false)
     542
     543  ("LosslessCuEnabled",        m_useLossless, false)
     544
     545  ("WeightedPredP,-wpP",          m_useWeightedPred,               false,      "Use weighted prediction in P slices")
     546  ("WeightedPredB,-wpB",          m_useWeightedBiPred,             false,      "Use weighted (bidirectional) prediction in B slices")
     547  ("Log2ParallelMergeLevel",      m_log2ParallelMergeLevel,     2u,          "Parallel merge estimation region")
     548  ("UniformSpacingIdc",           m_iUniformSpacingIdr,            0,          "Indicates if the column and row boundaries are distributed uniformly")
     549  ("NumTileColumnsMinus1",        m_iNumColumnsMinus1,             0,          "Number of columns in a picture minus 1")
     550  ("ColumnWidthArray",            cfg_ColumnWidth,                 string(""), "Array containing ColumnWidth values in units of LCU")
     551  ("NumTileRowsMinus1",           m_iNumRowsMinus1,                0,          "Number of rows in a picture minus 1")
     552  ("RowHeightArray",              cfg_RowHeight,                   string(""), "Array containing RowHeight values in units of LCU")
     553  ("LFCrossTileBoundaryFlag",      m_bLFCrossTileBoundaryFlag,             true,          "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
     554  ("WaveFrontSynchro",            m_iWaveFrontSynchro,             0,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
     555  ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
     556  ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
     557  ("SignHideFlag,-SBH",                m_signHideFlag, 1)
     558  ("MaxNumMergeCand",             m_maxNumMergeCand,             5u,         "Maximum number of merge candidates")
     559
     560  /* Misc. */
     561  ("SEIDecodedPictureHash",       m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
     562                                                                    "\t3: checksum\n"
     563                                                                    "\t2: CRC\n"
     564                                                                    "\t1: use MD5\n"
     565                                                                    "\t0: disable")
     566  ("SEIpictureDigest",            m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
     567  ("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")
     568  ("FEN", m_bUseFastEnc, false, "fast encoder setting")
     569  ("ECU", m_bUseEarlyCU, false, "Early CU setting")
     570  ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
     571  ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
     572  ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
     573#if RATE_CONTROL_LAMBDA_DOMAIN
     574  ( "RateControl",         m_RCEnableRateControl,   false, "Rate control: enable rate control" )
     575  ( "TargetBitrate",       m_RCTargetBitrate,           0, "Rate control: target bitrate" )
     576#if M0036_RC_IMPROVEMENT
     577  ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit,     0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
     578#else
     579  ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, false, "Rate control: keep hierarchical bit allocation in rate control algorithm" )
     580#endif
     581  ( "LCULevelRateControl", m_RCLCULevelRC,           true, "Rate control: true: LCU level RC; false: picture level RC" )
     582  ( "RCLCUSeparateModel",  m_RCUseLCUSeparateModel,  true, "Rate control: use LCU level separate R-lambda model" )
     583  ( "InitialQP",           m_RCInitialQP,               0, "Rate control: initial QP" )
     584  ( "RCForceIntraQP",      m_RCForceIntraQP,        false, "Rate control: force intra QP to be equal to initial QP" )
     585#else
     586  ("RateCtrl,-rc", m_enableRateCtrl, false, "Rate control on/off")
     587  ("TargetBitrate,-tbr", m_targetBitrate, 0, "Input target bitrate")
     588  ("NumLCUInUnit,-nu", m_numLCUInUnit, 0, "Number of LCUs in an Unit")
     589#endif
     590
     591  ("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
     592  ("CUTransquantBypassFlagValue", m_CUTransquantBypassFlagValue, false, "Fixed cu_transquant_bypass_flag value, when transquant_bypass_enable_flag is enabled")
     593  ("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
     594  ("StrongIntraSmoothing,-sis",      m_useStrongIntraSmoothing,           true, "Enable strong intra smoothing for 32x32 blocks")
     595  ("SEIActiveParameterSets",         m_activeParameterSetsSEIEnabled,          0, "Enable generation of active parameter sets SEI messages")
     596  ("VuiParametersPresent,-vui",      m_vuiParametersPresentFlag,           false, "Enable generation of vui_parameters()")
     597  ("AspectRatioInfoPresent",         m_aspectRatioInfoPresentFlag,         false, "Signals whether aspect_ratio_idc is present")
     598  ("AspectRatioIdc",                 m_aspectRatioIdc,                         0, "aspect_ratio_idc")
     599  ("SarWidth",                       m_sarWidth,                               0, "horizontal size of the sample aspect ratio")
     600  ("SarHeight",                      m_sarHeight,                              0, "vertical size of the sample aspect ratio")
     601  ("OverscanInfoPresent",            m_overscanInfoPresentFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
     602  ("OverscanAppropriate",            m_overscanAppropriateFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
     603  ("VideoSignalTypePresent",         m_videoSignalTypePresentFlag,         false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
     604  ("VideoFormat",                    m_videoFormat,                            5, "Indicates representation of pictures")
     605  ("VideoFullRange",                 m_videoFullRangeFlag,                 false, "Indicates the black level and range of luma and chroma signals")
     606  ("ColourDescriptionPresent",       m_colourDescriptionPresentFlag,       false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
     607  ("ColourPrimaries",                m_colourPrimaries,                        2, "Indicates chromaticity coordinates of the source primaries")
     608  ("TransferCharateristics",         m_transferCharacteristics,                2, "Indicates the opto-electronic transfer characteristics of the source")
     609  ("MatrixCoefficients",             m_matrixCoefficients,                     2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
     610  ("ChromaLocInfoPresent",           m_chromaLocInfoPresentFlag,           false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
     611  ("ChromaSampleLocTypeTopField",    m_chromaSampleLocTypeTopField,            0, "Specifies the location of chroma samples for top field")
     612  ("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField,         0, "Specifies the location of chroma samples for bottom field")
     613  ("NeutralChromaIndication",        m_neutralChromaIndicationFlag,        false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
     614  ("DefaultDisplayWindowFlag",       m_defaultDisplayWindowFlag,           false, "Indicates the presence of the Default Window parameters")
     615  ("DefDispWinLeftOffset",           m_defDispWinLeftOffset,                   0, "Specifies the left offset of the default display window from the conformance window")
     616  ("DefDispWinRightOffset",          m_defDispWinRightOffset,                  0, "Specifies the right offset of the default display window from the conformance window")
     617  ("DefDispWinTopOffset",            m_defDispWinTopOffset,                    0, "Specifies the top offset of the default display window from the conformance window")
     618  ("DefDispWinBottomOffset",         m_defDispWinBottomOffset,                 0, "Specifies the bottom offset of the default display window from the conformance window")
     619  ("FrameFieldInfoPresentFlag",      m_frameFieldInfoPresentFlag,               false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
     620  ("PocProportionalToTimingFlag",   m_pocProportionalToTimingFlag,         false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
     621  ("NumTicksPocDiffOneMinus1",      m_numTicksPocDiffOneMinus1,                0, "Number of ticks minus 1 that for a POC difference of one")
     622  ("BitstreamRestriction",           m_bitstreamRestrictionFlag,           false, "Signals whether bitstream restriction parameters are present")
     623  ("TilesFixedStructure",            m_tilesFixedStructureFlag,            false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
     624  ("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
     625  ("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")
     626  ("MaxBitsPerMinCuDenom",           m_maxBitsPerMinCuDenom,                   1, "Indicates an upper bound for the number of bits of coding_unit() data")
     627  ("Log2MaxMvLengthHorizontal",      m_log2MaxMvLengthHorizontal,             15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
     628  ("Log2MaxMvLengthVertical",        m_log2MaxMvLengthVertical,               15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
     629  ("SEIRecoveryPoint",               m_recoveryPointSEIEnabled,                0, "Control generation of recovery point SEI messages")
     630  ("SEIBufferingPeriod",             m_bufferingPeriodSEIEnabled,              0, "Control generation of buffering period SEI messages")
     631  ("SEIPictureTiming",               m_pictureTimingSEIEnabled,                0, "Control generation of picture timing SEI messages")
     632  ("SEIToneMappingInfo",                       m_toneMappingInfoSEIEnabled,    false, "Control generation of Tone Mapping SEI messages")
     633  ("SEIToneMapId",                             m_toneMapId,                        0, "Specifies Id of Tone Mapping SEI message for a given session")
     634  ("SEIToneMapCancelFlag",                     m_toneMapCancelFlag,            false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
     635  ("SEIToneMapPersistenceFlag",                m_toneMapPersistenceFlag,        true, "Specifies the persistence of the Tone Mapping SEI message")
     636  ("SEIToneMapCodedDataBitDepth",              m_toneMapCodedDataBitDepth,         8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
     637  ("SEIToneMapTargetBitDepth",                 m_toneMapTargetBitDepth,            8, "Specifies Output BitDepth of Tome mapping function")
     638  ("SEIToneMapModelId",                        m_toneMapModelId,                   0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
     639                                                                                      "\t0:  linear mapping with clipping\n"
     640                                                                                      "\t1:  sigmoidal mapping\n"
     641                                                                                      "\t2:  user-defined table mapping\n"
     642                                                                                      "\t3:  piece-wise linear mapping\n"
     643                                                                                      "\t4:  luminance dynamic range information ")
     644  ("SEIToneMapMinValue",                              m_toneMapMinValue,                          0, "Specifies the minimum value in mode 0")
     645  ("SEIToneMapMaxValue",                              m_toneMapMaxValue,                       1023, "Specifies the maxmum value in mode 0")
     646  ("SEIToneMapSigmoidMidpoint",                       m_sigmoidMidpoint,                        512, "Specifies the centre point in mode 1")
     647  ("SEIToneMapSigmoidWidth",                          m_sigmoidWidth,                           960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
     648  ("SEIToneMapStartOfCodedInterval",                  cfg_startOfCodedInterval,          string(""), "Array of user-defined mapping table")
     649  ("SEIToneMapNumPivots",                             m_numPivots,                                0, "Specifies the number of pivot points in mode 3")
     650  ("SEIToneMapCodedPivotValue",                       cfg_codedPivotValue,               string(""), "Array of pivot point")
     651  ("SEIToneMapTargetPivotValue",                      cfg_targetPivotValue,              string(""), "Array of pivot point")
     652  ("SEIToneMapCameraIsoSpeedIdc",                     m_cameraIsoSpeedIdc,                        0, "Indicates the camera ISO speed for daylight illumination")
     653  ("SEIToneMapCameraIsoSpeedValue",                   m_cameraIsoSpeedValue,                    400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
     654  ("SEIToneMapExposureCompensationValueSignFlag",     m_exposureCompensationValueSignFlag,        0, "Specifies the sign of ExposureCompensationValue")
     655  ("SEIToneMapExposureCompensationValueNumerator",    m_exposureCompensationValueNumerator,       0, "Specifies the numerator of ExposureCompensationValue")
     656  ("SEIToneMapExposureCompensationValueDenomIdc",     m_exposureCompensationValueDenomIdc,        2, "Specifies the denominator of ExposureCompensationValue")
     657  ("SEIToneMapRefScreenLuminanceWhite",               m_refScreenLuminanceWhite,                350, "Specifies reference screen brightness setting in units of candela per square metre")
     658  ("SEIToneMapExtendedRangeWhiteLevel",               m_extendedRangeWhiteLevel,                800, "Indicates the luminance dynamic range")
     659  ("SEIToneMapNominalBlackLevelLumaCodeValue",        m_nominalBlackLevelLumaCodeValue,          16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
     660  ("SEIToneMapNominalWhiteLevelLumaCodeValue",        m_nominalWhiteLevelLumaCodeValue,         235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
     661  ("SEIToneMapExtendedWhiteLevelLumaCodeValue",       m_extendedWhiteLevelLumaCodeValue,        300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
     662  ("SEIFramePacking",                m_framePackingSEIEnabled,                 0, "Control generation of frame packing SEI messages")
     663  ("SEIFramePackingType",            m_framePackingSEIType,                    0, "Define frame packing arrangement\n"
     664                                                                                  "\t0: checkerboard - pixels alternatively represent either frames\n"
     665                                                                                  "\t1: column alternation - frames are interlaced by column\n"
     666                                                                                  "\t2: row alternation - frames are interlaced by row\n"
     667                                                                                  "\t3: side by side - frames are displayed horizontally\n"
     668                                                                                  "\t4: top bottom - frames are displayed vertically\n"
     669                                                                                  "\t5: frame alternation - one frame is alternated with the other")
     670  ("SEIFramePackingId",              m_framePackingSEIId,                      0, "Id of frame packing SEI message for a given session")
     671  ("SEIFramePackingQuincunx",        m_framePackingSEIQuincunx,                0, "Indicate the presence of a Quincunx type video frame")
     672  ("SEIFramePackingInterpretation",  m_framePackingSEIInterpretation,          0, "Indicate the interpretation of the frame pair\n"
     673                                                                                  "\t0: unspecified\n"
     674                                                                                  "\t1: stereo pair, frame0 represents left view\n"
     675                                                                                  "\t2: stereo pair, frame0 represents right view")
     676  ("SEIDisplayOrientation",          m_displayOrientationSEIAngle,             0, "Control generation of display orientation SEI messages\n"
     677                                                              "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
     678                                                              "\t0: disable")
     679  ("SEITemporalLevel0Index",         m_temporalLevel0IndexSEIEnabled,          0, "Control generation of temporal level 0 index SEI messages")
     680  ("SEIGradualDecodingRefreshInfo",  m_gradualDecodingRefreshInfoEnabled,      0, "Control generation of gradual decoding refresh information SEI message")
     681  ("SEIDecodingUnitInfo",             m_decodingUnitInfoSEIEnabled,                       0, "Control generation of decoding unit information SEI message.")
     682  ("SEISOPDescription",              m_SOPDescriptionSEIEnabled,              0, "Control generation of SOP description SEI messages")
     683  ("SEIScalableNesting",             m_scalableNestingSEIEnabled,              0, "Control generation of scalable nesting SEI messages")
     684#if H_3D
    335685  ("CameraParameterFile,cpf", m_pchCameraParameterFile,    (Char *) 0, "Camera Parameter File Name")
    336 #if QC_MVHEVC_B0046
    337   ("BaseViewCameraNumbers" ,  m_aiVId,     std::vector<Int>(1, MAX_VIEW_NUM), "Numbers of base views")
    338 #endif
    339686  ("BaseViewCameraNumbers" ,  m_pchBaseViewCameraNumbers,  (Char *) 0, "Numbers of base views")
    340 
    341   /* View Synthesis Optimization */
    342 
    343 #if HHI_VSO
     687  ("CodedCamParsPrecision",   m_iCodedCamParPrecision,  STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
     688/* View Synthesis Optimization */
     689
     690#if H_3D_VSO
    344691  ("VSOConfig",                       m_pchVSOConfig            , (Char *) 0    , "VSO configuration")
    345692  ("VSO",                             m_bUseVSO                 , false         , "Use VSO" )   
    346693  ("VSOMode",                         m_uiVSOMode               , (UInt)   4    , "VSO Mode")
    347694  ("LambdaScaleVSO",                  m_dLambdaScaleVSO         , (Double) 1    , "Lambda Scaling for VSO")
    348 
    349 #if HHI_VSO_LS_TABLE_M23714
    350   ("VSOLSTable",                      m_bVSOLSTable             , true          , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )   
    351 #endif
    352 
    353 #if SAIT_VSO_EST_A0033
     695  ("VSOLSTable",                      m_bVSOLSTable             , true          , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )     
     696  ("ForceLambdaScaleVSO",             m_bForceLambdaScaleVSO    , false         , "Force using Lambda Scale VSO also in non-VSO-Mode")
     697  ("AllowNegDist",                    m_bAllowNegDist           , true          , "Allow negative Distortion in VSO")
     698 
    354699  ("UseEstimatedVSD",                 m_bUseEstimatedVSD        , true          , "Model based VSD estimation instead of rendering based for some encoder decisions" )     
    355 #endif
    356 #if LGE_VSO_EARLY_SKIP_A0093
    357700  ("VSOEarlySkip",                    m_bVSOEarlySkip           , true          , "Early skip of VSO computation if synthesis error assumed to be zero" )     
    358 #endif
    359   ("ForceLambdaScaleVSO",             m_bForceLambdaScaleVSO    , false         , "Force using Lambda Scale VSO also in non-VSO-Mode")
    360 #if HHI_VSO_DIST_INT
    361   ("AllowNegDist",                    m_bAllowNegDist           , true          , "Allow negative Distortion in VSO")
    362 #endif
    363 #if LGE_WVSO_A0119
     701 
    364702  ("WVSO",                            m_bUseWVSO                , true          , "Use depth fidelity term for VSO" )
    365703  ("VSOWeight",                       m_iVSOWeight              , 10            , "Synthesized View Distortion Change weight" )
    366704  ("VSDWeight",                       m_iVSDWeight              , 1             , "View Synthesis Distortion estimate weight" )
    367705  ("DWeight",                         m_iDWeight                , 1             , "Depth Distortion weight" )
    368 #endif
    369 
    370 #if H3D_QTL
    371   ("QTLPC",                           m_bUseQTLPC               , true         , "Use depth Quadtree Limitation + Predictive Coding" )
    372 #endif
    373 
    374 #endif
    375 
    376 #if DEPTH_MAP_GENERATION
    377   ("PredDepthMapGen",  m_uiPredDepthMapGeneration, (UInt)0, "generation of prediction depth maps for motion data prediction" )
    378 #endif
    379 #if H3D_IVMP
    380   ("MultiviewMvPred",  m_uiMultiviewMvPredMode,    (UInt)0, "usage of predicted depth maps" )
    381   ("MultiviewMvRegMode",        m_uiMultiviewMvRegMode,         (UInt)0, "regularization mode for multiview motion vectors" )
    382   ("MultiviewMvRegLambdaScale", m_dMultiviewMvRegLambdaScale, (Double)0, "lambda scale for multiview motion vector regularization" )
    383 #endif
    384 #if H3D_IVRP
    385 #if QC_ARP_D0177
    386   ("MultiviewResPred", m_nUseAdvResPred,           (UInt)0, "usage of Advanced residual prediction" )
    387 #else
    388   ("MultiviewResPred", m_uiMultiviewResPredMode,   (UInt)0, "usage of inter-view residual prediction" )
    389 #endif
    390 #endif
    391 #if MTK_D0156
    392   ("UseVSPCompensation", m_bUseVSPCompensation,   true, "Depth dependent tools: BVSP" )
    393   ("UseDVPRefine", m_bUseDVPRefine,   true, "Depth dependent tools: DoNBDV" )
    394 #endif
    395 
    396   /* Coding tools */
    397   ("LMChroma", m_bUseLMChroma, true, "intra chroma prediction based on recontructed luma")
    398 
    399   ("ALF", m_abUseALF, std::vector<Bool>(1,true), "Enables ALF")
    400   ("SAO", m_abUseSAO, std::vector<Bool>(1, true), "SAO")
    401   ("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "2048: default")   
    402 #if LGE_SAO_MIGRATION_D0091
    403   ("SAOLcuBoundary",          m_saoLcuBoundary,          false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
    404   ("SAOLcuBasedOptimization", m_saoLcuBasedOptimization, true, "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
    405 #else
    406   ("SAOInterleaving", m_saoInterleavingFlag, false, "0: SAO Picture Mode, 1: SAO Interleaving ")   
    407 #endif
    408 
    409   ("ALFEncodePassReduction", m_iALFEncodePassReduction, 0, "0:Original 16-pass, 1: 1-pass, 2: 2-pass encoding")
    410 
    411   ("ALFMaxNumFilter,-ALFMNF", m_iALFMaxNumberFilters, 16, "16: No Constrained, 1-15: Constrained max number of filter")
    412   ("ALFParamInSlice", m_bALFParamInSlice, false, "ALF parameters in 0: APS, 1: slice header")
    413   ("ALFPicBasedEncode", m_bALFPicBasedEncode, true, "ALF picture-based encoding 0: false, 1: true")
    414 
    415     ("SliceMode",            m_iSliceMode,           0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes")
    416     ("SliceArgument",        m_iSliceArgument,       0, "if SliceMode==1 SliceArgument represents max # of LCUs. if SliceMode==2 SliceArgument represents max # of bytes.")
    417     ("EntropySliceMode",     m_iEntropySliceMode,    0, "0: Disable all entropy slice limits, 1: Enforce max # of LCUs, 2: Enforce constraint based entropy slices")
    418     ("EntropySliceArgument", m_iEntropySliceArgument,0, "if EntropySliceMode==1 SliceArgument represents max # of LCUs. if EntropySliceMode==2 EntropySliceArgument represents max # of bins.")
    419     ("SliceGranularity",     m_iSliceGranularity,    0, "0: Slices always end at LCU borders. 1-3: slices may end at a depth of 1-3 below LCU level.")
    420     ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
    421 
    422     ("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
    423     ("PCMEnabledFlag", m_usePCM         , false)
    424     ("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
    425     ("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
    426 
    427     ("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
    428     ("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
    429 #if LOSSLESS_CODING
    430     ("LosslessCuEnabled", m_useLossless, false)
    431 #endif
    432     ("weighted_pred_flag,-wpP",     m_bUseWeightPred, false, "weighted prediction flag (P-Slices)")
    433     ("weighted_bipred_idc,-wpBidc", m_uiBiPredIdc,    0u,    "weighted bipred idc (B-Slices)")
    434     ("TileInfoPresentFlag",         m_iColumnRowInfoPresent,         1,          "0: tiles parameters are NOT present in the PPS. 1: tiles parameters are present in the PPS")
    435     ("UniformSpacingIdc",           m_iUniformSpacingIdr,            0,          "Indicates if the column and row boundaries are distributed uniformly")
    436     ("NumTileColumnsMinus1",        m_iNumColumnsMinus1,             0,          "Number of columns in a picture minus 1")
    437     ("ColumnWidthArray",            cfg_ColumnWidth,                 string(""), "Array containing ColumnWidth values in units of LCU")
    438     ("NumTileRowsMinus1",           m_iNumRowsMinus1,                0,          "Number of rows in a picture minus 1")
    439     ("RowHeightArray",              cfg_RowHeight,                   string(""), "Array containing RowHeight values in units of LCU")
    440     ("TileLocationInSliceHeaderFlag", m_iTileLocationInSliceHeaderFlag, 0,       "0: Disable transmission of tile location in slice header. 1: Transmit tile locations in slice header.")
    441     ("TileMarkerFlag",                m_iTileMarkerFlag,                0,       "0: Disable transmission of lightweight tile marker. 1: Transmit light weight tile marker.")
    442     ("MaxTileMarkerEntryPoints",    m_iMaxTileMarkerEntryPoints,    4,       "Maximum number of uniformly-spaced tile entry points (using light weigh tile markers). Default=4. If number of tiles < MaxTileMarkerEntryPoints then all tiles have entry points.")
    443     ("TileControlPresentFlag",       m_iTileBehaviorControlPresentFlag,         1,          "0: tiles behavior control parameters are NOT present in the PPS. 1: tiles behavior control parameters are present in the PPS")
    444     ("LFCrossTileBoundaryFlag",      m_bLFCrossTileBoundaryFlag,             true,          "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
    445     ("WaveFrontSynchro",            m_iWaveFrontSynchro,             0,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
    446     ("WaveFrontFlush",              m_iWaveFrontFlush,               0,          "Flush and terminate CABAC coding for each LCU line")
    447     ("WaveFrontSubstreams",         m_iWaveFrontSubstreams,          1,          "# coded substreams wanted; per tile if TileBoundaryIndependenceIdc is 1, otherwise per frame")
    448     ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
    449     ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
    450     ("SignHideFlag,-SBH",                m_signHideFlag, 1)
    451     ("SignHideThreshold,-TSIG",          m_signHidingThreshold,         4)
    452 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    453   ("DMM",                         m_bUseDMM,                       false,      "depth model modes flag")
    454 #endif
    455 
    456   /* Misc. */
    457   ("SEIpictureDigest", m_pictureDigestEnabled, true, "Control generation of picture_digest SEI messages\n"
    458                                               "\t1: use MD5\n"
    459                                               "\t0: disable")
    460 
    461 #if TMVP_DEPTH_SWITCH
    462   ("TMVP", m_enableTMVP, std::vector<Bool>(1,true), "Enable TMVP" )
    463 #else
    464   ("TMVP", m_enableTMVP, true, "Enable TMVP" )
    465 #endif
    466 
    467   ("FEN", m_bUseFastEnc, false, "fast encoder setting")
    468   ("ECU", m_bUseEarlyCU, false, "Early CU setting")
    469   ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
    470   ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
    471 #if HHI_INTERVIEW_SKIP
    472   ("InterViewSkip",  m_bInterViewSkip,    false, "usage of interview skip" )
    473 #if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    474   ("InterViewSkipLambdaScale",  m_dInterViewSkipLambdaScale,    (Double)8, "lambda scale for interview skip" )
    475 #endif
    476 #endif
    477   /* Compatability with old style -1 FOO or -0 FOO options. */
    478   ("1", doOldStyleCmdlineOn, "turn option <name> on")
    479   ("0", doOldStyleCmdlineOff, "turn option <name> off")
    480 #if HHI_MPI
    481   ("MVI", m_bUseMVI, false, "use motion vector inheritance for depth map coding")
    482 #endif
    483 #if RWTH_SDC_DLT_B0036
    484   ("DLT", m_bUseDLT, true, "use depth lookup table for depth map coding")
    485   ("SDC", m_bUseSDC, true, "use simplified depth coding tree")
    486 #endif
     706
     707#endif //HHI_VSO
     708#if H_3D_QTLPC
     709  ("QTL",                             m_bUseQTL                 , true          , "Use depth Quadtree Limitation" )
     710  ("PC",                              m_bUsePC                  , true          , "Use Predictive Coding with QTL" )
     711#endif
     712#if H_3D_IV_MERGE
     713  ("IvMvPred",                        m_ivMvPredFlag,           true            , "inter view motion prediction " ) 
     714#endif
     715#if H_3D_NBDV_REF
     716  ("DepthRefinement",                 m_depthRefinementFlag,    true           , "depth refinement by DoNBDV" ) 
     717#endif
     718#if H_3D_VSP
     719  ("ViewSynthesisPred",               m_viewSynthesisPredFlag,  true           , "view synthesis prediction " ) 
     720#endif
     721#if H_3D_TMVP
     722  ("IvMvScaling",                     m_ivMvScalingFlag      ,  true            , "inter view motion vector scaling" )   
     723#endif
     724#endif //H_3D
    487725  ;
    488  
     726  #if H_MV
    489727  // parse coding structure
    490   for( Int k = 0; k < MAX_VIEW_NUM; k++ )
    491   {
     728  for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
     729  {
     730    m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
    492731    if( k == 0 )
    493732    {
     
    496735        std::ostringstream cOSS;
    497736        cOSS<<"Frame"<<i;
    498         opts.addOptions()( cOSS.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc() );
     737        opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
     738        if ( i != 1 )
     739        {
     740          opts.opt_list.back()->opt->opt_duplicate = true;
     741        }       
    499742      }
    500743    }
     
    502745    {
    503746      std::ostringstream cOSS1;
    504       cOSS1<<"FrameI"<<"_v"<<k;
    505       opts.addOptions()(cOSS1.str(), m_GOPListsMvc[k][MAX_GOP], GOPEntryMvc());
     747      cOSS1<<"FrameI"<<"_l"<<k;
     748
     749      opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
     750      if ( k > 1 )
     751      {
     752        opts.opt_list.back()->opt->opt_duplicate = true;
     753      }       
     754
    506755
    507756      for( Int i = 1; i < MAX_GOP + 1; i++ )
    508757      {
    509758        std::ostringstream cOSS2;
    510         cOSS2<<"Frame"<<i<<"_v"<<k;
    511         opts.addOptions()(cOSS2.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc());
    512       }
    513     }
    514   }
    515 
     759        cOSS2<<"Frame"<<i<<"_l"<<k;
     760        opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
     761        if ( i != 1 || k > 0 )
     762        {
     763          opts.opt_list.back()->opt->opt_duplicate = true;
     764        }       
     765      }
     766    }
     767  }
     768#else
     769  for(Int i=1; i<MAX_GOP+1; i++) {
     770    std::ostringstream cOSS;
     771    cOSS<<"Frame"<<i;
     772    opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
     773  }
     774#endif
    516775  po::setDefaults(opts);
    517   const list<const char*>& argv_unhandled = po::scanArgv(opts, argc, (const char**) argv);
    518 
    519   for (list<const char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
     776  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
     777
     778  for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    520779  {
    521780    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
     
    526785    /* argc == 1: no options have been specified */
    527786    po::doHelp(cout, opts);
    528     xPrintUsage();
    529787    return false;
    530788  }
     
    534792   */
    535793  /* convert std::string to c string for compatability */
     794#if !H_MV
     795  m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
     796#endif
    536797  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
     798#if !H_MV
     799  m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
     800#endif
    537801  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
    538 #if FLEX_CODING_ORDER_M23723
    539   m_pchMVCJointCodingOrder= cfg_JointCodingOrdering.empty()?NULL:strdup(cfg_JointCodingOrdering.c_str());
    540   // If flexible order is enabled and if depth comes before the texture for a view, disable VSO
    541 #if HHI_VSO && DISABLE_FCO_FOR_VSO
    542   Bool depthComesFirst = false;
    543   int iter = 0;
    544   if ( m_b3DVFlexOrder )
    545   {
    546     for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
    547     {
    548       iter = 0;
    549       for ( Int ii=1; ii<12; ii+=2 )
    550       {
    551         Int iViewIdxCfg = (Int)(m_pchMVCJointCodingOrder[ii]-'0');
    552         if ( iViewIdxCfg == iViewIdx )
    553         {
    554           iter ++;
    555           if ( m_pchMVCJointCodingOrder[ii-1]=='D' ) // depth comes first for this view
    556           {
    557             if(iter == 1)
    558            {
    559             depthComesFirst = true;
    560             break;
    561            }
    562           }
    563           else
    564           {
    565             assert(m_pchMVCJointCodingOrder[ii-1]=='T');
    566           }
    567         }
    568       }
    569     }
    570   }
    571   if (depthComesFirst)
    572   {
    573     m_bUseVSO = false;
    574   }
    575 #endif
    576 #endif
    577   m_pchColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
    578   m_pchRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
     802 
     803  Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
     804  Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
     805  if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
     806  {
     807    char *columnWidth;
     808    int  i=0;
     809    m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
     810    columnWidth = strtok(pColumnWidth, " ,-");
     811    while(columnWidth!=NULL)
     812    {
     813      if( i>=m_iNumColumnsMinus1 )
     814      {
     815        printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
     816        exit( EXIT_FAILURE );
     817      }
     818      *( m_pColumnWidth + i ) = atoi( columnWidth );
     819      columnWidth = strtok(NULL, " ,-");
     820      i++;
     821    }
     822    if( i<m_iNumColumnsMinus1 )
     823    {
     824      printf( "The width of some columns is not defined.\n" );
     825      exit( EXIT_FAILURE );
     826    }
     827  }
     828  else
     829  {
     830    m_pColumnWidth = NULL;
     831  }
     832
     833  if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
     834  {
     835    char *rowHeight;
     836    int  i=0;
     837    m_pRowHeight = new UInt[m_iNumRowsMinus1];
     838    rowHeight = strtok(pRowHeight, " ,-");
     839    while(rowHeight!=NULL)
     840    {
     841      if( i>=m_iNumRowsMinus1 )
     842      {
     843        printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
     844        exit( EXIT_FAILURE );
     845      }
     846      *( m_pRowHeight + i ) = atoi( rowHeight );
     847      rowHeight = strtok(NULL, " ,-");
     848      i++;
     849    }
     850    if( i<m_iNumRowsMinus1 )
     851    {
     852      printf( "The height of some rows is not defined.\n" );
     853      exit( EXIT_FAILURE );
     854   }
     855  }
     856  else
     857  {
     858    m_pRowHeight = NULL;
     859  }
     860#if H_MV
     861  free ( pColumnWidth );
     862  free ( pRowHeight   );
     863#endif
    579864  m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
    580865 
    581   if ( m_bUsingDepthMaps )
    582   {
    583     for(Int i = 0; i < m_pchDepthReconFileList.size() ; i++)
    584     {
    585       if ((m_pchDepthInputFileList[i] != NULL) && (m_pchReconFileList[i] != NULL) && (i < m_iNumberOfViews) )
    586       {
    587         if (m_pchDepthReconFileList[i] == NULL )
    588         {
    589           xAppendToFileNameEnd( m_pchReconFileList[i], "_depth", m_pchDepthReconFileList[i] );
    590         }
    591       }
    592       else
    593       {
    594         m_pchDepthReconFileList[i] = NULL;
    595       }
    596     };
    597   }
    598   if ( m_adQP.size() < 2 )
    599   {
    600     m_adQP.push_back( m_adQP[0] );
    601   };
    602   for (UInt uiK = 0; uiK < m_adQP.size(); uiK++)
    603   {
    604     m_aiQP.push_back( (Int)( m_adQP[uiK] ) );
    605   }
    606 
    607   switch (m_croppingMode)
     866  /* rules for input, output and internal bitdepths as per help text */
     867  if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
     868  if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
     869  if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
     870  if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
     871  if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
     872
     873  // TODO:ChromaFmt assumes 4:2:0 below
     874  switch (m_conformanceMode)
    608875  {
    609876  case 0:
    610877    {
    611       // no cropping or padding
    612       m_cropLeft = m_cropRight = m_cropTop = m_cropBottom = 0;
     878      // no conformance or padding
     879      m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
    613880      m_aiPad[1] = m_aiPad[0] = 0;
    614881      break;
     
    620887      if (m_iSourceWidth % minCuSize)
    621888      {
    622         m_aiPad[0] = m_cropRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
    623         m_iSourceWidth  += m_cropRight;
     889        m_aiPad[0] = m_confRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
     890        m_iSourceWidth  += m_confRight;
    624891      }
    625892      if (m_iSourceHeight % minCuSize)
    626893      {
    627         m_aiPad[1] = m_cropBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
    628         m_iSourceHeight += m_cropBottom;
     894        m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
     895        m_iSourceHeight += m_confBottom;
     896      }
     897      if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
     898      {
     899        fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
     900        exit(EXIT_FAILURE);
     901      }
     902      if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
     903      {
     904        fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
     905        exit(EXIT_FAILURE);
    629906      }
    630907      break;
     
    635912      m_iSourceWidth  += m_aiPad[0];
    636913      m_iSourceHeight += m_aiPad[1];
    637       m_cropRight  = m_aiPad[0];
    638       m_cropBottom = m_aiPad[1];
     914      m_confRight  = m_aiPad[0];
     915      m_confBottom = m_aiPad[1];
    639916      break;
    640917    }
    641918  case 3:
    642919    {
    643       // cropping
    644       if ((m_cropLeft == 0) && (m_cropRight == 0) && (m_cropTop == 0) && (m_cropBottom == 0))
    645       {
    646         fprintf(stderr, "Warning: Cropping enabled, but all cropping parameters set to zero\n");
     920      // conformance
     921      if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
     922      {
     923        fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
    647924      }
    648925      if ((m_aiPad[1] != 0) || (m_aiPad[0]!=0))
    649926      {
    650         fprintf(stderr, "Warning: Cropping enabled, padding parameters will be ignored\n");
     927        fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
    651928      }
    652929      m_aiPad[1] = m_aiPad[0] = 0;
     
    656933 
    657934  // allocate slice-based dQP values
    658   m_aidQP = new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
    659   m_aidQPdepth =  new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
    660   ::memset( m_aidQP, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
    661   ::memset( m_aidQPdepth, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
     935#if H_MV
     936  xResizeVector( m_viewId    );
     937#if H_3D
     938  xResizeVector( m_depthFlag );
     939
     940  std::vector<Int> uniqueViewIds;
     941  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     942  {   
     943    Bool isIn = false;
     944    for ( Int i = 0 ; i < uniqueViewIds.size(); i++ )
     945    {
     946      isIn = isIn || ( m_viewId[ layer ] == uniqueViewIds[ i ] );
     947    }
     948    if ( !isIn )
     949    {
     950      uniqueViewIds.push_back( m_viewId[ layer ] );
     951    }
     952  }
     953  m_iNumberOfViews = (Int) uniqueViewIds.size();
     954#endif
     955
     956  xResizeVector( m_fQP );
     957
     958  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     959  {
     960    m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
     961    ::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
     962
     963    // handling of floating-point QP values
     964    // if QP is not integer, sequence is split into two sections having QP and QP+1
     965    m_iQP.push_back((Int)( m_fQP[layer] ));
     966    if ( m_iQP[layer] < m_fQP[layer] )
     967    {
     968      Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
     969
     970      iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
     971      for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
     972      {
     973        m_aidQP[layer][i] = 1;
     974      }
     975    }
     976  }
     977
     978  xResizeVector( m_bLoopFilterDisable );
     979  xResizeVector( m_bUseSAO );
     980
     981#else
     982  m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
     983  ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
    662984 
    663985  // handling of floating-point QP values
    664986  // if QP is not integer, sequence is split into two sections having QP and QP+1
    665   m_aiQP[0] = (Int)( m_adQP[0] );
    666   if ( m_aiQP[0] < m_adQP[0] )
    667   {
    668     Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[0] - m_aiQP[0])*m_iFrameToBeEncoded + 0.5 );
     987  m_iQP = (Int)( m_fQP );
     988  if ( m_iQP < m_fQP )
     989  {
     990    Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
    669991   
    670992    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
    671     for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
     993    for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
    672994    {
    673995      m_aidQP[i] = 1;
    674996    }
    675997  }
    676 
    677   m_aiQP[1] = (Int)( m_adQP[1] );
    678   if ( m_aiQP[1] < m_adQP[1] )
    679   {
    680     Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[1] - m_aiQP[1])*m_iFrameToBeEncoded + 0.5 );
    681 
    682     iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
    683     for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
    684     {
    685       m_aidQPdepth[i] = 1;
    686     }
    687   }
    688 
     998#endif
     999 
    6891000  // reading external dQP description from file
    6901001  if ( m_pchdQPFile )
     
    6931004    if ( fpt )
    6941005    {
     1006#if H_MV
     1007      for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     1008      {
     1009#endif
    6951010      Int iValue;
    6961011      Int iPOC = 0;
    697       while ( iPOC < m_iFrameToBeEncoded )
     1012      while ( iPOC < m_framesToBeEncoded )
    6981013      {
    6991014        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
     1015#if H_MV
     1016        m_aidQP[layer][ iPOC ] = iValue;
     1017        iPOC++;
     1018      }
     1019#else
    7001020        m_aidQP[ iPOC ] = iValue;
    7011021        iPOC++;
     1022#endif
    7021023      }
    7031024      fclose(fpt);
    7041025    }
    7051026  }
    706 
    707 #if HHI_VSO
    708   m_bUseVSO = m_bUseVSO && m_bUsingDepthMaps && (m_uiVSOMode != 0);
    709 #endif
    710 
    711 #if LGE_WVSO_A0119
    712   m_bUseWVSO = m_bUseVSO && m_bUseWVSO && m_bUsingDepthMaps;
    713 #endif
    714   xCleanUpVectors();
    715 
    716 
    717 #if TMVP_DEPTH_SWITCH
    718   if ( m_enableTMVP.size() < 2)
    719   {
    720     m_enableTMVP.push_back( m_enableTMVP[0]  );
    721   }
    722 #endif
    723  
    724 
    725 #if HHI_VSO
    726   if ( m_abUseALF .size() < 2)
    727     m_abUseALF .push_back( m_bUseVSO ? false : m_abUseALF[0]  );
    728 
    729   if ( m_abUseRDOQ.size() < 2)
    730     m_abUseRDOQ.push_back( m_bUseVSO ? true : m_abUseRDOQ[0] );
    731 
    732   if ( m_abLoopFilterDisable.size() < 2)
    733     m_abLoopFilterDisable.push_back( m_bUseVSO ? true : m_abLoopFilterDisable[0]  );
    734 
    735   if (m_abUseSAO.size() < 2)
    736     m_abUseSAO.push_back            ( m_bUseVSO ? false : m_abUseSAO[0] );
    737 #else
    738   if ( m_abUseALF .size() < 2)
    739     m_abUseALF .push_back( m_abUseALF[0]  );
    740 
    741   if ( m_abUseRDOQ.size() < 2)
    742     m_abUseRDOQ.push_back( m_abUseRDOQ[0] );
    743 
    744   if ( m_abLoopFilterDisable.size() < 2)
    745     m_abLoopFilterDisable.push_back( m_abLoopFilterDisable[0]  );
    746 
    747   if (m_abUseSAO.size() < 2)
    748     m_abUseSAO.push_back            ( m_abUseSAO[0] );
    749 #endif
    750 
    751 #if HHI_VSO
    752 
    753 #if HHI_VSO_LS_TABLE_M23714
     1027  m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
     1028
     1029  if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
     1030  {
     1031    Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
     1032    Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
     1033    Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
     1034    if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
     1035    {
     1036      char *startOfCodedInterval;
     1037      UInt num = 1u<< m_toneMapTargetBitDepth;
     1038      m_startOfCodedInterval = new Int[num];
     1039      ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
     1040      startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
     1041      int i = 0;
     1042      while( startOfCodedInterval && ( i < num ) )
     1043      {
     1044        m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
     1045        startOfCodedInterval = strtok(NULL, " .");
     1046        i++;
     1047      }
     1048    }
     1049    else
     1050    {
     1051      m_startOfCodedInterval = NULL;
     1052    }
     1053    if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
     1054    {
     1055      if( pcCodedPivotValue && pcTargetPivotValue )
     1056      {
     1057        char *codedPivotValue;
     1058        char *targetPivotValue;
     1059        m_codedPivotValue = new Int[m_numPivots];
     1060        m_targetPivotValue = new Int[m_numPivots];
     1061        ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
     1062        ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
     1063        codedPivotValue = strtok(pcCodedPivotValue, " .");
     1064        int i=0;
     1065        while(codedPivotValue&&i<m_numPivots)
     1066        {
     1067          m_codedPivotValue[i] = atoi( codedPivotValue );
     1068          codedPivotValue = strtok(NULL, " .");
     1069          i++;
     1070        }
     1071        i=0;
     1072        targetPivotValue = strtok(pcTargetPivotValue, " .");
     1073        while(targetPivotValue&&i<m_numPivots)
     1074        {
     1075          m_targetPivotValue[i]= atoi( targetPivotValue );
     1076          targetPivotValue = strtok(NULL, " .");
     1077          i++;
     1078        }
     1079      }
     1080    }
     1081    else
     1082    {
     1083      m_codedPivotValue = NULL;
     1084      m_targetPivotValue = NULL;
     1085    }
     1086  }
     1087#if H_3D
     1088  // set global varibles
     1089  xSetGlobal();
     1090#if H_3D_VSO
     1091// Table base optimization
    7541092  // Q&D
    7551093  Double adLambdaScaleTable[] =
     
    7611099     0.753550, 0.800000 
    7621100  };
    763   if ( m_bVSOLSTable )
    764   {
    765     AOT( (m_aiQP[1] < 0) || (m_aiQP[1] > 51));
    766     m_dLambdaScaleVSO *= adLambdaScaleTable[m_aiQP[1]];
    767   }
    768 #endif
    769 #endif
    770 
    771  // set global variables
    772   xSetGlobal();
    773 
    774   // read and check camera parameters
    775 #if HHI_VSO
     1101  if ( m_bUseVSO && m_bVSOLSTable )
     1102  {
     1103    Int firstDepthLayer = -1;
     1104    for (Int layer = 0; layer < m_numberOfLayers; layer++ )
     1105    {
     1106      if ( m_depthFlag[ layer ])
     1107      {
     1108        firstDepthLayer = layer;
     1109        break;
     1110      }
     1111    }
     1112    AOT( firstDepthLayer == -1 );
     1113    AOT( (m_iQP[firstDepthLayer] < 0) || (m_iQP[firstDepthLayer] > 51));
     1114    m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
     1115  }
     1116#endif
     1117#if H_3D_VSO
    7761118if ( m_bUseVSO && m_uiVSOMode == 4)
    7771119{
    7781120  m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
    779   m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
    780                                       m_uiInputBitDepth,
     1121  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ),
     1122                                      g_bitDepthY,
    7811123                                (UInt)m_iCodedCamParPrecision,
    7821124                                      m_FrameSkip,
    783                                 (UInt)m_iFrameToBeEncoded,
     1125                                (UInt)m_framesToBeEncoded,
    7841126                                      m_pchCameraParameterFile,
    7851127                                      m_pchBaseViewCameraNumbers,
     
    7901132else if ( m_bUseVSO && m_uiVSOMode != 4 )
    7911133{
    792   m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
    793                                       m_uiInputBitDepth,
     1134  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ),
     1135                                      g_bitDepthY,
    7941136                                (UInt)m_iCodedCamParPrecision,
    7951137                                      m_FrameSkip,
    796                                 (UInt)m_iFrameToBeEncoded,
     1138                                (UInt)m_framesToBeEncoded,
    7971139                                      m_pchCameraParameterFile,
    7981140                                      m_pchBaseViewCameraNumbers,
     
    8031145else
    8041146{
    805   m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
    806     m_uiInputBitDepth,
    807     (UInt)m_iCodedCamParPrecision,
     1147  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ),
     1148    g_bitDepthY,
     1149    (UInt) m_iCodedCamParPrecision,
    8081150    m_FrameSkip,
    809     (UInt)m_iFrameToBeEncoded,
     1151    (UInt) m_framesToBeEncoded,
    8101152    m_pchCameraParameterFile,
    8111153    m_pchBaseViewCameraNumbers,
     
    8151157}
    8161158#else
    817 #if !QC_MVHEVC_B0046
    818   m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
    819     m_uiInputBitDepth,
    820     (UInt)m_iCodedCamParPrecision,
     1159  m_cCameraData     .init     ( ((UInt) m_iNumberOfViews ),
     1160    g_bitDepthY,
     1161    (UInt) m_iCodedCamParPrecision,
    8211162    m_FrameSkip,
    822     (UInt)m_iFrameToBeEncoded,
     1163    (UInt) m_framesToBeEncoded,
    8231164    m_pchCameraParameterFile,
    8241165    m_pchBaseViewCameraNumbers,
     
    8271168    LOG2_DISP_PREC_LUT );
    8281169#endif
    829 #endif
    830 
    831 
     1170  m_cCameraData.check( false, true );
     1171#endif
    8321172  // check validity of input parameters
    8331173  xCheckParameter();
    834 #if !QC_MVHEVC_B0046
    835   m_cCameraData.check( false, true );
    836 #endif
     1174
     1175#if !H_3D
     1176  // set global varibles
     1177  xSetGlobal();
     1178#endif
     1179 
    8371180  // print-out parameters
    8381181  xPrintParameter();
     
    8401183  return true;
    8411184}
    842 
    8431185// ====================================================================================================================
    8441186// Private member functions
    8451187// ====================================================================================================================
    8461188
    847 Bool confirmPara(Bool bflag, const char* message);
     1189Bool confirmPara(Bool bflag, const Char* message);
    8481190
    8491191Void TAppEncCfg::xCheckParameter()
    8501192{
    851   bool check_failed = false; /* abort if there is a fatal configuration problem */
     1193  if (!m_decodedPictureHashSEIEnabled)
     1194  {
     1195    fprintf(stderr, "******************************************************************\n");
     1196    fprintf(stderr, "** WARNING: --SEIDecodedPictureHash is now disabled by default. **\n");
     1197    fprintf(stderr, "**          Automatic verification of decoded pictures by a     **\n");
     1198    fprintf(stderr, "**          decoder requires this option to be enabled.         **\n");
     1199    fprintf(stderr, "******************************************************************\n");
     1200  }
     1201  if( m_profile==Profile::NONE )
     1202  {
     1203    fprintf(stderr, "***************************************************************************\n");
     1204    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Profile value must be set! **\n");
     1205    fprintf(stderr, "***************************************************************************\n");
     1206  }
     1207  if( m_level==Level::NONE )
     1208  {
     1209    fprintf(stderr, "***************************************************************************\n");
     1210    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Level value must be set!   **\n");
     1211    fprintf(stderr, "***************************************************************************\n");
     1212  }
     1213
     1214  Bool check_failed = false; /* abort if there is a fatal configuration problem */
    8521215#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
    8531216  // check range of parameters
    854   xConfirmPara( m_uiInputBitDepth < 8,                                                      "InputBitDepth must be at least 8" );
     1217  xConfirmPara( m_inputBitDepthY < 8,                                                     "InputBitDepth must be at least 8" );
     1218  xConfirmPara( m_inputBitDepthC < 8,                                                     "InputBitDepthC must be at least 8" );
    8551219  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
    856   xConfirmPara( m_iFrameToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
     1220  xConfirmPara( m_framesToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
     1221#if H_MV
     1222  xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS ,                                      "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
     1223
     1224
     1225  xConfirmPara( m_layerIdInNuh[0] != 0      , "LayerIdInNuh must be 0 for the first layer. ");
     1226  xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
     1227 
     1228#if H_3D
     1229  xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
     1230#else
     1231  xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
     1232#endif
     1233 
     1234  m_dimIds.push_back( m_viewId );
     1235  const Int viewDimPosition = 0;
     1236#if H_3D
     1237  if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
     1238    m_dimIds.push_back( m_depthFlag );
     1239#endif
     1240
     1241  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
     1242
     1243  dimBitOffset[ 0 ] = 0;
     1244  for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
     1245 {
     1246    dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
     1247  }
     1248
     1249  if ( m_splittingFlag )
     1250  {
     1251    dimBitOffset[ (Int) m_dimIds.size() ] = 6;
     1252  }
     1253 
     1254  for( Int j = 0; j < m_dimIds.size(); j++ )
     1255  {   
     1256    xConfirmPara( m_dimIds[j].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");   
     1257    xConfirmPara( ( j != viewDimPosition ) &&  (m_dimIds[j][0] != 0), "DimensionId of layer 0 must be 0. " );
     1258    xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
     1259     
     1260
     1261   for( Int i = 1; i < m_numberOfLayers; i++ )
     1262   {     
     1263      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. " );
     1264      if ( m_splittingFlag )
     1265      {
     1266        Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] :  i;
     1267        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. ");
     1268      }
     1269   }
     1270 }
     1271
     1272 for( Int i = 0; i < m_numberOfLayers; i++ )
     1273 {
     1274   for( Int j = 0; j < i; j++ )
     1275   {     
     1276     Int numDiff  = 0;
     1277     Int lastDiff = -1;
     1278     for( Int dim = 0; dim < m_dimIds.size(); dim++ )
     1279     {
     1280       if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
     1281       {
     1282         numDiff ++;
     1283         lastDiff = dim;
     1284       }
     1285     }
     1286
     1287     Bool allEqual = ( numDiff == 0 );
     1288
     1289     if ( allEqual )
     1290     {
     1291       printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
     1292     }
     1293
     1294     xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
     1295
     1296     if ( numDiff  == 1 )
     1297     {
     1298       Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
     1299       Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ;
     1300       if ( shallBeButIsNotIncreasing )
     1301       {       
     1302         printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
     1303       }
     1304       xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ),  "DimensionIds shall be increasing within one dimension. " );
     1305     }
     1306   }
     1307 }
     1308
     1309  /// Layer sets
     1310  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ;
     1311  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
     1312  {
     1313    if (lsIdx == 0)
     1314    {
     1315      xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 || m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
     1316    }
     1317    for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
     1318    {
     1319      xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 || m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than 64" );
     1320    }
     1321  }
     1322
     1323  // Output layer sets
     1324  xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
     1325  for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
     1326  {   
     1327    Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
     1328    xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
     1329
     1330    for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
     1331    {
     1332      Bool isAlsoInLayerSet = false;
     1333      for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
     1334      {
     1335        if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
     1336        {
     1337          isAlsoInLayerSet = true;
     1338          break;
     1339        }       
     1340      }
     1341      xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
     1342    }
     1343  }
     1344  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" );
     1345
     1346  // Layer Dependencies 
     1347  for (Int i = 0; i < m_numberOfLayers; i++ )
     1348  {
     1349    xConfirmPara( (i == 0)  && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
     1350    xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
     1351    for (Int j = 0; j < m_directRefLayers[i].size(); j++)
     1352    {
     1353      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");
     1354      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");
     1355    }       
     1356  } 
     1357#endif
    8571358  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
    8581359  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
    8591360  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
    8601361  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
    861   xConfirmPara( m_aiQP[0] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[0] > 51,         "QP exceeds supported range (-QpBDOffsety to 51)" );
    862   if ( m_aiQP.size() >= 2 )
    863   {
    864     xConfirmPara( m_aiQP[1] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[1] > 51,       "QP depth exceeds supported range (-QpBDOffsety to 51)" );
    865   }
    866   xConfirmPara( m_iALFEncodePassReduction < 0 || m_iALFEncodePassReduction > 2,             "ALFEncodePassReduction must be equal to 0, 1 or 2");
    867   xConfirmPara( m_iALFMaxNumberFilters < 1,                                                 "ALFMaxNumFilter should be larger than 1"); 
    868   xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 || m_loopFilterBetaOffsetDiv2 > 13,          "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
    869   xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 || m_loopFilterTcOffsetDiv2 > 13,              "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
     1362#if H_MV
     1363  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     1364  {
     1365    xConfirmPara( m_iQP[layer] <  -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51,      "QP exceeds supported range (-QpBDOffsety to 51)" );
     1366  }
     1367#else
     1368  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
     1369#endif
     1370  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6,          "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
     1371  xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6,              "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
    8701372  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
    8711373  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
    872 #if DV_V_RESTRICTION_B0037
    873   xConfirmPara( m_iVerticalDisparitySearchRange <= 0 ,                                      "Vertical Disparity Search Range must be more than 0" );
    874 #endif
    8751374  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
    8761375  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
    8771376  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
    8781377
    879   xConfirmPara( m_iChromaQpOffset    < -12,   "Min. Chroma Qp Offset is -12"    );
    880   xConfirmPara( m_iChromaQpOffset    >  12,   "Max. Chroma Qp Offset is  12"    );
    881   xConfirmPara( m_iChromaQpOffset2nd < -12,   "Min. Chroma Qp Offset 2nd is -12" );
    882   xConfirmPara( m_iChromaQpOffset2nd >  12,   "Max. Chroma Qp Offset 2nd is  12" );
     1378  xConfirmPara( m_cbQpOffset < -12,   "Min. Chroma Cb QP Offset is -12" );
     1379  xConfirmPara( m_cbQpOffset >  12,   "Max. Chroma Cb QP Offset is  12" );
     1380  xConfirmPara( m_crQpOffset < -12,   "Min. Chroma Cr QP Offset is -12" );
     1381  xConfirmPara( m_crQpOffset >  12,   "Max. Chroma Cr QP Offset is  12" );
    8831382
    8841383  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
     
    8951394 
    8961395  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
    897   xConfirmPara( m_uiQuadtreeTULog2MinSize > 5,                                        "QuadtreeTULog2MinSize must be 5 or smaller.");
    898   xConfirmPara( m_uiQuadtreeTULog2MaxSize < 2,                                        "QuadtreeTULog2MaxSize must be 2 or greater.");
    8991396  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
     1397  xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth,                                        "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
     1398 
    9001399  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
    9011400  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
     
    9041403  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
    9051404  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
    906   xConfirmPara( m_uiQuadtreeTUMaxDepthInter > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthInter must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
     1405  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" );
    9071406  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
    908   xConfirmPara( m_uiQuadtreeTUMaxDepthIntra > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthIntra must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
    909 
    910   xConfirmPara( m_iNumberOfViews > MAX_VIEW_NUM ,                                     "NumberOfViews must be less than or equal to MAX_VIEW_NUM");
    911   xConfirmPara    ( Int( m_pchInputFileList.size() ) < m_iNumberOfViews,              "Number of InputFiles must be greater than or equal to NumberOfViews" );
    912   xConfirmPara    ( Int( m_pchReconFileList.size() ) < m_iNumberOfViews,              "Number of ReconFiles must be greater than or equal to NumberOfViews" );
    913   xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
    914 #if HHI_INTERVIEW_SKIP
    915   xConfirmPara    ( m_bInterViewSkip && !m_bUsingDepthMaps,                       "RenderingSkipMode requires CodeDepthMaps = 1" );
    916 #endif
    917 #if DEPTH_MAP_GENERATION
    918   xConfirmPara    ( m_uiPredDepthMapGeneration > 2,                                   "PredDepthMapGen must be less than or equal to 2" );
    919   xConfirmPara    ( m_uiPredDepthMapGeneration >= 2 && !m_bUsingDepthMaps,            "PredDepthMapGen >= 2 requires CodeDepthMaps = 1" );
    920 #endif
    921 #if H3D_IVMP
    922   xConfirmPara    ( m_uiMultiviewMvPredMode > 7,                                      "MultiviewMvPred must be less than or equal to 7" );
    923   xConfirmPara    ( m_uiMultiviewMvPredMode > 0 && m_uiPredDepthMapGeneration == 0 ,  "MultiviewMvPred > 0 requires PredDepthMapGen > 0" );
    924   xConfirmPara    ( m_uiMultiviewMvRegMode       > 1,                                 "MultiviewMvRegMode must be less than or equal to 1" );
    925   xConfirmPara    ( m_dMultiviewMvRegLambdaScale < 0.0,                               "MultiviewMvRegLambdaScale must not be negative" );
    926   if( m_uiMultiviewMvRegMode )
    927   {
    928     xConfirmPara  ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews,         "MultiviewMvRegMode > 0 requires the presence of input depth maps" );
    929   }
    930 #endif
    931 #if H3D_IVRP
    932 #if QC_ARP_D0177
    933 #if QC_ARP_WARNING_FIX
    934   xConfirmPara    ( m_nUseAdvResPred > 1 , "0<=ARP<=1" );
    935 #else
    936   xConfirmPara    ( m_nUseAdvResPred < 0 || m_nUseAdvResPred > 1 , "0<=ARP<=1" );
    937 #endif
    938 #else
    939   xConfirmPara    ( m_uiMultiviewResPredMode > 1,                                     "MultiviewResPred must be less than or equal to 1" );
    940   xConfirmPara    ( m_uiMultiviewResPredMode > 0 && m_uiPredDepthMapGeneration == 0 , "MultiviewResPred > 0 requires PredDepthMapGen > 0" );
    941 #endif
    942 #endif
    943   if( m_bUsingDepthMaps )
    944   {
    945     xConfirmPara  ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews,         "Number of DepthInputFiles must be greater than or equal to NumberOfViews" );
    946     xConfirmPara  ( Int( m_pchDepthReconFileList.size() ) < m_iNumberOfViews,         "Number of DepthReconFiles must be greater than or equal to NumberOfViews" );
    947 
    948 #if HHI_VSO
    949     if( m_bUseVSO )
    950     {
    951       xConfirmPara( m_pchCameraParameterFile    == 0                             ,   "CameraParameterFile must be given");
    952       xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
    953       xConfirmPara( m_pchBaseViewCameraNumbers  == 0                             ,   "BaseViewCameraNumbers must be given" );
    954       xConfirmPara( m_iNumberOfViews != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
    955       xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
    956     }
    957 #endif
    958   }
     1407  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" );
     1408 
     1409  xConfirmPara(  m_maxNumMergeCand < 1,  "MaxNumMergeCand must be 1 or greater.");
     1410  xConfirmPara(  m_maxNumMergeCand > 5,  "MaxNumMergeCand must be 5 or smaller.");
     1411
     1412#if H_3D_ARP
     1413  xConfirmPara( ( 0 != m_uiUseAdvResPred ) &&  ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
     1414#endif
    9591415#if ADAPTIVE_QP_SELECTION
    960   xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[0] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
    961   xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[1] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
    962   xConfirmPara( m_bUseAdaptQpSelect == true && (m_iChromaQpOffset !=0 || m_iChromaQpOffset2nd != 0 ),  "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
     1416#if H_MV
     1417  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     1418  {
     1419    xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0,                                     "AdaptiveQpSelection must be disabled when QP < 0.");
     1420  }
     1421#else
     1422  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
     1423#endif
     1424  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
    9631425#endif
    9641426
     
    9711433  }
    9721434
    973   xConfirmPara( m_iSliceMode < 0 || m_iSliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
    974   if (m_iSliceMode!=0)
    975   {
    976     xConfirmPara( m_iSliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
    977   }
    978   if (m_iSliceMode==3)
    979   {
    980     xConfirmPara( m_iSliceGranularity > 0 ,      "When SliceMode == 3 is chosen, the SliceGranularity must be 0" );
    981   }
    982   xConfirmPara( m_iEntropySliceMode < 0 || m_iEntropySliceMode > 2, "EntropySliceMode exceeds supported range (0 to 2)" );
    983   if (m_iEntropySliceMode!=0)
    984   {
    985     xConfirmPara( m_iEntropySliceArgument < 1 ,         "EntropySliceArgument should be larger than or equal to 1" );
    986   }
    987   xConfirmPara( m_iSliceGranularity >= m_uiMaxCUDepth, "SliceGranularity must be smaller than maximum cu depth");
    988   xConfirmPara( m_iSliceGranularity <0 || m_iSliceGranularity > 3, "SliceGranularity exceeds supported range (0 to 3)" );
    989   xConfirmPara( m_iSliceGranularity > m_iMaxCuDQPDepth, "SliceGranularity must be smaller smaller than or equal to maximum dqp depth" );
    990 
    991   bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
    992   xConfirmPara( tileFlag && m_iEntropySliceMode,            "Tile and Entropy Slice can not be applied together");
     1435  xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
     1436  if (m_sliceMode!=0)
     1437  {
     1438    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
     1439  }
     1440  xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
     1441  if (m_sliceSegmentMode!=0)
     1442  {
     1443    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
     1444  }
     1445 
     1446  Bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
    9931447  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
    994   xConfirmPara( m_iWaveFrontSynchro && m_iEntropySliceMode, "Wavefront and Entropy Slice can not be applied together"); 
    995 
     1448
     1449  //TODO:ChromaFmt assumes 4:2:0 below
     1450  xConfirmPara( m_iSourceWidth  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
     1451  xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
     1452
     1453  xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
     1454  xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
     1455
     1456  xConfirmPara( m_confLeft   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
     1457  xConfirmPara( m_confRight  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
     1458  xConfirmPara( m_confTop    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
     1459  xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
     1460
     1461#if H_3D
     1462  xConfirmPara( m_pchCameraParameterFile    == 0                ,   "CameraParameterFile must be given");
     1463  xConfirmPara( m_pchBaseViewCameraNumbers  == 0                ,   "BaseViewCameraNumbers must be given" );
     1464  xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
     1465  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
     1466#if H_3D_VSO
     1467    if( m_bUseVSO )
     1468    {
     1469      xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
     1470      xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
     1471    }
     1472#endif
     1473#endif
    9961474  // max CU width and height should be power of 2
    9971475  UInt ui = m_uiMaxCUWidth;
     
    10091487      xConfirmPara( ui != 1 , "Height should be 2^n");
    10101488  }
    1011  
    1012   xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
    1013   xConfirmPara( m_iWaveFrontFlush < 0, "WaveFrontFlush cannot be negative" );
    1014   xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
    1015   xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
    1016 
    1017 #undef xConfirmPara
    1018   if (check_failed)
    1019   {
    1020     exit(EXIT_FAILURE);
    1021   }
    1022 
    1023   xCheckCodingStructureMvc();
    1024 }
    1025 
    1026 Void TAppEncCfg::xCheckCodingStructureMvc()
    1027 {
    1028   bool check_failed = false; /* abort if there is a fatal configuration problem */
    1029 #define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
    1030 
    1031   // validate that POC of same frame is identical across multiple views
     1489
     1490#if H_MV
     1491  // validate that POC of same frame is identical across multiple layers
    10321492  Bool bErrorMvePoc = false;
    1033   if( m_iNumberOfViews > 1 )
    1034   {
    1035     for( Int k = 1; k < m_iNumberOfViews; k++ )
     1493  if( m_numberOfLayers > 1 )
     1494  {
     1495    for( Int k = 1; k < m_numberOfLayers; k++ )
    10361496    {
    10371497      for( Int i = 0; i < MAX_GOP; i++ )
    10381498      {
    1039         if( m_GOPListsMvc[k][i].m_POC != m_GOPListsMvc[0][i].m_POC )
     1499        if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
    10401500        {
    1041           printf( "\nError: Frame%d_v%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListsMvc[k][i].m_POC, i );
     1501          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 );
    10421502          bErrorMvePoc = true;
    10431503        }
     
    10451505    }
    10461506  }
    1047   xConfirmPara( bErrorMvePoc,  "Invalid inter-view POC structure given" );
     1507  xConfirmPara( bErrorMvePoc,  "Invalid inter-layer POC structure given" );
    10481508
    10491509  // validate that baseview has no inter-view refs
     
    10511511  for( Int i = 0; i < MAX_GOP; i++ )
    10521512  {
    1053     if( m_GOPListsMvc[0][i].m_numInterViewRefPics != 0 )
    1054     {
    1055       printf( "\nError: Frame%d inter_view refs not available in view 0\n", i );
     1513    if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
     1514    {
     1515      printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
    10561516      bErrorIvpBase = true;
    10571517    }
    10581518  }
    1059   xConfirmPara( bErrorIvpBase, "Inter-view refs not possible in base view" );
     1519  xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
    10601520
    10611521  // validate inter-view refs
    10621522  Bool bErrorIvpEnhV = false;
    1063   if( m_iNumberOfViews > 1 )
    1064   {
    1065     for( Int k = 1; k < m_iNumberOfViews; k++ )
     1523  if( m_numberOfLayers > 1 )
     1524  {
     1525    for( Int layer = 1; layer < m_numberOfLayers; layer++ )
    10661526    {
    10671527      for( Int i = 0; i < MAX_GOP+1; i++ )
    10681528      {
    1069         for( Int j = 0; j < m_GOPListsMvc[k][i].m_numInterViewRefPics; j++ )
     1529        GOPEntry gopEntry = m_GOPListMvc[layer][i]; 
     1530        for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
    10701531        {
    1071           Int iAbsViewId = m_GOPListsMvc[k][i].m_interViewRefs[j] + k;
    1072           if( iAbsViewId < 0 || iAbsViewId >= k )
     1532          Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
     1533          if( ilPredLayerIdc < 0 || ilPredLayerIdc >= m_directRefLayers[layer].size() )
    10731534          {
    1074             printf( "\nError: inter-view ref pic %d is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefs[j], i, k );
     1535            printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
    10751536            bErrorIvpEnhV = true;
    10761537          }
    1077           if( m_GOPListsMvc[k][i].m_interViewRefPosL0[j] < 0 || m_GOPListsMvc[k][i].m_interViewRefPosL0[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
     1538          if( gopEntry.m_interViewRefPosL[0][j] < -1 || gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
    10781539          {
    1079             printf( "\nError: inter-view ref pos %d on L0 is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefPosL0[j], i, k );
     1540            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 );
    10801541            bErrorIvpEnhV = true;
    10811542          }
    1082           if( m_GOPListsMvc[k][i].m_interViewRefPosL1[j] < 0 || m_GOPListsMvc[k][i].m_interViewRefPosL1[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
     1543          if( gopEntry.m_interViewRefPosL[1][j] < -1  || gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
    10831544          {
    1084             printf( "\nError: inter-view ref pos %d on L1 is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefPosL1[j], i, k );
     1545            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 );
    10851546            bErrorIvpEnhV = true;
    10861547          }
     
    10881549        if( i == MAX_GOP ) // inter-view refs at I pic position in base view
    10891550        {
    1090           if( m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'B' && m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'P' && m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'I' )
     1551          if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
    10911552          {
    1092             printf( "\nError: slice type of FrameI_v%d must be equal to B or P or I\n", k );
     1553            printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
    10931554            bErrorIvpEnhV = true;
    10941555          }
    10951556
    1096           if( m_GOPListsMvc[k][MAX_GOP].m_POC != 0 )
     1557          if( gopEntry.m_POC != 0 )
    10971558          {
    1098             printf( "\nError: POC %d not possible for FrameI_v%d, must be 0\n", m_GOPListsMvc[k][MAX_GOP].m_POC, k );
     1559            printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
    10991560            bErrorIvpEnhV = true;
    11001561          }
    11011562
    1102           if( m_GOPListsMvc[k][MAX_GOP].m_temporalId != 0 )
     1563          if( gopEntry.m_temporalId != 0 )
    11031564          {
    1104             printf( "\nWarning: Temporal id of FrameI_v%d must be 0 (cp. I-frame in base view)\n", k );
    1105             m_GOPListsMvc[k][MAX_GOP].m_temporalId = 0;
     1565            printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
     1566            gopEntry.m_temporalId = 0;
    11061567          }
    11071568
    1108           if( !(m_GOPListsMvc[k][MAX_GOP].m_refPic) )
     1569          if( gopEntry.m_numRefPics != 0 )
    11091570          {
    1110             printf( "\nWarning: FrameI_v%d must be ref pic (cp. I-frame in base view)\n", k );
    1111             m_GOPListsMvc[k][MAX_GOP].m_refPic = true;
     1571            printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
     1572            for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
     1573            {
     1574              gopEntry.m_referencePics[j] = 0;
     1575            }
     1576            gopEntry.m_numRefPics = 0;
    11121577          }
    11131578
    1114           if( m_GOPListsMvc[k][MAX_GOP].m_numRefPics != 0 )
     1579          if( gopEntry.m_interRPSPrediction )
    11151580          {
    1116             printf( "\nWarning: temporal references not possible for FrameI_v%d\n", k );
    1117             for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numRefPics; j++ )
    1118             {
    1119               m_GOPListsMvc[k][MAX_GOP].m_referencePics[j] = 0;
    1120             }
    1121             m_GOPListsMvc[k][MAX_GOP].m_numRefPics = 0;
    1122           }
    1123 
    1124           if( m_GOPListsMvc[k][MAX_GOP].m_interRPSPrediction )
    1125           {
    1126             printf( "\nError: inter RPS prediction not possible for FrameI_v%d, must be 0\n", k );
     1581            printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
    11271582            bErrorIvpEnhV = true;
    11281583          }
    11291584
    1130           if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'I' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics != 0 )
     1585          if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
    11311586          {
    1132             printf( "\nError: inter-view prediction not possible for FrameI_v%d with slice type I, #IV_ref_pics must be 0\n", k );
     1587            printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
    11331588            bErrorIvpEnhV = true;
    11341589          }
    11351590
    1136           if( m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive > m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics )
     1591          if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
    11371592          {
    1138             m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive = m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics;
     1593            gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
    11391594          }
    11401595
    1141           if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'P' )
     1596          if( gopEntry.m_sliceType == 'P' )
    11421597          {
    1143             if( m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
     1598            if( gopEntry.m_numActiveRefLayerPics < 1 )
    11441599            {
    1145               printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type P\n", k );
     1600              printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
    11461601              bErrorIvpEnhV = true;
    11471602            }
    11481603            else
    11491604            {
    1150               for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics; j++ )
     1605              for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
    11511606              {
    1152                 if( m_GOPListsMvc[k][MAX_GOP].m_interViewRefPosL1[j] != 0 )
     1607                if( gopEntry.m_interViewRefPosL[1][j] != -1 )
    11531608                {
    1154                   printf( "\nError: inter-view ref pos %d on L1 not possible for FrameI_v%d with slice type P\n", m_GOPListsMvc[k][MAX_GOP].m_interViewRefPosL1[j], k );
     1609                  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 );
    11551610                  bErrorIvpEnhV = true;
    11561611                }
     
    11591614          }
    11601615
    1161           if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'B' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
     1616          if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
    11621617          {
    1163             printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type B\n", k );
     1618            printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
    11641619            bErrorIvpEnhV = true;
    11651620          }
     
    11681623    }
    11691624  }
    1170   xConfirmPara( bErrorIvpEnhV, "Invalid inter-view coding structure for enhancement views given" );
     1625  xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
    11711626
    11721627  // validate temporal coding structure
    11731628  if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
    11741629  {
    1175     for( Int viewId = 0; viewId < m_iNumberOfViews; viewId++ )
    1176     {
    1177       Bool verifiedGOP = false;
    1178       Bool errorGOP    = false;
    1179       Int  checkGOP    = 1;
    1180       Int  numRefs     = 1;
    1181       Int refList[MAX_NUM_REF_PICS+1];
    1182       refList[0] = 0;
    1183       Bool isOK[MAX_GOP];
    1184       for( Int i = 0; i < MAX_GOP; i++ ) { isOK[i] = false; }
    1185       Int numOK = 0;
    1186       m_extraRPSs[viewId] = 0;
    1187       //start looping through frames in coding order until we can verify that the GOP structure is correct.
    1188       while( !verifiedGOP && !errorGOP )
    1189       {
    1190         Int curGOP = (checkGOP-1)%m_iGOPSize;
    1191         Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPListsMvc[viewId][curGOP].m_POC;   
    1192         if( m_GOPListsMvc[viewId][curGOP].m_POC < 0 )
     1630    for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     1631    {
     1632      GOPEntry* m_GOPList            = m_GOPListMvc           [layer]; // It is not a member, but this name helps avoiding code duplication !!!
     1633      Int&      m_extraRPSs          = m_extraRPSsMvc         [layer]; // It is not a member, but this name helps avoiding code duplication !!!
     1634      Int&      m_maxTempLayer       = m_maxTempLayerMvc      [layer]; // It is not a member, but this name helps avoiding code duplication !!!
     1635      Int*      m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
     1636      Int*      m_numReorderPics     = m_numReorderPicsMvc    [layer]; // It is not a member, but this name helps avoiding code duplication !!!
     1637#endif
     1638  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
     1639   * This permits the ability to omit a GOP structure specification */
     1640  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
     1641    m_GOPList[0] = GOPEntry();
     1642    m_GOPList[0].m_QPFactor = 1;
     1643    m_GOPList[0].m_betaOffsetDiv2 = 0;
     1644    m_GOPList[0].m_tcOffsetDiv2 = 0;
     1645    m_GOPList[0].m_POC = 1;
     1646    m_GOPList[0].m_numRefPicsActive = 4;
     1647  }
     1648 
     1649  Bool verifiedGOP=false;
     1650  Bool errorGOP=false;
     1651  Int checkGOP=1;
     1652  Int numRefs = 1;
     1653  Int refList[MAX_NUM_REF_PICS+1];
     1654  refList[0]=0;
     1655  Bool isOK[MAX_GOP];
     1656  for(Int i=0; i<MAX_GOP; i++)
     1657  {
     1658    isOK[i]=false;
     1659  }
     1660  Int numOK=0;
     1661  xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
     1662
     1663  for(Int i=0; i<m_iGOPSize; i++)
     1664  {
     1665    if(m_GOPList[i].m_POC==m_iGOPSize)
     1666    {
     1667      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
     1668    }
     1669  }
     1670 
     1671#if H_MV
     1672  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
     1673#else
     1674  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
     1675#endif
     1676  {
     1677    for(Int i=0; i<m_iGOPSize; i++)
     1678    {
     1679      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)" );
     1680      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)" );
     1681    }
     1682  }
     1683  m_extraRPSs=0;
     1684  //start looping through frames in coding order until we can verify that the GOP structure is correct.
     1685  while(!verifiedGOP&&!errorGOP)
     1686  {
     1687    Int curGOP = (checkGOP-1)%m_iGOPSize;
     1688    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
     1689    if(m_GOPList[curGOP].m_POC<0)
     1690    {
     1691#if H_MV
     1692      printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
     1693#else
     1694      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
     1695#endif
     1696      errorGOP=true;
     1697    }
     1698    else
     1699    {
     1700      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
     1701      Bool beforeI = false;
     1702      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
     1703      {
     1704        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
     1705        if(absPOC < 0)
    11931706        {
    1194           printf( "\nError: found fewer Reference Picture Sets than GOPSize for view %d\n", viewId );
    1195           errorGOP = true;
     1707          beforeI=true;
    11961708        }
    11971709        else
    11981710        {
    1199           //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
    1200           Bool beforeI = false;
    1201           for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
     1711          Bool found=false;
     1712          for(Int j=0; j<numRefs; j++)
    12021713          {
    1203             Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
    1204             if( absPOC < 0 )
     1714            if(refList[j]==absPOC)
    12051715            {
    1206               beforeI = true;
    1207             }
    1208             else
    1209             {
    1210               Bool found = false;
    1211               for( Int j = 0; j < numRefs; j++ )
     1716              found=true;
     1717              for(Int k=0; k<m_iGOPSize; k++)
    12121718              {
    1213                 if( refList[j] == absPOC )
     1719                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
    12141720                {
    1215                   found = true;
    1216                   for( Int k = 0; k < m_iGOPSize; k++ )
     1721                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
    12171722                  {
    1218                     if( absPOC%m_iGOPSize == m_GOPListsMvc[viewId][k].m_POC%m_iGOPSize )
    1219                     {
    1220                       m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i] = (m_GOPListsMvc[viewId][k].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
    1221                     }
     1723                    m_GOPList[k].m_refPic = true;
    12221724                  }
     1725                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
    12231726                }
    1224               }
    1225               if( !found )
    1226               {
    1227                 printf("\nError: ref pic %d is not available for GOP frame %d of view %d\n", m_GOPListsMvc[viewId][curGOP].m_referencePics[i], curGOP+1, viewId );
    1228                 errorGOP = true;
    12291727              }
    12301728            }
    12311729          }
    1232           if( !beforeI && !errorGOP )
     1730          if(!found)
    12331731          {
    1234             //all ref frames were present
    1235             if( !isOK[curGOP] )
     1732#if H_MV
     1733            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);
     1734#else
     1735            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
     1736#endif
     1737            errorGOP=true;
     1738          }
     1739        }
     1740      }
     1741      if(!beforeI&&!errorGOP)
     1742      {
     1743        //all ref frames were present
     1744        if(!isOK[curGOP])
     1745        {
     1746          numOK++;
     1747          isOK[curGOP]=true;
     1748          if(numOK==m_iGOPSize)
     1749          {
     1750            verifiedGOP=true;
     1751          }
     1752        }
     1753      }
     1754      else
     1755      {
     1756        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
     1757        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
     1758        Int newRefs=0;
     1759        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
     1760        {
     1761          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
     1762          if(absPOC>=0)
     1763          {
     1764            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
     1765            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
     1766            newRefs++;
     1767          }
     1768        }
     1769        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
     1770       
     1771        for(Int offset = -1; offset>-checkGOP; offset--)
     1772        {
     1773          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
     1774          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
     1775          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
     1776          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
     1777          {
     1778            Bool newRef=false;
     1779            for(Int i=0; i<numRefs; i++)
    12361780            {
    1237               numOK++;
    1238               isOK[curGOP] = true;
    1239               if( numOK == m_iGOPSize )
     1781              if(refList[i]==offPOC)
    12401782              {
    1241                 verifiedGOP = true;
     1783                newRef=true;
    12421784              }
    12431785            }
    1244           }
    1245           else
    1246           {
    1247             //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
    1248             m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]] = m_GOPListsMvc[viewId][curGOP];
    1249             Int newRefs = 0;
    1250             for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
     1786            for(Int i=0; i<newRefs; i++)
    12511787            {
    1252               Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
    1253               if( absPOC >= 0 )
     1788              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
    12541789              {
    1255                 m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[newRefs] = m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
    1256                 m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[newRefs] = m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i];
    1257                 newRefs++;
     1790                newRef=false;
    12581791              }
    12591792            }
    1260             Int numPrefRefs = m_GOPListsMvc[viewId][curGOP].m_numRefPicsActive;
    1261 
    1262             for( Int offset = -1; offset > -checkGOP; offset-- )
     1793            if(newRef)
    12631794            {
    1264               //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
    1265               Int offGOP =  (checkGOP - 1 + offset)%m_iGOPSize;
    1266               Int offPOC = ((checkGOP - 1 + offset)/m_iGOPSize) * m_iGOPSize + m_GOPListsMvc[viewId][offGOP].m_POC;
    1267               if( offPOC >= 0 && m_GOPListsMvc[viewId][offGOP].m_refPic && m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId )
     1795              Int insertPoint=newRefs;
     1796              //this picture can be added, find appropriate place in list and insert it.
     1797              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
    12681798              {
    1269                 Bool newRef = false;
    1270                 for( Int i = 0; i < numRefs; i++ )
     1799                m_GOPList[offGOP].m_refPic = true;
     1800              }
     1801              for(Int j=0; j<newRefs; j++)
     1802              {
     1803                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
    12711804                {
    1272                   if( refList[i] == offPOC )
    1273                   {
    1274                     newRef = true;
    1275                   }
    1276                 }
    1277                 for( Int i = 0; i < newRefs; i++ )
    1278                 {
    1279                   if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[i] == (offPOC - curPOC) )
    1280                   {
    1281                     newRef = false;
    1282                   }
    1283                 }
    1284                 if( newRef )
    1285                 {
    1286                   Int insertPoint = newRefs;
    1287                   //this picture can be added, find appropriate place in list and insert it.
    1288                   for( Int j = 0; j < newRefs; j++ )
    1289                   {
    1290                     if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] < (offPOC - curPOC) ||
    1291                         m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] > 0 )
    1292                     {
    1293                       insertPoint = j;
    1294                       break;
    1295                     }
    1296                   }
    1297                   Int prev = offPOC - curPOC;
    1298                   Int prevUsed = (m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
    1299                   for( Int j = insertPoint; j < newRefs+1; j++ )
    1300                   {
    1301                     Int newPrev = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j];
    1302                     Int newUsed = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j];
    1303                     m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] = prev;
    1304                     m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] = prevUsed;
    1305                     prevUsed = newUsed;
    1306                     prev = newPrev;
    1307                   }
    1308                   newRefs++;
     1805                  insertPoint = j;
     1806                  break;
    13091807                }
    13101808              }
    1311               if( newRefs >= numPrefRefs )
     1809              Int prev = offPOC-curPOC;
     1810              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
     1811              for(Int j=insertPoint; j<newRefs+1; j++)
    13121812              {
    1313                 break;
     1813                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
     1814                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
     1815                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
     1816                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
     1817                prevUsed=newUsed;
     1818                prev=newPrev;
     1819              }
     1820              newRefs++;
     1821            }
     1822          }
     1823          if(newRefs>=numPrefRefs)
     1824          {
     1825            break;
     1826          }
     1827        }
     1828        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
     1829        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
     1830        if (m_extraRPSs == 0)
     1831        {
     1832          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
     1833          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
     1834        }
     1835        else
     1836        {
     1837          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
     1838          Int refPOC = m_GOPList[rIdx].m_POC;
     1839          Int refPics = m_GOPList[rIdx].m_numRefPics;
     1840          Int newIdc=0;
     1841          for(Int i = 0; i<= refPics; i++)
     1842          {
     1843            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
     1844            Int absPOCref = refPOC+deltaPOC;
     1845            Int refIdc = 0;
     1846            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
     1847            {
     1848              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
     1849              {
     1850                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
     1851                {
     1852                  refIdc = 1;
     1853                }
     1854                else
     1855                {
     1856                  refIdc = 2;
     1857                }
    13141858              }
    13151859            }
    1316             m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics = newRefs;
    1317             m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC = curPOC;
    1318             if( m_extraRPSs[viewId] == 0 )
    1319             {
    1320               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 0;
    1321               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = 0;
    1322             }
    1323             else
    1324             {
    1325               Int rIdx =  m_iGOPSize + m_extraRPSs[viewId] - 1;
    1326               Int refPOC = m_GOPListsMvc[viewId][rIdx].m_POC;
    1327               Int refPics = m_GOPListsMvc[viewId][rIdx].m_numRefPics;
    1328               Int newIdc = 0;
    1329               for( Int i = 0; i <= refPics; i++ )
    1330               {
    1331                 Int deltaPOC = ((i != refPics)? m_GOPListsMvc[viewId][rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
    1332                 Int absPOCref = refPOC + deltaPOC;
    1333                 Int refIdc = 0;
    1334                 for( Int j = 0; j < m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics; j++ )
    1335                 {
    1336                   if( (absPOCref - curPOC) == m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] )
    1337                   {
    1338                     if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] )
    1339                     {
    1340                       refIdc = 1;
    1341                     }
    1342                     else
    1343                     {
    1344                       refIdc = 2;
    1345                     }
    1346                   }
    1347                 }
    1348                 m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_refIdc[newIdc] = refIdc;
    1349                 newIdc++;
    1350               }
    1351               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 1; 
    1352               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = newIdc;
    1353               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRPS = refPOC - m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC;
    1354               m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRIdxMinus1 = 0;
    1355             }
    1356             curGOP = m_iGOPSize + m_extraRPSs[viewId];
    1357             m_extraRPSs[viewId]++;
     1860            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
     1861            newIdc++;
    13581862          }
    1359           numRefs = 0;
    1360           for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
    1361           {
    1362             Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
    1363             if( absPOC >= 0 )
    1364             {
    1365               refList[numRefs] = absPOC;
    1366               numRefs++;
    1367             }
    1368           }
    1369           refList[numRefs] = curPOC;
     1863          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
     1864          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
     1865          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
     1866        }
     1867        curGOP=m_iGOPSize+m_extraRPSs;
     1868        m_extraRPSs++;
     1869      }
     1870      numRefs=0;
     1871      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
     1872      {
     1873        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
     1874        if(absPOC >= 0)
     1875        {
     1876          refList[numRefs]=absPOC;
    13701877          numRefs++;
    13711878        }
    1372         checkGOP++;
    1373       }
    1374       xConfirmPara( errorGOP, "Invalid GOP structure given" );
    1375       m_maxTempLayer[viewId] = 1;
    1376       for( Int i = 0; i < m_iGOPSize; i++ )
    1377       {
    1378         if( m_GOPListsMvc[viewId][i].m_temporalId >= m_maxTempLayer[viewId] )
     1879      }
     1880      refList[numRefs]=curPOC;
     1881      numRefs++;
     1882    }
     1883    checkGOP++;
     1884  }
     1885  xConfirmPara(errorGOP,"Invalid GOP structure given");
     1886  m_maxTempLayer = 1;
     1887  for(Int i=0; i<m_iGOPSize; i++)
     1888  {
     1889    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
     1890    {
     1891      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
     1892    }
     1893    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
     1894  }
     1895  for(Int i=0; i<MAX_TLAYER; i++)
     1896  {
     1897    m_numReorderPics[i] = 0;
     1898    m_maxDecPicBuffering[i] = 1;
     1899  }
     1900  for(Int i=0; i<m_iGOPSize; i++)
     1901  {
     1902    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
     1903    {
     1904      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
     1905    }
     1906    Int highestDecodingNumberWithLowerPOC = 0;
     1907    for(Int j=0; j<m_iGOPSize; j++)
     1908    {
     1909      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
     1910      {
     1911        highestDecodingNumberWithLowerPOC = j;
     1912      }
     1913    }
     1914    Int numReorder = 0;
     1915    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
     1916    {
     1917      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
     1918        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
     1919      {
     1920        numReorder++;
     1921      }
     1922    }   
     1923    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
     1924    {
     1925      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
     1926    }
     1927  }
     1928  for(Int i=0; i<MAX_TLAYER-1; i++)
     1929  {
     1930    // a lower layer can not have higher value of m_numReorderPics than a higher layer
     1931    if(m_numReorderPics[i+1] < m_numReorderPics[i])
     1932    {
     1933      m_numReorderPics[i+1] = m_numReorderPics[i];
     1934    }
     1935    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
     1936    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
     1937    {
     1938      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
     1939    }
     1940    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
     1941    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
     1942    {
     1943      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
     1944    }
     1945  }
     1946
     1947
     1948  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
     1949  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
     1950  {
     1951    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
     1952  }
     1953
     1954  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
     1955  {
     1956    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
     1957    if(tileFlag)
     1958    {
     1959      Int maxTileWidth = 0;
     1960      Int maxTileHeight = 0;
     1961      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
     1962      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
     1963      if(m_iUniformSpacingIdr)
     1964      {
     1965        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
     1966        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
     1967        // if only the last tile-row is one treeblock higher than the others
     1968        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
     1969        if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
    13791970        {
    1380           m_maxTempLayer[viewId] = m_GOPListsMvc[viewId][i].m_temporalId + 1;
     1971          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
     1972        }     
     1973        // if only the last tile-column is one treeblock wider than the others
     1974        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
     1975        if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
     1976        {
     1977          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
    13811978        }
    1382         xConfirmPara( m_GOPListsMvc[viewId][i].m_sliceType != 'B' && m_GOPListsMvc[viewId][i].m_sliceType != 'P', "Slice type must be equal to B or P" );
    1383       }
    1384 
    1385       for( Int i = 0; i < MAX_TLAYER; i++ )
    1386       {
    1387         m_numReorderPics[viewId][i] = 0;
    1388         m_maxDecPicBuffering[viewId][i] = 0;
    1389       }
    1390       for( Int i = 0; i < m_iGOPSize; i++ )
    1391       {
    1392         if( m_GOPListsMvc[viewId][i].m_numRefPics > m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
     1979      }
     1980      else // not uniform spacing
     1981      {
     1982        if(m_iNumColumnsMinus1<1)
    13931983        {
    1394           m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = m_GOPListsMvc[viewId][i].m_numRefPics;
     1984          maxTileWidth = m_iSourceWidth;
    13951985        }
    1396         Int highestDecodingNumberWithLowerPOC = 0;
    1397         for( Int j = 0; j < m_iGOPSize; j++ )
     1986        else
    13981987        {
    1399           if( m_GOPListsMvc[viewId][j].m_POC <= m_GOPListsMvc[viewId][i].m_POC )
     1988          Int accColumnWidth = 0;
     1989          for(Int col=0; col<(m_iNumColumnsMinus1); col++)
    14001990          {
    1401             highestDecodingNumberWithLowerPOC = j;
     1991            maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
     1992            accColumnWidth += m_pColumnWidth[col];
    14021993          }
     1994          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
    14031995        }
    1404         Int numReorder = 0;
    1405         for( Int j = 0; j < highestDecodingNumberWithLowerPOC; j++ )
     1996        if(m_iNumRowsMinus1<1)
    14061997        {
    1407           if( m_GOPListsMvc[viewId][j].m_temporalId <= m_GOPListsMvc[viewId][i].m_temporalId &&
    1408               m_GOPListsMvc[viewId][j].m_POC        >  m_GOPListsMvc[viewId][i].m_POC )
     1998          maxTileHeight = m_iSourceHeight;
     1999        }
     2000        else
     2001        {
     2002          Int accRowHeight = 0;
     2003          for(Int row=0; row<(m_iNumRowsMinus1); row++)
    14092004          {
    1410             numReorder++;
     2005            maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
     2006            accRowHeight += m_pRowHeight[row];
    14112007          }
    1412         }   
    1413         if( numReorder > m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
    1414         {
    1415           m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = numReorder;
     2008          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
    14162009        }
    14172010      }
    1418       for( Int i = 0; i < MAX_TLAYER-1; i++ )
    1419       {
    1420         // a lower layer can not have higher value of m_numReorderPics than a higher layer
    1421         if( m_numReorderPics[viewId][i+1] < m_numReorderPics[viewId][i] )
    1422         {
    1423           m_numReorderPics[viewId][i+1] = m_numReorderPics[viewId][i];
    1424         }
    1425         // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
    1426         if( m_numReorderPics[viewId][i] > m_maxDecPicBuffering[viewId][i] )
    1427         {
    1428           m_maxDecPicBuffering[viewId][i] = m_numReorderPics[viewId][i];
    1429         }
    1430         // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
    1431         if( m_maxDecPicBuffering[viewId][i+1] < m_maxDecPicBuffering[viewId][i] )
    1432         {
    1433           m_maxDecPicBuffering[viewId][i+1] = m_maxDecPicBuffering[viewId][i];
    1434         }
    1435       }
    1436       // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
    1437       if( m_numReorderPics[viewId][MAX_TLAYER-1] > m_maxDecPicBuffering[viewId][MAX_TLAYER-1] )
    1438       {
    1439         m_maxDecPicBuffering[viewId][MAX_TLAYER-1] = m_numReorderPics[viewId][MAX_TLAYER-1];
    1440       }
    1441 
    1442       xConfirmPara( m_bUseLComb == false && m_numReorderPics[viewId][MAX_TLAYER-1] != 0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" );  // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
    1443     }
    1444   }
     2011      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
     2012      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
     2013    }
     2014    else if(m_iWaveFrontSynchro)
     2015    {
     2016      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
     2017    }
     2018    else if(m_sliceMode == 1)
     2019    {
     2020      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
     2021    }
     2022    else
     2023    {
     2024      m_minSpatialSegmentationIdc = 0;
     2025    }
     2026  }
     2027  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
     2028  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
     2029  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
     2030
     2031  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
     2032
     2033  if (m_toneMappingInfoSEIEnabled)
     2034  {
     2035    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
     2036    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
     2037    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
     2038    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
     2039    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
     2040    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
     2041    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
     2042  }
     2043
     2044#if RATE_CONTROL_LAMBDA_DOMAIN
     2045  if ( m_RCEnableRateControl )
     2046  {
     2047    if ( m_RCForceIntraQP )
     2048    {
     2049      if ( m_RCInitialQP == 0 )
     2050      {
     2051        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
     2052        m_RCForceIntraQP = false;
     2053      }
     2054    }
     2055    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
     2056  }
     2057#else
     2058  if(m_enableRateCtrl)
     2059  {
     2060    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
     2061    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
     2062    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
     2063
     2064    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
     2065
     2066    m_iMaxDeltaQP       = MAX_DELTA_QP;
     2067    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
     2068  }
     2069#endif
     2070
     2071  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
     2072
     2073  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
     2074  if (m_framePackingSEIEnabled)
     2075  {
     2076    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
     2077  }
     2078
     2079#if H_MV
     2080  }
     2081  }
     2082#endif
    14452083#undef xConfirmPara
    1446   if( check_failed )
     2084  if (check_failed)
    14472085  {
    14482086    exit(EXIT_FAILURE);
    14492087  }
    1450 }
    1451 
    1452 template <class T>
    1453 Void
    1454 TAppEncCfg::xCleanUpVector( std::vector<T>& rcVec, const T& rcInvalid )
    1455 {
    1456   Int iFirstInv = (Int)rcVec.size();
    1457   for( Int iIdx = 0; iIdx < (Int)rcVec.size(); iIdx++ )
    1458   {
    1459     if( rcVec[ iIdx ] == rcInvalid )
    1460     {
    1461       iFirstInv = iIdx;
    1462       break;
    1463     }
    1464   }
    1465   while( (Int)rcVec.size() > iFirstInv )
    1466   {
    1467     rcVec.pop_back();
    1468   }
    1469 }
    1470 
    1471 Void
    1472 TAppEncCfg::xCleanUpVectors()
    1473 {
    1474   xCleanUpVector( m_pchInputFileList,       (char*)0 );
    1475   xCleanUpVector( m_pchDepthInputFileList,  (char*)0 );
    1476   xCleanUpVector( m_pchReconFileList,       (char*)0 );
    1477   xCleanUpVector( m_pchDepthReconFileList,  (char*)0 );
    14782088}
    14792089
     
    14952105 
    14962106  // set internal bit-depth and constants
    1497 #if FULL_NBIT
    1498   g_uiBitDepth = m_uiInternalBitDepth;
    1499   g_uiBitIncrement = 0;
    1500 #else
    1501   g_uiBitDepth = 8;
    1502   g_uiBitIncrement = m_uiInternalBitDepth - g_uiBitDepth;
    1503 #endif
    1504 
    1505 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    1506   g_iDeltaDCsQuantOffset = g_uiBitIncrement - 2;
    1507 #endif
    1508 
    1509   g_uiBASE_MAX     = ((1<<(g_uiBitDepth))-1);
    1510  
    1511 #if IBDI_NOCLIP_RANGE
    1512   g_uiIBDI_MAX     = g_uiBASE_MAX << g_uiBitIncrement;
    1513 #else
    1514   g_uiIBDI_MAX     = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
    1515 #endif
    1516  
    1517   if (m_uiOutputBitDepth == 0)
    1518   {
    1519     m_uiOutputBitDepth = m_uiInternalBitDepth;
    1520   }
    1521 
    1522   g_uiPCMBitDepthLuma = m_uiPCMBitDepthLuma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
    1523   g_uiPCMBitDepthChroma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
     2107  g_bitDepthY = m_internalBitDepthY;
     2108  g_bitDepthC = m_internalBitDepthC;
     2109 
     2110  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
     2111  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
    15242112}
    15252113
     
    15272115{
    15282116  printf("\n");
    1529   for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
    1530   {
    1531     printf("Texture Input File %i            : %s\n", iCounter, m_pchInputFileList[iCounter]);
    1532   }
    1533   if( m_bUsingDepthMaps )
    1534   {
    1535     for( Int iCounter = 0; iCounter < m_iNumberOfViews; iCounter++)
    1536     {
    1537       printf("Depth Input File %i              : %s\n", iCounter, m_pchDepthInputFileList[iCounter]);
    1538     }
    1539   }
    1540   printf("Bitstream File                  : %s\n", m_pchBitstreamFile      );
    1541   for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
    1542   {
    1543     printf("Texture Reconstruction File %i   : %s\n", iCounter, m_pchReconFileList[iCounter]);
    1544   }
    1545   if( m_bUsingDepthMaps )
    1546   {
    1547     for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
    1548     {
    1549       printf("Depth Reconstruction File %i     : %s\n", iCounter, m_pchDepthReconFileList[iCounter]);
    1550     }
    1551   }
    1552   printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_cropLeft - m_cropRight, m_iSourceHeight - m_cropTop - m_cropBottom, m_iFrameRate );
     2117#if H_MV
     2118  for( Int layer = 0; layer < m_numberOfLayers; layer++)
     2119  {
     2120    printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
     2121  }
     2122#else
     2123  printf("Input          File          : %s\n", m_pchInputFile          );
     2124#endif
     2125  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
     2126#if H_MV
     2127  for( Int layer = 0; layer < m_numberOfLayers; layer++)
     2128  {
     2129    printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
     2130  }
     2131#else
     2132  printf("Reconstruction File          : %s\n", m_pchReconFile          );
     2133#endif
     2134#if H_MV
     2135  xPrintParaVector( "ViewId", m_viewId );
     2136#endif
     2137#if H_3D
     2138  xPrintParaVector( "DepthFlag", m_depthFlag );
     2139  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
     2140#endif
     2141#if H_MV 
     2142  xPrintParaVector( "QP"               , m_fQP                );
     2143  xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
     2144  xPrintParaVector( "SAO"              , m_bUseSAO            );
     2145#endif
     2146  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
    15532147  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
    1554   printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_iFrameToBeEncoded-1, m_iFrameToBeEncoded );
     2148  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
    15552149  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
    15562150  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
     
    15592153  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
    15602154  printf("Motion search range          : %d\n", m_iSearchRange );
    1561 #if DV_V_RESTRICTION_B0037
    1562   printf("Disp search range restriction: %d\n", m_bUseDisparitySearchRangeRestriction );
    1563   printf("Vertical disp search range   : %d\n", m_iVerticalDisparitySearchRange );
    1564 #endif
    15652155  printf("Intra period                 : %d\n", m_iIntraPeriod );
    15662156  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
    1567   printf("QP Texture                   : %5.2f\n", m_adQP[0] );
    1568   if( m_bUsingDepthMaps )
    1569   {
    1570     printf("QP Depth                     : %5.2f\n", m_adQP[ m_adQP.size()  < 2 ? 0 : 1] );
    1571   }
     2157#if !H_MV
     2158  printf("QP                           : %5.2f\n", m_fQP );
     2159#endif
    15722160  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
    15732161
    1574   printf("Chroma Qp Offset             : %d\n", m_iChromaQpOffset   );
    1575   printf("Chroma Qp Offset 2nd         : %d\n", m_iChromaQpOffset2nd);
     2162  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
     2163  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
    15762164
    15772165  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
    15782166  printf("GOP size                     : %d\n", m_iGOPSize );
    1579   printf("Internal bit depth           : %d\n", m_uiInternalBitDepth );
    1580   printf("PCM sample bit depth         : %d\n", m_uiPCMBitDepthLuma );
    1581   if((m_uiMaxCUWidth >> m_uiMaxCUDepth) == 4)
    1582   {
    1583     printf("DisableInter4x4              : %d\n", m_bDisInter4x4); 
    1584   }
    1585 
    1586 printf("Loop Filter Disabled         : %d %d\n", m_abLoopFilterDisable[0] ? 1 : 0,  m_abLoopFilterDisable[1] ? 1 : 0 );
     2167  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
     2168  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
     2169#if RATE_CONTROL_LAMBDA_DOMAIN
     2170  printf("RateControl                  : %d\n", m_RCEnableRateControl );
     2171  if(m_RCEnableRateControl)
     2172  {
     2173    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
     2174    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
     2175    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
     2176    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
     2177    printf("InitialQP                    : %d\n", m_RCInitialQP );
     2178    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
     2179  }
     2180#else
     2181  printf("RateControl                  : %d\n", m_enableRateCtrl);
     2182  if(m_enableRateCtrl)
     2183  {
     2184    printf("TargetBitrate                : %d\n", m_targetBitrate);
     2185    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
     2186  }
     2187#endif
     2188  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
     2189#if H_3D
     2190  printf("BaseViewCameraNumbers        : %s\n", m_pchBaseViewCameraNumbers );
    15872191  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
    1588 
    1589 #if HHI_VSO
     2192#if H_3D_VSO
    15902193  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
    15912194
    15922195  if ( m_bUseVSO )
    1593   {
     2196  {   
    15942197    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
    15952198    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
    15962199    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
    1597 #if HHI_VSO_DIST_INT
    15982200    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
    1599 #endif
    1600 #if HHI_VSO_LS_TABLE_M23714
    1601     printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);   
    1602 #endif
    1603 #if SAIT_VSO_EST_A0033
    1604     printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);       
    1605 #endif
    1606 #if LGE_VSO_EARLY_SKIP_A0093
    1607     printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
    1608 #endif
    1609    
    1610   }
    1611 #endif
    1612 #if HHI_INTERVIEW_SKIP
    1613     printf("InterView Skip:              : %d\n",    m_bInterViewSkip ? 1:0 );
    1614     printf("InterView Skip Lambda Scale  : %f\n",    m_dInterViewSkipLambdaScale );
    1615 #endif
    1616 
     2201    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);
     2202    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);
     2203    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
     2204    if ( m_bUseWVSO )
     2205    printf("Dist. Weights (VSO/VSD/SAD)  : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
     2206  }
     2207#endif //HHI_VSO
     2208#endif //H_3D
    16172209  printf("\n");
    1618  
    1619   printf("TOOL CFG General: "); 
    1620   printf("ALFMNF:%d ", m_iALFMaxNumberFilters);
    1621   printf("ALFInSlice:%d ", m_bALFParamInSlice);
    1622   printf("ALFPicEnc:%d ", m_bALFPicBasedEncode);
    1623   printf("IBD:%d ", !!g_uiBitIncrement);
     2210#if H_MV
     2211  printf("TOOL CFG General: ");
     2212#else
     2213  printf("TOOL CFG: ");
     2214#endif
     2215  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
    16242216  printf("HAD:%d ", m_bUseHADME           );
    16252217  printf("SRD:%d ", m_bUseSBACRD          );
     2218  printf("RDQ:%d ", m_useRDOQ            );
     2219  printf("RDQTS:%d ", m_useRDOQTS        );
     2220  printf("RDpenalty:%d ", m_rdPenalty  );
    16262221  printf("SQP:%d ", m_uiDeltaQpRD         );
    16272222  printf("ASR:%d ", m_bUseASR             );
    1628   printf("LComb:%d ", m_bUseLComb         );
    1629   printf("LCMod:%d ", m_bLCMod         );
    16302223  printf("FEN:%d ", m_bUseFastEnc         );
    16312224  printf("ECU:%d ", m_bUseEarlyCU         );
    16322225  printf("FDM:%d ", m_useFastDecisionForMerge );
    16332226  printf("CFM:%d ", m_bUseCbfFastMode         );
     2227  printf("ESD:%d ", m_useEarlySkipDetection  );
    16342228  printf("RQT:%d ", 1     );
    1635   printf("LMC:%d ", m_bUseLMChroma        );
    1636   printf("Slice: G=%d M=%d ", m_iSliceGranularity, m_iSliceMode);
    1637   if (m_iSliceMode!=0)
    1638   {
    1639     printf("A=%d ", m_iSliceArgument);
    1640   }
    1641   printf("EntropySlice: M=%d ",m_iEntropySliceMode);
    1642   if (m_iEntropySliceMode!=0)
    1643   {
    1644     printf("A=%d ", m_iEntropySliceArgument);
     2229  printf("TransformSkip:%d ",     m_useTransformSkip              );
     2230  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
     2231  printf("Slice: M=%d ", m_sliceMode);
     2232  if (m_sliceMode!=0)
     2233  {
     2234    printf("A=%d ", m_sliceArgument);
     2235  }
     2236  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
     2237  if (m_sliceSegmentMode!=0)
     2238  {
     2239    printf("A=%d ", m_sliceSegmentArgument);
    16452240  }
    16462241  printf("CIP:%d ", m_bUseConstrainedIntraPred);
     2242#if !H_MV
     2243  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
     2244#endif
    16472245  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
    1648 #if LGE_SAO_MIGRATION_D0091
    16492246  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
    1650 #else
    1651   printf("SAOInterleaving:%d ", (m_saoInterleavingFlag)?(1):(0));
    1652 #endif
    1653 #if LOSSLESS_CODING
     2247
    16542248  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
    1655 #endif 
    1656   printf("WPP:%d ", (Int)m_bUseWeightPred);
    1657   printf("WPB:%d ", m_uiBiPredIdc);
    1658   printf("TileLocationInSliceHdr:%d ", m_iTileLocationInSliceHeaderFlag);
    1659   printf("TileMarker:%d", m_iTileMarkerFlag);
    1660   if (m_iTileMarkerFlag)
    1661   {
    1662     printf("[%d] ", m_iMaxTileMarkerEntryPoints);
    1663   }
    1664   else
    1665   {
    1666     printf(" ");
    1667   }
    1668   printf(" WaveFrontSynchro:%d WaveFrontFlush:%d WaveFrontSubstreams:%d",
    1669           m_iWaveFrontSynchro, m_iWaveFrontFlush, m_iWaveFrontSubstreams);
     2249  printf("WPP:%d ", (Int)m_useWeightedPred);
     2250  printf("WPB:%d ", (Int)m_useWeightedBiPred);
     2251  printf("PME:%d ", m_log2ParallelMergeLevel);
     2252  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
     2253          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
    16702254  printf(" ScalingList:%d ", m_useScalingListId );
    1671 
    1672 #if !TMVP_DEPTH_SWITCH
    1673   printf("TMVP:%d ", m_enableTMVP     );
    1674 #endif
    1675 
     2255  printf("TMVPMode:%d ", m_TMVPModeId     );
    16762256#if ADAPTIVE_QP_SELECTION
    1677   printf("AQpS:%d", m_bUseAdaptQpSelect   );
    1678 #endif
    1679 
    1680   printf(" SignBitHidingFlag:%d SignBitHidingThreshold:%d", m_signHideFlag, m_signHidingThreshold);
    1681   printf("\n");
    1682   printf("TOOL CFG VIDEO  : ");
    1683   printf("ALF:%d ", (m_abUseALF [0] ? 1 : 0) );
    1684   printf("SAO:%d ", (m_abUseSAO [0] ? 1 : 0));
    1685   printf("RDQ:%d ", (m_abUseRDOQ[0] ? 1 : 0) );
    1686 #if TMVP_DEPTH_SWITCH
    1687   printf("TMVP:%d ", (m_enableTMVP[0] ? 1 : 0) );
    1688 #endif
    1689 #if LGE_ILLUCOMP_B0045
    1690 #if LGE_ILLUCOMP_DEPTH_C0046
    1691   printf("IlluCompEnable: %d %d", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0);
    1692 #else
    1693   printf("IlluCompEnable: %d ", m_bUseIC);
    1694 #endif
    1695 #endif
    1696 #if INTER_VIEW_VECTOR_SCALING_C0115
    1697   printf("IVSEnable: %d ", m_bUseIVS);
    1698 #endif
    1699 #if QC_ARP_D0177
    1700   printf(" ARP:%d  " , m_nUseAdvResPred  );
    1701 #endif
    1702   printf("\n");
    1703 
    1704   printf("TOOL CFG DEPTH  : ");
    1705   printf("ALF:%d ", (m_abUseALF [1] ? 1 : 0));
    1706   printf("SAO:%d ", (m_abUseSAO [1] ? 1 : 0));
    1707   printf("RDQ:%d ", (m_abUseRDOQ[1] ? 1 : 0));
    1708 #if TMVP_DEPTH_SWITCH
    1709   printf("TMVP:%d ", (m_enableTMVP[1] ? 1 : 0) );
    1710 #endif
    1711 #if FLEX_CODING_ORDER_M23723
    1712   printf("FCO:%d ",   (m_b3DVFlexOrder ? 1: 0));
    1713 
    1714   if(m_b3DVFlexOrder)
    1715   {
    1716     printf("CodingOrder: %s ", m_pchMVCJointCodingOrder);
    1717   }
    1718 #endif
    1719 #if HHI_VSO
    1720   printf("VSO:%d ", m_bUseVSO             );
    1721 #endif
    1722 #if LGE_WVSO_A0119
    1723   printf("WVSO:%d ", m_bUseWVSO );
    1724 #endif
    1725 #if H3D_QTL
    1726   printf("QTLPC:%d ", m_bUseQTLPC);
    1727 #endif
    1728 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    1729   printf("DMM:%d ", m_bUseDMM );
    1730 #endif
    1731 #if HHI_MPI
    1732   printf("MVI:%d ", m_bUseMVI ? 1 : 0 );
    1733 #endif
    1734 #if RWTH_SDC_DLT_B0036
    1735   printf("SDC:%d ", m_bUseSDC ? 1 : 0 );
    1736   printf("DLT:%d ", m_bUseDLT ? 1 : 0 );
    1737 #endif
    1738 
    1739 #if MTK_D0156
    1740   printf("BVSP:%d ", m_bUseVSPCompensation ? 1 : 0 );
    1741   printf("DoNBDV:%d ",  m_bUseDVPRefine ? 1 : 0 );
    1742 #endif
    1743 
    1744 #if LGE_WVSO_A0119
    1745   if ( m_bUseWVSO )
    1746     printf("\nVSO : VSD : SAD weight = %d : %d : %d ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
    1747 #endif
    1748   printf("\n\n");
    1749  
     2257  printf("AQpS:%d ", m_bUseAdaptQpSelect   );
     2258#endif
     2259
     2260  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
     2261  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
     2262#if H_3D_VSO
     2263  printf("VSO:%d ", m_bUseVSO   );
     2264  printf("WVSO:%d ", m_bUseWVSO ); 
     2265#endif
     2266#if H_3D_QTLPC
     2267  printf("QTL:%d ", m_bUseQTL);
     2268  printf("PC:%d " , m_bUsePC );
     2269#endif
     2270#if H_3D_IV_MERGE
     2271  printf("IvMvPred:%d ", m_ivMvPredFlag );
     2272#endif
     2273#if H_3D_ARP
     2274  printf(" ARP:%d  ", m_uiUseAdvResPred  );
     2275#endif
     2276#if H_3D_IC
     2277  printf( "IlluCompEnable: %d %d ", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0 );
     2278#endif
     2279#if H_3D_NBDV_REF
     2280  printf("DepthRefinement:%d ", m_depthRefinementFlag ); 
     2281#endif
     2282#if H_3D_VSP
     2283  printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
     2284#endif
     2285#if H_3D_TMVP
     2286  printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0  );
     2287#endif
     2288#if H_3D_DIM
     2289  printf("DMM:%d ", m_useDMM );
     2290  printf("RBC:%d ", m_useRBC );
     2291  printf("SDC:%d ", m_useSDC );
     2292  printf("DLT:%d ", m_useDLT );
     2293#endif
     2294#if LGE_INTER_SDC_E0156
     2295  printf( "interSDC: %d ", m_bDepthInterSDCFlag ? 1 : 0 );
     2296#endif
     2297  printf("\n\n"); 
     2298
    17502299  fflush(stdout);
    17512300}
    17522301
    1753 Void TAppEncCfg::xPrintUsage()
    1754 {
    1755   printf( "          <name> = ALF - adaptive loop filter\n");
    1756   printf( "                   IBD - bit-depth increasement\n");
    1757   printf( "                   GPB - generalized B instead of P in low-delay mode\n");
    1758   printf( "                   HAD - hadamard ME for fractional-pel\n");
    1759   printf( "                   SRD - SBAC based RD estimation\n");
    1760   printf( "                   RDQ - RDOQ\n");
    1761   printf( "                   LDC - low-delay mode\n");
    1762   printf( "                   NRF - non-reference frame marking in last layer\n");
    1763   printf( "                   BQP - hier-P style QP assignment in low-delay mode\n");
    1764   printf( "                   PAD - automatic source padding of multiple of 16\n");
    1765   printf( "                   ASR - adaptive motion search range\n");
    1766   printf( "                   FEN - fast encoder setting\n"); 
    1767   printf( "                   ECU - Early CU setting\n");
    1768   printf( "                   CFM - Cbf fast mode setting\n");
    1769   printf( "                   LMC - intra chroma prediction based on luma\n");
    1770   printf( "\n" );
    1771   printf( "  Example 1) TAppEncoder.exe -c test.cfg -q 32 -g 8 -f 9 -s 64 -h 4\n");
    1772   printf("              -> QP 32, hierarchical-B GOP 8, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
    1773   printf( "  Example 2) TAppEncoder.exe -c test.cfg -q 32 -g 4 -f 9 -s 64 -h 4 -1 LDC\n");
    1774   printf("              -> QP 32, hierarchical-P GOP 4, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
    1775 }
    1776 
    1777 Bool confirmPara(Bool bflag, const char* message)
     2302Bool confirmPara(Bool bflag, const Char* message)
    17782303{
    17792304  if (!bflag)
     
    17842309}
    17852310
    1786 /* helper function */
    1787 /* for handling "-1/-0 FOO" */
    1788 void translateOldStyleCmdline(const char* value, po::Options& opts, const std::string& arg)
    1789 {
    1790   const char* argv[] = {arg.c_str(), value};
    1791   /* replace some short names with their long name varients */
    1792   if (arg == "LDC")
    1793   {
    1794     argv[0] = "LowDelayCoding";
    1795   }
    1796   else if (arg == "RDQ")
    1797   {
    1798     argv[0] = "RDOQ";
    1799   }
    1800   else if (arg == "HAD")
    1801   {
    1802     argv[0] = "HadamardME";
    1803   }
    1804   else if (arg == "SRD")
    1805   {
    1806     argv[0] = "SBACRD";
    1807   }
    1808   else if (arg == "IBD")
    1809   {
    1810     argv[0] = "BitIncrement";
    1811   }
    1812   /* issue a warning for change in FEN behaviour */
    1813   if (arg == "FEN")
    1814   {
    1815     /* xxx todo */
    1816   }
    1817   po::storePair(opts, argv[0], argv[1]);
    1818 }
    1819 
    1820 void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg)
    1821 {
    1822   if (arg == "IBD")
    1823   {
    1824     translateOldStyleCmdline("4", opts, arg);
    1825     return;
    1826   }
    1827   translateOldStyleCmdline("1", opts, arg);
    1828 }
    1829 
    1830 void doOldStyleCmdlineOff(po::Options& opts, const std::string& arg)
    1831 {
    1832   translateOldStyleCmdline("0", opts, arg);
    1833 }
    1834 
    1835 Void TAppEncCfg::xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName)
    1836 {
    1837   size_t iInLength     = strlen(pchInputFileName);
    1838   size_t iAppendLength = strlen(pchStringToAppend);
    1839 
    1840   rpchOutputFileName = (Char*) malloc(iInLength+iAppendLength+1);
    1841   Char* pCDot = strrchr(pchInputFileName,'.');
    1842   pCDot = pCDot ? pCDot : pchInputFileName + iInLength;
    1843   size_t iCharsToDot = pCDot - pchInputFileName ;
    1844   size_t iCharsToEnd = iInLength - iCharsToDot;
    1845   strncpy(rpchOutputFileName                            ,  pchInputFileName            , iCharsToDot  );
    1846   strncpy(rpchOutputFileName+ iCharsToDot               ,  pchStringToAppend           , iAppendLength);
    1847   strncpy(rpchOutputFileName+ iCharsToDot+iAppendLength ,  pchInputFileName+iCharsToDot, iCharsToEnd  );
    1848   rpchOutputFileName[iInLength+iAppendLength] = '\0';
    1849 }
    1850 
    18512311//! \}
  • trunk/source/App/TAppEncoder/TAppEncCfg.h

    r443 r608  
    44 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4242
    4343#include "TLibEncoder/TEncCfg.h"
     44#include <sstream>
     45#if H_3D
    4446#include "TAppCommon/TAppComCamPara.h"
    45 #include "TLibRenderer/TRenTop.h"
    4647#include "TLibRenderer/TRenModel.h"
    4748#include "TLibRenderer/TRenModSetupStrParser.h"
    48 
    49 #include <sstream>
    50 #include <vector>
    51 
     49#endif
    5250//! \ingroup TAppEncoder
    5351//! \{
     
    6260protected:
    6361  // file I/O
     62#if H_MV
    6463  std::vector<char*>     m_pchInputFileList;                  ///< source file names
    65   std::vector<char*>     m_pchDepthInputFileList;             ///< source depth file names
     64#else
     65  Char*     m_pchInputFile;                                   ///< source file name
     66#endif
     67  Char*     m_pchBitstreamFile;                               ///< output bitstream file
     68#if H_MV
    6669  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
    67   std::vector<char*>     m_pchDepthReconFileList;             ///< output depth reconstruction file names
    68   char*     m_pchBitstreamFile;                               ///< output bitstream file
     70  Int                    m_numberOfLayers;                    ///< number of Layers to Encode
     71#if H_3D
     72  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
     73#endif
     74#else
     75  Char*     m_pchReconFile;                                   ///< output reconstruction file
     76#endif
     77  #if H_MV
     78// VPS specification
     79  std::vector< std::vector<Int> > m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
     80  std::vector<Int>       m_viewId;                            ///< view id
     81#if H_3D
     82  std::vector<Int>       m_depthFlag;                         ///< depth flag
     83#endif
     84  std::vector<Int>       m_layerIdInNuh;                      ///< layer Id in Nuh for each layer
     85  Bool                   m_splittingFlag;                     ///< Splitting Flag
     86  Int                    m_scalabilityMask;                   ///< Mask indicating scalabilities, 1: texture; 3: texture + depth                                                               
     87  std::vector<Int>       m_dimensionIdLen;                    ///< Length of scalability dimension s
     88 
     89// layer sets   
     90  Int                    m_vpsNumLayerSets;                   ///< Number of layer sets
     91  std::vector< std::vector<Int> > m_layerIdsInSets;           ///< LayerIds in vps of layer set
     92  Bool                   m_defaultOneTargetOutputLayerFlag;   ///< Output highest layer of layer sets by default 
     93  std::vector<Int>       m_outputLayerSetIdx;                 ///< Indices of layer sets used as additional output layer sets 
     94  std::vector< std::vector<Int> > m_layerIdsInAddOutputLayerSet; ///< LayerIds in vps of additional output layers
     95  std::vector<Int>       m_profileLevelTierIdx;               ///< Indices of of profile level tier
     96 
     97  // Dependencies
     98  std::vector< std::vector<Int> > m_directRefLayers;          ///< LayerIds of direct reference layers
     99  std::vector< std::vector<Int> > m_dependencyTypes;          ///< Dependency types of direct reference layers
     100
     101#if H_3D_IV_MERGE
     102  Bool                   m_ivMvPredFlag;                      ///< Interview motion vector prediction
     103#endif
     104#if H_3D_ARP                                                  /// < flag and number of weighting factors in ARP
     105  UInt                   m_uiUseAdvResPred;
     106  UInt                   m_uiARPStepNum;
     107#endif
     108#if H_3D_IC
     109  vector<Bool> m_abUseIC;                                    ///< flag for using illumination compensation for inter-view prediction
     110#endif
     111#if H_3D_NBDV_REF
     112  Bool m_depthRefinementFlag; 
     113#endif
     114#if H_3D_VSP
     115  Bool m_viewSynthesisPredFlag;
     116#endif
     117#if H_3D_TMVP
     118  Bool m_ivMvScalingFlag;
     119#endif
     120#endif
    69121  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
    70122  // source specification
    71123  Int       m_iFrameRate;                                     ///< source frame-rates (Hz)
    72   unsigned int m_FrameSkip;                                   ///< number of skipped frames from the beginning
     124  UInt      m_FrameSkip;                                      ///< number of skipped frames from the beginning
    73125  Int       m_iSourceWidth;                                   ///< source width in pixel
    74126  Int       m_iSourceHeight;                                  ///< source height in pixel
    75   Int       m_croppingMode;
    76   Int       m_cropLeft;
    77   Int       m_cropRight;
    78   Int       m_cropTop;
    79   Int       m_cropBottom;
    80   Int       m_iFrameToBeEncoded;                              ///< number of encoded frames
     127  Int       m_conformanceMode;
     128  Int       m_confLeft;
     129  Int       m_confRight;
     130  Int       m_confTop;
     131  Int       m_confBottom;
     132  Int       m_framesToBeEncoded;                              ///< number of encoded frames
    81133  Int       m_aiPad[2];                                       ///< number of padded pixels for width and height
    82134 
    83   Int       m_iNumberOfViews;                                 ///< number Views to Encode
    84   Bool      m_bUsingDepthMaps;
    85  
    86 #if FLEX_CODING_ORDER_M23723
    87   Char*  m_pchMVCJointCodingOrder;      ///<  texture-depth coding order
    88   Bool    m_b3DVFlexOrder;    ///<  flexible coding order flag
    89 #endif
    90 
     135  // profile/level
     136  Profile::Name m_profile;
     137  Level::Tier   m_levelTier;
     138  Level::Name   m_level;
     139  Bool m_progressiveSourceFlag;
     140  Bool m_interlacedSourceFlag;
     141  Bool m_nonPackedConstraintFlag;
     142  Bool m_frameOnlyConstraintFlag;
     143 
    91144  // coding structure
    92145  Int       m_iIntraPeriod;                                   ///< period of I-slice (random access period)
    93146  Int       m_iDecodingRefreshType;                           ///< random access type
    94147  Int       m_iGOPSize;                                       ///< GOP size of hierarchical structure
    95   Int       m_extraRPSs[MAX_VIEW_NUM];
    96   GOPEntryMvc m_GOPListsMvc[MAX_VIEW_NUM][MAX_GOP+1];
    97   Int       m_numReorderPics[MAX_VIEW_NUM][MAX_TLAYER];       ///< total number of reorder pictures
    98   Int       m_maxDecPicBuffering[MAX_VIEW_NUM][MAX_TLAYER];   ///< total number of reference pictures needed for decoding
    99   Bool      m_bUseLComb;                                      ///< flag for using combined reference list for uni-prediction in B-slices (JCTVC-D421)
    100   Bool      m_bLCMod;                                         ///< flag for specifying whether the combined reference list for uni-prediction in B-slices is uploaded explicitly
    101   Bool      m_bDisInter4x4;
    102   Bool      m_enableNSQT;                                     ///< flag for enabling NSQT
     148#if H_MV
     149  Int       m_extraRPSsMvc[MAX_NUM_LAYERS];                       ///< extra RPSs added to handle CRA for each layer
     150  std::vector< GOPEntry* >  m_GOPListMvc;                            ///< the coding structure entries from the config file for each layer
     151  Int       m_numReorderPicsMvc[MAX_NUM_LAYERS][MAX_TLAYER];      ///< total number of reorder pictures for each layer
     152  Int       m_maxDecPicBufferingMvc[MAX_NUM_LAYERS][MAX_TLAYER];  ///< total number of reference pictures needed for decoding for each layer
     153#else
     154  Int       m_extraRPSs;                                      ///< extra RPSs added to handle CRA
     155  GOPEntry  m_GOPList[MAX_GOP];                               ///< the coding structure entries from the config file
     156  Int       m_numReorderPics[MAX_TLAYER];                     ///< total number of reorder pictures
     157  Int       m_maxDecPicBuffering[MAX_TLAYER];                 ///< total number of pictures in the decoded picture buffer
     158  #endif
     159  Bool      m_useTransformSkip;                               ///< flag for enabling intra transform skipping
     160  Bool      m_useTransformSkipFast;                           ///< flag for enabling fast intra transform skipping
    103161  Bool      m_enableAMP;
    104162  // coding quality
    105   std::vector<Double>  m_adQP;                                ///< QP value of key-picture (floating point) [0] video, [1] depth
    106   std::vector<Int>     m_aiQP;                                ///< QP value of key-picture (integer) [0] video, [1] depth
    107 #if QC_MVHEVC_B0046
    108   std::vector<Int>     m_aiVId;                                ///< view id
    109 #endif
    110   Int       m_aiTLayerQPOffset[MAX_TLAYER];                   ///< QP offset corresponding to temporal layer depth
    111   char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
     163#if H_MV
     164  std::vector<Double>  m_fQP;                                 ///< QP value of key-picture (floating point) for each layer
     165  std::vector<Int>     m_iQP;                                 ///< QP value of key-picture (integer) for each layer
     166#else
     167  Double    m_fQP;                                            ///< QP value of key-picture (floating point)
     168  Int       m_iQP;                                            ///< QP value of key-picture (integer)
     169#endif
     170  Char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
     171#if H_MV
     172  std::vector<Int*> m_aidQP;                                    ///< array of slice QP values for each layer
     173#else
    112174  Int*      m_aidQP;                                          ///< array of slice QP values
    113   Int*      m_aidQPdepth;                                     ///< array of depth slice QP values
     175#endif
    114176  Int       m_iMaxDeltaQP;                                    ///< max. |delta QP|
    115177  UInt      m_uiDeltaQpRD;                                    ///< dQP range for multi-pass slice QP optimization
    116178  Int       m_iMaxCuDQPDepth;                                 ///< Max. depth for a minimum CuDQPSize (0:default)
    117179
    118   Int       m_iChromaQpOffset;                                 ///< ChromaQpOffset    (0:default)
    119   Int       m_iChromaQpOffset2nd;                              ///< ChromaQpOffset2nd (0:default)
     180  Int       m_cbQpOffset;                                     ///< Chroma Cb QP Offset (0:default)
     181  Int       m_crQpOffset;                                     ///< Chroma Cr QP Offset (0:default)
    120182
    121183#if ADAPTIVE_QP_SELECTION
     
    126188  Int       m_iQPAdaptationRange;                             ///< dQP range by QP adaptation
    127189 
    128   Int       m_maxTempLayer[MAX_VIEW_NUM];                     ///< Max temporal layer
     190#if H_MV
     191  Int       m_maxTempLayerMvc[MAX_NUM_LAYER_IDS];             ///< Max temporal layer for each layer
     192#else
     193  Int       m_maxTempLayer;                                  ///< Max temporal layer
     194#endif
    129195
    130196  // coding unit (CU) definition
     
    141207 
    142208  // coding tools (bit-depth)
    143   UInt      m_uiInputBitDepth;                                ///< bit-depth of input file
    144   UInt      m_uiOutputBitDepth;                               ///< bit-depth of output file
    145   UInt      m_uiInternalBitDepth;                             ///< Internal bit-depth (BitDepth+BitIncrement)
     209  Int       m_inputBitDepthY;                               ///< bit-depth of input file (luma component)
     210  Int       m_inputBitDepthC;                               ///< bit-depth of input file (chroma component)
     211  Int       m_outputBitDepthY;                              ///< bit-depth of output file (luma component)
     212  Int       m_outputBitDepthC;                              ///< bit-depth of output file (chroma component)
     213  Int       m_internalBitDepthY;                            ///< bit-depth codec operates at in luma (input/output files will be converted)
     214  Int       m_internalBitDepthC;                            ///< bit-depth codec operates at in chroma (input/output files will be converted)
    146215
    147216  // coding tools (PCM bit-depth)
    148217  Bool      m_bPCMInputBitDepthFlag;                          ///< 0: PCM bit-depth is internal bit-depth. 1: PCM bit-depth is input bit-depth.
    149   UInt      m_uiPCMBitDepthLuma;                              ///< PCM bit-depth for luma
    150218
    151219  // coding tool (lossless)
    152 #if LOSSLESS_CODING
    153220  Bool      m_useLossless;                                    ///< flag for using lossless coding
    154 #endif
    155   vector<Bool> m_abUseSAO;
    156 #if LGE_ILLUCOMP_B0045
    157 #if LGE_ILLUCOMP_DEPTH_C0046
    158   vector<Bool> m_abUseIC;                                    ///< flag for using illumination compensation for inter-view prediction
    159 #else
    160   Bool      m_bUseIC;                                     ///< flag for using illumination compensation for inter-view prediction
    161 #endif
    162 #endif
    163 #if INTER_VIEW_VECTOR_SCALING_C0115
    164   Bool      m_bUseIVS;                                        ///< flag for using inter-view vector scaling
     221#if H_MV
     222  std::vector<Bool> m_bUseSAO;
     223#else
     224  Bool      m_bUseSAO;
    165225#endif
    166226  Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
    167 #if LGE_SAO_MIGRATION_D0091
    168227  Bool      m_saoLcuBoundary;                                 ///< SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
    169228  Bool      m_saoLcuBasedOptimization;                        ///< SAO LCU-based optimization
    170 #else
    171   Bool      m_saoInterleavingFlag;                            ///< SAO interleaving flag
    172 #endif
    173229  // coding tools (loop filter)
    174   vector<Bool> m_abUseALF;                                    ///< flag for using adaptive loop filter [0] - video, [1] - depth
    175   Int       m_iALFEncodePassReduction;                        //!< ALF encoding pass, 0 = original 16-pass, 1 = 1-pass, 2 = 2-pass
    176  
    177   Int       m_iALFMaxNumberFilters;                           ///< ALF Max Number Filters in one picture
    178   Bool      m_bALFParamInSlice;
    179   Bool      m_bALFPicBasedEncode;
    180 
    181   vector<Bool> m_abLoopFilterDisable;                         ///< flag for using deblocking filter filter [0] - video, [1] - depth
    182   Bool      m_loopFilterOffsetInAPS;                         ///< offset for deblocking filter in 0 = slice header, 1 = APS
     230#if H_MV
     231  std::vector<Bool> m_bLoopFilterDisable;                     ///< flag for using deblocking filter for each layer
     232#else
     233  Bool      m_bLoopFilterDisable;                             ///< flag for using deblocking filter
     234#endif
     235  Bool      m_loopFilterOffsetInPPS;                         ///< offset for deblocking filter in 0 = slice header, 1 = PPS
    183236  Int       m_loopFilterBetaOffsetDiv2;                     ///< beta offset for deblocking filter
    184237  Int       m_loopFilterTcOffsetDiv2;                       ///< tc offset for deblocking filter
    185238  Bool      m_DeblockingFilterControlPresent;                 ///< deblocking filter control present flag in PPS
     239  Bool      m_DeblockingFilterMetric;                         ///< blockiness metric in encoder
    186240 
    187   Bool      m_bUseLMChroma;                                  ///< JL: Chroma intra prediction based on luma signal
    188 
    189241  // coding tools (PCM)
    190242  Bool      m_usePCM;                                         ///< flag for using IPCM
     
    197249  Bool      m_bUseASR;                                        ///< flag for using adaptive motion search range
    198250  Bool      m_bUseHADME;                                      ///< flag for using HAD in sub-pel ME
    199 vector<Bool> m_abUseRDOQ;                                   ///< flag for using RD optimized quantization [0]-video, [1]-depth
     251  Bool      m_useRDOQ;                                       ///< flag for using RD optimized quantization
     252  Bool      m_useRDOQTS;                                     ///< flag for using RD optimized quantization for transform skip
     253  Int      m_rdPenalty;                                      ///< RD-penalty for 32x32 TU for intra in non-intra slices (0: no RD-penalty, 1: RD-penalty, 2: maximum RD-penalty)
    200254  Int       m_iFastSearch;                                    ///< ME mode, 0 = full, 1 = diamond, 2 = PMVFAST
    201255  Int       m_iSearchRange;                                   ///< ME search range
    202 #if DV_V_RESTRICTION_B0037
    203   Bool      m_bUseDisparitySearchRangeRestriction;            ///< restrict vertical search range for inter-view prediction
    204   Int       m_iVerticalDisparitySearchRange;                  ///< ME vertical search range for inter-view prediction
    205 #endif
    206256  Int       m_bipredSearchRange;                              ///< ME search range for bipred refinement
    207257  Bool      m_bUseFastEnc;                                    ///< flag for using fast encoder setting
    208 #if HHI_INTERVIEW_SKIP
    209   Bool      m_bInterViewSkip;                            ///< usage of interview skip mode ( do not transmit residual)
    210 #if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    211   Double    m_dInterViewSkipLambdaScale;                 ///< lambda scale for interview skip
    212 #endif
    213 #endif
    214258  Bool      m_bUseEarlyCU;                                    ///< flag for using Early CU setting
    215 
    216 #if DEPTH_MAP_GENERATION
    217   UInt      m_uiPredDepthMapGeneration;                       ///< using of (virtual) depth maps for texture coding
    218 #endif
    219 #if H3D_IVMP
    220   UInt      m_uiMultiviewMvPredMode;                          ///< usage of predictors for multi-view mv prediction
    221   UInt      m_uiMultiviewMvRegMode;                           ///< regularization for multiview motion vectors
    222   Double    m_dMultiviewMvRegLambdaScale;                     ///< lambda scale for multiview motion vectors regularization
    223 #endif
    224 #if H3D_IVRP
    225 #if QC_ARP_D0177
    226   UInt      m_nUseAdvResPred;
    227 #else
    228   UInt      m_uiMultiviewResPredMode;          ///< using multiview residual prediction
    229 #endif
    230 #endif
    231 
    232   Bool      m_useFastDecisionForMerge;         ///< flag for using Fast Decision Merge RD-Cost
    233   Bool      m_bUseCbfFastMode;                 ///< flag for using Cbf Fast PU Mode Decision
    234   Int       m_iSliceMode;                      ///< 0: Disable all Recon slice limits, 1 : Maximum number of largest coding units per slice, 2: Maximum number of bytes in a slice
    235   Int       m_iSliceArgument;                  ///< If m_iSliceMode==1, m_iSliceArgument=max. # of largest coding units. If m_iSliceMode==2, m_iSliceArgument=max. # of bytes.
    236   Int       m_iEntropySliceMode;               ///< 0: Disable all entropy slice limits, 1 : Maximum number of largest coding units per slice, 2: Constraint based entropy slice
    237   Int       m_iEntropySliceArgument;           ///< If m_iEntropySliceMode==1, m_iEntropySliceArgument=max. # of largest coding units. If m_iEntropySliceMode==2, m_iEntropySliceArgument=max. # of bins.
    238 
    239   Int       m_iSliceGranularity;               ///< 0: Slices always end at LCU borders. 1-3: slices may end at a depth of 1-3 below LCU level.
    240   Bool      m_bLFCrossSliceBoundaryFlag;       ///< 0: Cross-slice-boundary in-loop filtering 1: non-cross-slice-boundary in-loop filtering
    241   Int       m_iTileBehaviorControlPresentFlag; //!< 1: tile behavior control parameters are in PPS 0: tile behavior control parameters are not in PPS
    242   Bool      m_bLFCrossTileBoundaryFlag;        //!< 1: Cross-tile-boundary in-loop filtering 0: non-cross-tile-boundary in-loop filtering
    243   Int       m_iColumnRowInfoPresent;
     259  Bool      m_useFastDecisionForMerge;                        ///< flag for using Fast Decision Merge RD-Cost
     260  Bool      m_bUseCbfFastMode;                              ///< flag for using Cbf Fast PU Mode Decision
     261  Bool      m_useEarlySkipDetection;                         ///< flag for using Early SKIP Detection
     262  Int       m_sliceMode;                                     ///< 0: no slice limits, 1 : max number of CTBs per slice, 2: max number of bytes per slice,
     263                                                             ///< 3: max number of tiles per slice
     264  Int       m_sliceArgument;                                 ///< argument according to selected slice mode
     265  Int       m_sliceSegmentMode;                              ///< 0: no slice segment limits, 1 : max number of CTBs per slice segment, 2: max number of bytes per slice segment,
     266                                                             ///< 3: max number of tiles per slice segment
     267  Int       m_sliceSegmentArgument;                          ///< argument according to selected slice segment mode
     268
     269  Bool      m_bLFCrossSliceBoundaryFlag;  ///< 1: filter across slice boundaries 0: do not filter across slice boundaries
     270  Bool      m_bLFCrossTileBoundaryFlag;   ///< 1: filter across tile boundaries  0: do not filter across tile boundaries
    244271  Int       m_iUniformSpacingIdr;
    245272  Int       m_iNumColumnsMinus1;
    246   char*     m_pchColumnWidth;
     273  Char*     m_pchColumnWidth;
    247274  Int       m_iNumRowsMinus1;
    248   char*     m_pchRowHeight;
    249   Int       m_iTileLocationInSliceHeaderFlag; //< enable(1)/disable(0) transmitssion of tile location in slice header
    250   Int       m_iTileMarkerFlag;              //< enable(1)/disable(0) transmitssion of light weight tile marker
    251   Int       m_iMaxTileMarkerEntryPoints;    //< maximum number of tile markers allowed in a slice (controls degree of parallelism)
    252   Double    m_dMaxTileMarkerOffset;         //< Calculated offset. Light weight tile markers will be transmitted for TileIdx= Offset, 2*Offset, 3*Offset ...
    253 
     275  Char*     m_pchRowHeight;
     276  UInt*     m_pColumnWidth;
     277  UInt*     m_pRowHeight;
    254278  Int       m_iWaveFrontSynchro; //< 0: no WPP. >= 1: WPP is enabled, the "Top right" from which inheritance occurs is this LCU offset in the line above the current.
    255   Int       m_iWaveFrontFlush; //< enable(1)/disable(0) the CABAC flush at the end of each line of LCUs.
    256279  Int       m_iWaveFrontSubstreams; //< If iWaveFrontSynchro, this is the number of substreams per frame (dependent tiles) or per tile (independent tiles).
    257280
    258281  Bool      m_bUseConstrainedIntraPred;                       ///< flag for using constrained intra prediction
    259282 
    260   bool m_pictureDigestEnabled; ///< enable(1)/disable(0) md5 computation and SEI signalling
    261 
     283  Int       m_decodedPictureHashSEIEnabled;                    ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
     284  Int       m_recoveryPointSEIEnabled;
     285  Int       m_bufferingPeriodSEIEnabled;
     286  Int       m_pictureTimingSEIEnabled;
     287  Bool      m_toneMappingInfoSEIEnabled;
     288  Int       m_toneMapId;
     289  Bool      m_toneMapCancelFlag;
     290  Bool      m_toneMapPersistenceFlag;
     291  Int       m_toneMapCodedDataBitDepth;
     292  Int       m_toneMapTargetBitDepth;
     293  Int       m_toneMapModelId;
     294  Int       m_toneMapMinValue;
     295  Int       m_toneMapMaxValue;
     296  Int       m_sigmoidMidpoint;
     297  Int       m_sigmoidWidth;
     298  Int       m_numPivots;
     299  Int       m_cameraIsoSpeedIdc;
     300  Int       m_cameraIsoSpeedValue;
     301  Int       m_exposureCompensationValueSignFlag;
     302  Int       m_exposureCompensationValueNumerator;
     303  Int       m_exposureCompensationValueDenomIdc;
     304  Int       m_refScreenLuminanceWhite;
     305  Int       m_extendedRangeWhiteLevel;
     306  Int       m_nominalBlackLevelLumaCodeValue;
     307  Int       m_nominalWhiteLevelLumaCodeValue;
     308  Int       m_extendedWhiteLevelLumaCodeValue;
     309  Int*      m_startOfCodedInterval;
     310  Int*      m_codedPivotValue;
     311  Int*      m_targetPivotValue;
     312  Int       m_framePackingSEIEnabled;
     313  Int       m_framePackingSEIType;
     314  Int       m_framePackingSEIId;
     315  Int       m_framePackingSEIQuincunx;
     316  Int       m_framePackingSEIInterpretation;
     317  Int       m_displayOrientationSEIAngle;
     318  Int       m_temporalLevel0IndexSEIEnabled;
     319  Int       m_gradualDecodingRefreshInfoEnabled;
     320  Int       m_decodingUnitInfoSEIEnabled;
     321  Int       m_SOPDescriptionSEIEnabled;
     322  Int       m_scalableNestingSEIEnabled;
    262323  // weighted prediction
    263   Bool      m_bUseWeightPred;                                 ///< Use of explicit Weighting Prediction for P_SLICE
    264   UInt      m_uiBiPredIdc;                                    ///< Use of Bi-Directional Weighting Prediction (B_SLICE): explicit(1) or implicit(2)
    265 
    266 #if TMVP_DEPTH_SWITCH
    267   vector<Bool> m_enableTMVP;                                  ///< Enable TMVP [0] video, [1] depth
    268 #else
    269   Bool      m_enableTMVP;
    270 #endif
    271 
     324  Bool      m_useWeightedPred;                    ///< Use of weighted prediction in P slices
     325  Bool      m_useWeightedBiPred;                  ///< Use of bi-directional weighted prediction in B slices
     326 
     327  UInt      m_log2ParallelMergeLevel;                         ///< Parallel merge estimation region
     328  UInt      m_maxNumMergeCand;                                ///< Max number of merge candidates
     329
     330  Int       m_TMVPModeId;
    272331  Int       m_signHideFlag;
    273   Int       m_signHidingThreshold;
    274 #if HHI_MPI
    275   Bool      m_bUseMVI;  ///< flag for using Motion Vector Inheritance for depth map coding
    276 #endif
    277 #if RWTH_SDC_DLT_B0036
    278   Bool      m_bUseDLT;
    279   Bool      m_bUseSDC;
    280 #endif
    281 
     332#if RATE_CONTROL_LAMBDA_DOMAIN
     333  Bool      m_RCEnableRateControl;                ///< enable rate control or not
     334  Int       m_RCTargetBitrate;                    ///< target bitrate when rate control is enabled
     335#if M0036_RC_IMPROVEMENT
     336  Int       m_RCKeepHierarchicalBit;              ///< 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation
     337#else
     338  Bool      m_RCKeepHierarchicalBit;              ///< whether keeping hierarchical bit allocation structure or not
     339#endif
     340  Bool      m_RCLCULevelRC;                       ///< true: LCU level rate control; false: picture level rate control
     341  Bool      m_RCUseLCUSeparateModel;              ///< use separate R-lambda model at LCU level
     342  Int       m_RCInitialQP;                        ///< inital QP for rate control
     343  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
     344#else
     345  Bool      m_enableRateCtrl;                                   ///< Flag for using rate control algorithm
     346  Int       m_targetBitrate;                                 ///< target bitrate
     347  Int       m_numLCUInUnit;                                  ///< Total number of LCUs in a frame should be completely divided by the NumLCUInUnit
     348#endif
    282349  Int       m_useScalingListId;                               ///< using quantization matrix
    283   char*     m_scalingListFile;                                ///< quantization matrix file name
    284 
    285   // camera parameter
     350  Char*     m_scalingListFile;                                ///< quantization matrix file name
     351
     352  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
     353  Bool      m_CUTransquantBypassFlagValue;                    ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
     354
     355  Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value
     356  Bool      m_useStrongIntraSmoothing;                        ///< enable strong intra smoothing for 32x32 blocks where the reference samples are flat
     357  Int       m_activeParameterSetsSEIEnabled;
     358
     359  Bool      m_vuiParametersPresentFlag;                       ///< enable generation of VUI parameters
     360  Bool      m_aspectRatioInfoPresentFlag;                     ///< Signals whether aspect_ratio_idc is present
     361  Int       m_aspectRatioIdc;                                 ///< aspect_ratio_idc
     362  Int       m_sarWidth;                                       ///< horizontal size of the sample aspect ratio
     363  Int       m_sarHeight;                                      ///< vertical size of the sample aspect ratio
     364  Bool      m_overscanInfoPresentFlag;                        ///< Signals whether overscan_appropriate_flag is present
     365  Bool      m_overscanAppropriateFlag;                        ///< Indicates whether conformant decoded pictures are suitable for display using overscan
     366  Bool      m_videoSignalTypePresentFlag;                     ///< Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present
     367  Int       m_videoFormat;                                    ///< Indicates representation of pictures
     368  Bool      m_videoFullRangeFlag;                             ///< Indicates the black level and range of luma and chroma signals
     369  Bool      m_colourDescriptionPresentFlag;                   ///< Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present
     370  Int       m_colourPrimaries;                                ///< Indicates chromaticity coordinates of the source primaries
     371  Int       m_transferCharacteristics;                        ///< Indicates the opto-electronic transfer characteristics of the source
     372  Int       m_matrixCoefficients;                             ///< Describes the matrix coefficients used in deriving luma and chroma from RGB primaries
     373  Bool      m_chromaLocInfoPresentFlag;                       ///< Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present
     374  Int       m_chromaSampleLocTypeTopField;                    ///< Specifies the location of chroma samples for top field
     375  Int       m_chromaSampleLocTypeBottomField;                 ///< Specifies the location of chroma samples for bottom field
     376  Bool      m_neutralChromaIndicationFlag;                    ///< Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)
     377  Bool      m_defaultDisplayWindowFlag;                       ///< Indicates the presence of the default window parameters
     378  Int       m_defDispWinLeftOffset;                           ///< Specifies the left offset from the conformance window of the default window
     379  Int       m_defDispWinRightOffset;                          ///< Specifies the right offset from the conformance window of the default window
     380  Int       m_defDispWinTopOffset;                            ///< Specifies the top offset from the conformance window of the default window
     381  Int       m_defDispWinBottomOffset;                         ///< Specifies the bottom offset from the conformance window of the default window
     382  Bool      m_frameFieldInfoPresentFlag;                      ///< Indicates that pic_struct values are present in picture timing SEI messages
     383  Bool      m_pocProportionalToTimingFlag;                    ///< Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS
     384  Int       m_numTicksPocDiffOneMinus1;                       ///< Number of ticks minus 1 that for a POC difference of one
     385  Bool      m_bitstreamRestrictionFlag;                       ///< Signals whether bitstream restriction parameters are present
     386  Bool      m_tilesFixedStructureFlag;                        ///< Indicates that each active picture parameter set has the same values of the syntax elements related to tiles
     387  Bool      m_motionVectorsOverPicBoundariesFlag;             ///< Indicates that no samples outside the picture boundaries are used for inter prediction
     388  Int       m_minSpatialSegmentationIdc;                      ///< Indicates the maximum size of the spatial segments in the pictures in the coded video sequence
     389  Int       m_maxBytesPerPicDenom;                            ///< Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture
     390  Int       m_maxBitsPerMinCuDenom;                           ///< Indicates an upper bound for the number of bits of coding_unit() data
     391  Int       m_log2MaxMvLengthHorizontal;                      ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
     392  Int       m_log2MaxMvLengthVertical;                        ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
     393
     394#if H_3D
     395  // Camera parameters
    286396  Char*     m_pchCameraParameterFile;                         ///< camera parameter file
    287397  Char*     m_pchBaseViewCameraNumbers;
    288 #if !QC_MVHEVC_B0046
    289398  TAppComCamPara m_cCameraData;
    290 #endif
    291399  Int       m_iCodedCamParPrecision;                          ///< precision for coding of camera parameters
    292 
    293 #if HHI_VSO
     400#if H_3D_VSO
    294401  Char*     m_pchVSOConfig;
    295402  Bool      m_bUseVSO;                                    ///< flag for using View Synthesis Optimization
    296 #if HHI_VSO_LS_TABLE_M23714
    297403  Bool      m_bVSOLSTable;                                ///< Depth QP dependent Lagrange parameter optimization (m23714)
    298 #endif
    299 #if LGE_VSO_EARLY_SKIP_A0093
    300404  Bool      m_bVSOEarlySkip;                              ///< Early skip of VSO computation (JCT3V-A0093 modification 4)
    301 #endif
     405
    302406  //// Used for development by GT, might be removed later
    303407  Double    m_dLambdaScaleVSO;                            ///< Scaling factor for Lambda in VSO mode
    304408  Bool      m_bForceLambdaScaleVSO;                       ///< Use Lambda Scale for depth even if VSO is turned off
    305 #if HHI_VSO_DIST_INT
    306409  Bool      m_bAllowNegDist;                              ///< Allow negative distortion in VSO
    307 #endif
    308410  UInt      m_uiVSOMode;                                  ///< Number of VSO Mode, 1 = , 2 = simple, org vs. ren, 3 = simple, ren vs. ren, 4 = full 
    309 #endif
    310 #if SAIT_VSO_EST_A0033
     411
     412  // SAIT_VSO_EST_A0033
    311413  Bool      m_bUseEstimatedVSD;                           ///< Flag for using model based VSD estimation instead of VSO for some encoder decisions (JCT3V-A0033 modification 3) 
    312 #endif
    313 #if LGE_WVSO_A0119
     414
     415  // LGE_WVSO_A0119
    314416  Bool      m_bUseWVSO;                                    ///< flag for using View Synthesis Optimization 
    315417  Int       m_iVSOWeight;
    316418  Int       m_iVSDWeight;
    317419  Int       m_iDWeight;
    318 #endif
    319   // coding tools (depth intra modes)
    320 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    321   Bool      m_bUseDMM;                                        ///< flag for using DMM
    322 #endif
    323 
    324 #if H3D_QTL
    325   Bool      m_bUseQTLPC;                                      ///< flag for using depth QuadTree Limitation + Predictive Coding
    326 #endif
    327 
    328 #if MTK_D0156
    329 
    330 #if MERL_VSP_COMPENSATION_C0152
    331   Bool      m_bUseVSPCompensation;
    332 #endif
    333 
    334   Bool      m_bUseDVPRefine;
    335 #endif
    336 
     420
     421  // Ren Model String
     422  TRenModSetupStrParser       m_cRenModStrParser;
     423#endif
     424#if H_3D_DIM
     425  Bool      m_useDMM;                                        ///< flag for using DMM
     426  Bool      m_useRBC;                                        ///< flag for using RBC
     427  Bool      m_useSDC;                                        ///< flag for using SDC
     428  Bool      m_useDLT;                                        ///< flag for using DLT
     429#endif
     430#if H_3D_QTLPC
     431  Bool      m_bUseQTL;                                        ///< flag for using depth QuadTree Limitation
     432  Bool      m_bUsePC;                                         ///< flag for using Predictive Coding with QTL
     433#endif
     434#if LGE_INTER_SDC_E0156
     435  Bool m_bDepthInterSDCFlag;                                ///< flag for inter SDC of depth map coding
     436#endif
     437#endif
    337438  // internal member functions
    338439  Void  xSetGlobal      ();                                   ///< set global variables
     
    340441  Void  xPrintParameter ();                                   ///< print configuration values
    341442  Void  xPrintUsage     ();                                   ///< print usage
    342  
    343   Void  xCleanUpVectors ();                                   ///< clean up vector sizes
    344   Void  xInitCameraPars ();                                   ///< init camera parameters
    345 
    346 
    347   // set MVD Parameters and LUTs
    348   Void xSetShiftParameters();
    349   Void xGetShiftParameter( UInt uiSourceView, UInt uiTargetView, bool bExternal, double& rdScale, double& rdOffset ); ///< Get one Shift Parameters
    350 
    351   Void  xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char* & rpchOutputFileName);
    352 
    353   Void  xCheckCodingStructureMvc();                           ///< validate and configure inter-view coding structure
    354 
    355   template <class T> Void xCleanUpVector( std::vector<T>& rcVec, const T& rcInvalid );
    356 #if HHI_VSO
    357   // Ren Model String
    358   TRenModSetupStrParser       m_cRenModStrParser;
     443#if H_MV
     444  template <typename T>
     445  Void xResizeVector(  std::vector<T> & rpcVector )
     446  {
     447    for( Int layer = 0; rpcVector.size() < m_numberOfLayers; layer++ )
     448    {
     449      assert( rpcVector.size() > 0 );
     450      rpcVector.push_back( rpcVector[layer] );     
     451    }
     452
     453    for( ; rpcVector.size() > m_numberOfLayers; )
     454    {     
     455      rpcVector.pop_back( );     
     456    }
     457  }
     458
     459  template <typename T>
     460  Void xPrintParaVector( std::string description, std::vector<T> & rpcVector )
     461  {
     462    Int iSpace = max(1, ENC_CFG_CONSOUT_SPACE - (Int) description.length() );
     463   
     464    for ( Int i = 0; i < iSpace; i++ )
     465      description.append( " " );
     466     
     467    description.append( ":" );
     468    printf( "%s", description.c_str() );
     469
     470    for(Int i=0;i<rpcVector.size();i++)               
     471      xPrintVectorElem( rpcVector[i] );
     472
     473    printf("\n");
     474  }
     475 
     476  Void xPrintVectorElem( UInt   elem ) { printf(" %d"   , elem            );};
     477  Void xPrintVectorElem( Int    elem ) { printf(" %d"   , elem            );};
     478 
     479  Void xPrintVectorElem( Double elem ) { printf(" %5.2f", elem            );}; 
     480  Void xPrintVectorElem( Bool   elem ) { printf(" %d"   , ( elem ? 1 : 0 ));};
     481#endif
     482#if H_MV
     483  Int   getGOPSize() { return m_iGOPSize; }
    359484#endif
    360485public:
  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

    r443 r608  
    44 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    5757TAppEncTop::TAppEncTop()
    5858{
     59#if !H_MV
     60  m_iFrameRcvd = 0;
     61#endif
    5962  m_totalBytes = 0;
    6063  m_essentialBytes = 0;
     
    6770Void TAppEncTop::xInitLibCfg()
    6871{
    69 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    70 #if !QC_MVHEVC_B0046
    71   UInt layerId = 0;
    72 #endif
    73   // TODO: fix the assumption here that the temporal structures are all equal across all layers???
    74   m_cVPS.setMaxTLayers( m_maxTempLayer[0] );
    75 #if QC_MVHEVC_B0046
    76   m_cVPS.setMaxLayers( m_iNumberOfViews );
    77 #else
    78   m_cVPS.setMaxLayers( m_iNumberOfViews * (m_bUsingDepthMaps ? 2:1) );
    79 #endif
     72#if H_MV
     73  TComVPS& vps = m_vps;   
     74#else
     75  TComVPS vps;
     76#endif
     77 
     78#if H_MV
     79  Int maxTempLayer = -1;
     80  for (Int j = 0; j < m_numberOfLayers; j++)
     81  {
     82    maxTempLayer = max( m_maxTempLayerMvc[ j ], maxTempLayer );
     83  }
     84
     85  vps.setMaxTLayers                       ( maxTempLayer );
     86  if ( maxTempLayer )
     87  {
     88    vps.setTemporalNestingFlag(true);
     89  }
     90  vps.setMaxLayers( m_numberOfLayers );
    8091  for(Int i = 0; i < MAX_TLAYER; i++)
    8192  {
    82     m_cVPS.setNumReorderPics( m_numReorderPics[0][i], i );
    83     m_cVPS.setMaxDecPicBuffering( m_maxDecPicBuffering[0][i], i );
    84   }
    85 #endif
    86  
    87   for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
    88   {
    89     m_frameRcvd.push_back(0);
    90     m_acTEncTopList.push_back(new TEncTop);
     93    Int maxNumReOrderPics  = 0;
     94    Int maxDecPicBuffering = 0;
     95    for (Int j = 0; j < m_numberOfLayers; j++)
     96    {
     97      maxNumReOrderPics  = max( maxNumReOrderPics,  m_numReorderPicsMvc    [ j ][ i ] );     
     98      maxDecPicBuffering = max( maxDecPicBuffering, m_maxDecPicBufferingMvc[ j ][ i ] );     
     99    }
     100
     101    vps.setNumReorderPics                 ( maxNumReOrderPics  ,i );
     102    vps.setMaxDecPicBuffering             ( maxDecPicBuffering ,i );
     103  }
     104#else
     105  vps.setMaxTLayers                       ( m_maxTempLayer );
     106  if (m_maxTempLayer == 1)
     107  {
     108    vps.setTemporalNestingFlag(true);
     109  }
     110  vps.setMaxLayers                        ( 1 );
     111  for(Int i = 0; i < MAX_TLAYER; i++)
     112  {
     113    vps.setNumReorderPics                 ( m_numReorderPics[i], i );
     114    vps.setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
     115  }
     116#endif
     117#if H_MV
     118  xSetLayerIds             ( vps );   
     119  xSetDimensionIdAndLength ( vps );
     120  xSetDependencies( vps );
     121  xSetProfileTierLevel     ( vps );
     122  xSetLayerSets            ( vps );
     123#if H_3D
     124  vps.initViewIndex();
     125  xSetVPSExtension2        ( vps );
     126  m_ivPicLists.setVPS      ( &vps );
     127#endif
     128
     129  for(Int layer = 0; layer < m_numberOfLayers; layer++)
     130  {
     131    m_frameRcvd                 .push_back(0);
     132    m_acTEncTopList             .push_back(new TEncTop);
    91133    m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
    92134    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
    93     m_picYuvRec.push_back(new TComList<TComPicYuv*>) ;
    94 
    95     m_acTEncTopList[iViewIdx]->setFrameRate                    ( m_iFrameRate );
    96     m_acTEncTopList[iViewIdx]->setFrameSkip                    ( m_FrameSkip );
    97     m_acTEncTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
    98     m_acTEncTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
    99     m_acTEncTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
    100     m_acTEncTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
    101     m_acTEncTopList[iViewIdx]->setCropRight                    ( m_cropRight );
    102     m_acTEncTopList[iViewIdx]->setCropTop                      ( m_cropTop );
    103     m_acTEncTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
    104     m_acTEncTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
    105     m_acTEncTopList[iViewIdx]->setViewId                       ( iViewIdx );
    106     m_acTEncTopList[iViewIdx]->setIsDepth                      ( false );
    107 #if QC_MVHEVC_B0046
    108     m_acTEncTopList[iViewIdx]->setLayerId                      ( iViewIdx );
    109     m_cVPS.setViewId                                           ( m_aiVId[ iViewIdx ], iViewIdx );
    110 #else
    111     m_acTEncTopList[iViewIdx]->setViewOrderIdx                 ( m_cCameraData.getViewOrderIndex()[ iViewIdx ] );
    112 #if VIDYO_VPS_INTEGRATION
    113     layerId = iViewIdx * (m_bUsingDepthMaps ? 2:1);
    114     m_acTEncTopList[iViewIdx]->setLayerId                      ( layerId );
    115     m_cVPS.setDepthFlag                                        ( false, layerId );
    116     m_cVPS.setViewId                                           ( iViewIdx, layerId );
    117     m_cVPS.setViewOrderIdx                                     ( m_cCameraData.getViewOrderIndex()[ iViewIdx ], layerId );
    118     // TODO: set correct dependentFlag and dependentLayer
    119     m_cVPS.setDependentFlag                                    ( iViewIdx ? true:false, layerId );
    120     m_cVPS.setDependentLayer                                   ( layerId - (m_bUsingDepthMaps ? 2:1), layerId );
    121 #if INTER_VIEW_VECTOR_SCALING_C0115
    122     m_cVPS.setIVScalingFlag                                    ( m_bUseIVS );
    123 #endif
    124 #endif
     135    m_picYuvRec                 .push_back(new TComList<TComPicYuv*>) ;
     136
     137    m_ivPicLists.push_back( m_acTEncTopList[ layer ]->getListPic()  );
     138    TEncTop& m_cTEncTop = *m_acTEncTopList[ layer ];  // It is not a member, but this name helps avoiding code duplication !!!
    125139   
    126     m_acTEncTopList[iViewIdx]->setCamParPrecision              ( m_cCameraData.getCamParsCodedPrecision  () );
    127     m_acTEncTopList[iViewIdx]->setCamParInSliceHeader          ( m_cCameraData.getVaryingCameraParameters() );
    128     m_acTEncTopList[iViewIdx]->setCodedScale                   ( m_cCameraData.getCodedScale             () );
    129     m_acTEncTopList[iViewIdx]->setCodedOffset                  ( m_cCameraData.getCodedOffset            () );
    130 #endif   
    131 
     140    m_cTEncTop.setLayerIdInVps                 ( layer );
     141    m_cTEncTop.setLayerId                      ( vps.getLayerIdInNuh( layer ) );   
     142    m_cTEncTop.setViewId                       ( vps.getViewId      ( layer ) );
     143#if H_3D
     144    Bool isDepth = ( vps.getDepthId     ( layer ) != 0 ) ;
     145    m_cTEncTop.setViewIndex                    ( vps.getViewIndex   ( layer ) );
     146    m_cTEncTop.setIsDepth                      ( isDepth );
     147    //====== Camera Parameters =========
     148    m_cTEncTop.setCameraParameters             ( &m_cCameraData );     
     149    m_cTEncTop.setCamParPrecision              ( isDepth ? false : m_cCameraData.getCamParsCodedPrecision  () );
     150    m_cTEncTop.setCamParInSliceHeader          ( isDepth ? 0     : m_cCameraData.getVaryingCameraParameters() );
     151    m_cTEncTop.setCodedScale                   ( isDepth ? 0     : m_cCameraData.getCodedScale             () );
     152    m_cTEncTop.setCodedOffset                  ( isDepth ? 0     : m_cCameraData.getCodedOffset            () );
     153#if H_3D_VSO
     154    //====== VSO =========
     155    m_cTEncTop.setRenderModelParameters        ( &m_cRenModStrParser );
     156    m_cTEncTop.setForceLambdaScaleVSO          ( isDepth ? m_bForceLambdaScaleVSO : false );
     157    m_cTEncTop.setLambdaScaleVSO               ( isDepth ? m_dLambdaScaleVSO      : 1     );
     158    m_cTEncTop.setVSOMode                      ( isDepth ? m_uiVSOMode            : 0     );
     159
     160    m_cTEncTop.setAllowNegDist                 ( isDepth ? m_bAllowNegDist        : false );
     161
     162    // SAIT_VSO_EST_A0033
     163    m_cTEncTop.setUseEstimatedVSD              ( isDepth ? m_bUseEstimatedVSD     : false );
     164
     165    // LGE_WVSO_A0119
     166    m_cTEncTop.setUseWVSO                      ( isDepth ? m_bUseWVSO             : false );   
     167    m_cTEncTop.setVSOWeight                    ( isDepth ? m_iVSOWeight           : 0     );
     168    m_cTEncTop.setVSDWeight                    ( isDepth ? m_iVSDWeight           : 0     );
     169    m_cTEncTop.setDWeight                      ( isDepth ? m_iDWeight             : 0     );
     170#endif // H_3D_VSO
     171#if H_3D_ARP
     172    //====== Advanced Inter-view Residual Prediction =========
     173    m_cTEncTop.setUseAdvRP                     ( ( isDepth || 0==layer ) ? 0 : m_uiUseAdvResPred );
     174    m_cTEncTop.setARPStepNum                   ( ( isDepth || 0==layer ) ? 1 : H_3D_ARP_WFNR     );
     175#endif
     176#if H_3D_IC
     177    m_cTEncTop.setUseIC                        ( vps.getViewIndex( layer ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
     178#endif
     179  //========== Depth intra modes ==========
     180#if H_3D_DIM
     181    m_cTEncTop.setUseDMM                       ( isDepth ? m_useDMM               : false );
     182    m_cTEncTop.setUseRBC                       ( isDepth ? m_useRBC               : false );
     183    m_cTEncTop.setUseSDC                       ( isDepth ? m_useSDC               : false );
     184    m_cTEncTop.setUseDLT                       ( isDepth ? m_useDLT               : false );
     185#endif
     186#if H_3D_QTLPC
     187    m_cTEncTop.setUseQTL                       ( isDepth ? m_bUseQTL               : false );
     188    m_cTEncTop.setUsePC                        ( isDepth ? m_bUsePC                : false );
     189#endif
     190    //====== Depth Inter SDC =========
     191#if LGE_INTER_SDC_E0156
     192    m_cTEncTop.setInterSDCEnable               ( isDepth ? m_bDepthInterSDCFlag    : false );
     193#endif
     194#endif // H_3D
     195
     196    m_cTEncTop.setIvPicLists                   ( &m_ivPicLists );
     197#endif // H_MV
     198  m_cTEncTop.setVPS(&vps);
     199
     200  m_cTEncTop.setProfile(m_profile);
     201  m_cTEncTop.setLevel(m_levelTier, m_level);
     202  m_cTEncTop.setProgressiveSourceFlag(m_progressiveSourceFlag);
     203  m_cTEncTop.setInterlacedSourceFlag(m_interlacedSourceFlag);
     204  m_cTEncTop.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
     205  m_cTEncTop.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
     206 
     207  m_cTEncTop.setFrameRate                    ( m_iFrameRate );
     208  m_cTEncTop.setFrameSkip                    ( m_FrameSkip );
     209  m_cTEncTop.setSourceWidth                  ( m_iSourceWidth );
     210  m_cTEncTop.setSourceHeight                 ( m_iSourceHeight );
     211  m_cTEncTop.setConformanceWindow            ( m_confLeft, m_confRight, m_confTop, m_confBottom );
     212  m_cTEncTop.setFramesToBeEncoded            ( m_framesToBeEncoded );
     213 
    132214  //====== Coding Structure ========
    133     m_acTEncTopList[iViewIdx]->setIntraPeriod                  ( m_iIntraPeriod );
    134     m_acTEncTopList[iViewIdx]->setDecodingRefreshType          ( m_iDecodingRefreshType );
    135     m_acTEncTopList[iViewIdx]->setGOPSize                      ( m_iGOPSize );
    136     m_acTEncTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
    137     m_acTEncTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
    138     for(Int i = 0; i < MAX_TLAYER; i++)
    139     {
    140       m_acTEncTopList[iViewIdx]->setNumReorderPics             ( m_numReorderPics[iViewIdx][i], i );
    141       m_acTEncTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
    142     }
    143     for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
    144     {
    145       m_acTEncTopList[iViewIdx]->setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
    146     }
    147     m_acTEncTopList[iViewIdx]->setQP                           ( m_aiQP[0] );
    148  
    149     m_acTEncTopList[iViewIdx]->setTemporalLayerQPOffset        ( m_aiTLayerQPOffset );
    150     m_acTEncTopList[iViewIdx]->setPad                          ( m_aiPad );
    151    
    152     m_acTEncTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
    153 
    154     m_acTEncTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
    155  
    156     m_acTEncTopList[iViewIdx]->setUseNSQT( m_enableNSQT );
    157     m_acTEncTopList[iViewIdx]->setUseAMP( m_enableAMP );
     215  m_cTEncTop.setIntraPeriod                  ( m_iIntraPeriod );
     216  m_cTEncTop.setDecodingRefreshType          ( m_iDecodingRefreshType );
     217  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
     218#if H_MV
     219  m_cTEncTop.setGopList                      ( m_GOPListMvc[layer] );
     220  m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layer] );
     221  for(Int i = 0; i < MAX_TLAYER; i++)
     222  {
     223    m_cTEncTop.setNumReorderPics             ( m_numReorderPicsMvc[layer][i], i );
     224    m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBufferingMvc[layer][i], i );
     225  }
     226#else
     227  m_cTEncTop.setGopList                      ( m_GOPList );
     228  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
     229  for(Int i = 0; i < MAX_TLAYER; i++)
     230  {
     231    m_cTEncTop.setNumReorderPics             ( m_numReorderPics[i], i );
     232    m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
     233  }
     234#endif
     235  for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
     236  {
     237    m_cTEncTop.setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
     238  }
     239#if H_MV
     240  m_cTEncTop.setQP                           ( m_iQP[layer] );
     241#else
     242  m_cTEncTop.setQP                           ( m_iQP );
     243#endif
     244
     245  m_cTEncTop.setPad                          ( m_aiPad );
     246
     247#if H_MV
     248  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layer] );
     249#else
     250  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
     251#endif
     252  m_cTEncTop.setUseAMP( m_enableAMP );
    158253 
    159254  //===== Slice ========
    160255 
    161256  //====== Loop/Deblock Filter ========
    162     m_acTEncTopList[iViewIdx]->setLoopFilterDisable            ( m_abLoopFilterDisable[0]       );
    163     m_acTEncTopList[iViewIdx]->setLoopFilterOffsetInAPS        ( m_loopFilterOffsetInAPS );
    164     m_acTEncTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
    165     m_acTEncTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
    166     m_acTEncTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
     257#if H_MV
     258  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layer]);
     259#else
     260  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
     261#endif
     262  m_cTEncTop.setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
     263  m_cTEncTop.setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
     264  m_cTEncTop.setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
     265  m_cTEncTop.setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
     266  m_cTEncTop.setDeblockingFilterMetric       ( m_DeblockingFilterMetric );
    167267
    168268  //====== Motion search ========
    169     m_acTEncTopList[iViewIdx]->setFastSearch                   ( m_iFastSearch  );
    170     m_acTEncTopList[iViewIdx]->setSearchRange                  ( m_iSearchRange );
    171     m_acTEncTopList[iViewIdx]->setBipredSearchRange            ( m_bipredSearchRange );
    172 #if DV_V_RESTRICTION_B0037
    173     m_acTEncTopList[iViewIdx]->setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
    174     m_acTEncTopList[iViewIdx]->setVerticalDisparitySearchRange( m_iVerticalDisparitySearchRange );
    175 #endif
     269  m_cTEncTop.setFastSearch                   ( m_iFastSearch  );
     270  m_cTEncTop.setSearchRange                  ( m_iSearchRange );
     271  m_cTEncTop.setBipredSearchRange            ( m_bipredSearchRange );
     272
    176273  //====== Quality control ========
    177     m_acTEncTopList[iViewIdx]->setMaxDeltaQP                   ( m_iMaxDeltaQP  );
    178     m_acTEncTopList[iViewIdx]->setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
    179 
    180     m_acTEncTopList[iViewIdx]->setChromaQpOffset               ( m_iChromaQpOffset     );
    181     m_acTEncTopList[iViewIdx]->setChromaQpOffset2nd            ( m_iChromaQpOffset2nd  );
     274  m_cTEncTop.setMaxDeltaQP                   ( m_iMaxDeltaQP  );
     275  m_cTEncTop.setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
     276
     277  m_cTEncTop.setChromaCbQpOffset               ( m_cbQpOffset     );
     278  m_cTEncTop.setChromaCrQpOffset            ( m_crQpOffset  );
    182279
    183280#if ADAPTIVE_QP_SELECTION
    184     m_acTEncTopList[iViewIdx]->setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
    185 #endif
    186 
    187 #if LOSSLESS_CODING
    188     Int lowestQP;
    189     lowestQP =  - ( (Int)(6*(g_uiBitDepth + g_uiBitIncrement - 8)) );
    190     if ((m_iMaxDeltaQP == 0 ) && (m_aiQP[0] == lowestQP) && (m_useLossless == true))
    191     {
    192       m_bUseAdaptiveQP = false;
    193     }
    194 #endif
    195 
    196     m_acTEncTopList[iViewIdx]->setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
    197     m_acTEncTopList[iViewIdx]->setQPAdaptationRange            ( m_iQPAdaptationRange );
    198  
    199 #if HHI_VSO
    200     //====== VSO =========
    201     m_acTEncTopList[iViewIdx]->setForceLambdaScaleVSO          ( false );
    202     m_acTEncTopList[iViewIdx]->setLambdaScaleVSO               ( 1     );
    203     m_acTEncTopList[iViewIdx]->setVSOMode                      ( 0     );
    204     m_acTEncTopList[iViewIdx]->setUseVSO                       ( false );
    205 #if SAIT_VSO_EST_A0033
    206     m_acTEncTopList[iViewIdx]->setUseEstimatedVSD              ( false );
    207 #endif
    208 #if LGE_WVSO_A0119
    209     m_acTEncTopList[iViewIdx]->setUseWVSO                      ( false );
    210 #endif
    211 #endif
    212 
    213 #if DEPTH_MAP_GENERATION
    214     m_acTEncTopList[iViewIdx]->setPredDepthMapGeneration       ( m_uiPredDepthMapGeneration );
    215     m_acTEncTopList[iViewIdx]->setPdmPrecision                 ( (UInt)m_cCameraData.getPdmPrecision     () );
    216     m_acTEncTopList[iViewIdx]->setPdmScaleNomDelta             (       m_cCameraData.getPdmScaleNomDelta () );
    217     m_acTEncTopList[iViewIdx]->setPdmOffset                    (       m_cCameraData.getPdmOffset        () );
    218 #endif
    219 #if H3D_IVMP
    220     m_acTEncTopList[iViewIdx]->setMultiviewMvPredMode          ( m_uiMultiviewMvPredMode );
    221     m_acTEncTopList[iViewIdx]->setMultiviewMvRegMode           ( iViewIdx ? m_uiMultiviewMvRegMode       : 0   );
    222     m_acTEncTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( iViewIdx ? m_dMultiviewMvRegLambdaScale : 0.0 );
    223 #endif
    224 #if H3D_IVRP
    225 #if QC_ARP_D0177
    226     m_acTEncTopList[iViewIdx]->setUseAdvRP                     ( iViewIdx ? m_nUseAdvResPred             : 0   );
    227     m_acTEncTopList[iViewIdx]->setARPStepNum                   ( iViewIdx ? QC_ARP_WFNR                  : 1   );
    228 #else
    229     m_acTEncTopList[iViewIdx]->setMultiviewResPredMode         ( m_uiMultiviewResPredMode );
    230 #endif
    231 #endif
    232 #if MTK_D0156
    233 #if MERL_VSP_COMPENSATION_C0152
    234     m_acTEncTopList[iViewIdx]->setUseVSPCompensation           ( iViewIdx ? m_bUseVSPCompensation : 0 );
    235 #endif
    236     m_acTEncTopList[iViewIdx]->setUseDVPRefine                  ( iViewIdx ? m_bUseDVPRefine : 0 );
    237 #endif
    238 
     281  m_cTEncTop.setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
     282#endif
     283
     284  Int lowestQP;
     285  lowestQP =  - 6*(g_bitDepthY - 8); // XXX: check
     286
     287#if H_MV
     288  if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layer] == lowestQP) && (m_useLossless == true))
     289#else
     290  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
     291#endif
     292  {
     293    m_bUseAdaptiveQP = false;
     294  }
     295  m_cTEncTop.setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
     296  m_cTEncTop.setQPAdaptationRange            ( m_iQPAdaptationRange );
     297 
    239298  //====== Tool list ========
    240     m_acTEncTopList[iViewIdx]->setUseSBACRD                    ( m_bUseSBACRD   );
    241     m_acTEncTopList[iViewIdx]->setDeltaQpRD                    ( m_uiDeltaQpRD  );
    242     m_acTEncTopList[iViewIdx]->setUseASR                       ( m_bUseASR      );
    243     m_acTEncTopList[iViewIdx]->setUseHADME                     ( m_bUseHADME    );
    244     m_acTEncTopList[iViewIdx]->setUseALF                       ( m_abUseALF[0]  );
    245     m_acTEncTopList[iViewIdx]->setALFEncodePassReduction       ( m_iALFEncodePassReduction );
    246 #if LOSSLESS_CODING
    247     m_acTEncTopList[iViewIdx]->setUseLossless                  ( m_useLossless );
    248 #endif
    249     m_acTEncTopList[iViewIdx]->setALFMaxNumberFilters          ( m_iALFMaxNumberFilters ) ;
    250 
    251     m_acTEncTopList[iViewIdx]->setUseLComb                     ( m_bUseLComb    );
    252     m_acTEncTopList[iViewIdx]->setLCMod                        ( m_bLCMod         );
    253     m_acTEncTopList[iViewIdx]->setdQPs                         ( m_aidQP        );
    254     m_acTEncTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[0] );
    255     m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
    256     m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
    257     m_acTEncTopList[iViewIdx]->setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
    258     m_acTEncTopList[iViewIdx]->setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
    259     m_acTEncTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
    260     m_acTEncTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  );
    261     m_acTEncTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
    262     m_acTEncTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
    263 #if HHI_INTERVIEW_SKIP
    264     m_acTEncTopList[iViewIdx]->setInterViewSkip            ( iViewIdx>0 ? m_bInterViewSkip : false );
    265 #if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    266     m_acTEncTopList[iViewIdx]->setInterViewSkipLambdaScale ( iViewIdx>0 ? (UInt)m_dInterViewSkipLambdaScale : 1 );
    267 #endif
    268 #endif
    269     m_acTEncTopList[iViewIdx]->setUseLMChroma                  ( m_bUseLMChroma );
    270     m_acTEncTopList[iViewIdx]->setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
    271     m_acTEncTopList[iViewIdx]->setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
    272     m_acTEncTopList[iViewIdx]->setUsePCM                       ( m_usePCM );
    273     m_acTEncTopList[iViewIdx]->setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
     299  m_cTEncTop.setUseSBACRD                    ( m_bUseSBACRD   );
     300  m_cTEncTop.setDeltaQpRD                    ( m_uiDeltaQpRD  );
     301  m_cTEncTop.setUseASR                       ( m_bUseASR      );
     302  m_cTEncTop.setUseHADME                     ( m_bUseHADME    );
     303  m_cTEncTop.setUseLossless                  ( m_useLossless );
     304#if H_MV
     305  m_cTEncTop.setdQPs                         ( m_aidQP[layer]   );
     306#else
     307  m_cTEncTop.setdQPs                         ( m_aidQP        );
     308#endif
     309  m_cTEncTop.setUseRDOQ                      ( m_useRDOQ     );
     310  m_cTEncTop.setUseRDOQTS                    ( m_useRDOQTS   );
     311  m_cTEncTop.setRDpenalty                 ( m_rdPenalty );
     312  m_cTEncTop.setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
     313  m_cTEncTop.setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
     314  m_cTEncTop.setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
     315  m_cTEncTop.setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
     316  m_cTEncTop.setUseFastEnc                   ( m_bUseFastEnc  );
     317  m_cTEncTop.setUseEarlyCU                   ( m_bUseEarlyCU  );
     318  m_cTEncTop.setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
     319  m_cTEncTop.setUseCbfFastMode            ( m_bUseCbfFastMode  );
     320  m_cTEncTop.setUseEarlySkipDetection            ( m_useEarlySkipDetection );
     321
     322  m_cTEncTop.setUseTransformSkip             ( m_useTransformSkip      );
     323  m_cTEncTop.setUseTransformSkipFast         ( m_useTransformSkipFast  );
     324  m_cTEncTop.setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
     325  m_cTEncTop.setPCMLog2MinSize          ( m_uiPCMLog2MinSize);
     326  m_cTEncTop.setUsePCM                       ( m_usePCM );
     327  m_cTEncTop.setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
     328  m_cTEncTop.setMaxNumMergeCand              ( m_maxNumMergeCand );
     329 
    274330
    275331  //====== Weighted Prediction ========
    276     m_acTEncTopList[iViewIdx]->setUseWP                        ( m_bUseWeightPred      );
    277     m_acTEncTopList[iViewIdx]->setWPBiPredIdc                  ( m_uiBiPredIdc         );
     332  m_cTEncTop.setUseWP                   ( m_useWeightedPred      );
     333  m_cTEncTop.setWPBiPred                ( m_useWeightedBiPred   );
     334  //====== Parallel Merge Estimation ========
     335  m_cTEncTop.setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
     336
    278337  //====== Slice ========
    279     m_acTEncTopList[iViewIdx]->setSliceMode                    ( m_iSliceMode                );
    280     m_acTEncTopList[iViewIdx]->setSliceArgument                ( m_iSliceArgument            );
    281 
    282   //====== Entropy Slice ========
    283     m_acTEncTopList[iViewIdx]->setEntropySliceMode             ( m_iEntropySliceMode         );
    284     m_acTEncTopList[iViewIdx]->setEntropySliceArgument         ( m_iEntropySliceArgument     );
    285     int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
    286     if(m_iEntropySliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
    287     {
    288       m_acTEncTopList[iViewIdx]->setEntropySliceArgument ( m_iEntropySliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
    289     }
    290     if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
    291     {
    292       m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
    293     }
    294     if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
    295     {
    296       m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
    297     }
    298     m_acTEncTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
    299     if(m_iSliceMode == 0 )
    300     {
    301       m_bLFCrossSliceBoundaryFlag = true;
    302     }
    303     m_acTEncTopList[iViewIdx]->setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
    304     m_acTEncTopList[iViewIdx]->setUseSAO               ( m_abUseSAO[0]     );
    305 #if LGE_ILLUCOMP_B0045
    306 #if LGE_ILLUCOMP_DEPTH_C0046
    307     m_acTEncTopList[iViewIdx]->setUseIC                ( m_abUseIC[0]      );
    308 #else
    309     m_acTEncTopList[iViewIdx]->setUseIC                ( m_bUseIC          );
    310 #endif
    311 #endif
    312 #if INTER_VIEW_VECTOR_SCALING_C0115
    313     m_acTEncTopList[iViewIdx]->setUseIVS               ( m_bUseIVS          );
    314 #endif
    315     m_acTEncTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
    316 #if LGE_SAO_MIGRATION_D0091
    317     m_acTEncTopList[iViewIdx]->setSaoLcuBoundary (m_saoLcuBoundary);
    318     m_acTEncTopList[iViewIdx]->setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
    319 #else
    320     m_acTEncTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
    321 #endif
    322     m_acTEncTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
    323     m_acTEncTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
    324 
    325     m_acTEncTopList[iViewIdx]->setPictureDigestEnabled(m_pictureDigestEnabled);
    326 
    327     m_acTEncTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
    328     m_acTEncTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
    329     m_acTEncTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
    330     m_acTEncTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
    331     if(m_iUniformSpacingIdr==0)
    332     {
    333       m_acTEncTopList[iViewIdx]->setColumnWidth              ( m_pchColumnWidth );
    334       m_acTEncTopList[iViewIdx]->setRowHeight                ( m_pchRowHeight );
    335     }
    336     m_acTEncTopList[iViewIdx]->xCheckGSParameters();
    337     m_acTEncTopList[iViewIdx]->setTileLocationInSliceHeaderFlag ( m_iTileLocationInSliceHeaderFlag );
    338     m_acTEncTopList[iViewIdx]->setTileMarkerFlag              ( m_iTileMarkerFlag );
    339     m_acTEncTopList[iViewIdx]->setMaxTileMarkerEntryPoints    ( m_iMaxTileMarkerEntryPoints );
    340  
    341     Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
    342     m_dMaxTileMarkerOffset    = ((Double)uiTilesCount) / m_iMaxTileMarkerEntryPoints;
    343     m_acTEncTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
    344     m_acTEncTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
    345     if(uiTilesCount == 1)
    346     {
    347       m_bLFCrossTileBoundaryFlag = true;
    348     }
    349     m_acTEncTopList[iViewIdx]->setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
    350     m_acTEncTopList[iViewIdx]->setWaveFrontSynchro           ( m_iWaveFrontSynchro );
    351     m_acTEncTopList[iViewIdx]->setWaveFrontFlush             ( m_iWaveFrontFlush );
    352     m_acTEncTopList[iViewIdx]->setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
    353 #if TMVP_DEPTH_SWITCH
    354     m_acTEncTopList[iViewIdx]->setEnableTMVP                 ( m_enableTMVP[0] );
    355 #else
    356     m_acTEncTopList[iViewIdx]->setEnableTMVP ( m_enableTMVP );
    357 #endif
    358     m_acTEncTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
    359     m_acTEncTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
    360     m_acTEncTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
    361     m_acTEncTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
    362 
    363     if(uiTilesCount > 1)
    364     {
    365       m_bALFParamInSlice = false;
    366       m_bALFPicBasedEncode = true;
    367     }
    368     m_acTEncTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
    369     m_acTEncTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
    370 
    371     //====== Depth tools ========
    372 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    373     m_acTEncTopList[iViewIdx]->setUseDMM                     ( false );
    374 #endif
    375 #if H3D_QTL
    376     m_acTEncTopList[iViewIdx]->setUseQTLPC                   ( false );
    377 #endif
    378 #if HHI_MPI
    379     m_acTEncTopList[iViewIdx]->setUseMVI( false );
    380 #endif
    381 #if RWTH_SDC_DLT_B0036
    382     m_acTEncTopList[iViewIdx]->setUseDLT                      ( false );
    383     m_acTEncTopList[iViewIdx]->setUseSDC                      ( false );
    384 #endif
    385   }
    386   if( m_bUsingDepthMaps )
    387   {
    388     for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
    389     {
    390 
    391 #if FLEX_CODING_ORDER_M23723
    392       // Detect whether depth comes before than texture for this view
    393       Bool isDepthFirst = false;
    394       if ( m_b3DVFlexOrder )
     338  m_cTEncTop.setSliceMode               ( m_sliceMode                );
     339  m_cTEncTop.setSliceArgument           ( m_sliceArgument            );
     340
     341  //====== Dependent Slice ========
     342  m_cTEncTop.setSliceSegmentMode        ( m_sliceSegmentMode         );
     343  m_cTEncTop.setSliceSegmentArgument    ( m_sliceSegmentArgument     );
     344  Int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
     345  if(m_sliceSegmentMode==FIXED_NUMBER_OF_LCU)
     346  {
     347    m_cTEncTop.setSliceSegmentArgument ( m_sliceSegmentArgument * iNumPartInCU );
     348  }
     349  if(m_sliceMode==FIXED_NUMBER_OF_LCU)
     350  {
     351    m_cTEncTop.setSliceArgument ( m_sliceArgument * iNumPartInCU );
     352  }
     353  if(m_sliceMode==FIXED_NUMBER_OF_TILES)
     354  {
     355    m_cTEncTop.setSliceArgument ( m_sliceArgument );
     356  }
     357 
     358  if(m_sliceMode == 0 )
     359  {
     360    m_bLFCrossSliceBoundaryFlag = true;
     361  }
     362  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
     363#if H_MV
     364  m_cTEncTop.setUseSAO ( m_bUseSAO[layer] );
     365#else
     366  m_cTEncTop.setUseSAO ( m_bUseSAO );
     367#endif
     368  m_cTEncTop.setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
     369
     370  m_cTEncTop.setSaoLcuBoundary (m_saoLcuBoundary);
     371  m_cTEncTop.setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
     372  m_cTEncTop.setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
     373  m_cTEncTop.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
     374
     375  m_cTEncTop.setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
     376  m_cTEncTop.setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
     377  m_cTEncTop.setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
     378  m_cTEncTop.setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
     379  m_cTEncTop.setToneMappingInfoSEIEnabled                 ( m_toneMappingInfoSEIEnabled );
     380  m_cTEncTop.setTMISEIToneMapId                           ( m_toneMapId );
     381  m_cTEncTop.setTMISEIToneMapCancelFlag                   ( m_toneMapCancelFlag );
     382  m_cTEncTop.setTMISEIToneMapPersistenceFlag              ( m_toneMapPersistenceFlag );
     383  m_cTEncTop.setTMISEICodedDataBitDepth                   ( m_toneMapCodedDataBitDepth );
     384  m_cTEncTop.setTMISEITargetBitDepth                      ( m_toneMapTargetBitDepth );
     385  m_cTEncTop.setTMISEIModelID                             ( m_toneMapModelId );
     386  m_cTEncTop.setTMISEIMinValue                            ( m_toneMapMinValue );
     387  m_cTEncTop.setTMISEIMaxValue                            ( m_toneMapMaxValue );
     388  m_cTEncTop.setTMISEISigmoidMidpoint                     ( m_sigmoidMidpoint );
     389  m_cTEncTop.setTMISEISigmoidWidth                        ( m_sigmoidWidth );
     390  m_cTEncTop.setTMISEIStartOfCodedInterva                 ( m_startOfCodedInterval );
     391  m_cTEncTop.setTMISEINumPivots                           ( m_numPivots );
     392  m_cTEncTop.setTMISEICodedPivotValue                     ( m_codedPivotValue );
     393  m_cTEncTop.setTMISEITargetPivotValue                    ( m_targetPivotValue );
     394  m_cTEncTop.setTMISEICameraIsoSpeedIdc                   ( m_cameraIsoSpeedIdc );
     395  m_cTEncTop.setTMISEICameraIsoSpeedValue                 ( m_cameraIsoSpeedValue );
     396  m_cTEncTop.setTMISEIExposureCompensationValueSignFlag   ( m_exposureCompensationValueSignFlag );
     397  m_cTEncTop.setTMISEIExposureCompensationValueNumerator  ( m_exposureCompensationValueNumerator );
     398  m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc   ( m_exposureCompensationValueDenomIdc );
     399  m_cTEncTop.setTMISEIRefScreenLuminanceWhite             ( m_refScreenLuminanceWhite );
     400  m_cTEncTop.setTMISEIExtendedRangeWhiteLevel             ( m_extendedRangeWhiteLevel );
     401  m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue      ( m_nominalBlackLevelLumaCodeValue );
     402  m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue      ( m_nominalWhiteLevelLumaCodeValue );
     403  m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue     ( m_extendedWhiteLevelLumaCodeValue );
     404  m_cTEncTop.setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled );
     405  m_cTEncTop.setFramePackingArrangementSEIType( m_framePackingSEIType );
     406  m_cTEncTop.setFramePackingArrangementSEIId( m_framePackingSEIId );
     407  m_cTEncTop.setFramePackingArrangementSEIQuincunx( m_framePackingSEIQuincunx );
     408  m_cTEncTop.setFramePackingArrangementSEIInterpretation( m_framePackingSEIInterpretation );
     409  m_cTEncTop.setDisplayOrientationSEIAngle( m_displayOrientationSEIAngle );
     410  m_cTEncTop.setTemporalLevel0IndexSEIEnabled( m_temporalLevel0IndexSEIEnabled );
     411  m_cTEncTop.setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled );
     412  m_cTEncTop.setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled );
     413  m_cTEncTop.setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled );
     414  m_cTEncTop.setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled );
     415  m_cTEncTop.setUniformSpacingIdr          ( m_iUniformSpacingIdr );
     416  m_cTEncTop.setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
     417  m_cTEncTop.setNumRowsMinus1              ( m_iNumRowsMinus1 );
     418  if(m_iUniformSpacingIdr==0)
     419  {
     420    m_cTEncTop.setColumnWidth              ( m_pColumnWidth );
     421    m_cTEncTop.setRowHeight                ( m_pRowHeight );
     422  }
     423  m_cTEncTop.xCheckGSParameters();
     424  Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
     425  if(uiTilesCount == 1)
     426  {
     427    m_bLFCrossTileBoundaryFlag = true;
     428  }
     429  m_cTEncTop.setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
     430  m_cTEncTop.setWaveFrontSynchro           ( m_iWaveFrontSynchro );
     431  m_cTEncTop.setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
     432  m_cTEncTop.setTMVPModeId ( m_TMVPModeId );
     433  m_cTEncTop.setUseScalingListId           ( m_useScalingListId  );
     434  m_cTEncTop.setScalingListFile            ( m_scalingListFile   );
     435  m_cTEncTop.setSignHideFlag(m_signHideFlag);
     436#if RATE_CONTROL_LAMBDA_DOMAIN
     437  m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
     438  m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
     439  m_cTEncTop.setKeepHierBit         ( m_RCKeepHierarchicalBit );
     440  m_cTEncTop.setLCULevelRC          ( m_RCLCULevelRC );
     441  m_cTEncTop.setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
     442  m_cTEncTop.setInitialQP           ( m_RCInitialQP );
     443  m_cTEncTop.setForceIntraQP        ( m_RCForceIntraQP );
     444#else
     445  m_cTEncTop.setUseRateCtrl     ( m_enableRateCtrl);
     446  m_cTEncTop.setTargetBitrate   ( m_targetBitrate);
     447  m_cTEncTop.setNumLCUInUnit    ( m_numLCUInUnit);
     448#endif
     449  m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
     450  m_cTEncTop.setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
     451  m_cTEncTop.setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
     452  m_cTEncTop.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
     453  m_cTEncTop.setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
     454  m_cTEncTop.setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
     455  m_cTEncTop.setAspectRatioIdc( m_aspectRatioIdc );
     456  m_cTEncTop.setSarWidth( m_sarWidth );
     457  m_cTEncTop.setSarHeight( m_sarHeight );
     458  m_cTEncTop.setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
     459  m_cTEncTop.setOverscanAppropriateFlag( m_overscanAppropriateFlag );
     460  m_cTEncTop.setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
     461  m_cTEncTop.setVideoFormat( m_videoFormat );
     462  m_cTEncTop.setVideoFullRangeFlag( m_videoFullRangeFlag );
     463  m_cTEncTop.setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
     464  m_cTEncTop.setColourPrimaries( m_colourPrimaries );
     465  m_cTEncTop.setTransferCharacteristics( m_transferCharacteristics );
     466  m_cTEncTop.setMatrixCoefficients( m_matrixCoefficients );
     467  m_cTEncTop.setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
     468  m_cTEncTop.setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
     469  m_cTEncTop.setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
     470  m_cTEncTop.setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
     471  m_cTEncTop.setDefaultDisplayWindow( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
     472  m_cTEncTop.setFrameFieldInfoPresentFlag( m_frameFieldInfoPresentFlag );
     473  m_cTEncTop.setPocProportionalToTimingFlag( m_pocProportionalToTimingFlag );
     474  m_cTEncTop.setNumTicksPocDiffOneMinus1   ( m_numTicksPocDiffOneMinus1    );
     475  m_cTEncTop.setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
     476  m_cTEncTop.setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
     477  m_cTEncTop.setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
     478  m_cTEncTop.setMinSpatialSegmentationIdc( m_minSpatialSegmentationIdc );
     479  m_cTEncTop.setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
     480  m_cTEncTop.setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
     481  m_cTEncTop.setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
     482  m_cTEncTop.setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
     483#if H_MV
     484  }
     485#endif
     486#if H_3D_VSO
     487  if ( m_bUseVSO )
     488  {
     489    if ( m_uiVSOMode == 4 )
     490    {
     491#if H_3D_VSO_EARLY_SKIP
     492      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, m_bVSOEarlySkip );
     493#else
     494      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 );
     495#endif
     496      for ( Int layer = 0; layer < m_numberOfLayers ; layer++ )
    395497      {
    396         for ( Int ii=1; ii<12; ii+=2 )
     498        TEncTop* pcEncTop =  m_acTEncTopList[ layer ];
     499        Int iViewNum      = pcEncTop->getViewIndex();
     500        Int iContent      = pcEncTop->getIsDepth() ? 1 : 0;
     501        Int iNumOfModels  = m_cRenModStrParser.getNumOfModelsForView(iViewNum, iContent);
     502
     503        Bool bUseVSO      = (iNumOfModels != 0);
     504
     505        pcEncTop->setUseVSO( bUseVSO );
     506        pcEncTop->getRdCost()->setRenModel( bUseVSO ? &m_cRendererModel : NULL );
     507
     508        for (Int iCurModel = 0; iCurModel < iNumOfModels; iCurModel++ )
    397509        {
    398           Int iViewIdxCfg = (Int)(m_pchMVCJointCodingOrder[ii]-'0');
    399           if ( iViewIdxCfg == iViewIdx )
    400           {
    401             if ( m_pchMVCJointCodingOrder[ii-1]=='D' ) // depth comes first for this view
    402             {
    403               isDepthFirst = true;
    404             }
    405             else
    406             {
    407               assert(m_pchMVCJointCodingOrder[ii-1]=='T');
    408             }
    409             break;
    410           }
    411         }
     510          Int iModelNum; Int iLeftViewNum; Int iRightViewNum; Int iDump; Int iOrgRefNum; Int iBlendMode;
     511
     512          m_cRenModStrParser.getSingleModelData  ( iViewNum, iContent, iCurModel, iModelNum, iBlendMode, iLeftViewNum, iRightViewNum, iOrgRefNum, iDump ) ;
     513          m_cRendererModel  .createSingleModel   ( iViewNum, iContent, iModelNum, iLeftViewNum, iRightViewNum, (iOrgRefNum != -1), iBlendMode );
     514        }           
    412515      }
    413 #endif
    414 
    415       m_depthFrameRcvd.push_back(0);
    416       m_acTEncDepthTopList.push_back(new TEncTop);
    417       m_acTVideoIOYuvDepthInputFileList.push_back(new TVideoIOYuv);
    418       m_acTVideoIOYuvDepthReconFileList.push_back(new TVideoIOYuv);
    419       m_picYuvDepthRec.push_back(new TComList<TComPicYuv*>) ;
    420 
    421       m_acTEncDepthTopList[iViewIdx]->setFrameRate                    ( m_iFrameRate );
    422       m_acTEncDepthTopList[iViewIdx]->setFrameSkip                    ( m_FrameSkip );
    423       m_acTEncDepthTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
    424       m_acTEncDepthTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
    425       m_acTEncDepthTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
    426       m_acTEncDepthTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
    427       m_acTEncDepthTopList[iViewIdx]->setCropRight                    ( m_cropRight );
    428       m_acTEncDepthTopList[iViewIdx]->setCropTop                      ( m_cropTop );
    429       m_acTEncDepthTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
    430       m_acTEncDepthTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
    431       m_acTEncDepthTopList[iViewIdx]->setViewId                       ( iViewIdx );
    432       m_acTEncDepthTopList[iViewIdx]->setIsDepth                      ( true );
    433 #if QC_MVHEVC_B0046
    434       m_acTEncDepthTopList[iViewIdx]->setLayerId                      ( iViewIdx );
    435 #else
    436       m_acTEncDepthTopList[iViewIdx]->setViewOrderIdx                 ( m_cCameraData.getViewOrderIndex()[ iViewIdx ] );
    437 #endif
    438 #if VIDYO_VPS_INTEGRATION
    439       layerId = iViewIdx * 2 + 1;
    440       m_acTEncDepthTopList[iViewIdx]->setLayerId                      ( layerId );
    441       m_cVPS.setDepthFlag                                             ( true, layerId );
    442       m_cVPS.setViewId                                                ( iViewIdx, layerId );
    443       m_cVPS.setViewOrderIdx                                          ( m_cCameraData.getViewOrderIndex()[ iViewIdx ], layerId );
    444       m_cVPS.setDependentFlag                                         ( true, layerId );
    445       m_cVPS.setDependentLayer                                        ( layerId-1, layerId);
    446 #endif
    447 #if FCO_FIX_SPS_CHANGE
    448       m_acTEncDepthTopList[iViewIdx]->setCamParPrecision              ( m_cCameraData.getCamParsCodedPrecision  () );
    449       m_acTEncDepthTopList[iViewIdx]->setCamParInSliceHeader          ( m_cCameraData.getVaryingCameraParameters() );
    450       m_acTEncDepthTopList[iViewIdx]->setCodedScale                   ( m_cCameraData.getCodedScale             () );
    451       m_acTEncDepthTopList[iViewIdx]->setCodedOffset                  ( m_cCameraData.getCodedOffset            () );
    452 #else
    453       m_acTEncDepthTopList[iViewIdx]->setCamParPrecision              ( 0 );
    454       m_acTEncDepthTopList[iViewIdx]->setCamParInSliceHeader          ( false );
    455       m_acTEncDepthTopList[iViewIdx]->setCodedScale                   ( 0 );
    456       m_acTEncDepthTopList[iViewIdx]->setCodedOffset                  ( 0 );
    457 #endif
    458 
    459       //====== Coding Structure ========
    460       m_acTEncDepthTopList[iViewIdx]->setIntraPeriod                  ( m_iIntraPeriod );
    461       m_acTEncDepthTopList[iViewIdx]->setDecodingRefreshType          ( m_iDecodingRefreshType );
    462       m_acTEncDepthTopList[iViewIdx]->setGOPSize                      ( m_iGOPSize );
    463       m_acTEncDepthTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
    464       m_acTEncDepthTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
    465       for(Int i = 0; i < MAX_TLAYER; i++)
    466       {
    467         m_acTEncDepthTopList[iViewIdx]->setNumReorderPics             ( m_numReorderPics[iViewIdx][i], i );
    468         m_acTEncDepthTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
    469       }
    470       for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
    471       {
    472         m_acTEncDepthTopList[iViewIdx]->setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
    473       }
    474       m_acTEncDepthTopList[iViewIdx]->setQP                           ( m_aiQP[1] );
    475 
    476       m_acTEncDepthTopList[iViewIdx]->setTemporalLayerQPOffset        ( m_aiTLayerQPOffset );
    477       m_acTEncDepthTopList[iViewIdx]->setPad                          ( m_aiPad );
    478 
    479       m_acTEncDepthTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
    480 
    481       m_acTEncDepthTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
    482 
    483       m_acTEncDepthTopList[iViewIdx]->setUseNSQT( m_enableNSQT );
    484       m_acTEncDepthTopList[iViewIdx]->setUseAMP( m_enableAMP );
    485 
    486       //===== Slice ========
    487 
    488       //====== Loop/Deblock Filter ========
    489       m_acTEncDepthTopList[iViewIdx]->setLoopFilterDisable            ( m_abLoopFilterDisable[1]   );
    490       m_acTEncDepthTopList[iViewIdx]->setLoopFilterOffsetInAPS        ( m_loopFilterOffsetInAPS );
    491       m_acTEncDepthTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
    492       m_acTEncDepthTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
    493       m_acTEncDepthTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
    494 
    495       //====== Motion search ========
    496       m_acTEncDepthTopList[iViewIdx]->setFastSearch                   ( m_iFastSearch  );
    497       m_acTEncDepthTopList[iViewIdx]->setSearchRange                  ( m_iSearchRange );
    498       m_acTEncDepthTopList[iViewIdx]->setBipredSearchRange            ( m_bipredSearchRange );
    499 #if DV_V_RESTRICTION_B0037
    500       m_acTEncDepthTopList[iViewIdx]->setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
    501       m_acTEncDepthTopList[iViewIdx]->setVerticalDisparitySearchRange( m_iVerticalDisparitySearchRange );
    502 #endif
    503       //====== Quality control ========
    504       m_acTEncDepthTopList[iViewIdx]->setMaxDeltaQP                   ( m_iMaxDeltaQP  );
    505       m_acTEncDepthTopList[iViewIdx]->setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
    506 
    507       m_acTEncDepthTopList[iViewIdx]->setChromaQpOffset               ( m_iChromaQpOffset     );
    508       m_acTEncDepthTopList[iViewIdx]->setChromaQpOffset2nd            ( m_iChromaQpOffset2nd  );
    509 
    510 #if ADAPTIVE_QP_SELECTION
    511       m_acTEncDepthTopList[iViewIdx]->setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
    512 #endif
    513 
    514       m_acTEncDepthTopList[iViewIdx]->setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
    515       m_acTEncDepthTopList[iViewIdx]->setQPAdaptationRange            ( m_iQPAdaptationRange );
    516 
    517       //====== Tool list ========
    518       m_acTEncDepthTopList[iViewIdx]->setUseSBACRD                    ( m_bUseSBACRD   );
    519       m_acTEncDepthTopList[iViewIdx]->setDeltaQpRD                    ( m_uiDeltaQpRD  );
    520       m_acTEncDepthTopList[iViewIdx]->setUseASR                       ( m_bUseASR      );
    521       m_acTEncDepthTopList[iViewIdx]->setUseHADME                     ( m_bUseHADME    );
    522       m_acTEncDepthTopList[iViewIdx]->setUseALF                       ( m_abUseALF[1]  );
    523       m_acTEncDepthTopList[iViewIdx]->setALFEncodePassReduction       ( m_iALFEncodePassReduction );
    524 #if LOSSLESS_CODING
    525       m_acTEncDepthTopList[iViewIdx]->setUseLossless                  ( m_useLossless );
    526 #endif
    527       m_acTEncDepthTopList[iViewIdx]->setALFMaxNumberFilters          ( m_iALFMaxNumberFilters ) ;
    528 
    529       m_acTEncDepthTopList[iViewIdx]->setUseLComb                     ( m_bUseLComb    );
    530       m_acTEncDepthTopList[iViewIdx]->setLCMod                        ( m_bLCMod       );
    531       m_acTEncDepthTopList[iViewIdx]->setdQPs                         ( m_aidQPdepth   );
    532       m_acTEncDepthTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[1] );
    533       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
    534       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
    535       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
    536       m_acTEncDepthTopList[iViewIdx]->setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
    537       m_acTEncDepthTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
    538       m_acTEncDepthTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  );
    539       m_acTEncDepthTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
    540       m_acTEncDepthTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
    541 #if HHI_INTERVIEW_SKIP
    542       m_acTEncDepthTopList[iViewIdx]->setInterViewSkip            ( 0 );
    543 #if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    544       m_acTEncDepthTopList[iViewIdx]->setInterViewSkipLambdaScale ( 1 );
    545 #endif
    546 #endif
    547       m_acTEncDepthTopList[iViewIdx]->setUseLMChroma                  ( m_bUseLMChroma );
    548       m_acTEncDepthTopList[iViewIdx]->setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
    549       m_acTEncDepthTopList[iViewIdx]->setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
    550       m_acTEncDepthTopList[iViewIdx]->setUsePCM                       ( m_usePCM );
    551       m_acTEncDepthTopList[iViewIdx]->setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
    552       //====== VSO ========
    553 #if HHI_VSO
    554       m_acTEncDepthTopList[iViewIdx]->setUseVSO                       ( m_bUseVSO      ); //GT: might be enabled/disabled later for VSO Mode 4
    555       m_acTEncDepthTopList[iViewIdx]->setForceLambdaScaleVSO          ( m_bForceLambdaScaleVSO );
    556       m_acTEncDepthTopList[iViewIdx]->setLambdaScaleVSO               ( m_dLambdaScaleVSO );
    557 #if HHI_VSO_DIST_INT
    558       m_acTEncDepthTopList[iViewIdx]->setAllowNegDist                 ( m_bAllowNegDist );
    559 #endif
    560       m_acTEncDepthTopList[iViewIdx]->setVSOMode                      ( m_uiVSOMode );
    561 
    562 #if SAIT_VSO_EST_A0033
    563       m_acTEncDepthTopList[iViewIdx]->setUseEstimatedVSD              ( m_bUseEstimatedVSD );
    564 #endif
    565 #if LGE_WVSO_A0119
    566       m_acTEncDepthTopList[iViewIdx]->setUseWVSO                      ( m_bUseWVSO         );
    567 #endif
    568 #endif
    569 
    570 #if DEPTH_MAP_GENERATION
    571       m_acTEncDepthTopList[iViewIdx]->setPredDepthMapGeneration       ( 0 );
    572 #endif
    573 #if H3D_IVMP
    574       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvPredMode          ( 0 );
    575       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegMode           ( 0 );
    576       m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( 0.0 );
    577 #endif
    578 #if H3D_IVRP
    579 #if QC_ARP_D0177
    580     m_acTEncDepthTopList[iViewIdx]->setUseAdvRP                          ( 0 );
    581     m_acTEncDepthTopList[iViewIdx]->setARPStepNum                        ( 1 );
    582 #else
    583     m_acTEncDepthTopList[iViewIdx]->setMultiviewResPredMode         ( 0 );
    584 #endif
    585 #endif
    586 #if MTK_D0156
    587 
    588 #if MERL_VSP_COMPENSATION_C0152
    589       m_acTEncDepthTopList[iViewIdx]->setUseVSPCompensation           ( iViewIdx ? true : false );
    590 #endif
    591 
    592       m_acTEncDepthTopList[iViewIdx]->setUseDVPRefine                 ( iViewIdx ? true : false );
    593 #endif
    594 
    595       //====== Weighted Prediction ========
    596       m_acTEncDepthTopList[iViewIdx]->setUseWP                        ( m_bUseWeightPred      );
    597       m_acTEncDepthTopList[iViewIdx]->setWPBiPredIdc                  ( m_uiBiPredIdc         );
    598       //====== Slice ========
    599       m_acTEncDepthTopList[iViewIdx]->setSliceMode                    ( m_iSliceMode                );
    600       m_acTEncDepthTopList[iViewIdx]->setSliceArgument                ( m_iSliceArgument            );
    601 
    602       //====== Entropy Slice ========
    603       m_acTEncDepthTopList[iViewIdx]->setEntropySliceMode             ( m_iEntropySliceMode         );
    604       m_acTEncDepthTopList[iViewIdx]->setEntropySliceArgument         ( m_iEntropySliceArgument     );
    605       int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
    606       if(m_iEntropySliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
    607       {
    608         m_acTEncDepthTopList[iViewIdx]->setEntropySliceArgument ( m_iEntropySliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
    609       }
    610       if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
    611       {
    612         m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
    613       }
    614       if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
    615       {
    616         m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
    617       }
    618       m_acTEncDepthTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
    619       if(m_iSliceMode == 0 )
    620       {
    621         m_bLFCrossSliceBoundaryFlag = true;
    622       }
    623       m_acTEncDepthTopList[iViewIdx]->setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
    624       m_acTEncDepthTopList[iViewIdx]->setUseSAO               ( m_abUseSAO[1]     );
    625 #if LGE_ILLUCOMP_B0045
    626 #if LGE_ILLUCOMP_DEPTH_C0046
    627       m_acTEncDepthTopList[iViewIdx]->setUseIC                ( m_abUseIC[1] );
    628 #else
    629       m_acTEncDepthTopList[iViewIdx]->setUseIC                ( false     );
    630 #endif
    631 #endif
    632 #if INTER_VIEW_VECTOR_SCALING_C0115
    633      m_acTEncDepthTopList[iViewIdx]->setUseIVS                ( m_bUseIVS );
    634 #endif
    635       m_acTEncDepthTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
    636 #if LGE_SAO_MIGRATION_D0091
    637       m_acTEncDepthTopList[iViewIdx]->setSaoLcuBoundary (m_saoLcuBoundary);
    638       m_acTEncDepthTopList[iViewIdx]->setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
    639 #else
    640       m_acTEncDepthTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
    641 #endif
    642       m_acTEncDepthTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
    643       m_acTEncDepthTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
    644 
    645       m_acTEncDepthTopList[iViewIdx]->setPictureDigestEnabled(m_pictureDigestEnabled);
    646 
    647       m_acTEncDepthTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
    648       m_acTEncDepthTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
    649       m_acTEncDepthTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
    650       m_acTEncDepthTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
    651       if(m_iUniformSpacingIdr==0)
    652       {
    653         m_acTEncDepthTopList[iViewIdx]->setColumnWidth              ( m_pchColumnWidth );
    654         m_acTEncDepthTopList[iViewIdx]->setRowHeight                ( m_pchRowHeight );
    655       }
    656       m_acTEncDepthTopList[iViewIdx]->xCheckGSParameters();
    657       m_acTEncDepthTopList[iViewIdx]->setTileLocationInSliceHeaderFlag ( m_iTileLocationInSliceHeaderFlag );
    658       m_acTEncDepthTopList[iViewIdx]->setTileMarkerFlag              ( m_iTileMarkerFlag );
    659       m_acTEncDepthTopList[iViewIdx]->setMaxTileMarkerEntryPoints    ( m_iMaxTileMarkerEntryPoints );
    660 
    661       Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
    662       m_dMaxTileMarkerOffset    = ((Double)uiTilesCount) / m_iMaxTileMarkerEntryPoints;
    663       m_acTEncDepthTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
    664       m_acTEncDepthTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
    665       if(uiTilesCount == 1)
    666       {
    667         m_bLFCrossTileBoundaryFlag = true;
    668       }
    669       m_acTEncDepthTopList[iViewIdx]->setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
    670       m_acTEncDepthTopList[iViewIdx]->setWaveFrontSynchro           ( m_iWaveFrontSynchro );
    671       m_acTEncDepthTopList[iViewIdx]->setWaveFrontFlush             ( m_iWaveFrontFlush );
    672       m_acTEncDepthTopList[iViewIdx]->setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
    673 #if TMVP_DEPTH_SWITCH
    674       m_acTEncDepthTopList[iViewIdx]->setEnableTMVP                 ( m_enableTMVP[1] );
    675 #else
    676       m_acTEncDepthTopList[iViewIdx]->setEnableTMVP ( m_enableTMVP );
    677 #endif
    678       m_acTEncDepthTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
    679       m_acTEncDepthTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
    680       m_acTEncDepthTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
    681       m_acTEncDepthTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
    682 
    683       if(uiTilesCount > 1)
    684       {
    685         m_bALFParamInSlice = false;
    686         m_bALFPicBasedEncode = true;
    687       }
    688       m_acTEncDepthTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
    689       m_acTEncDepthTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
    690 
    691   //====== Depth tools ========
    692 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    693     m_acTEncDepthTopList[iViewIdx]->setUseDMM                     ( m_bUseDMM );
    694 #endif
    695 #if FLEX_CODING_ORDER_M23723 && HHI_DMM_PRED_TEX
    696     m_acTEncDepthTopList[iViewIdx]->setUseDMM34( (m_b3DVFlexOrder && isDepthFirst) ? false : m_bUseDMM );
    697 #endif
    698 
    699 #if H3D_QTL
    700     m_acTEncDepthTopList[iViewIdx]->setUseQTLPC                   (m_bUseQTLPC);
    701 #endif
    702 #if HHI_MPI
    703 #if FLEX_CODING_ORDER_M23723
    704     m_acTEncDepthTopList[iViewIdx]->setUseMVI( (m_b3DVFlexOrder && isDepthFirst) ? false : m_bUseMVI );
    705 #else
    706      m_acTEncDepthTopList[iViewIdx]->setUseMVI( m_bUseMVI );
    707 #endif
    708 #endif
    709 #if RWTH_SDC_DLT_B0036
    710       m_acTEncDepthTopList[iViewIdx]->setUseDLT                   ( m_bUseDLT );
    711       m_acTEncDepthTopList[iViewIdx]->setUseSDC                   ( m_bUseSDC );
    712 #endif
    713     }
    714   }
    715 
    716 #if H3D_IVMP
    717   else if( m_uiMultiviewMvRegMode )
    718   {
    719     for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
    720     {
    721       m_acTVideoIOYuvDepthInputFileList.push_back( new TVideoIOYuv );
    722     }
    723   }
    724 #endif
    725 
    726 #if HHI_VSO
    727   if ( m_bUseVSO )
    728   {
    729     if ( m_uiVSOMode == 4 )
    730     {
    731 #if LGE_VSO_EARLY_SKIP_A0093
    732       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, m_bVSOEarlySkip );
    733 #else
    734       m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 );
    735 #endif
    736 
    737       for ( Int iViewNum = 0; iViewNum < m_iNumberOfViews; iViewNum++ )
    738       {
    739         for (Int iContent = 0; iContent < 2; iContent++ )
    740         {
    741           Int iNumOfModels   = m_cRenModStrParser.getNumOfModelsForView(iViewNum, iContent);
    742           Bool bUseVSO = (iNumOfModels != 0);
    743 
    744           TEncTop* pcEncTop = ( iContent == 0 ) ? m_acTEncTopList[iViewNum] : m_acTEncDepthTopList[iViewNum];
    745           pcEncTop->setUseVSO( bUseVSO );
    746           pcEncTop->getRdCost()->setRenModel( bUseVSO ? &m_cRendererModel : NULL );
    747 
    748           for (Int iCurModel = 0; iCurModel < iNumOfModels; iCurModel++ )
    749           {
    750             Int iModelNum; Int iLeftViewNum; Int iRightViewNum; Int iDump; Int iOrgRefNum; Int iBlendMode;
    751 
    752             m_cRenModStrParser.getSingleModelData  ( iViewNum, iContent, iCurModel, iModelNum, iBlendMode, iLeftViewNum, iRightViewNum, iOrgRefNum, iDump ) ;
    753             m_cRendererModel  .createSingleModel   ( iViewNum, iContent, iModelNum, iLeftViewNum, iRightViewNum, (iOrgRefNum != -1), iBlendMode );
    754           }
    755         }
    756       }
    757516    }
    758517    else
     
    760519      AOT(true);
    761520    }
    762 #if LGE_WVSO_A0119
    763     for ( Int iViewNum = 0; iViewNum < m_iNumberOfViews; iViewNum++ )
    764     {
    765       for (Int iContent = 0; iContent < 2; iContent++ )
    766       {
    767         TEncTop* pcEncTop = ( iContent == 0 ) ? m_acTEncTopList[iViewNum] : m_acTEncDepthTopList[iViewNum];
    768         pcEncTop->setUseWVSO  ( m_bUseWVSO );
    769         pcEncTop->setVSOWeight( m_iVSOWeight );
    770         pcEncTop->setVSDWeight( m_iVSDWeight );
    771         pcEncTop->setDWeight  ( m_iDWeight );
    772       }
    773     }
    774 #endif
    775   }
    776 #endif
    777 
    778 #if HHI_INTERVIEW_SKIP
    779   m_cUsedPelsRenderer.init(m_iSourceWidth, m_iSourceHeight, true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 4, 1, 0, 6 );
    780 #endif
    781 
     521  }
     522#endif
    782523}
    783524
    784525Void TAppEncTop::xCreateLib()
    785526{
    786   for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
    787   {
    788     m_acTVideoIOYuvInputFileList[iViewIdx]->open( m_pchInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
    789     m_acTVideoIOYuvInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
    790 
    791     if (m_pchReconFileList[iViewIdx])
    792       m_acTVideoIOYuvReconFileList[iViewIdx]->open(m_pchReconFileList[iViewIdx], true, m_uiOutputBitDepth, m_uiInternalBitDepth);  // write mode
    793     m_acTEncTopList[iViewIdx]->create();
    794     if( m_bUsingDepthMaps )
    795     {
    796       m_acTVideoIOYuvDepthInputFileList[iViewIdx]->open( m_pchDepthInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
    797       m_acTVideoIOYuvDepthInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
    798 
    799       if (m_pchDepthReconFileList[iViewIdx])
    800         m_acTVideoIOYuvDepthReconFileList[iViewIdx]->open(m_pchDepthReconFileList[iViewIdx], true, m_uiOutputBitDepth, m_uiInternalBitDepth);  // write mode
    801       m_acTEncDepthTopList[iViewIdx]->create();
    802     }
    803 #if H3D_IVMP
    804     else if( m_uiMultiviewMvRegMode )
    805     {
    806       m_acTVideoIOYuvDepthInputFileList[iViewIdx]->open( m_pchDepthInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
    807       m_acTVideoIOYuvDepthInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth, m_iSourceHeight);
    808     }
    809 #endif
    810   }
     527#if H_MV
     528  // initialize global variables
     529  initROM();
     530#if H_3D_DIM_DMM