source: 3DVCSoftware/branches/HTM-5.1-dev1-LG/source/App/TAppEncoder/TAppEncCfg.cpp @ 253

Last change on this file since 253 was 253, checked in by lg, 11 years ago

Integration of JCT3V-C0046

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