source: 3DVCSoftware/branches/HTM-4.1-dev2-LG/source/App/TAppEncoder/TAppEncCfg.cpp @ 145

Last change on this file since 145 was 145, checked in by lg, 12 years ago

JCT3V-B0131 with macro LGE_WVSO_A0119 (LG)

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