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

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

Initial integration of VSP into HTM 4.0.1. The version used for JCT3V-B0102 at Shanghai meeting.

  • VC9 project/solution files updated. Other Visual C++ project/solution files are not updated.
  • Linux make file updated.

TODO

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