source: 3DVCSoftware/branches/HTM-6.2-dev2-Qualcomm/source/App/TAppEncoder/TAppEncCfg.cpp @ 373

Last change on this file since 373 was 373, checked in by zhang, 11 years ago

JCT3V-D0177: ARP

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