source: 3DVCSoftware/branches/HTM-5.0-Nokia/source/App/TAppEncoder/TAppEncCfg.cpp @ 201

Last change on this file since 201 was 201, checked in by nokia, 11 years ago
  1. Recommended coding style changes
  2. Disabling Compile flags:

#define QC_IV_AS_LT_B0046 0
#define QC_TMVP_IDX_MOD_B0046 0
#define QC_REM_IDV_B0046 0
#define FIX_DEL_NULLPTR 0

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