source: 3DVCSoftware/branches/HTM-5.1-dev2-Sony/source/App/TAppEncoder/TAppEncCfg.cpp @ 262

Last change on this file since 262 was 262, checked in by sony, 11 years ago

JCT2-C0115 Inter-view vector scaling for TMVP & flag
The macro is INTER_VIEW_VECTOR_SCALING_C0115.

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