source: 3DVCSoftware/branches/HTM-6.2-dev1-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp @ 384

Last change on this file since 384 was 384, checked in by mediatek-htm, 11 years ago

D0156 source code

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