source: 3DVCSoftware/branches/HTM-4.0-Orange/source/App/TAppEncoder/TAppEncCfg.cpp @ 1417

Last change on this file since 1417 was 117, checked in by tech, 12 years ago

Cleanup

  • Property svn:eol-style set to native
File size: 78.5 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TAppEncCfg.cpp
35    \brief    Handle encoder configuration parameters
36*/
37
38#include <stdlib.h>
39#include <cassert>
40#include <cstring>
41#include <string>
42#include "TLibCommon/TComRom.h"
43#include "TAppEncCfg.h"
44#include "TAppCommon/program_options_lite.h"
45
46#ifdef WIN32
47#define strdup _strdup
48#endif
49
50using namespace std;
51namespace po = df::program_options_lite;
52
53//! \ingroup TAppEncoder
54//! \{
55
56/* configuration helper funcs */
57void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg);
58void 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
68
69// ====================================================================================================================
70// Constructor / destructor / initialization / destroy
71// ====================================================================================================================
72
73TAppEncCfg::TAppEncCfg()
74{
75  m_aidQP = NULL;
76#if FIXES
77  m_aidQPdepth = NULL;
78#endif
79}
80
81TAppEncCfg::~TAppEncCfg()
82{
83  if ( m_aidQP )
84  {
85    delete[] m_aidQP; m_aidQP = NULL;
86  }
87
88#if FIXES
89  if ( m_aidQPdepth )
90  {
91    delete[] m_aidQPdepth; m_aidQPdepth = NULL;
92  }
93#endif
94
95  for(Int i = 0; i< m_pchInputFileList.size(); i++ )
96  {
97    if ( m_pchInputFileList[i] != NULL )
98      free (m_pchInputFileList[i]);
99  }
100  for(Int i = 0; i< m_pchDepthInputFileList.size(); i++ )
101  {
102    if ( m_pchDepthInputFileList[i] != NULL )
103      free (m_pchDepthInputFileList[i]);
104  }
105  for(Int i = 0; i< m_pchReconFileList.size(); i++ )
106  {
107    if ( m_pchReconFileList[i] != NULL )
108      free (m_pchReconFileList[i]);
109  }
110  for(Int i = 0; i< m_pchDepthReconFileList.size(); i++ )
111  {
112    if ( m_pchDepthReconFileList[i] != NULL )
113      free (m_pchDepthReconFileList[i]);
114  }
115  if (m_pchBitstreamFile != NULL)
116    free (m_pchBitstreamFile) ;
117#if HHI_VSO
118  if (  m_pchVSOConfig != NULL)
119    free (  m_pchVSOConfig );
120#endif
121
122}
123
124Void TAppEncCfg::create()
125{
126}
127
128Void TAppEncCfg::destroy()
129{
130}
131
132std::istringstream &operator>>( std::istringstream &in, GOPEntryMvc &entry )     //input
133{
134  in>>entry.m_sliceType;
135  in>>entry.m_POC;
136  in>>entry.m_QPOffset;
137  in>>entry.m_QPFactor;
138  in>>entry.m_temporalId;
139  in>>entry.m_numRefPicsActive;
140  in>>entry.m_refPic;
141  in>>entry.m_numRefPics;
142  for ( Int i = 0; i < entry.m_numRefPics; i++ )
143  {
144    in>>entry.m_referencePics[i];
145  }
146  in>>entry.m_interRPSPrediction;
147  if (entry.m_interRPSPrediction)
148  {
149    in>>entry.m_deltaRIdxMinus1;
150    in>>entry.m_deltaRPS;
151    in>>entry.m_numRefIdc;
152    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
153    {
154      in>>entry.m_refIdc[i];
155    }
156  }
157  in>>entry.m_numInterViewRefPics;
158  for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
159  {
160    in>>entry.m_interViewRefs[i];
161  }
162  for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
163  {
164    in>>entry.m_interViewRefPosL0[i];
165  }
166  for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
167  {
168    in>>entry.m_interViewRefPosL1[i];
169  }
170  return in;
171}
172
173// ====================================================================================================================
174// Public member functions
175// ====================================================================================================================
176
177/** \param  argc        number of arguments
178    \param  argv        array of arguments
179    \retval             true when success
180 */
181Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
182{
183  bool do_help = false;
184 
185  string cfg_BitstreamFile;
186  string cfg_dQPFile;
187  string cfg_ColumnWidth;
188  string cfg_RowHeight;
189  string cfg_ScalingListFile;
190  po::Options opts;
191  opts.addOptions()
192  ("help", do_help, false, "this help text")
193  ("c", po::parseConfigFile, "configuration file name")
194 
195  /* File, I/O and source parameters */
196  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_VIEW_NUM , "original Yuv input file name %d")
197  ("DepthInputFile_%d,di_%d", m_pchDepthInputFileList,  (char *) 0 , MAX_VIEW_NUM , "original Yuv depth input file name %d")
198  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv output file name %d")
199  ("DepthReconFile_%d,do_%d", m_pchDepthReconFileList,  (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv depth output file name %d")
200  ("BitstreamFile,b", cfg_BitstreamFile, string(""), "bitstream output file name")
201  ("CodeDepthMaps",         m_bUsingDepthMaps, false, "Encode depth maps" )
202  ("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
203  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( double )1.0, "Lambda modifier for temporal layer 0")
204  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( double )1.0, "Lambda modifier for temporal layer 1")
205  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( double )1.0, "Lambda modifier for temporal layer 2")
206  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( double )1.0, "Lambda modifier for temporal layer 3")
207  ("SourceWidth,-wdt",      m_iSourceWidth,  0, "Source picture width")
208  ("SourceHeight,-hgt",     m_iSourceHeight, 0, "Source picture height")
209#if PIC_CROPPING
210  ("CroppingMode",          m_croppingMode,  0, "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
211  ("CropLeft",              m_cropLeft,      0, "Left cropping/padding for cropping mode 3")
212  ("CropRight",             m_cropRight,     0, "Right cropping/padding for cropping mode 3")
213  ("CropTop",               m_cropTop,       0, "Top cropping/padding for cropping mode 3")
214  ("CropBottom",            m_cropBottom,    0, "Bottom cropping/padding for cropping mode 3")
215  ("HorizontalPadding,-pdx",m_aiPad[0],      0, "horizontal source padding for cropping mode 2")
216  ("VerticalPadding,-pdy",  m_aiPad[1],      0, "vertical source padding for cropping mode 2")
217#endif
218  ("InputBitDepth",         m_uiInputBitDepth, 8u, "bit-depth of input file")
219  ("BitDepth",              m_uiInputBitDepth, 8u, "deprecated alias of InputBitDepth")
220  ("OutputBitDepth",        m_uiOutputBitDepth, 0u, "bit-depth of output file")
221  ("InternalBitDepth",      m_uiInternalBitDepth, 0u, "Internal bit-depth (BitDepth+BitIncrement)")
222#if !PIC_CROPPING
223  ("HorizontalPadding,-pdx",m_aiPad[0],      0, "horizontal source padding size")
224  ("VerticalPadding,-pdy",  m_aiPad[1],      0, "vertical source padding size")
225  ("PAD",                   m_bUsePAD,   false, "automatic source padding of multiple of 16" )
226#endif
227  ("FrameRate,-fr",         m_iFrameRate,        0, "Frame rate")
228  ("FrameSkip,-fs",         m_FrameSkip,         0u, "Number of frames to skip at start of input YUV")
229  ("FramesToBeEncoded,f",   m_iFrameToBeEncoded, 0, "number of frames to be encoded (default=all)")
230  ("FrameToBeEncoded",      m_iFrameToBeEncoded, 0, "depricated alias of FramesToBeEncoded")
231 
232  ("NumberOfViews",         m_iNumberOfViews,    0, "Number of views")
233  /* Unit definition parameters */
234  ("MaxCUWidth",          m_uiMaxCUWidth,  64u)
235  ("MaxCUHeight",         m_uiMaxCUHeight, 64u)
236  /* todo: remove defaults from MaxCUSize */
237  ("MaxCUSize,s",         m_uiMaxCUWidth,  64u, "max CU size")
238  ("MaxCUSize,s",         m_uiMaxCUHeight, 64u, "max CU size")
239  ("MaxPartitionDepth,h", m_uiMaxCUDepth,   4u, "CU depth")
240 
241  ("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u)
242  ("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u)
243 
244  ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u)
245  ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u)
246 
247  /* Coding structure paramters */
248  ("IntraPeriod,-ip",m_iIntraPeriod, -1, "intra period in frames, (-1: only first frame)")
249  ("DecodingRefreshType,-dr",m_iDecodingRefreshType, 0, "intra refresh, (0:none 1:CRA 2:IDR)")
250  ("GOPSize,g",      m_iGOPSize,      1, "GOP size of temporal structure")
251#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
252  ("MaxNumberOfReorderPictures",   m_numReorderFrames,               -1, "Max. number of reorder pictures: -1: encoder determines value, >=0: set explicitly")
253  ("MaxNumberOfReferencePictures", m_maxNumberOfReferencePictures, 6, "Max. number of reference pictures")
254#endif
255  ("ListCombination,-lc", m_bUseLComb, true, "combined reference list flag for uni-prediction in B-slices")
256  ("LCModification", m_bLCMod, false, "enables signalling of combined reference list derivation")
257  ("DisableInter4x4", m_bDisInter4x4, true, "Disable Inter 4x4")
258  ("NSQT", m_enableNSQT, true, "Enable non-square transforms")
259  ("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
260  /* motion options */
261  ("FastSearch", m_iFastSearch, 1, "0:Full search  1:Diamond  2:PMVFAST")
262  ("SearchRange,-sr",m_iSearchRange, 96, "motion search range")
263  ("BipredSearchRange", m_bipredSearchRange, 4, "motion search range for bipred refinement")
264  ("HadamardME", m_bUseHADME, true, "hadamard ME for fractional-pel")
265  ("ASR", m_bUseASR, false, "adaptive motion search range")
266 
267  /* Quantization parameters */
268  ("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")
269  ("DeltaQpRD,-dqr",m_uiDeltaQpRD,       0u, "max dQp offset for slice")
270  ("MaxDeltaQP,d",  m_iMaxDeltaQP,        0, "max dQp offset for block")
271  ("MaxCuDQPDepth,-dqd",  m_iMaxCuDQPDepth,        0, "max depth for a minimum CuDQP")
272
273    ("ChromaQpOffset,   -cqo",   m_iChromaQpOffset,           0, "ChromaQpOffset")
274    ("ChromaQpOffset2nd,-cqo2",  m_iChromaQpOffset2nd,        0, "ChromaQpOffset2nd")
275
276#if ADAPTIVE_QP_SELECTION
277    ("AdaptiveQpSelection,-aqps",   m_bUseAdaptQpSelect,           false, "AdaptiveQpSelection")
278#endif
279
280  ("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
281  ("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
282  ("dQPFile,m",     cfg_dQPFile, string(""), "dQP file name")
283  ("RDOQ",          m_abUseRDOQ, std::vector<Bool>(1,true), "Enable RDOQ")
284  ("TemporalLayerQPOffset_L0,-tq0", m_aiTLayerQPOffset[0], MAX_QP + 1, "QP offset of temporal layer 0")
285  ("TemporalLayerQPOffset_L1,-tq1", m_aiTLayerQPOffset[1], MAX_QP + 1, "QP offset of temporal layer 1")
286  ("TemporalLayerQPOffset_L2,-tq2", m_aiTLayerQPOffset[2], MAX_QP + 1, "QP offset of temporal layer 2")
287  ("TemporalLayerQPOffset_L3,-tq3", m_aiTLayerQPOffset[3], MAX_QP + 1, "QP offset of temporal layer 3")
288 
289#if !H0566_TLA
290  ("TLayeringBasedOnCodingStruct,-tl", m_bTLayering, false, "Temporal ID is set based on the hierarchical coding structure")
291 
292  ("TLayerSwitchingFlag_L0,-ts0", m_abTLayerSwitchingFlag[0], false, "Switching flag for temporal layer 0")
293  ("TLayerSwitchingFlag_L1,-ts1", m_abTLayerSwitchingFlag[1], false, "Switching flag for temporal layer 1")
294  ("TLayerSwitchingFlag_L2,-ts2", m_abTLayerSwitchingFlag[2], false, "Switching flag for temporal layer 2")
295  ("TLayerSwitchingFlag_L3,-ts3", m_abTLayerSwitchingFlag[3], false, "Switching flag for temporal layer 3")
296#endif
297
298  /* Entropy coding parameters */
299  ("SBACRD", m_bUseSBACRD, true, "SBAC based RD estimation")
300 
301  /* Deblocking filter parameters */
302  ("LoopFilterDisable", m_abLoopFilterDisable, std::vector<Bool>(1,false), "Disables LoopFilter")
303
304  ("LoopFilterOffsetInAPS", m_loopFilterOffsetInAPS, false)
305  ("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
306  ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
307#if DBL_CONTROL
308  ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false)
309#endif
310
311  /* Camera Paremetes */
312  ("CameraParameterFile,cpf", m_pchCameraParameterFile,    (Char *) 0, "Camera Parameter File Name")
313  ("BaseViewCameraNumbers" ,  m_pchBaseViewCameraNumbers,  (Char *) 0, "Numbers of base views")
314
315  /* View Synthesis Optimization */
316
317#if HHI_VSO
318  ("VSOConfig",                       m_pchVSOConfig            , (Char *) 0    , "VSO configuration")
319  ("VSO",                             m_bUseVSO                 , false         , "Use VSO" )   
320  ("VSOMode",                         m_uiVSOMode               , (UInt)   4    , "VSO Mode")
321  ("LambdaScaleVSO",                  m_dLambdaScaleVSO         , (Double) 1    , "Lambda Scaling for VSO")
322
323#if HHI_VSO_LS_TABLE
324  ("VSOLSTable",                      m_bVSOLSTable             , true          , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )   
325#endif
326
327#if SAIT_VSO_EST_A0033
328  ("UseEstimatedVSD",                 m_bUseEstimatedVSD        , true          , "Model based VSD estimation instead of rendering based for some encoder decisions" )     
329#endif
330#if LGE_VSO_EARLY_SKIP_A0093
331  ("VSOEarlySkip",                    m_bVSOEarlySkip           , true          , "Early skip of VSO computation if synthesis error assumed to be zero" )     
332#endif
333  ("ForceLambdaScaleVSO",             m_bForceLambdaScaleVSO    , false         , "Force using Lambda Scale VSO also in non-VSO-Mode")
334#if HHI_VSO_DIST_INT
335  ("AllowNegDist",                    m_bAllowNegDist           , true          , "Allow negative Distortion in VSO")
336#endif
337#if LGE_WVSO_A0119
338  ("WVSO",                            m_bWVSO                   , true          , "Use WVSO" )
339  ("VSOWeight",                       m_iVSOWeight              , 10            , "VSO Weight" )
340  ("VSDWeight",                       m_iVSDWeight              , 1             , "SAIT Weight" )
341  ("DWeight",                         m_iDWeight                , 1             , "SSE Weight" )
342#endif
343
344#if OL_DEPTHLIMIT_A0044
345  ("DPL",   m_bDepthPartitionLimiting           , false         , "Use DepthPartitionLimiting" )
346#endif
347
348#endif
349
350#if DEPTH_MAP_GENERATION
351  ("PredDepthMapGen",  m_uiPredDepthMapGeneration, (UInt)0, "generation of prediction depth maps for motion data prediction" )
352#endif
353#if HHI_INTER_VIEW_MOTION_PRED
354  ("MultiviewMvPred",  m_uiMultiviewMvPredMode,    (UInt)0, "usage of predicted depth maps" )
355  ("MultiviewMvRegMode",        m_uiMultiviewMvRegMode,         (UInt)0, "regularization mode for multiview motion vectors" )
356  ("MultiviewMvRegLambdaScale", m_dMultiviewMvRegLambdaScale, (Double)0, "lambda scale for multiview motion vector regularization" )
357#endif
358#if HHI_INTER_VIEW_RESIDUAL_PRED
359  ("MultiviewResPred", m_uiMultiviewResPredMode,   (UInt)0, "usage of inter-view residual prediction" )
360#endif
361
362  /* Coding tools */
363  ("LMChroma", m_bUseLMChroma, true, "intra chroma prediction based on recontructed luma")
364
365  ("ALF", m_abUseALF, std::vector<Bool>(1,true), "Enables ALF")
366  ("SAO", m_abUseSAO, std::vector<Bool>(1, true), "SAO")
367#if SAO_UNIT_INTERLEAVING
368  ("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "2048: default")   
369  ("SAOInterleaving", m_saoInterleavingFlag, false, "0: SAO Picture Mode, 1: SAO Interleaving ")   
370#endif
371
372  ("ALFEncodePassReduction", m_iALFEncodePassReduction, 0, "0:Original 16-pass, 1: 1-pass, 2: 2-pass encoding")
373
374  ("ALFMaxNumFilter,-ALFMNF", m_iALFMaxNumberFilters, 16, "16: No Constrained, 1-15: Constrained max number of filter")
375#if LCU_SYNTAX_ALF
376  ("ALFParamInSlice", m_bALFParamInSlice, false, "ALF parameters in 0: APS, 1: slice header")
377  ("ALFPicBasedEncode", m_bALFPicBasedEncode, true, "ALF picture-based encoding 0: false, 1: true")
378#endif
379
380    ("SliceMode",            m_iSliceMode,           0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes")
381    ("SliceArgument",        m_iSliceArgument,       0, "if SliceMode==1 SliceArgument represents max # of LCUs. if SliceMode==2 SliceArgument represents max # of bytes.")
382    ("EntropySliceMode",     m_iEntropySliceMode,    0, "0: Disable all entropy slice limits, 1: Enforce max # of LCUs, 2: Enforce constraint based entropy slices")
383    ("EntropySliceArgument", m_iEntropySliceArgument,0, "if EntropySliceMode==1 SliceArgument represents max # of LCUs. if EntropySliceMode==2 EntropySliceArgument represents max # of bins.")
384    ("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.")
385    ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
386
387    ("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
388    ("PCMEnabledFlag", m_usePCM         , false)
389    ("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
390    ("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
391
392    ("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
393    ("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
394#if LOSSLESS_CODING
395    ("LosslessCuEnabled", m_useLossless, false)
396#endif
397    ("weighted_pred_flag,-wpP",     m_bUseWeightPred, false, "weighted prediction flag (P-Slices)")
398    ("weighted_bipred_idc,-wpBidc", m_uiBiPredIdc,    0u,    "weighted bipred idc (B-Slices)")
399    ("TileInfoPresentFlag",         m_iColumnRowInfoPresent,         1,          "0: tiles parameters are NOT present in the PPS. 1: tiles parameters are present in the PPS")
400    ("UniformSpacingIdc",           m_iUniformSpacingIdr,            0,          "Indicates if the column and row boundaries are distributed uniformly")
401#if !REMOVE_TILE_DEPENDENCE
402    ("TileBoundaryIndependenceIdc", m_iTileBoundaryIndependenceIdr,  1,          "Indicates if the column and row boundaries break the prediction")
403#endif
404    ("NumTileColumnsMinus1",        m_iNumColumnsMinus1,             0,          "Number of columns in a picture minus 1")
405    ("ColumnWidthArray",            cfg_ColumnWidth,                 string(""), "Array containing ColumnWidth values in units of LCU")
406    ("NumTileRowsMinus1",           m_iNumRowsMinus1,                0,          "Number of rows in a picture minus 1")
407    ("RowHeightArray",              cfg_RowHeight,                   string(""), "Array containing RowHeight values in units of LCU")
408    ("TileLocationInSliceHeaderFlag", m_iTileLocationInSliceHeaderFlag, 0,       "0: Disable transmission of tile location in slice header. 1: Transmit tile locations in slice header.")
409    ("TileMarkerFlag",                m_iTileMarkerFlag,                0,       "0: Disable transmission of lightweight tile marker. 1: Transmit light weight tile marker.")
410    ("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.")
411    ("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")
412    ("LFCrossTileBoundaryFlag",      m_bLFCrossTileBoundaryFlag,             true,          "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
413    ("WaveFrontSynchro",            m_iWaveFrontSynchro,             0,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
414    ("WaveFrontFlush",              m_iWaveFrontFlush,               0,          "Flush and terminate CABAC coding for each LCU line")
415    ("WaveFrontSubstreams",         m_iWaveFrontSubstreams,          1,          "# coded substreams wanted; per tile if TileBoundaryIndependenceIdc is 1, otherwise per frame")
416    ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
417    ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
418#if MULTIBITS_DATA_HIDING
419    ("SignHideFlag,-SBH",                m_signHideFlag, 1)
420    ("SignHideThreshold,-TSIG",          m_signHidingThreshold,         4)
421#endif
422#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
423  ("DMM",                         m_bUseDMM,                       false,      "depth model modes flag")
424#endif
425
426  /* Misc. */
427  ("SEIpictureDigest", m_pictureDigestEnabled, true, "Control generation of picture_digest SEI messages\n"
428                                              "\t1: use MD5\n"
429                                              "\t0: disable")
430
431  ("TMVP", m_enableTMVP, true, "Enable TMVP" )
432
433  ("FEN", m_bUseFastEnc, false, "fast encoder setting")
434  ("ECU", m_bUseEarlyCU, false, "Early CU setting") 
435#if FAST_DECISION_FOR_MRG_RD_COST
436  ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost") 
437#endif
438  ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
439#if HHI_INTERVIEW_SKIP
440  ("InterViewSkip",  m_bInterViewSkip,    false, "usage of interview skip" )
441#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
442  ("InterViewSkipLambdaScale",  m_dInterViewSkipLambdaScale,    (Double)8, "lambda scale for interview skip" )
443#endif
444#endif
445  /* Compatability with old style -1 FOO or -0 FOO options. */
446  ("1", doOldStyleCmdlineOn, "turn option <name> on")
447  ("0", doOldStyleCmdlineOff, "turn option <name> off")
448#if HHI_MPI
449  ("MVI", m_bUseMVI, false, "use motion vector inheritance for depth map coding")
450#endif
451  ;
452 
453  // parse coding structure
454  for( Int k = 0; k < MAX_VIEW_NUM; k++ )
455  {
456    if( k == 0 )
457    {
458      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
459      {
460        std::ostringstream cOSS;
461        cOSS<<"Frame"<<i;
462        opts.addOptions()( cOSS.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc() );
463      }
464    }
465    else
466    {
467      std::ostringstream cOSS1;
468      cOSS1<<"FrameI"<<"_v"<<k;
469      opts.addOptions()(cOSS1.str(), m_GOPListsMvc[k][MAX_GOP], GOPEntryMvc());
470
471      for( Int i = 1; i < MAX_GOP + 1; i++ ) 
472      {
473        std::ostringstream cOSS2;
474        cOSS2<<"Frame"<<i<<"_v"<<k;
475        opts.addOptions()(cOSS2.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc());
476      }
477    }
478  }
479
480  po::setDefaults(opts);
481  const list<const char*>& argv_unhandled = po::scanArgv(opts, argc, (const char**) argv);
482
483  for (list<const char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
484  {
485    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
486  }
487 
488  if (argc == 1 || do_help)
489  {
490    /* argc == 1: no options have been specified */
491    po::doHelp(cout, opts);
492    xPrintUsage();
493    return false;
494  }
495 
496  /*
497   * Set any derived parameters
498   */
499  /* convert std::string to c string for compatability */
500  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
501  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
502 
503  m_pchColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
504  m_pchRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
505  m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
506 
507  if ( m_bUsingDepthMaps )
508  {
509    for(Int i = 0; i < m_pchDepthReconFileList.size() ; i++)
510    {
511      if ((m_pchDepthInputFileList[i] != NULL) && (m_pchReconFileList[i] != NULL) && (i < m_iNumberOfViews) )
512      {
513        if (m_pchDepthReconFileList[i] == NULL )
514        {
515          xAppendToFileNameEnd( m_pchReconFileList[i], "_depth", m_pchDepthReconFileList[i] );
516        }
517      }
518      else
519      {
520        m_pchDepthReconFileList[i] = NULL;
521      }
522    };
523  }
524  if ( m_adQP.size() < 2 )
525  {
526    m_adQP.push_back( m_adQP[0] );
527  };
528  for (UInt uiK = 0; uiK < m_adQP.size(); uiK++)
529  {
530    m_aiQP.push_back( (Int)( m_adQP[uiK] ) );
531  }
532
533#if PIC_CROPPING
534  switch (m_croppingMode)
535  {
536  case 0:
537    {
538      // no cropping or padding
539      m_cropLeft = m_cropRight = m_cropTop = m_cropBottom = 0;
540      m_aiPad[1] = m_aiPad[0] = 0;
541      break;
542    }
543  case 1:
544    {
545      // automatic padding to minimum CU size
546      Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
547      if (m_iSourceWidth % minCuSize)
548      {
549        m_aiPad[0] = m_cropRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
550        m_iSourceWidth  += m_cropRight;
551      }
552      if (m_iSourceHeight % minCuSize)
553      {
554        m_aiPad[1] = m_cropBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
555        m_iSourceHeight += m_cropBottom;
556      }
557      break;
558    }
559  case 2:
560    {
561      //padding
562      m_iSourceWidth  += m_aiPad[0];
563      m_iSourceHeight += m_aiPad[1];
564      m_cropRight  = m_aiPad[0];
565      m_cropBottom = m_aiPad[1];
566      break;
567    }
568  case 3:
569    {
570      // cropping
571      if ((m_cropLeft == 0) && (m_cropRight == 0) && (m_cropTop == 0) && (m_cropBottom == 0))
572      {
573        fprintf(stderr, "Warning: Cropping enabled, but all cropping parameters set to zero\n");
574      }
575      if ((m_aiPad[1] != 0) || (m_aiPad[0]!=0))
576      {
577        fprintf(stderr, "Warning: Cropping enabled, padding parameters will be ignored\n");
578      }
579      m_aiPad[1] = m_aiPad[0] = 0;
580      break;
581    }
582  }
583#else
584
585  // compute source padding size
586  if ( m_bUsePAD )
587  {
588    if ( m_iSourceWidth%MAX_PAD_SIZE )
589    {
590      m_aiPad[0] = (m_iSourceWidth/MAX_PAD_SIZE+1)*MAX_PAD_SIZE - m_iSourceWidth;
591    }
592   
593    if ( m_iSourceHeight%MAX_PAD_SIZE )
594    {
595      m_aiPad[1] = (m_iSourceHeight/MAX_PAD_SIZE+1)*MAX_PAD_SIZE - m_iSourceHeight;
596    }
597  }
598  m_iSourceWidth  += m_aiPad[0];
599  m_iSourceHeight += m_aiPad[1];
600#endif
601 
602  // allocate slice-based dQP values
603  m_aidQP = new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
604  m_aidQPdepth =  new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
605  ::memset( m_aidQP, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
606  ::memset( m_aidQPdepth, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
607 
608  // handling of floating-point QP values
609  // if QP is not integer, sequence is split into two sections having QP and QP+1
610  m_aiQP[0] = (Int)( m_adQP[0] );
611  if ( m_aiQP[0] < m_adQP[0] )
612  {
613    Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[0] - m_aiQP[0])*m_iFrameToBeEncoded + 0.5 );
614   
615    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
616    for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
617    {
618      m_aidQP[i] = 1;
619    }
620  }
621
622  m_aiQP[1] = (Int)( m_adQP[1] );
623  if ( m_aiQP[1] < m_adQP[1] )
624  {
625    Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[1] - m_aiQP[1])*m_iFrameToBeEncoded + 0.5 );
626
627    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
628    for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
629    {
630      m_aidQPdepth[i] = 1;
631    }
632  }
633
634  // reading external dQP description from file
635  if ( m_pchdQPFile )
636  {
637    FILE* fpt=fopen( m_pchdQPFile, "r" );
638    if ( fpt )
639    {
640      Int iValue;
641      Int iPOC = 0;
642      while ( iPOC < m_iFrameToBeEncoded )
643      {
644        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
645        m_aidQP[ iPOC ] = iValue;
646        iPOC++;
647      }
648      fclose(fpt);
649    }
650  }
651
652#if HHI_VSO
653  m_bUseVSO = m_bUseVSO && m_bUsingDepthMaps && (m_uiVSOMode != 0);
654#endif
655
656#if LGE_WVSO_A0119
657  m_bWVSO = m_bUseVSO && m_bWVSO && m_bUsingDepthMaps;
658#endif
659  xCleanUpVectors();
660
661#if HHI_VSO
662  if ( m_abUseALF .size() < 2)
663    m_abUseALF .push_back( m_bUseVSO ? false : m_abUseALF[0]  );
664
665  if ( m_abUseRDOQ.size() < 2)
666    m_abUseRDOQ.push_back( m_bUseVSO ? true : m_abUseRDOQ[0] );
667
668  if ( m_abLoopFilterDisable.size() < 2)
669    m_abLoopFilterDisable.push_back( m_bUseVSO ? true : m_abLoopFilterDisable[0]  );
670
671  if (m_abUseSAO.size() < 2)
672    m_abUseSAO.push_back            ( m_bUseVSO ? false : m_abUseSAO[0] );
673#else
674  if ( m_abUseALF .size() < 2)
675    m_abUseALF .push_back( m_abUseALF[0]  );
676
677  if ( m_abUseRDOQ.size() < 2)
678    m_abUseRDOQ.push_back( m_abUseRDOQ[0] );
679
680  if ( m_abLoopFilterDisable.size() < 2)
681    m_abLoopFilterDisable.push_back( m_abLoopFilterDisable[0]  );
682
683  if (m_abUseSAO.size() < 2)
684    m_abUseSAO.push_back            ( m_abUseSAO[0] );
685#endif
686
687#if HHI_VSO
688
689#if HHI_VSO_LS_TABLE
690  // Q&D
691  Double adLambdaScaleTable[] = 
692  {  0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755, 
693     0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648, 
694     0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542, 
695     0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388, 
696     0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100, 
697     0.753550, 0.800000 
698  }; 
699  if ( m_bVSOLSTable )
700  {
701    AOT( (m_aiQP[1] < 0) || (m_aiQP[1] > 51));
702    m_dLambdaScaleVSO *= adLambdaScaleTable[m_aiQP[1]]; 
703  }
704#endif
705#endif
706
707 // set global variables
708  xSetGlobal();
709
710  // read and check camera parameters
711#if HHI_VSO
712if ( m_bUseVSO && m_uiVSOMode == 4)
713{
714  m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
715  m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
716                                      m_uiInputBitDepth,
717                                (UInt)m_iCodedCamParPrecision,
718                                      m_FrameSkip,
719                                (UInt)m_iFrameToBeEncoded,
720                                      m_pchCameraParameterFile,
721                                      m_pchBaseViewCameraNumbers,
722                                      NULL,
723                                      m_cRenModStrParser.getSynthViews(),
724                                      LOG2_DISP_PREC_LUT );
725}
726else if ( m_bUseVSO && m_uiVSOMode != 4 )
727{
728  m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
729                                      m_uiInputBitDepth,
730                                (UInt)m_iCodedCamParPrecision,
731                                      m_FrameSkip,
732                                (UInt)m_iFrameToBeEncoded,
733                                      m_pchCameraParameterFile,
734                                      m_pchBaseViewCameraNumbers,
735                                      m_pchVSOConfig,
736                                      NULL,
737                                      LOG2_DISP_PREC_LUT );
738}
739else
740{
741  m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
742    m_uiInputBitDepth,
743    (UInt)m_iCodedCamParPrecision,
744    m_FrameSkip,
745    (UInt)m_iFrameToBeEncoded,
746    m_pchCameraParameterFile,
747    m_pchBaseViewCameraNumbers,
748    NULL,
749    NULL,
750    LOG2_DISP_PREC_LUT );
751}
752#else
753  m_cCameraData     .init     ( (UInt)m_iNumberOfViews,
754    m_uiInputBitDepth,
755    (UInt)m_iCodedCamParPrecision,
756    m_FrameSkip,
757    (UInt)m_iFrameToBeEncoded,
758    m_pchCameraParameterFile,
759    m_pchBaseViewCameraNumbers,
760    NULL,
761    NULL,
762    LOG2_DISP_PREC_LUT );
763#endif
764
765
766  // check validity of input parameters
767  xCheckParameter();
768  m_cCameraData.check( false, true );
769 
770  // print-out parameters
771  xPrintParameter();
772 
773  return true;
774}
775
776// ====================================================================================================================
777// Private member functions
778// ====================================================================================================================
779
780Bool confirmPara(Bool bflag, const char* message);
781
782Void TAppEncCfg::xCheckParameter()
783{
784  bool check_failed = false; /* abort if there is a fatal configuration problem */
785#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
786  // check range of parameters
787  xConfirmPara( m_uiInputBitDepth < 8,                                                      "InputBitDepth must be at least 8" );
788  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
789  xConfirmPara( m_iFrameToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
790  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
791  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
792  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
793  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
794#if H0736_AVC_STYLE_QP_RANGE
795  xConfirmPara( m_aiQP[0] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[0] > 51,         "QP exceeds supported range (-QpBDOffsety to 51)" );
796  if ( m_aiQP.size() >= 2 )
797  {
798    xConfirmPara( m_aiQP[1] < -6 * ((Int)m_uiInternalBitDepth - 8) || m_aiQP[1] > 51,       "QP depth exceeds supported range (-QpBDOffsety to 51)" );
799  }
800#else
801  xConfirmPara( m_aiQP[0] < 0 || m_aiQP[0] > 51,                                             "QP exceeds supported range (0 to 51)" );
802  if ( m_aiQP.size() >= 2 )
803  {
804    xConfirmPara( m_aiQP[1] < 0 || m_aiQP[1] > 51,                                           "QP Depth exceeds supported range (0 to 51)" );
805  }
806#endif
807  xConfirmPara( m_iALFEncodePassReduction < 0 || m_iALFEncodePassReduction > 2,             "ALFEncodePassReduction must be equal to 0, 1 or 2");
808#if LCU_SYNTAX_ALF
809  xConfirmPara( m_iALFMaxNumberFilters < 1,                                                 "ALFMaxNumFilter should be larger than 1"); 
810#else
811  xConfirmPara( m_iALFMaxNumberFilters < 1 || m_iALFMaxNumberFilters > 16,                  "ALFMaxNumFilter exceeds supported range (1 to 16)"); 
812#endif
813  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 || m_loopFilterBetaOffsetDiv2 > 13,          "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
814  xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 || m_loopFilterTcOffsetDiv2 > 13,              "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
815  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
816  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
817  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
818  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
819  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
820
821  xConfirmPara( m_iChromaQpOffset    < -12,   "Min. Chroma Qp Offset is -12"     );
822  xConfirmPara( m_iChromaQpOffset    >  12,   "Max. Chroma Qp Offset is  12"     );
823  xConfirmPara( m_iChromaQpOffset2nd < -12,   "Min. Chroma Qp Offset 2nd is -12" );
824  xConfirmPara( m_iChromaQpOffset2nd >  12,   "Max. Chroma Qp Offset 2nd is  12" );
825
826  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
827  if (m_iDecodingRefreshType == 2)
828  {
829    xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
830  }
831  xConfirmPara( (m_uiMaxCUWidth  >> m_uiMaxCUDepth) < 4,                                    "Minimum partition width size should be larger than or equal to 8");
832  xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4,                                    "Minimum partition height size should be larger than or equal to 8");
833  xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
834  xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
835#if PIC_CROPPING
836  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
837  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
838#else
839  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Frame width should be multiple of minimum CU size");
840  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Frame height should be multiple of minimum CU size");
841#endif
842 
843  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
844  xConfirmPara( m_uiQuadtreeTULog2MinSize > 5,                                        "QuadtreeTULog2MinSize must be 5 or smaller.");
845  xConfirmPara( m_uiQuadtreeTULog2MaxSize < 2,                                        "QuadtreeTULog2MaxSize must be 2 or greater.");
846  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
847  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
848  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
849  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
850  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth  >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
851  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
852  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
853  xConfirmPara( m_uiQuadtreeTUMaxDepthInter > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthInter must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
854  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
855  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthIntra must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
856
857  xConfirmPara( m_iNumberOfViews > MAX_VIEW_NUM ,                                     "NumberOfViews must be less than or equal to MAX_VIEW_NUM");
858  xConfirmPara    ( Int( m_pchInputFileList.size() ) < m_iNumberOfViews,              "Number of InputFiles must be greater than or equal to NumberOfViews" );
859  xConfirmPara    ( Int( m_pchReconFileList.size() ) < m_iNumberOfViews,              "Number of ReconFiles must be greater than or equal to NumberOfViews" );
860  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
861#if HHI_INTERVIEW_SKIP
862  xConfirmPara    ( m_bInterViewSkip && !m_bUsingDepthMaps,                       "RenderingSkipMode requires CodeDepthMaps = 1" );
863#endif
864#if DEPTH_MAP_GENERATION
865  xConfirmPara    ( m_uiPredDepthMapGeneration > 2,                                   "PredDepthMapGen must be less than or equal to 2" );
866  xConfirmPara    ( m_uiPredDepthMapGeneration >= 2 && !m_bUsingDepthMaps,            "PredDepthMapGen >= 2 requires CodeDepthMaps = 1" );
867#endif
868#if HHI_INTER_VIEW_MOTION_PRED
869  xConfirmPara    ( m_uiMultiviewMvPredMode > 7,                                      "MultiviewMvPred must be less than or equal to 7" );
870  xConfirmPara    ( m_uiMultiviewMvPredMode > 0 && m_uiPredDepthMapGeneration == 0 ,  "MultiviewMvPred > 0 requires PredDepthMapGen > 0" );
871  xConfirmPara    ( m_uiMultiviewMvRegMode       > 1,                                 "MultiviewMvRegMode must be less than or equal to 1" );
872  xConfirmPara    ( m_dMultiviewMvRegLambdaScale < 0.0,                               "MultiviewMvRegLambdaScale must not be negative" );
873  if( m_uiMultiviewMvRegMode )
874  {
875    xConfirmPara  ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews,         "MultiviewMvRegMode > 0 requires the presence of input depth maps" );
876  }
877#endif
878#if HHI_INTER_VIEW_RESIDUAL_PRED
879  xConfirmPara    ( m_uiMultiviewResPredMode > 1,                                     "MultiviewResPred must be less than or equal to 1" );
880  xConfirmPara    ( m_uiMultiviewResPredMode > 0 && m_uiPredDepthMapGeneration == 0 , "MultiviewResPred > 0 requires PredDepthMapGen > 0" );
881#endif
882  if( m_bUsingDepthMaps )
883  {
884    xConfirmPara  ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews,         "Number of DepthInputFiles must be greater than or equal to NumberOfViews" );
885    xConfirmPara  ( Int( m_pchDepthReconFileList.size() ) < m_iNumberOfViews,         "Number of DepthReconFiles must be greater than or equal to NumberOfViews" );
886
887#if HHI_VSO
888    if( m_bUseVSO )
889    {
890      xConfirmPara( m_pchCameraParameterFile    == 0                             ,   "CameraParameterFile must be given");
891      xConfirmPara(   m_pchVSOConfig            == 0                             ,   "VSO Setup string must be given");
892      xConfirmPara( m_pchBaseViewCameraNumbers  == 0                             ,   "BaseViewCameraNumbers must be given" );
893      xConfirmPara( m_iNumberOfViews != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
894      xConfirmPara( m_uiVSOMode > 4 ,                                                "VSO Mode must be less than 5");
895    }
896#endif
897  }
898#if ADAPTIVE_QP_SELECTION
899#if H0736_AVC_STYLE_QP_RANGE
900  xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[0] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
901  xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[1] < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
902  xConfirmPara( m_bUseAdaptQpSelect == true && (m_iChromaQpOffset !=0 || m_iChromaQpOffset2nd != 0 ),  "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
903#endif
904#endif
905
906  if( m_usePCM)
907  {
908    xConfirmPara(  m_uiPCMLog2MinSize < 3,                                      "PCMLog2MinSize must be 3 or greater.");
909    xConfirmPara(  m_uiPCMLog2MinSize > 5,                                      "PCMLog2MinSize must be 5 or smaller.");
910    xConfirmPara(  m_pcmLog2MaxSize > 5,                                        "PCMLog2MaxSize must be 5 or smaller.");
911    xConfirmPara(  m_pcmLog2MaxSize < m_uiPCMLog2MinSize,                       "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
912  }
913
914#if FIXED_NUMBER_OF_TILES_SLICE_MODE
915  xConfirmPara( m_iSliceMode < 0 || m_iSliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
916#endif
917  if (m_iSliceMode!=0)
918  {
919    xConfirmPara( m_iSliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
920  }
921#if FIXED_NUMBER_OF_TILES_SLICE_MODE
922  if (m_iSliceMode==3)
923  {
924    xConfirmPara( m_iSliceGranularity > 0 ,      "When SliceMode == 3 is chosen, the SliceGranularity must be 0" );
925  }
926#endif
927  xConfirmPara( m_iEntropySliceMode < 0 || m_iEntropySliceMode > 2, "EntropySliceMode exceeds supported range (0 to 2)" );
928  if (m_iEntropySliceMode!=0)
929  {
930    xConfirmPara( m_iEntropySliceArgument < 1 ,         "EntropySliceArgument should be larger than or equal to 1" );
931  }
932  xConfirmPara( m_iSliceGranularity >= m_uiMaxCUDepth, "SliceGranularity must be smaller than maximum cu depth");
933  xConfirmPara( m_iSliceGranularity <0 || m_iSliceGranularity > 3, "SliceGranularity exceeds supported range (0 to 3)" );
934  xConfirmPara( m_iSliceGranularity > m_iMaxCuDQPDepth, "SliceGranularity must be smaller smaller than or equal to maximum dqp depth" );
935
936#if NO_COMBINED_PARALLEL
937  bool tileFlag = (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0 );
938  xConfirmPara( tileFlag && m_iEntropySliceMode,            "Tile and Entropy Slice can not be applied together");
939  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
940  xConfirmPara( m_iWaveFrontSynchro && m_iEntropySliceMode, "Wavefront and Entropy Slice can not be applied together"); 
941#endif
942
943  // max CU width and height should be power of 2
944  UInt ui = m_uiMaxCUWidth;
945  while(ui)
946  {
947    ui >>= 1;
948    if( (ui & 1) == 1)
949      xConfirmPara( ui != 1 , "Width should be 2^n");
950  }
951  ui = m_uiMaxCUHeight;
952  while(ui)
953  {
954    ui >>= 1;
955    if( (ui & 1) == 1)
956      xConfirmPara( ui != 1 , "Height should be 2^n");
957  }
958 
959  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
960  xConfirmPara( m_iWaveFrontFlush < 0, "WaveFrontFlush cannot be negative" );
961  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
962  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
963
964#undef xConfirmPara
965  if (check_failed)
966  {
967    exit(EXIT_FAILURE);
968  }
969
970  xCheckCodingStructureMvc();
971}
972
973Void TAppEncCfg::xCheckCodingStructureMvc()
974{
975  bool check_failed = false; /* abort if there is a fatal configuration problem */
976#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
977
978  // validate that POC of same frame is identical across multiple views
979  Bool bErrorMvePoc = false;
980  if( m_iNumberOfViews > 1 )
981  {
982    for( Int k = 1; k < m_iNumberOfViews; k++ )
983    {
984      for( Int i = 0; i < MAX_GOP; i++ )
985      {
986        if( m_GOPListsMvc[k][i].m_POC != m_GOPListsMvc[0][i].m_POC )
987        {
988          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 );
989          bErrorMvePoc = true;
990        }
991      }
992    }
993  }
994  xConfirmPara( bErrorMvePoc,  "Invalid inter-view POC structure given" );
995
996  // validate that baseview has no inter-view refs
997  Bool bErrorIvpBase = false;
998  for( Int i = 0; i < MAX_GOP; i++ )
999  {
1000    if( m_GOPListsMvc[0][i].m_numInterViewRefPics != 0 )
1001    {
1002      printf( "\nError: Frame%d inter_view refs not available in view 0\n", i );
1003      bErrorIvpBase = true;
1004    }
1005  }
1006  xConfirmPara( bErrorIvpBase, "Inter-view refs not possible in base view" );
1007
1008  // validate inter-view refs
1009  Bool bErrorIvpEnhV = false;
1010  if( m_iNumberOfViews > 1 )
1011  {
1012    for( Int k = 1; k < m_iNumberOfViews; k++ )
1013    {
1014      for( Int i = 0; i < MAX_GOP+1; i++ )
1015      {
1016        for( Int j = 0; j < m_GOPListsMvc[k][i].m_numInterViewRefPics; j++ )
1017        {
1018          Int iAbsViewId = m_GOPListsMvc[k][i].m_interViewRefs[j] + k;
1019          if( iAbsViewId < 0 || iAbsViewId >= k )
1020          {
1021            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 );
1022            bErrorIvpEnhV = true;
1023          }
1024          if( m_GOPListsMvc[k][i].m_interViewRefPosL0[j] < 0 || m_GOPListsMvc[k][i].m_interViewRefPosL0[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
1025          {
1026            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 );
1027            bErrorIvpEnhV = true;
1028          }
1029          if( m_GOPListsMvc[k][i].m_interViewRefPosL1[j] < 0 || m_GOPListsMvc[k][i].m_interViewRefPosL1[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
1030          {
1031            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 );
1032            bErrorIvpEnhV = true;
1033          }
1034        }
1035        if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1036        {
1037          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' )
1038          {
1039            printf( "\nError: slice type of FrameI_v%d must be equal to B or P or I\n", k );
1040            bErrorIvpEnhV = true;
1041          }
1042
1043          if( m_GOPListsMvc[k][MAX_GOP].m_POC != 0 )
1044          {
1045            printf( "\nError: POC %d not possible for FrameI_v%d, must be 0\n", m_GOPListsMvc[k][MAX_GOP].m_POC, k );
1046            bErrorIvpEnhV = true;
1047          }
1048
1049          if( m_GOPListsMvc[k][MAX_GOP].m_temporalId != 0 )
1050          {
1051            printf( "\nWarning: Temporal id of FrameI_v%d must be 0 (cp. I-frame in base view)\n", k );
1052            m_GOPListsMvc[k][MAX_GOP].m_temporalId = 0;
1053          }
1054
1055          if( !(m_GOPListsMvc[k][MAX_GOP].m_refPic) )
1056          {
1057            printf( "\nWarning: FrameI_v%d must be ref pic (cp. I-frame in base view)\n", k );
1058            m_GOPListsMvc[k][MAX_GOP].m_refPic = true;
1059          }
1060
1061          if( m_GOPListsMvc[k][MAX_GOP].m_numRefPics != 0 )
1062          {
1063            printf( "\nWarning: temporal references not possible for FrameI_v%d\n", k );
1064            for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numRefPics; j++ )
1065            {
1066              m_GOPListsMvc[k][MAX_GOP].m_referencePics[j] = 0;
1067            }
1068            m_GOPListsMvc[k][MAX_GOP].m_numRefPics = 0;
1069          }
1070
1071          if( m_GOPListsMvc[k][MAX_GOP].m_interRPSPrediction )
1072          {
1073            printf( "\nError: inter RPS prediction not possible for FrameI_v%d, must be 0\n", k );
1074            bErrorIvpEnhV = true;
1075          }
1076
1077          if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'I' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics != 0 )
1078          {
1079            printf( "\nError: inter-view prediction not possible for FrameI_v%d with slice type I, #IV_ref_pics must be 0\n", k );
1080            bErrorIvpEnhV = true;
1081          }
1082
1083          if( m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive > m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics )
1084          {
1085            m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive = m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics;
1086          }
1087
1088          if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'P' )
1089          {
1090            if( m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
1091            {
1092              printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type P\n", k );
1093              bErrorIvpEnhV = true;
1094            }
1095            else
1096            {
1097              for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics; j++ )
1098              {
1099                if( m_GOPListsMvc[k][MAX_GOP].m_interViewRefPosL1[j] != 0 )
1100                {
1101                  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 );
1102                  bErrorIvpEnhV = true;
1103                }
1104              }
1105            }
1106          }
1107
1108          if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'B' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
1109          {
1110            printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type B\n", k );
1111            bErrorIvpEnhV = true;
1112          }
1113        }
1114      }
1115    }
1116  }
1117  xConfirmPara( bErrorIvpEnhV, "Invalid inter-view coding structure for enhancement views given" );
1118
1119  // validate temporal coding structure
1120  if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1121  {
1122    for( Int viewId = 0; viewId < m_iNumberOfViews; viewId++ )
1123    {
1124      Bool verifiedGOP = false;
1125      Bool errorGOP    = false;
1126      Int  checkGOP    = 1;
1127      Int  numRefs     = 1;
1128      Int refList[MAX_NUM_REF_PICS+1];
1129      refList[0] = 0;
1130      Bool isOK[MAX_GOP];
1131      for( Int i = 0; i < MAX_GOP; i++ ) { isOK[i] = false; }
1132      Int numOK = 0;
1133#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1134      Int numReorderFramesRequired=0;
1135      m_maxNumberOfReferencePictures=0;
1136      Int lastDisp = -1;
1137#endif
1138      m_extraRPSs[viewId] = 0;
1139      //start looping through frames in coding order until we can verify that the GOP structure is correct.
1140      while( !verifiedGOP && !errorGOP )
1141      {
1142        Int curGOP = (checkGOP-1)%m_iGOPSize;
1143        Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPListsMvc[viewId][curGOP].m_POC;   
1144        if( m_GOPListsMvc[viewId][curGOP].m_POC < 0 )
1145        {
1146          printf( "\nError: found fewer Reference Picture Sets than GOPSize for view %d\n", viewId );
1147          errorGOP = true;
1148        }
1149        else 
1150        {
1151          //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1152          Bool beforeI = false;
1153          for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ ) 
1154          {
1155            Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
1156            if( absPOC < 0 )
1157            {
1158              beforeI = true;
1159            }
1160            else 
1161            {
1162              Bool found = false;
1163              for( Int j = 0; j < numRefs; j++ )
1164              {
1165                if( refList[j] == absPOC ) 
1166                {
1167                  found = true;
1168                  for( Int k = 0; k < m_iGOPSize; k++ )
1169                  {
1170                    if( absPOC%m_iGOPSize == m_GOPListsMvc[viewId][k].m_POC%m_iGOPSize )
1171                    {
1172                      m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i] = (m_GOPListsMvc[viewId][k].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
1173                    }
1174                  }
1175                }
1176              }
1177              if( !found )
1178              {
1179                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 );
1180                errorGOP = true;
1181              }
1182            }
1183          }
1184          if( !beforeI && !errorGOP )
1185          {
1186            //all ref frames were present
1187            if( !isOK[curGOP] ) 
1188            {
1189              numOK++;
1190              isOK[curGOP] = true;
1191              if( numOK == m_iGOPSize )
1192              {
1193                verifiedGOP = true;
1194              }
1195            }
1196          }
1197          else 
1198          {
1199            //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1200            m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]] = m_GOPListsMvc[viewId][curGOP];
1201            Int newRefs = 0;
1202            for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
1203            {
1204              Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
1205              if( absPOC >= 0 )
1206              {
1207                m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[newRefs] = m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
1208                m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[newRefs] = m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i];
1209                newRefs++;
1210              }
1211            }
1212            Int numPrefRefs = m_GOPListsMvc[viewId][curGOP].m_numRefPicsActive;
1213
1214            for( Int offset = -1; offset > -checkGOP; offset-- )
1215            {
1216              //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1217              Int offGOP =  (checkGOP - 1 + offset)%m_iGOPSize;
1218              Int offPOC = ((checkGOP - 1 + offset)/m_iGOPSize) * m_iGOPSize + m_GOPListsMvc[viewId][offGOP].m_POC;
1219              if( offPOC >= 0 && m_GOPListsMvc[viewId][offGOP].m_refPic && m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId )
1220              {
1221                Bool newRef = false;
1222                for( Int i = 0; i < numRefs; i++ )
1223                {
1224                  if( refList[i] == offPOC )
1225                  {
1226                    newRef = true;
1227                  }
1228                }
1229                for( Int i = 0; i < newRefs; i++ ) 
1230                {
1231                  if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[i] == (offPOC - curPOC) )
1232                  {
1233                    newRef = false;
1234                  }
1235                }
1236                if( newRef ) 
1237                {
1238                  Int insertPoint = newRefs;
1239                  //this picture can be added, find appropriate place in list and insert it.
1240                  for( Int j = 0; j < newRefs; j++ )
1241                  {
1242                    if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] < (offPOC - curPOC) || 
1243                        m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] > 0 )
1244                    {
1245                      insertPoint = j;
1246                      break;
1247                    }
1248                  }
1249                  Int prev = offPOC - curPOC;
1250                  Int prevUsed = (m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
1251                  for( Int j = insertPoint; j < newRefs+1; j++ )
1252                  {
1253                    Int newPrev = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j];
1254                    Int newUsed = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j];
1255                    m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] = prev;
1256                    m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] = prevUsed;
1257                    prevUsed = newUsed;
1258                    prev = newPrev;
1259                  }
1260                  newRefs++;
1261                }
1262              }
1263              if( newRefs >= numPrefRefs )
1264              {
1265                break;
1266              }
1267            }
1268            m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics = newRefs;
1269            m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC = curPOC;
1270            if( m_extraRPSs[viewId] == 0 )
1271            {
1272              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 0;
1273              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = 0;
1274            }
1275            else
1276            {
1277              Int rIdx =  m_iGOPSize + m_extraRPSs[viewId] - 1;
1278              Int refPOC = m_GOPListsMvc[viewId][rIdx].m_POC;
1279              Int refPics = m_GOPListsMvc[viewId][rIdx].m_numRefPics;
1280              Int newIdc = 0;
1281              for( Int i = 0; i <= refPics; i++ )
1282              {
1283                Int deltaPOC = ((i != refPics)? m_GOPListsMvc[viewId][rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
1284                Int absPOCref = refPOC + deltaPOC;
1285                Int refIdc = 0;
1286                for( Int j = 0; j < m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics; j++ )
1287                {
1288                  if( (absPOCref - curPOC) == m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] )
1289                  {
1290                    if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] )
1291                    {
1292                      refIdc = 1;
1293                    }
1294                    else
1295                    {
1296                      refIdc = 2;
1297                    }
1298                  }
1299                }
1300                m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_refIdc[newIdc] = refIdc;
1301                newIdc++;
1302              }
1303              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 1; 
1304              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = newIdc;
1305              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRPS = refPOC - m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC; 
1306              m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRIdxMinus1 = 0; 
1307            }
1308            curGOP = m_iGOPSize + m_extraRPSs[viewId];
1309            m_extraRPSs[viewId]++;
1310          }
1311          numRefs = 0;
1312          for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
1313          {
1314            Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
1315            if( absPOC >= 0 )
1316            {
1317              refList[numRefs] = absPOC;
1318              numRefs++;
1319            }
1320          }
1321#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1322          if(m_maxNumberOfReferencePictures<numRefs)
1323          {
1324            m_maxNumberOfReferencePictures=numRefs;
1325          }
1326#endif
1327          refList[numRefs] = curPOC;
1328          numRefs++;
1329#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1330          Int nonDisplayed=0;
1331          for(Int i=0; i<numRefs; i++) 
1332          {
1333            if(refList[i]==lastDisp+1) 
1334            {
1335              lastDisp=refList[i];
1336              i=0;
1337            }
1338          }
1339          for(Int i=0; i<numRefs; i++) 
1340          {
1341            if(refList[i]>lastDisp)
1342            {
1343              nonDisplayed++;
1344            }
1345          }
1346          if(nonDisplayed>numReorderFramesRequired)
1347          {
1348            numReorderFramesRequired=nonDisplayed;
1349          }
1350#endif
1351        }
1352        checkGOP++;
1353      }
1354#if !H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1355      if (m_numReorderFrames == -1)
1356      {
1357        m_numReorderFrames = numReorderFramesRequired;
1358      }
1359#endif
1360      xConfirmPara( errorGOP, "Invalid GOP structure given" );
1361#if H0566_TLA
1362      m_maxTempLayer[viewId] = 1;
1363#endif
1364      for( Int i = 0; i < m_iGOPSize; i++ ) 
1365      {
1366#if H0566_TLA
1367        if( m_GOPListsMvc[viewId][i].m_temporalId >= m_maxTempLayer[viewId] )
1368        {
1369          m_maxTempLayer[viewId] = m_GOPListsMvc[viewId][i].m_temporalId + 1;
1370        }
1371#endif
1372        xConfirmPara( m_GOPListsMvc[viewId][i].m_sliceType != 'B' && m_GOPListsMvc[viewId][i].m_sliceType != 'P', "Slice type must be equal to B or P" );
1373      }
1374
1375#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1376      for( Int i = 0; i < MAX_TLAYER; i++ )
1377      {
1378        m_numReorderPics[viewId][i] = 0;
1379        m_maxDecPicBuffering[viewId][i] = 0;
1380      }
1381      for( Int i = 0; i < m_iGOPSize; i++ ) 
1382      {
1383        if( m_GOPListsMvc[viewId][i].m_numRefPics > m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
1384        {
1385          m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = m_GOPListsMvc[viewId][i].m_numRefPics;
1386        }
1387        Int highestDecodingNumberWithLowerPOC = 0; 
1388        for( Int j = 0; j < m_iGOPSize; j++ )
1389        {
1390          if( m_GOPListsMvc[viewId][j].m_POC <= m_GOPListsMvc[viewId][i].m_POC )
1391          {
1392            highestDecodingNumberWithLowerPOC = j;
1393          }
1394        }
1395        Int numReorder = 0;
1396        for( Int j = 0; j < highestDecodingNumberWithLowerPOC; j++ )
1397        {
1398          if( m_GOPListsMvc[viewId][j].m_temporalId <= m_GOPListsMvc[viewId][i].m_temporalId && 
1399              m_GOPListsMvc[viewId][j].m_POC        >  m_GOPListsMvc[viewId][i].m_POC )
1400          {
1401            numReorder++;
1402          }
1403        }   
1404        if( numReorder > m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
1405        {
1406          m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = numReorder;
1407        }
1408      }
1409      for( Int i = 0; i < MAX_TLAYER-1; i++ ) 
1410      {
1411        // a lower layer can not have higher value of m_numReorderPics than a higher layer
1412        if( m_numReorderPics[viewId][i+1] < m_numReorderPics[viewId][i] )
1413        {
1414          m_numReorderPics[viewId][i+1] = m_numReorderPics[viewId][i];
1415        }
1416        // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1417        if( m_numReorderPics[viewId][i] > m_maxDecPicBuffering[viewId][i] )
1418        {
1419          m_maxDecPicBuffering[viewId][i] = m_numReorderPics[viewId][i];
1420        }
1421        // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
1422        if( m_maxDecPicBuffering[viewId][i+1] < m_maxDecPicBuffering[viewId][i] )
1423        {
1424          m_maxDecPicBuffering[viewId][i+1] = m_maxDecPicBuffering[viewId][i];
1425        }
1426      }
1427      // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1428      if( m_numReorderPics[viewId][MAX_TLAYER-1] > m_maxDecPicBuffering[viewId][MAX_TLAYER-1] )
1429      {
1430        m_maxDecPicBuffering[viewId][MAX_TLAYER-1] = m_numReorderPics[viewId][MAX_TLAYER-1];
1431      }
1432#endif
1433
1434#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1435      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.
1436#else
1437      xConfirmPara( m_bUseLComb==false && m_numReorderFrames!=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.
1438      xConfirmPara( m_numReorderFrames < numReorderFramesRequired, "For the used GOP the encoder requires more pictures for reordering than specified in MaxNumberOfReorderPictures" );
1439#endif
1440    }
1441  }
1442#undef xConfirmPara
1443  if( check_failed )
1444  {
1445    exit(EXIT_FAILURE);
1446  }
1447}
1448
1449template <class T>
1450Void
1451TAppEncCfg::xCleanUpVector( std::vector<T>& rcVec, const T& rcInvalid )
1452{
1453  Int iFirstInv = (Int)rcVec.size();
1454  for( Int iIdx = 0; iIdx < (Int)rcVec.size(); iIdx++ )
1455  {
1456    if( rcVec[ iIdx ] == rcInvalid )
1457    {
1458      iFirstInv = iIdx;
1459      break;
1460    }
1461  }
1462  while( (Int)rcVec.size() > iFirstInv )
1463  {
1464    rcVec.pop_back();
1465  }
1466}
1467
1468Void
1469TAppEncCfg::xCleanUpVectors()
1470{
1471  xCleanUpVector( m_pchInputFileList,       (char*)0 );
1472  xCleanUpVector( m_pchDepthInputFileList,  (char*)0 );
1473  xCleanUpVector( m_pchReconFileList,       (char*)0 );
1474  xCleanUpVector( m_pchDepthReconFileList,  (char*)0 );
1475}
1476
1477/** \todo use of global variables should be removed later
1478 */
1479Void TAppEncCfg::xSetGlobal()
1480{
1481  // set max CU width & height
1482  g_uiMaxCUWidth  = m_uiMaxCUWidth;
1483  g_uiMaxCUHeight = m_uiMaxCUHeight;
1484 
1485  // compute actual CU depth with respect to config depth and max transform size
1486  g_uiAddCUDepth  = 0;
1487  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
1488 
1489  m_uiMaxCUDepth += g_uiAddCUDepth;
1490  g_uiAddCUDepth++;
1491  g_uiMaxCUDepth = m_uiMaxCUDepth;
1492 
1493  // set internal bit-depth and constants
1494#if FULL_NBIT
1495  g_uiBitDepth = m_uiInternalBitDepth;
1496  g_uiBitIncrement = 0;
1497#else
1498  g_uiBitDepth = 8;
1499  g_uiBitIncrement = m_uiInternalBitDepth - g_uiBitDepth;
1500#endif
1501
1502#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1503  g_iDeltaDCsQuantOffset = g_uiBitIncrement - 2;
1504#endif
1505
1506  g_uiBASE_MAX     = ((1<<(g_uiBitDepth))-1);
1507 
1508#if IBDI_NOCLIP_RANGE
1509  g_uiIBDI_MAX     = g_uiBASE_MAX << g_uiBitIncrement;
1510#else
1511  g_uiIBDI_MAX     = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
1512#endif
1513 
1514  if (m_uiOutputBitDepth == 0)
1515  {
1516    m_uiOutputBitDepth = m_uiInternalBitDepth;
1517  }
1518
1519  g_uiPCMBitDepthLuma = m_uiPCMBitDepthLuma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
1520  g_uiPCMBitDepthChroma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
1521}
1522
1523Void TAppEncCfg::xPrintParameter()
1524{
1525  printf("\n");
1526  for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
1527  {
1528    printf("Texture Input File %i            : %s\n", iCounter, m_pchInputFileList[iCounter]);
1529  }
1530  if( m_bUsingDepthMaps )
1531  {
1532    for( Int iCounter = 0; iCounter < m_iNumberOfViews; iCounter++)
1533    {
1534      printf("Depth Input File %i              : %s\n", iCounter, m_pchDepthInputFileList[iCounter]);
1535    }
1536  }
1537  printf("Bitstream File                  : %s\n", m_pchBitstreamFile      );
1538  for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
1539  {
1540    printf("Texture Reconstruction File %i   : %s\n", iCounter, m_pchReconFileList[iCounter]);
1541  }
1542  if( m_bUsingDepthMaps )
1543  {
1544    for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
1545    {
1546      printf("Depth Reconstruction File %i     : %s\n", iCounter, m_pchDepthReconFileList[iCounter]);
1547    }
1548  }
1549#if PIC_CROPPING
1550  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_cropLeft - m_cropRight, m_iSourceHeight - m_cropTop - m_cropBottom, m_iFrameRate );
1551#else
1552  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_aiPad[0], m_iSourceHeight-m_aiPad[1], m_iFrameRate );
1553#endif
1554  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
1555  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_iFrameToBeEncoded-1, m_iFrameToBeEncoded );
1556  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
1557  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
1558  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
1559  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
1560  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
1561  printf("Motion search range          : %d\n", m_iSearchRange );
1562  printf("Intra period                 : %d\n", m_iIntraPeriod );
1563  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
1564  printf("QP Texture                   : %5.2f\n", m_adQP[0] );
1565  if( m_bUsingDepthMaps )
1566  {
1567    printf("QP Depth                     : %5.2f\n", m_adQP[ m_adQP.size()  < 2 ? 0 : 1] );
1568  }
1569  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
1570
1571  printf("Chroma Qp Offset             : %d\n", m_iChromaQpOffset   );
1572  printf("Chroma Qp Offset 2nd         : %d\n", m_iChromaQpOffset2nd);
1573
1574  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
1575  printf("GOP size                     : %d\n", m_iGOPSize );
1576  printf("Internal bit depth           : %d\n", m_uiInternalBitDepth );
1577  printf("PCM sample bit depth         : %d\n", m_uiPCMBitDepthLuma );
1578  if((m_uiMaxCUWidth >> m_uiMaxCUDepth) == 4)
1579  {
1580    printf("DisableInter4x4              : %d\n", m_bDisInter4x4); 
1581  }
1582
1583printf("Loop Filter Disabled         : %d %d\n", m_abLoopFilterDisable[0] ? 1 : 0,  m_abLoopFilterDisable[1] ? 1 : 0 );
1584  printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
1585
1586#if HHI_VSO
1587  printf("Force use of Lambda Scale    : %d\n", m_bForceLambdaScaleVSO );
1588
1589  if ( m_bUseVSO )
1590  {
1591    printf("VSO Lambda Scale             : %5.2f\n", m_dLambdaScaleVSO );
1592    printf("VSO Mode                     : %d\n",    m_uiVSOMode       );
1593    printf("VSO Config                   : %s\n",    m_pchVSOConfig    );
1594#if HHI_VSO_DIST_INT
1595    printf("VSO Negative Distortion      : %d\n",    m_bAllowNegDist ? 1 : 0);
1596#endif
1597#if HHI_VSO_LS_TABLE
1598    printf("VSO LS Table                 : %d\n",    m_bVSOLSTable ? 1 : 0);   
1599#endif
1600#if SAIT_VSO_EST_A0033
1601    printf("VSO Estimated VSD            : %d\n",    m_bUseEstimatedVSD ? 1 : 0);       
1602#endif
1603#if LGE_VSO_EARLY_SKIP_A0093
1604    printf("VSO Early Skip               : %d\n",    m_bVSOEarlySkip ? 1 : 0);   
1605#endif
1606   
1607  }
1608#endif
1609#if HHI_INTERVIEW_SKIP
1610    printf("InterView Skip:              : %d\n",    m_bInterViewSkip ? 1:0 );
1611    printf("InterView Skip Lambda Scale  : %f\n",    m_dInterViewSkipLambdaScale );
1612#endif
1613
1614  printf("\n");
1615 
1616  printf("TOOL CFG General: "); 
1617#if LCU_SYNTAX_ALF
1618  printf("ALFMNF:%d ", m_iALFMaxNumberFilters);
1619  printf("ALFInSlice:%d ", m_bALFParamInSlice);
1620  printf("ALFPicEnc:%d ", m_bALFPicBasedEncode);
1621#endif
1622  printf("IBD:%d ", !!g_uiBitIncrement);
1623  printf("HAD:%d ", m_bUseHADME           );
1624  printf("SRD:%d ", m_bUseSBACRD          );
1625  printf("SQP:%d ", m_uiDeltaQpRD         );
1626  printf("ASR:%d ", m_bUseASR             );
1627#if !PIC_CROPPING
1628  printf("PAD:%d ", m_bUsePAD             );
1629#endif
1630  printf("LComb:%d ", m_bUseLComb         );
1631  printf("LCMod:%d ", m_bLCMod         );
1632  printf("FEN:%d ", m_bUseFastEnc         );
1633  printf("ECU:%d ", m_bUseEarlyCU         );
1634#if FAST_DECISION_FOR_MRG_RD_COST
1635  printf("FDM:%d ", m_useFastDecisionForMerge );
1636#endif
1637  printf("CFM:%d ", m_bUseCbfFastMode         );
1638  printf("RQT:%d ", 1     );
1639  printf("LMC:%d ", m_bUseLMChroma        ); 
1640  printf("Slice: G=%d M=%d ", m_iSliceGranularity, m_iSliceMode);
1641  if (m_iSliceMode!=0)
1642  {
1643    printf("A=%d ", m_iSliceArgument);
1644  }
1645  printf("EntropySlice: M=%d ",m_iEntropySliceMode);
1646  if (m_iEntropySliceMode!=0)
1647  {
1648    printf("A=%d ", m_iEntropySliceArgument);
1649  }
1650  printf("CIP:%d ", m_bUseConstrainedIntraPred);
1651#if BURST_IPCM
1652  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
1653#else
1654  printf("PCM:%d ", ((1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
1655#endif
1656#if SAO_UNIT_INTERLEAVING
1657  printf("SAOInterleaving:%d ", (m_saoInterleavingFlag)?(1):(0));
1658#endif
1659#if LOSSLESS_CODING
1660  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
1661#endif 
1662  printf("WPP:%d ", (Int)m_bUseWeightPred);
1663  printf("WPB:%d ", m_uiBiPredIdc);
1664#if !REMOVE_TILE_DEPENDENCE
1665  printf("TileBoundaryIndependence:%d ", m_iTileBoundaryIndependenceIdr ); 
1666#endif
1667  printf("TileLocationInSliceHdr:%d ", m_iTileLocationInSliceHeaderFlag);
1668  printf("TileMarker:%d", m_iTileMarkerFlag);
1669  if (m_iTileMarkerFlag)
1670  {
1671    printf("[%d] ", m_iMaxTileMarkerEntryPoints);
1672  }
1673  else
1674  {
1675    printf(" ");
1676  }
1677  printf(" WaveFrontSynchro:%d WaveFrontFlush:%d WaveFrontSubstreams:%d",
1678          m_iWaveFrontSynchro, m_iWaveFrontFlush, m_iWaveFrontSubstreams);
1679  printf(" ScalingList:%d ", m_useScalingListId );
1680
1681  printf("TMVP:%d ", m_enableTMVP     );
1682
1683#if ADAPTIVE_QP_SELECTION
1684  printf("AQpS:%d", m_bUseAdaptQpSelect   );
1685#endif
1686
1687#if MULTIBITS_DATA_HIDING
1688  printf(" SignBitHidingFlag:%d SignBitHidingThreshold:%d", m_signHideFlag, m_signHidingThreshold);
1689#endif
1690  printf("\n");
1691  printf("TOOL CFG VIDEO  : ");
1692  printf("ALF:%d ", (m_abUseALF [0] ? 1 : 0) );
1693  printf("SAO:%d ", (m_abUseSAO [0] ? 1 : 0));
1694  printf("RDQ:%d ", (m_abUseRDOQ[0] ? 1 : 0) );
1695  printf("\n");
1696
1697  printf("TOOL CFG DEPTH  : ");
1698  printf("ALF:%d ", (m_abUseALF [1] ? 1 : 0));
1699  printf("SAO:%d ", (m_abUseSAO [1] ? 1 : 0));
1700  printf("RDQ:%d ", (m_abUseRDOQ[1] ? 1 : 0));
1701#if HHI_VSO
1702  printf("VSO:%d ", m_bUseVSO             );
1703#endif
1704#if LGE_WVSO_A0119
1705  printf("WVSO:%d ", m_bWVSO );
1706#endif
1707#if OL_DEPTHLIMIT_A0044
1708  printf("DPL:%d ", m_bDepthPartitionLimiting);
1709#endif
1710#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1711  printf("DMM:%d ", m_bUseDMM );
1712#endif
1713#if HHI_MPI
1714  printf("MVI:%d ", m_bUseMVI ? 1 : 0 );
1715#endif
1716#if LGE_WVSO_A0119
1717  printf("\nVSO : SAIT : SAD weight = %d : %d : %d ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
1718#endif
1719  printf("\n\n");
1720 
1721  fflush(stdout);
1722}
1723
1724Void TAppEncCfg::xPrintUsage()
1725{
1726  printf( "          <name> = ALF - adaptive loop filter\n");
1727  printf( "                   IBD - bit-depth increasement\n");
1728  printf( "                   GPB - generalized B instead of P in low-delay mode\n");
1729  printf( "                   HAD - hadamard ME for fractional-pel\n");
1730  printf( "                   SRD - SBAC based RD estimation\n");
1731  printf( "                   RDQ - RDOQ\n");
1732  printf( "                   LDC - low-delay mode\n");
1733  printf( "                   NRF - non-reference frame marking in last layer\n");
1734  printf( "                   BQP - hier-P style QP assignment in low-delay mode\n");
1735  printf( "                   PAD - automatic source padding of multiple of 16\n");
1736  printf( "                   ASR - adaptive motion search range\n");
1737  printf( "                   FEN - fast encoder setting\n"); 
1738  printf( "                   ECU - Early CU setting\n");
1739  printf( "                   CFM - Cbf fast mode setting\n");
1740  printf( "                   LMC - intra chroma prediction based on luma\n");
1741  printf( "\n" );
1742  printf( "  Example 1) TAppEncoder.exe -c test.cfg -q 32 -g 8 -f 9 -s 64 -h 4\n");
1743  printf("              -> QP 32, hierarchical-B GOP 8, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
1744  printf( "  Example 2) TAppEncoder.exe -c test.cfg -q 32 -g 4 -f 9 -s 64 -h 4 -1 LDC\n");
1745  printf("              -> QP 32, hierarchical-P GOP 4, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
1746}
1747
1748Bool confirmPara(Bool bflag, const char* message)
1749{
1750  if (!bflag)
1751    return false;
1752 
1753  printf("Error: %s\n",message);
1754  return true;
1755}
1756
1757/* helper function */
1758/* for handling "-1/-0 FOO" */
1759void translateOldStyleCmdline(const char* value, po::Options& opts, const std::string& arg)
1760{
1761  const char* argv[] = {arg.c_str(), value};
1762  /* replace some short names with their long name varients */
1763  if (arg == "LDC")
1764  {
1765    argv[0] = "LowDelayCoding";
1766  }
1767  else if (arg == "RDQ")
1768  {
1769    argv[0] = "RDOQ";
1770  }
1771  else if (arg == "HAD")
1772  {
1773    argv[0] = "HadamardME";
1774  }
1775  else if (arg == "SRD")
1776  {
1777    argv[0] = "SBACRD";
1778  }
1779  else if (arg == "IBD")
1780  {
1781    argv[0] = "BitIncrement";
1782  }
1783  /* issue a warning for change in FEN behaviour */
1784  if (arg == "FEN")
1785  {
1786    /* xxx todo */
1787  }
1788  po::storePair(opts, argv[0], argv[1]);
1789}
1790
1791void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg)
1792{
1793  if (arg == "IBD")
1794  {
1795    translateOldStyleCmdline("4", opts, arg);
1796    return;
1797  }
1798  translateOldStyleCmdline("1", opts, arg);
1799}
1800
1801void doOldStyleCmdlineOff(po::Options& opts, const std::string& arg)
1802{
1803  translateOldStyleCmdline("0", opts, arg);
1804}
1805
1806Void TAppEncCfg::xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName)
1807{
1808  size_t iInLength     = strlen(pchInputFileName);
1809  size_t iAppendLength = strlen(pchStringToAppend);
1810
1811  rpchOutputFileName = (Char*) malloc(iInLength+iAppendLength+1);
1812  Char* pCDot = strrchr(pchInputFileName,'.');
1813  pCDot = pCDot ? pCDot : pchInputFileName + iInLength;
1814  size_t iCharsToDot = pCDot - pchInputFileName ;
1815  size_t iCharsToEnd = iInLength - iCharsToDot;
1816  strncpy(rpchOutputFileName                            ,  pchInputFileName            , iCharsToDot  );
1817  strncpy(rpchOutputFileName+ iCharsToDot               ,  pchStringToAppend           , iAppendLength);
1818  strncpy(rpchOutputFileName+ iCharsToDot+iAppendLength ,  pchInputFileName+iCharsToDot, iCharsToEnd  );
1819  rpchOutputFileName[iInLength+iAppendLength] = '\0';
1820}
1821
1822//! \}
Note: See TracBrowser for help on using the repository browser.