source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 193

Last change on this file since 193 was 193, checked in by mitsubishi-htm, 12 years ago

A second release, as planned

  • Migrate to HTM 4.1
  • Move VSP related switches to cfg file instead of #define in the source code
  • A few bug fixes
  • For VC project files, only VC9 file is updated

TODO

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