source: SHVCSoftware/branches/SHM-dev/source/App/TAppEncoder/TAppEncCfg.cpp @ 917

Last change on this file since 917 was 912, checked in by seregin, 10 years ago

Overlay SEI with macro Q0096_OVERLAY_SEI, patch was provided by Nikolce Stefanoski <stefanos@…>

  • Property svn:eol-style set to native
File size: 188.1 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-2014, 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
45static istream& operator>>(istream &, Level::Name &);
46static istream& operator>>(istream &, Level::Tier &);
47static istream& operator>>(istream &, Profile::Name &);
48
49#include "TAppCommon/program_options_lite.h"
50#include "TLibEncoder/TEncRateCtrl.h"
51#ifdef WIN32
52#define strdup _strdup
53#endif
54
55using namespace std;
56namespace po = df::program_options_lite;
57
58//! \ingroup TAppEncoder
59//! \{
60
61// ====================================================================================================================
62// Constructor / destructor / initialization / destroy
63// ====================================================================================================================
64
65#if SVC_EXTENSION
66TAppEncCfg::TAppEncCfg()
67: m_pBitstreamFile()
68#if AVC_BASE
69#if VPS_AVC_BL_FLAG_REMOVAL
70, m_nonHEVCBaseLayerFlag(0)
71#else
72, m_avcBaseLayerFlag(0)
73#endif
74#endif
75, m_maxTidRefPresentFlag(1)
76#if OUTPUT_LAYER_SETS_CONFIG
77, m_defaultTargetOutputLayerIdc (-1)
78, m_numOutputLayerSets          (-1)
79#endif
80, m_scalingListFile()
81, m_elRapSliceBEnabled(0)
82{
83  for(UInt layer=0; layer<MAX_LAYERS; layer++)
84  {
85    m_acLayerCfg[layer].setAppEncCfg(this);
86  }
87  memset( m_scalabilityMask, 0, sizeof(m_scalabilityMask) );
88}
89#else
90TAppEncCfg::TAppEncCfg()
91: m_pchInputFile()
92, m_pchBitstreamFile()
93, m_pchReconFile()
94, m_pchdQPFile()
95, m_scalingListFile()
96{
97  m_aidQP = NULL;
98  m_startOfCodedInterval = NULL;
99  m_codedPivotValue = NULL;
100  m_targetPivotValue = NULL;
101#if Q0074_COLOUR_REMAPPING_SEI
102  for( Int c=0 ; c<3 ; c++)
103  {
104    m_colourRemapSEIPreLutCodedValue[c]   = NULL;
105    m_colourRemapSEIPreLutTargetValue[c]  = NULL;
106    m_colourRemapSEIPostLutCodedValue[c]  = NULL;
107    m_colourRemapSEIPostLutTargetValue[c] = NULL;
108  }
109#endif
110}
111#endif
112
113TAppEncCfg::~TAppEncCfg()
114{
115#if SVC_EXTENSION
116  if( m_pBitstreamFile )
117  {
118    free(m_pBitstreamFile);
119    m_pBitstreamFile = NULL;
120  }
121#else 
122  if ( m_aidQP )
123  {
124    delete[] m_aidQP;
125  }
126  if ( m_startOfCodedInterval )
127  {
128    delete[] m_startOfCodedInterval;
129    m_startOfCodedInterval = NULL;
130  }
131   if ( m_codedPivotValue )
132  {
133    delete[] m_codedPivotValue;
134    m_codedPivotValue = NULL;
135  }
136  if ( m_targetPivotValue )
137  {
138    delete[] m_targetPivotValue;
139    m_targetPivotValue = NULL;
140  }
141  free(m_pchInputFile);
142  free(m_pchBitstreamFile);
143#endif
144#if !SVC_EXTENSION 
145  free(m_pchReconFile);
146  free(m_pchdQPFile);
147#if Q0074_COLOUR_REMAPPING_SEI
148  for( Int c=0 ; c<3 ; c++)
149  {
150    if ( m_colourRemapSEIPreLutCodedValue[c] )
151    {
152      delete[] m_colourRemapSEIPreLutCodedValue[c];
153    }
154    if ( m_colourRemapSEIPreLutTargetValue[c] )
155    {
156      delete[] m_colourRemapSEIPreLutTargetValue[c];
157    }
158    if ( m_colourRemapSEIPostLutCodedValue[c] )
159    {
160      delete[] m_colourRemapSEIPostLutCodedValue[c];
161    }
162    if ( m_colourRemapSEIPostLutTargetValue[c] )
163    {
164      delete[] m_colourRemapSEIPostLutTargetValue[c];
165    }
166  }
167#endif
168#endif
169  free(m_scalingListFile);
170}
171
172Void TAppEncCfg::create()
173{
174}
175
176Void TAppEncCfg::destroy()
177{
178#if VPS_EXTN_DIRECT_REF_LAYERS
179  for(Int layer = 0; layer < MAX_LAYERS; layer++)
180  {
181    if( m_acLayerCfg[layer].m_numSamplePredRefLayers > 0 )
182    {
183      delete [] m_acLayerCfg[layer].m_samplePredRefLayerIds;
184      m_acLayerCfg[layer].m_samplePredRefLayerIds = NULL;
185    }
186    if( m_acLayerCfg[layer].m_numMotionPredRefLayers > 0 )
187    {
188      delete [] m_acLayerCfg[layer].m_motionPredRefLayerIds;
189      m_acLayerCfg[layer].m_motionPredRefLayerIds = NULL;
190    }
191    if( m_acLayerCfg[layer].m_numActiveRefLayers > 0 )
192    {
193      delete [] m_acLayerCfg[layer].m_predLayerIds;
194      m_acLayerCfg[layer].m_predLayerIds = NULL;
195    }
196  }
197#endif
198}
199
200std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry)     //input
201{
202  in>>entry.m_sliceType;
203  in>>entry.m_POC;
204  in>>entry.m_QPOffset;
205  in>>entry.m_QPFactor;
206  in>>entry.m_tcOffsetDiv2;
207  in>>entry.m_betaOffsetDiv2;
208  in>>entry.m_temporalId;
209  in>>entry.m_numRefPicsActive;
210  in>>entry.m_numRefPics;
211  for ( Int i = 0; i < entry.m_numRefPics; i++ )
212  {
213    in>>entry.m_referencePics[i];
214  }
215  in>>entry.m_interRPSPrediction;
216#if AUTO_INTER_RPS
217  if (entry.m_interRPSPrediction==1)
218  {
219    in>>entry.m_deltaRPS;
220    in>>entry.m_numRefIdc;
221    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
222    {
223      in>>entry.m_refIdc[i];
224    }
225  }
226  else if (entry.m_interRPSPrediction==2)
227  {
228    in>>entry.m_deltaRPS;
229  }
230#else
231  if (entry.m_interRPSPrediction)
232  {
233    in>>entry.m_deltaRPS;
234    in>>entry.m_numRefIdc;
235    for ( Int i = 0; i < entry.m_numRefIdc; i++ )
236    {
237      in>>entry.m_refIdc[i];
238    }
239  }
240#endif
241  return in;
242}
243
244#if AUXILIARY_PICTURES
245static inline ChromaFormat numberToChromaFormat(const Int val)
246{
247  switch (val)
248  {
249    case 400: return CHROMA_400; break;
250    case 420: return CHROMA_420; break;
251    case 422: return CHROMA_422; break;
252    case 444: return CHROMA_444; break;
253    default:  return NUM_CHROMA_FORMAT;
254  }
255}
256#endif
257
258#if SVC_EXTENSION
259void TAppEncCfg::getDirFilename(string& filename, string& dir, const string path)
260{
261  size_t pos = path.find_last_of("\\");
262  if(pos != std::string::npos)
263  {
264    filename.assign(path.begin() + pos + 1, path.end());
265    dir.assign(path.begin(), path.begin() + pos + 1);
266  }
267  else
268  {
269    pos = path.find_last_of("/");
270    if(pos != std::string::npos)
271    {
272      filename.assign(path.begin() + pos + 1, path.end());
273      dir.assign(path.begin(), path.begin() + pos + 1);
274    }
275    else
276    {
277      filename = path;
278      dir.assign("");
279    }
280  }
281}
282#endif
283
284static const struct MapStrToProfile {
285  const Char* str;
286  Profile::Name value;
287} strToProfile[] = {
288  {"none", Profile::NONE},
289  {"main", Profile::MAIN},
290  {"main10", Profile::MAIN10},
291  {"main-still-picture", Profile::MAINSTILLPICTURE},
292};
293
294static const struct MapStrToTier {
295  const Char* str;
296  Level::Tier value;
297} strToTier[] = {
298  {"main", Level::MAIN},
299  {"high", Level::HIGH},
300};
301
302static const struct MapStrToLevel {
303  const Char* str;
304  Level::Name value;
305} strToLevel[] = {
306  {"none",Level::NONE},
307  {"1",   Level::LEVEL1},
308  {"2",   Level::LEVEL2},
309  {"2.1", Level::LEVEL2_1},
310  {"3",   Level::LEVEL3},
311  {"3.1", Level::LEVEL3_1},
312  {"4",   Level::LEVEL4},
313  {"4.1", Level::LEVEL4_1},
314  {"5",   Level::LEVEL5},
315  {"5.1", Level::LEVEL5_1},
316  {"5.2", Level::LEVEL5_2},
317  {"6",   Level::LEVEL6},
318  {"6.1", Level::LEVEL6_1},
319  {"6.2", Level::LEVEL6_2},
320};
321
322template<typename T, typename P>
323static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
324{
325  string str;
326  in >> str;
327
328  for (Int i = 0; i < mapLen; i++)
329  {
330    if (str == map[i].str)
331    {
332      val = map[i].value;
333      goto found;
334    }
335  }
336  /* not found */
337  in.setstate(ios::failbit);
338found:
339  return in;
340}
341
342static istream& operator>>(istream &in, Profile::Name &profile)
343{
344  return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
345}
346
347static istream& operator>>(istream &in, Level::Tier &tier)
348{
349  return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
350}
351
352static istream& operator>>(istream &in, Level::Name &level)
353{
354  return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
355}
356
357// ====================================================================================================================
358// Public member functions
359// ====================================================================================================================
360
361/** \param  argc        number of arguments
362    \param  argv        array of arguments
363    \retval             true when success
364 */
365Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
366{
367  Bool do_help = false;
368 
369#if SVC_EXTENSION
370  string  cfg_LayerCfgFile   [MAX_LAYERS];
371  string  cfg_BitstreamFile;
372  string* cfg_InputFile      [MAX_LAYERS];
373  string* cfg_ReconFile      [MAX_LAYERS];
374  Double* cfg_fQP            [MAX_LAYERS];
375#if REPN_FORMAT_IN_VPS
376  Int*    cfg_repFormatIdx  [MAX_LAYERS];
377#endif
378  Int*    cfg_SourceWidth   [MAX_LAYERS]; 
379  Int*    cfg_SourceHeight  [MAX_LAYERS];
380  Int*    cfg_FrameRate     [MAX_LAYERS];
381  Int*    cfg_IntraPeriod   [MAX_LAYERS];
382  Int*    cfg_conformanceMode  [MAX_LAYERS];
383#if LAYER_CTB
384  // coding unit (CU) definition
385  UInt*      cfg_uiMaxCUWidth[MAX_LAYERS];                                   ///< max. CU width in pixel
386  UInt*      cfg_uiMaxCUHeight[MAX_LAYERS];                                  ///< max. CU height in pixel
387  UInt*      cfg_uiMaxCUDepth[MAX_LAYERS];                                   ///< max. CU depth
388 
389  // transfom unit (TU) definition
390  UInt*      cfg_uiQuadtreeTULog2MaxSize[MAX_LAYERS];
391  UInt*      cfg_uiQuadtreeTULog2MinSize[MAX_LAYERS];
392 
393  UInt*      cfg_uiQuadtreeTUMaxDepthInter[MAX_LAYERS];
394  UInt*      cfg_uiQuadtreeTUMaxDepthIntra[MAX_LAYERS];
395#endif
396#if AUXILIARY_PICTURES
397  Int      cfg_tmpChromaFormatIDC  [MAX_LAYERS];
398  Int      cfg_tmpInputChromaFormat[MAX_LAYERS];
399  Int*     cfg_auxId               [MAX_LAYERS];
400#endif
401#if VPS_EXTN_DIRECT_REF_LAYERS
402  Int*    cfg_numSamplePredRefLayers  [MAX_LAYERS];
403  string  cfg_samplePredRefLayerIds   [MAX_LAYERS];
404  string* cfg_samplePredRefLayerIdsPtr[MAX_LAYERS];
405  Int*    cfg_numMotionPredRefLayers  [MAX_LAYERS];
406  string  cfg_motionPredRefLayerIds   [MAX_LAYERS];
407  string* cfg_motionPredRefLayerIdsPtr[MAX_LAYERS];
408  Int*    cfg_numActiveRefLayers [MAX_LAYERS];
409  string  cfg_predLayerIds       [MAX_LAYERS];
410  string* cfg_predLayerIdsPtr    [MAX_LAYERS];
411#endif
412#if O0098_SCALED_REF_LAYER_ID
413  string    cfg_scaledRefLayerId [MAX_LAYERS];
414#endif
415  string    cfg_scaledRefLayerLeftOffset [MAX_LAYERS];
416  string    cfg_scaledRefLayerTopOffset [MAX_LAYERS];
417  string    cfg_scaledRefLayerRightOffset [MAX_LAYERS];
418  string    cfg_scaledRefLayerBottomOffset [MAX_LAYERS];
419  Int*      cfg_numScaledRefLayerOffsets[MAX_LAYERS];
420#if REF_REGION_OFFSET
421  string    cfg_scaledRefLayerOffsetPresentFlag [MAX_LAYERS];
422  string    cfg_refRegionOffsetPresentFlag      [MAX_LAYERS];
423  string    cfg_refRegionLeftOffset   [MAX_LAYERS];
424  string    cfg_refRegionTopOffset    [MAX_LAYERS];
425  string    cfg_refRegionRightOffset  [MAX_LAYERS];
426  string    cfg_refRegionBottomOffset [MAX_LAYERS];
427#endif
428#if R0209_GENERIC_PHASE
429  string    cfg_resamplePhaseSetPresentFlag [MAX_LAYERS];
430  string    cfg_phaseHorLuma   [MAX_LAYERS];
431  string    cfg_phaseVerLuma   [MAX_LAYERS];
432  string    cfg_phaseHorChroma [MAX_LAYERS];
433  string    cfg_phaseVerChroma [MAX_LAYERS];
434#else
435#if P0312_VERT_PHASE_ADJ
436  string    cfg_vertPhasePositionEnableFlag[MAX_LAYERS];
437#endif
438#endif
439
440#if O0098_SCALED_REF_LAYER_ID
441  string*    cfg_scaledRefLayerIdPtr           [MAX_LAYERS];
442#endif
443  string*    cfg_scaledRefLayerLeftOffsetPtr   [MAX_LAYERS];
444  string*    cfg_scaledRefLayerTopOffsetPtr    [MAX_LAYERS];
445  string*    cfg_scaledRefLayerRightOffsetPtr  [MAX_LAYERS];
446  string*    cfg_scaledRefLayerBottomOffsetPtr [MAX_LAYERS];
447#if REF_REGION_OFFSET
448  string*    cfg_scaledRefLayerOffsetPresentFlagPtr [MAX_LAYERS];
449  string*    cfg_refRegionOffsetPresentFlagPtr      [MAX_LAYERS];
450  string*    cfg_refRegionLeftOffsetPtr   [MAX_LAYERS];
451  string*    cfg_refRegionTopOffsetPtr    [MAX_LAYERS];
452  string*    cfg_refRegionRightOffsetPtr  [MAX_LAYERS];
453  string*    cfg_refRegionBottomOffsetPtr [MAX_LAYERS];
454#endif
455#if R0209_GENERIC_PHASE
456  string*    cfg_resamplePhaseSetPresentFlagPtr [MAX_LAYERS];
457  string*    cfg_phaseHorLumaPtr   [MAX_LAYERS];
458  string*    cfg_phaseVerLumaPtr   [MAX_LAYERS];
459  string*    cfg_phaseHorChromaPtr [MAX_LAYERS];
460  string*    cfg_phaseVerChromaPtr [MAX_LAYERS];
461#endif
462#if P0312_VERT_PHASE_ADJ
463  string*    cfg_vertPhasePositionEnableFlagPtr[MAX_LAYERS];
464#endif
465
466#if RC_SHVC_HARMONIZATION
467  Bool*   cfg_RCEnableRateControl  [MAX_LAYERS];
468  Int*    cfg_RCTargetBitRate      [MAX_LAYERS];
469  Bool*   cfg_RCKeepHierarchicalBit[MAX_LAYERS];
470  Bool*   cfg_RCLCULevelRC         [MAX_LAYERS];
471  Bool*   cfg_RCUseLCUSeparateModel[MAX_LAYERS];
472  Int*    cfg_RCInitialQP          [MAX_LAYERS];
473  Bool*   cfg_RCForceIntraQP       [MAX_LAYERS];
474#endif
475#if O0194_DIFFERENT_BITDEPTH_EL_BL
476  Int*    cfg_InputBitDepthY    [MAX_LAYERS];
477  Int*    cfg_InternalBitDepthY [MAX_LAYERS];
478  Int*    cfg_InputBitDepthC    [MAX_LAYERS];
479  Int*    cfg_InternalBitDepthC [MAX_LAYERS];
480  Int*    cfg_OutputBitDepthY   [MAX_LAYERS];
481  Int*    cfg_OutputBitDepthC   [MAX_LAYERS];
482#endif
483  Int*    cfg_maxTidIlRefPicsPlus1[MAX_LAYERS]; 
484#if Q0074_COLOUR_REMAPPING_SEI
485  string* cfg_colourRemapSEIFile[MAX_LAYERS];
486#endif
487  Int*    cfg_waveFrontSynchro[MAX_LAYERS];
488
489  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
490  {
491    cfg_InputFile[layer]    = &m_acLayerCfg[layer].m_cInputFile;
492    cfg_ReconFile[layer]    = &m_acLayerCfg[layer].m_cReconFile;
493    cfg_fQP[layer]          = &m_acLayerCfg[layer].m_fQP;
494#if Q0074_COLOUR_REMAPPING_SEI
495    cfg_colourRemapSEIFile[layer] = &m_acLayerCfg[layer].m_colourRemapSEIFile;
496#endif
497#if REPN_FORMAT_IN_VPS
498    cfg_repFormatIdx[layer] = &m_acLayerCfg[layer].m_repFormatIdx;
499#endif
500    cfg_SourceWidth[layer]  = &m_acLayerCfg[layer].m_iSourceWidth;
501    cfg_SourceHeight[layer] = &m_acLayerCfg[layer].m_iSourceHeight;
502    cfg_FrameRate[layer]    = &m_acLayerCfg[layer].m_iFrameRate; 
503    cfg_IntraPeriod[layer]  = &m_acLayerCfg[layer].m_iIntraPeriod; 
504    cfg_conformanceMode[layer] = &m_acLayerCfg[layer].m_conformanceMode;
505#if LAYER_CTB
506    // coding unit (CU) definition
507    cfg_uiMaxCUWidth[layer]  = &m_acLayerCfg[layer].m_uiMaxCUWidth;
508    cfg_uiMaxCUHeight[layer] = &m_acLayerCfg[layer].m_uiMaxCUHeight;
509    cfg_uiMaxCUDepth[layer]  = &m_acLayerCfg[layer].m_uiMaxCUDepth;
510
511    // transfom unit (TU) definition.
512    cfg_uiQuadtreeTULog2MaxSize[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTULog2MaxSize;
513    cfg_uiQuadtreeTULog2MinSize[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTULog2MinSize;
514
515    cfg_uiQuadtreeTUMaxDepthInter[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthInter;
516    cfg_uiQuadtreeTUMaxDepthIntra[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthIntra;
517#endif
518#if VPS_EXTN_DIRECT_REF_LAYERS
519    cfg_numSamplePredRefLayers  [layer] = &m_acLayerCfg[layer].m_numSamplePredRefLayers;
520    cfg_samplePredRefLayerIdsPtr[layer] = &cfg_samplePredRefLayerIds[layer];
521    cfg_numMotionPredRefLayers  [layer] = &m_acLayerCfg[layer].m_numMotionPredRefLayers;
522    cfg_motionPredRefLayerIdsPtr[layer] = &cfg_motionPredRefLayerIds[layer];
523    cfg_numActiveRefLayers  [layer] = &m_acLayerCfg[layer].m_numActiveRefLayers;
524    cfg_predLayerIdsPtr     [layer]  = &cfg_predLayerIds[layer];
525#endif
526    cfg_numScaledRefLayerOffsets [layer] = &m_acLayerCfg[layer].m_numScaledRefLayerOffsets;
527    cfg_waveFrontSynchro[layer]  = &m_acLayerCfg[layer].m_waveFrontSynchro;
528    for(Int i = 0; i < MAX_LAYERS; i++)
529    {
530#if O0098_SCALED_REF_LAYER_ID
531      cfg_scaledRefLayerIdPtr          [layer] = &cfg_scaledRefLayerId[layer];
532#endif
533      cfg_scaledRefLayerLeftOffsetPtr  [layer] = &cfg_scaledRefLayerLeftOffset[layer];
534      cfg_scaledRefLayerTopOffsetPtr   [layer] = &cfg_scaledRefLayerTopOffset[layer];
535      cfg_scaledRefLayerRightOffsetPtr [layer] = &cfg_scaledRefLayerRightOffset[layer];
536      cfg_scaledRefLayerBottomOffsetPtr[layer] = &cfg_scaledRefLayerBottomOffset[layer];
537#if P0312_VERT_PHASE_ADJ
538      cfg_vertPhasePositionEnableFlagPtr[layer] = &cfg_vertPhasePositionEnableFlag[layer];
539#endif
540#if REF_REGION_OFFSET
541      cfg_scaledRefLayerOffsetPresentFlagPtr [layer] = &cfg_scaledRefLayerOffsetPresentFlag [layer];
542      cfg_refRegionOffsetPresentFlagPtr      [layer] = &cfg_refRegionOffsetPresentFlag      [layer];
543      cfg_refRegionLeftOffsetPtr  [layer] = &cfg_refRegionLeftOffset  [layer];
544      cfg_refRegionTopOffsetPtr   [layer] = &cfg_refRegionTopOffset   [layer];
545      cfg_refRegionRightOffsetPtr [layer] = &cfg_refRegionRightOffset [layer];
546      cfg_refRegionBottomOffsetPtr[layer] = &cfg_refRegionBottomOffset[layer];
547#endif
548#if R0209_GENERIC_PHASE
549      cfg_resamplePhaseSetPresentFlagPtr [layer] = &cfg_resamplePhaseSetPresentFlag [layer];
550      cfg_phaseHorLumaPtr   [layer] = &cfg_phaseHorLuma   [layer];
551      cfg_phaseVerLumaPtr   [layer] = &cfg_phaseVerLuma   [layer];
552      cfg_phaseHorChromaPtr [layer] = &cfg_phaseHorChroma [layer];
553      cfg_phaseVerChromaPtr [layer] = &cfg_phaseVerChroma [layer];
554#endif
555    }
556#if RC_SHVC_HARMONIZATION
557    cfg_RCEnableRateControl[layer]   = &m_acLayerCfg[layer].m_RCEnableRateControl;
558    cfg_RCTargetBitRate[layer]       = &m_acLayerCfg[layer].m_RCTargetBitrate;
559    cfg_RCKeepHierarchicalBit[layer] = &m_acLayerCfg[layer].m_RCKeepHierarchicalBit;
560    cfg_RCLCULevelRC[layer]          = &m_acLayerCfg[layer].m_RCLCULevelRC;
561    cfg_RCUseLCUSeparateModel[layer] = &m_acLayerCfg[layer].m_RCUseLCUSeparateModel;
562    cfg_RCInitialQP[layer]           = &m_acLayerCfg[layer].m_RCInitialQP;
563    cfg_RCForceIntraQP[layer]        = &m_acLayerCfg[layer].m_RCForceIntraQP;
564#endif
565#if O0194_DIFFERENT_BITDEPTH_EL_BL
566  cfg_InputBitDepthY   [layer] = &m_acLayerCfg[layer].m_inputBitDepthY;
567  cfg_InternalBitDepthY[layer] = &m_acLayerCfg[layer].m_internalBitDepthY;
568  cfg_InputBitDepthC   [layer] = &m_acLayerCfg[layer].m_inputBitDepthC;
569  cfg_InternalBitDepthC[layer] = &m_acLayerCfg[layer].m_internalBitDepthC;
570  cfg_OutputBitDepthY  [layer] = &m_acLayerCfg[layer].m_outputBitDepthY;
571  cfg_OutputBitDepthC  [layer] = &m_acLayerCfg[layer].m_outputBitDepthC;
572#endif
573  cfg_maxTidIlRefPicsPlus1[layer] = &m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1; 
574#if AUXILIARY_PICTURES
575    cfg_auxId[layer]                = &m_acLayerCfg[layer].m_auxId; 
576#endif
577  }
578#if Q0078_ADD_LAYER_SETS
579  Int* cfg_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1];
580  string cfg_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1];
581  string* cfg_layerSetLayerIdListPtr[MAX_VPS_LAYER_SETS_PLUS1];
582  Int* cfg_numHighestLayerIdx[MAX_VPS_LAYER_SETS_PLUS1];
583  string cfg_highestLayerIdx[MAX_VPS_LAYER_SETS_PLUS1];
584  string* cfg_highestLayerIdxPtr[MAX_VPS_LAYER_SETS_PLUS1];
585  for (UInt i = 0; i < MAX_VPS_LAYER_SETS_PLUS1; i++)
586  {
587    cfg_numLayerInIdList[i] = &m_numLayerInIdList[i];
588    cfg_layerSetLayerIdListPtr[i] = &cfg_layerSetLayerIdList[i];
589    cfg_highestLayerIdxPtr[i] = &cfg_highestLayerIdx[i];
590    cfg_numHighestLayerIdx[i] = &m_numHighestLayerIdx[i];
591  }
592#endif
593#if OUTPUT_LAYER_SETS_CONFIG
594  string* cfg_numLayersInOutputLayerSet = new string;
595  string* cfg_listOfOutputLayers     = new string[MAX_VPS_OUTPUT_LAYER_SETS_PLUS1];
596  string* cfg_outputLayerSetIdx      = new string;
597#endif
598#if AVC_BASE
599  string  cfg_BLInputFile;
600#endif
601#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
602  string  cfg_tileSets;
603#endif
604#else //SVC_EXTENSION
605  string cfg_InputFile;
606  string cfg_BitstreamFile;
607  string cfg_ReconFile;
608  string cfg_dQPFile;
609#if Q0074_COLOUR_REMAPPING_SEI
610  string cfg_colourRemapSEIFile;
611#endif
612#endif //SVC_EXTENSION
613  string cfgColumnWidth;
614  string cfgRowHeight;
615  string cfg_ScalingListFile;
616  string cfg_startOfCodedInterval;
617  string cfg_codedPivotValue;
618  string cfg_targetPivotValue;
619#if P0050_KNEE_FUNCTION_SEI
620  string cfg_kneeSEIInputKneePointValue;
621  string cfg_kneeSEIOutputKneePointValue;
622#endif
623#if Q0096_OVERLAY_SEI
624  const Int CFG_MAX_OVERLAYS = 3;
625  UInt   cfg_overlaySEIIdx[CFG_MAX_OVERLAYS]; 
626  Bool   cfg_overlaySEILanguagePresentFlag[CFG_MAX_OVERLAYS]; 
627  UInt   cfg_overlaySEIContentLayerId[CFG_MAX_OVERLAYS];
628  Bool   cfg_overlaySEILabelPresentFlag[CFG_MAX_OVERLAYS];
629  UInt   cfg_overlaySEILabelLayerId[CFG_MAX_OVERLAYS];
630  Bool   cfg_overlaySEIAlphaPresentFlag[CFG_MAX_OVERLAYS];
631  UInt   cfg_overlaySEIAlphaLayerId[CFG_MAX_OVERLAYS];
632  UInt   cfg_overlaySEINumElementsMinus1[CFG_MAX_OVERLAYS];
633  string cfg_overlaySEIElementLabelRanges[CFG_MAX_OVERLAYS]; 
634  string cfg_overlaySEILanguage[CFG_MAX_OVERLAYS]; 
635  string cfg_overlaySEIName[CFG_MAX_OVERLAYS]; 
636  string cfg_overlaySEIElementNames[CFG_MAX_OVERLAYS]; 
637#endif
638
639  po::Options opts;
640  opts.addOptions()
641  ("help", do_help, false, "this help text")
642  ("c", po::parseConfigFile, "configuration file name")
643 
644  // File, I/O and source parameters
645#if SVC_EXTENSION
646  ("InputFile%d,-i%d",        cfg_InputFile,  string(""), MAX_LAYERS, "original YUV input file name for layer %d")
647  ("ReconFile%d,-o%d",        cfg_ReconFile,  string(""), MAX_LAYERS, "reconstruction YUV input file name for layer %d")
648  ("LayerConfig%d,-lc%d",     cfg_LayerCfgFile, string(""), MAX_LAYERS, "layer %d configuration file name")
649  ("SourceWidth%d,-wdt%d",    cfg_SourceWidth, 0, MAX_LAYERS, "Source picture width for layer %d")
650  ("SourceHeight%d,-hgt%d",   cfg_SourceHeight, 0, MAX_LAYERS, "Source picture height for layer %d")
651  ("FrameRate%d,-fr%d",       cfg_FrameRate,  0, MAX_LAYERS, "Frame rate for layer %d")
652  ("LambdaModifier%d,-LM%d",  m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
653#if O0215_PHASE_ALIGNMENT
654  ("PhaseAlignment",          m_phaseAlignFlag, false, "indicate the sample location alignment between layers (0: zero position aligned, 1: central position aligned)")
655#endif
656#if REPN_FORMAT_IN_VPS
657  ("RepFormatIdx%d",          cfg_repFormatIdx, -1, MAX_LAYERS, "Index to the representation format structure used from the VPS")
658#endif
659#if VPS_EXTN_DIRECT_REF_LAYERS
660  ("NumSamplePredRefLayers%d",cfg_numSamplePredRefLayers, -1, MAX_LAYERS, "Number of sample prediction reference layers")
661  ("SamplePredRefLayerIds%d", cfg_samplePredRefLayerIdsPtr, string(""), MAX_LAYERS, "sample pred reference layer IDs")
662  ("NumMotionPredRefLayers%d",cfg_numMotionPredRefLayers, -1, MAX_LAYERS, "Number of motion prediction reference layers")
663  ("MotionPredRefLayerIds%d", cfg_motionPredRefLayerIdsPtr, string(""), MAX_LAYERS, "motion pred reference layer IDs")
664  ("NumActiveRefLayers%d",    cfg_numActiveRefLayers, -1, MAX_LAYERS, "Number of active reference layers")
665  ("PredLayerIds%d",          cfg_predLayerIdsPtr, string(""), MAX_LAYERS, "inter-layer prediction layer IDs")
666#endif
667  ("NumLayers",               m_numLayers, 1, "Number of layers to code")
668#if Q0078_ADD_LAYER_SETS
669#if OUTPUT_LAYER_SETS_CONFIG
670  ("NumLayerSets",            m_numLayerSets, 1, "Number of layer sets")
671#else
672  ("NumLayerSets",            m_numLayerSets, 0, "Number of layer sets")
673#endif
674  ("NumLayerInIdList%d",      cfg_numLayerInIdList, 0, MAX_VPS_LAYER_ID_PLUS1, "Number of layers in the set")
675  ("LayerSetLayerIdList%d",   cfg_layerSetLayerIdListPtr, string(""), MAX_VPS_LAYER_ID_PLUS1, "Layer IDs for the set")
676  ("NumAddLayerSets",         m_numAddLayerSets, 0, "Number of additional layer sets")
677  ("NumHighestLayerIdx%d",    cfg_numHighestLayerIdx, 0, MAX_VPS_LAYER_ID_PLUS1, "Number of highest layer idx")
678  ("HighestLayerIdx%d",       cfg_highestLayerIdxPtr, string(""), MAX_VPS_LAYER_ID_PLUS1, "Highest layer idx for an additional layer set")
679#endif
680#if OUTPUT_LAYER_SETS_CONFIG
681  ("DefaultTargetOutputLayerIdc",    m_defaultTargetOutputLayerIdc, 1, "Default target output layers. 0: All layers are output layer, 1: Only highest layer is output layer, 2 or 3: No default output layers")
682  ("NumOutputLayerSets",            m_numOutputLayerSets, 1, "Number of output layer sets excluding the 0-th output layer set")
683  ("NumLayersInOutputLayerSet",   cfg_numLayersInOutputLayerSet, string(""), 1 , "List containing number of output layers in the output layer sets")
684  ("ListOfOutputLayers%d",          cfg_listOfOutputLayers, string(""), MAX_VPS_LAYER_ID_PLUS1, "Layer IDs for the set, in terms of layer ID in the output layer set Range: [0..NumLayersInOutputLayerSet-1]")
685  ("OutputLayerSetIdx",            cfg_outputLayerSetIdx, string(""), 1, "Corresponding layer set index, only for non-default output layer sets")
686#endif
687#if AUXILIARY_PICTURES
688  ("InputChromaFormat%d",     cfg_tmpInputChromaFormat,  420, MAX_LAYERS, "InputChromaFormatIDC for layer %d")
689  ("ChromaFormatIDC%d,-cf",   cfg_tmpChromaFormatIDC,    420, MAX_LAYERS, "ChromaFormatIDC (400|420|422|444 or set 0 (default) for same as InputChromaFormat) for layer %d")
690  ("AuxId%d",                 cfg_auxId,                 0,   MAX_LAYERS, "Auxilary picture ID for layer %d (0: Not aux pic, 1: Alpha plane, 2: Depth picture, 3: Cb enh, 4: Cr enh")
691#endif
692  ("ConformanceMode%d",       cfg_conformanceMode,0, MAX_LAYERS, "Window conformance mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
693  ("ScalabilityMask1",        m_scalabilityMask[1], 0, "scalability_mask[1] (multiview)")
694  ("ScalabilityMask2",        m_scalabilityMask[2], 1, "scalability_mask[2] (scalable)" )
695#if AUXILIARY_PICTURES
696  ("ScalabilityMask3",        m_scalabilityMask[3], 0, "scalability_mask[3] (auxiliary pictures)" )
697#endif
698  ("BitstreamFile,b",         cfg_BitstreamFile, string(""), "Bitstream output file name")
699#if !O0194_DIFFERENT_BITDEPTH_EL_BL
700  ("InputBitDepth",           m_inputBitDepthY,    8, "Bit-depth of input file")
701  ("OutputBitDepth",          m_outputBitDepthY,   0, "Bit-depth of output file (default:InternalBitDepth)")
702  ("InternalBitDepth",        m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
703                                                       "If different to InputBitDepth, source data will be converted")
704  ("InputBitDepthC",          m_inputBitDepthC,    0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
705  ("OutputBitDepthC",         m_outputBitDepthC,   0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
706  ("InternalBitDepthC",       m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
707#endif
708  ("NumScaledRefLayerOffsets%d",    cfg_numScaledRefLayerOffsets,     0, MAX_LAYERS,  "Number of scaled offset layer sets ")
709#if O0098_SCALED_REF_LAYER_ID
710  ("ScaledRefLayerId%d",           cfg_scaledRefLayerIdPtr,          string(""), MAX_LAYERS, "Layer ID of scaled base layer picture")
711#endif
712  ("ScaledRefLayerLeftOffset%d",   cfg_scaledRefLayerLeftOffsetPtr,  string(""), MAX_LAYERS, "Horizontal offset of top-left luma sample of scaled base layer picture with respect to"
713                                                                 " top-left luma sample of the EL picture, in units of two luma samples")
714  ("ScaledRefLayerTopOffset%d",    cfg_scaledRefLayerTopOffsetPtr,   string(""), MAX_LAYERS,   "Vertical offset of top-left luma sample of scaled base layer picture with respect to"
715                                                                 " top-left luma sample of the EL picture, in units of two luma samples")
716  ("ScaledRefLayerRightOffset%d",  cfg_scaledRefLayerRightOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of bottom-right luma sample of scaled base layer picture with respect to"
717                                                                 " bottom-right luma sample of the EL picture, in units of two luma samples")
718  ("ScaledRefLayerBottomOffset%d", cfg_scaledRefLayerBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of scaled base layer picture with respect to"
719  " bottom-right luma sample of the EL picture, in units of two luma samples")
720#if REF_REGION_OFFSET
721  ("ScaledRefLayerOffsetPresentFlag%d",      cfg_scaledRefLayerOffsetPresentFlagPtr,     string(""), MAX_LAYERS, "presense flag of scaled reference layer offsets")
722  ("RefRegionOffsetPresentFlag%d",           cfg_refRegionOffsetPresentFlagPtr,          string(""), MAX_LAYERS, "presense flag of reference region offsets")
723  ("RefRegionLeftOffset%d",   cfg_refRegionLeftOffsetPtr,  string(""), MAX_LAYERS, "Horizontal offset of top-left luma sample of ref region with respect to"
724                                                                 " top-left luma sample of the BL picture, in units of two luma samples")
725  ("RefRegionTopOffset%d",    cfg_refRegionTopOffsetPtr,   string(""), MAX_LAYERS,   "Vertical offset of top-left luma sample of ref region with respect to"
726                                                                 " top-left luma sample of the BL picture, in units of two luma samples")
727  ("RefRegionRightOffset%d",  cfg_refRegionRightOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of bottom-right luma sample of ref region with respect to"
728                                                                 " bottom-right luma sample of the BL picture, in units of two luma samples")
729  ("RefRegionBottomOffset%d", cfg_refRegionBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of ref region with respect to"
730                                                                 " bottom-right luma sample of the BL picture, in units of two luma samples")
731#endif
732#if R0209_GENERIC_PHASE
733  ("ResamplePhaseSetPresentFlag%d",  cfg_resamplePhaseSetPresentFlagPtr, string(""), MAX_LAYERS, "presense flag of resample phase set")
734  ("PhaseHorLuma%d",   cfg_phaseHorLumaPtr,   string(""), MAX_LAYERS, "luma shift in the horizontal direction used in resampling proces")
735  ("PhaseVerLuma%d",   cfg_phaseVerLumaPtr,   string(""), MAX_LAYERS, "luma shift in the vertical   direction used in resampling proces")
736  ("PhaseHorChroma%d", cfg_phaseHorChromaPtr, string(""), MAX_LAYERS, "chroma shift in the horizontal direction used in resampling proces")
737  ("PhaseVerChroma%d", cfg_phaseVerChromaPtr, string(""), MAX_LAYERS, "chroma shift in the vertical   direction used in resampling proces")
738#endif
739#if P0312_VERT_PHASE_ADJ
740  ("VertPhasePositionEnableFlag%d", cfg_vertPhasePositionEnableFlagPtr,string(""), MAX_LAYERS, "VertPhasePositionEnableFlag for layer %d")
741#endif
742#if Q0074_COLOUR_REMAPPING_SEI
743  ("SEIColourRemappingInfoFile%d", cfg_colourRemapSEIFile, string(""), MAX_LAYERS, "Colour Remapping Information SEI parameters file name for layer %d")
744#endif
745#if O0194_DIFFERENT_BITDEPTH_EL_BL
746  ("InputBitDepth%d",       cfg_InputBitDepthY,    8, MAX_LAYERS, "Bit-depth of input file for layer %d")
747  ("InternalBitDepth%d",    cfg_InternalBitDepthY, 0, MAX_LAYERS, "Bit-depth the codec operates at. (default:InputBitDepth) for layer %d ")
748//                                                       "If different to InputBitDepth, source data will be converted")
749  ("InputBitDepthC%d",      cfg_InputBitDepthC,    0, MAX_LAYERS, "As per InputBitDepth but for chroma component. (default:InputBitDepth) for layer %d")
750  ("InternalBitDepthC%d",   cfg_InternalBitDepthC, 0, MAX_LAYERS, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth) for layer %d")
751  ("OutputBitDepth%d",      cfg_OutputBitDepthY,   0, MAX_LAYERS, "Bit-depth of output file (default:InternalBitDepth)")
752  ("OutputBitDepthC%d",     cfg_OutputBitDepthC,   0, MAX_LAYERS, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
753#endif
754  ("MaxTidRefPresentFlag", m_maxTidRefPresentFlag, true, "max_tid_ref_present_flag (0: not present, 1: present(default)) " )
755  ("MaxTidIlRefPicsPlus1%d", cfg_maxTidIlRefPicsPlus1, 1, MAX_LAYERS, "allowed maximum temporal_id for inter-layer prediction")
756#if O0223_PICTURE_TYPES_ALIGN_FLAG
757  ("CrossLayerPictureTypeAlignFlag", m_crossLayerPictureTypeAlignFlag, true, "align picture type across layers" ) 
758#endif
759  ("CrossLayerIrapAlignFlag", m_crossLayerIrapAlignFlag, true, "align IRAP across layers" ) 
760#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
761  ("CrossLayerAlignedIdrOnlyFlag", m_crossLayerAlignedIdrOnlyFlag, true, "only idr for IRAP across layers" ) 
762#endif
763#if O0194_WEIGHTED_PREDICTION_CGS
764  ("InterLayerWeightedPred", m_useInterLayerWeightedPred, false, "enable IL WP parameters estimation at encoder" ) 
765#endif
766#if AVC_BASE
767#if VPS_AVC_BL_FLAG_REMOVAL
768  ("NonHEVCBase,-nonhevc",            m_nonHEVCBaseLayerFlag,     0, "BL is available but not internal")
769#else
770  ("AvcBase,-avc",            m_avcBaseLayerFlag,     0, "avc_base_layer_flag")
771#endif
772  ("InputBLFile,-ibl",        cfg_BLInputFile,     string(""), "Base layer rec YUV input file name")
773#endif
774  ("EnableElRapB,-use-rap-b",  m_elRapSliceBEnabled, 0, "Set ILP over base-layer I picture to B picture (default is P picture)")
775#else //SVC_EXTENSION
776  ("InputFile,i",           cfg_InputFile,     string(""), "Original YUV input file name")
777  ("BitstreamFile,b",       cfg_BitstreamFile, string(""), "Bitstream output file name")
778  ("ReconFile,o",           cfg_ReconFile,     string(""), "Reconstructed YUV output file name")
779  ("SourceWidth,-wdt",      m_iSourceWidth,        0, "Source picture width")
780  ("SourceHeight,-hgt",     m_iSourceHeight,       0, "Source picture height")
781  ("InputBitDepth",         m_inputBitDepthY,    8, "Bit-depth of input file")
782  ("OutputBitDepth",        m_outputBitDepthY,   0, "Bit-depth of output file (default:InternalBitDepth)")
783  ("InternalBitDepth",      m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
784                                                       "If different to InputBitDepth, source data will be converted")
785  ("InputBitDepthC",        m_inputBitDepthC,    0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
786  ("OutputBitDepthC",       m_outputBitDepthC,   0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
787  ("InternalBitDepthC",     m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
788#if AUXILIARY_PICTURES
789  ("InputChromaFormat",     tmpInputChromaFormat,                       420, "InputChromaFormatIDC")
790  ("ChromaFormatIDC,-cf",   tmpChromaFormat,                             0, "ChromaFormatIDC (400|420|422|444 or set 0 (default) for same as InputChromaFormat)")
791#endif
792  ("ConformanceMode",       m_conformanceWindowMode,  0, "Deprecated alias of ConformanceWindowMode")
793  ("ConformanceWindowMode", m_conformanceWindowMode,  0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
794  ("HorizontalPadding,-pdx",m_aiPad[0],               0, "Horizontal source padding for conformance window mode 2")
795  ("VerticalPadding,-pdy",  m_aiPad[1],               0, "Vertical source padding for conformance window mode 2")
796  ("ConfLeft",              m_confWinLeft,            0, "Deprecated alias of ConfWinLeft")
797  ("ConfRight",             m_confWinRight,           0, "Deprecated alias of ConfWinRight")
798  ("ConfTop",               m_confWinTop,             0, "Deprecated alias of ConfWinTop")
799  ("ConfBottom",            m_confWinBottom,          0, "Deprecated alias of ConfWinBottom")
800  ("ConfWinLeft",           m_confWinLeft,            0, "Left offset for window conformance mode 3")
801  ("ConfWinRight",          m_confWinRight,           0, "Right offset for window conformance mode 3")
802  ("ConfWinTop",            m_confWinTop,             0, "Top offset for window conformance mode 3")
803  ("ConfWinBottom",         m_confWinBottom,          0, "Bottom offset for window conformance mode 3")
804  ("FrameRate,-fr",         m_iFrameRate,          0, "Frame rate")
805#if Q0074_COLOUR_REMAPPING_SEI
806  ("SEIColourRemappingInfoFile", cfg_colourRemapSEIFile, string(""), "Colour Remapping Information SEI parameters file name")
807#endif
808#endif //SVC_EXTENSION
809  ("FrameSkip,-fs",         m_FrameSkip,          0u, "Number of frames to skip at start of input YUV")
810  ("FramesToBeEncoded,f",   m_framesToBeEncoded,   0, "Number of frames to be encoded (default=all)")
811
812  //Field coding parameters
813  ("FieldCoding", m_isField, false, "Signals if it's a field based coding")
814  ("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not")
815 
816  // Profile and level
817  ("Profile", m_profile,   Profile::NONE, "Profile to be used when encoding (Incomplete)")
818  ("Level",   m_level,     Level::NONE,   "Level limit to be used, eg 5.1 (Incomplete)")
819  ("Tier",    m_levelTier, Level::MAIN,   "Tier to use for interpretation of --Level")
820
821  ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
822  ("InterlacedSource",  m_interlacedSourceFlag,  false, "Indicate that source is interlaced")
823  ("NonPackedSource",   m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
824  ("FrameOnly",         m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
825
826#if LAYER_CTB
827  // Unit definition parameters
828  ("MaxCUWidth%d",              cfg_uiMaxCUWidth,             64u, MAX_LAYERS, "Maximum CU width")
829  ("MaxCUHeight%d",             cfg_uiMaxCUHeight,            64u, MAX_LAYERS, "Maximum CU height")
830  // todo: remove defaults from MaxCUSize
831  ("MaxCUSize%d,s%d",           cfg_uiMaxCUWidth,             64u, MAX_LAYERS, "Maximum CU size")
832  ("MaxCUSize%d,s%d",           cfg_uiMaxCUHeight,            64u, MAX_LAYERS, "Maximum CU size")
833  ("MaxPartitionDepth%d,h%d",   cfg_uiMaxCUDepth,              4u, MAX_LAYERS, "CU depth")
834 
835  ("QuadtreeTULog2MaxSize%d",   cfg_uiQuadtreeTULog2MaxSize,   6u, MAX_LAYERS, "Maximum TU size in logarithm base 2")
836  ("QuadtreeTULog2MinSize%d",   cfg_uiQuadtreeTULog2MinSize,   2u, MAX_LAYERS, "Minimum TU size in logarithm base 2")
837 
838  ("QuadtreeTUMaxDepthIntra%d", cfg_uiQuadtreeTUMaxDepthIntra, 1u, MAX_LAYERS, "Depth of TU tree for intra CUs")
839  ("QuadtreeTUMaxDepthInter%d", cfg_uiQuadtreeTUMaxDepthInter, 2u, MAX_LAYERS, "Depth of TU tree for inter CUs")
840
841
842  // set the same CU realted settings across all the layers if config file parameters are not layer specific
843  ("MaxCUWidth",              cfg_uiMaxCUWidth,             64u, MAX_LAYERS, "Maximum CU width")
844  ("MaxCUHeight",             cfg_uiMaxCUHeight,            64u, MAX_LAYERS, "Maximum CU height")
845  // todo: remove defaults from MaxCUSize
846  ("MaxCUSize,s",             cfg_uiMaxCUWidth,             64u, MAX_LAYERS, "Maximum CU size")
847  ("MaxCUSize,s",             cfg_uiMaxCUHeight,            64u, MAX_LAYERS, "Maximum CU size")
848  ("MaxPartitionDepth,h",     cfg_uiMaxCUDepth,              4u, MAX_LAYERS, "CU depth")
849 
850  ("QuadtreeTULog2MaxSize",   cfg_uiQuadtreeTULog2MaxSize,   6u, MAX_LAYERS, "Maximum TU size in logarithm base 2")
851  ("QuadtreeTULog2MinSize",   cfg_uiQuadtreeTULog2MinSize,   2u, MAX_LAYERS, "Minimum TU size in logarithm base 2")
852 
853  ("QuadtreeTUMaxDepthIntra", cfg_uiQuadtreeTUMaxDepthIntra, 1u, MAX_LAYERS, "Depth of TU tree for intra CUs")
854  ("QuadtreeTUMaxDepthInter", cfg_uiQuadtreeTUMaxDepthInter, 2u, MAX_LAYERS, "Depth of TU tree for inter CUs")
855#else
856  // Unit definition parameters
857  ("MaxCUWidth",              m_uiMaxCUWidth,             64u)
858  ("MaxCUHeight",             m_uiMaxCUHeight,            64u)
859  // todo: remove defaults from MaxCUSize
860  ("MaxCUSize,s",             m_uiMaxCUWidth,             64u, "Maximum CU size")
861  ("MaxCUSize,s",             m_uiMaxCUHeight,            64u, "Maximum CU size")
862  ("MaxPartitionDepth,h",     m_uiMaxCUDepth,              4u, "CU depth")
863 
864  ("QuadtreeTULog2MaxSize",   m_uiQuadtreeTULog2MaxSize,   6u, "Maximum TU size in logarithm base 2")
865  ("QuadtreeTULog2MinSize",   m_uiQuadtreeTULog2MinSize,   2u, "Minimum TU size in logarithm base 2")
866 
867  ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
868  ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
869#endif
870 
871  // Coding structure paramters
872#if SVC_EXTENSION
873  ("IntraPeriod%d,-ip%d",  cfg_IntraPeriod, -1, MAX_LAYERS, "intra period in frames for layer %d, (-1: only first frame)")
874#else
875  ("IntraPeriod,-ip",         m_iIntraPeriod,              -1, "Intra period in frames, (-1: only first frame)")
876#endif
877#if ALLOW_RECOVERY_POINT_AS_RAP
878  ("DecodingRefreshType,-dr", m_iDecodingRefreshType,       0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)")
879#else
880  ("DecodingRefreshType,-dr", m_iDecodingRefreshType,       0, "Intra refresh type (0:none 1:CRA 2:IDR)")
881#endif
882  ("GOPSize,g",               m_iGOPSize,                   1, "GOP size of temporal structure")
883  // motion options
884  ("FastSearch",              m_iFastSearch,                1, "0:Full search  1:Diamond  2:PMVFAST")
885  ("SearchRange,-sr",         m_iSearchRange,              96, "Motion search range")
886  ("BipredSearchRange",       m_bipredSearchRange,          4, "Motion search range for bipred refinement")
887  ("HadamardME",              m_bUseHADME,               true, "Hadamard ME for fractional-pel")
888  ("ASR",                     m_bUseASR,                false, "Adaptive motion search range")
889
890#if SVC_EXTENSION
891  ("LambdaModifier%d,-LM%d",  m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
892#else
893  // Mode decision parameters
894  ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
895  ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
896  ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
897  ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
898  ("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
899  ("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
900  ("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
901#endif
902
903  /* Quantization parameters */
904#if SVC_EXTENSION
905  ("QP%d,-q%d",     cfg_fQP,  30.0, MAX_LAYERS, "Qp value for layer %d, if value is float, QP is switched once during encoding")
906#else
907  ("QP,q",          m_fQP,             30.0, "Qp value, if value is float, QP is switched once during encoding")
908#endif
909  ("DeltaQpRD,-dqr",m_uiDeltaQpRD,       0u, "max dQp offset for slice")
910  ("MaxDeltaQP,d",  m_iMaxDeltaQP,        0, "max dQp offset for block")
911  ("MaxCuDQPDepth,-dqd",  m_iMaxCuDQPDepth,        0, "max depth for a minimum CuDQP")
912
913  ("CbQpOffset,-cbqpofs",  m_cbQpOffset,        0, "Chroma Cb QP Offset")
914  ("CrQpOffset,-crqpofs",  m_crQpOffset,        0, "Chroma Cr QP Offset")
915
916#if ADAPTIVE_QP_SELECTION
917  ("AdaptiveQpSelection,-aqps",   m_bUseAdaptQpSelect,           false, "AdaptiveQpSelection")
918#endif
919
920  ("AdaptiveQP,-aq",                m_bUseAdaptiveQP,           false, "QP adaptation based on a psycho-visual model")
921  ("MaxQPAdaptationRange,-aqr",     m_iQPAdaptationRange,           6, "QP adaptation range")
922#if !SVC_EXTENSION
923  ("dQPFile,m",                     cfg_dQPFile,           string(""), "dQP file name")
924#endif
925  ("RDOQ",                          m_useRDOQ,                  true )
926  ("RDOQTS",                        m_useRDOQTS,                true )
927  ("RDpenalty",                     m_rdPenalty,                0,  "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled  1:RD-penalty  2:maximum RD-penalty")
928 
929  // Deblocking filter parameters
930  ("LoopFilterDisable",              m_bLoopFilterDisable,             false )
931  ("LoopFilterOffsetInPPS",          m_loopFilterOffsetInPPS,          false )
932  ("LoopFilterBetaOffset_div2",      m_loopFilterBetaOffsetDiv2,           0 )
933  ("LoopFilterTcOffset_div2",        m_loopFilterTcOffsetDiv2,             0 )
934  ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
935  ("DeblockingFilterMetric",         m_DeblockingFilterMetric,         false )
936
937  // Coding tools
938  ("AMP",                      m_enableAMP,                 true,  "Enable asymmetric motion partitions")
939  ("TransformSkip",            m_useTransformSkip,          false, "Intra transform skipping")
940  ("TransformSkipFast",        m_useTransformSkipFast,      false, "Fast intra transform skipping")
941  ("SAO",                      m_bUseSAO,                   true,  "Enable Sample Adaptive Offset")
942  ("MaxNumOffsetsPerPic",      m_maxNumOffsetsPerPic,       2048,  "Max number of SAO offset per picture (Default: 2048)")   
943  ("SAOLcuBoundary",           m_saoLcuBoundary,            false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
944  ("SliceMode",                m_sliceMode,                0,     "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
945  ("SliceArgument",            m_sliceArgument,            0,     "Depending on SliceMode being:"
946                                                                   "\t1: max number of CTUs per slice"
947                                                                   "\t2: max number of bytes per slice"
948                                                                   "\t3: max number of tiles per slice")
949  ("SliceSegmentMode",         m_sliceSegmentMode,       0,     "0: Disable all slice segment limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
950  ("SliceSegmentArgument",     m_sliceSegmentArgument,   0,     "Depending on SliceSegmentMode being:"
951                                                                   "\t1: max number of CTUs per slice segment"
952                                                                   "\t2: max number of bytes per slice segment"
953                                                                   "\t3: max number of tiles per slice segment")
954  ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
955
956  ("ConstrainedIntraPred",     m_bUseConstrainedIntraPred,  false, "Constrained Intra Prediction")
957
958  ("PCMEnabledFlag",           m_usePCM,                    false)
959  ("PCMLog2MaxSize",           m_pcmLog2MaxSize,            5u)
960  ("PCMLog2MinSize",           m_uiPCMLog2MinSize,          3u)
961  ("PCMInputBitDepthFlag",     m_bPCMInputBitDepthFlag,     true)
962  ("PCMFilterDisableFlag",     m_bPCMFilterDisableFlag,    false)
963
964  ("WeightedPredP,-wpP",          m_useWeightedPred,               false,      "Use weighted prediction in P slices")
965  ("WeightedPredB,-wpB",          m_useWeightedBiPred,             false,      "Use weighted (bidirectional) prediction in B slices")
966  ("Log2ParallelMergeLevel",      m_log2ParallelMergeLevel,     2u,          "Parallel merge estimation region")
967
968  //deprecated copies of renamed tile parameters
969  ("UniformSpacingIdc",           m_tileUniformSpacingFlag,        false,      "deprecated alias of TileUniformSpacing")
970  ("ColumnWidthArray",            cfgColumnWidth,                  string(""), "deprecated alias of TileColumnWidthArray")
971  ("RowHeightArray",              cfgRowHeight,                    string(""), "deprecated alias of TileRowHeightArray")
972
973  ("TileUniformSpacing",          m_tileUniformSpacingFlag,        false,      "Indicates that tile columns and rows are distributed uniformly")
974  ("NumTileColumnsMinus1",        m_numTileColumnsMinus1,          0,          "Number of tile columns in a picture minus 1")
975  ("NumTileRowsMinus1",           m_numTileRowsMinus1,             0,          "Number of rows in a picture minus 1")
976  ("TileColumnWidthArray",        cfgColumnWidth,                  string(""), "Array containing tile column width values in units of LCU")
977  ("TileRowHeightArray",          cfgRowHeight,                    string(""), "Array containing tile row height values in units of LCU")
978  ("LFCrossTileBoundaryFlag",      m_bLFCrossTileBoundaryFlag,             true,          "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
979#if SVC_EXTENSION
980  ("WaveFrontSynchro%d",          cfg_waveFrontSynchro,             0,  MAX_LAYERS,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
981#else
982  ("WaveFrontSynchro",            m_iWaveFrontSynchro,             0,          "0: no synchro; 1 synchro with TR; 2 TRR etc")
983#endif
984  ("ScalingList",                 m_useScalingListId,              0,          "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
985  ("ScalingListFile",             cfg_ScalingListFile,             string(""), "Scaling list file name")
986  ("SignHideFlag,-SBH",                m_signHideFlag, 1)
987  ("MaxNumMergeCand",             m_maxNumMergeCand,             5u,         "Maximum number of merge candidates")
988
989  /* Misc. */
990  ("SEIDecodedPictureHash",       m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
991                                                                    "\t3: checksum\n"
992                                                                    "\t2: CRC\n"
993                                                                    "\t1: use MD5\n"
994                                                                    "\t0: disable")
995  ("SEIpictureDigest",            m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
996  ("TMVPMode", m_TMVPModeId, 1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only")
997  ("FEN", m_bUseFastEnc, false, "fast encoder setting")
998  ("ECU", m_bUseEarlyCU, false, "Early CU setting") 
999  ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost") 
1000  ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
1001  ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
1002#if FAST_INTRA_SHVC
1003  ("FIS", m_useFastIntraScalable, false, "Fast Intra Decision for Scalable HEVC")
1004#endif
1005#if RC_SHVC_HARMONIZATION
1006  ("RateControl%d", cfg_RCEnableRateControl, false, MAX_LAYERS, "Rate control: enable rate control for layer %d")
1007  ("TargetBitrate%d", cfg_RCTargetBitRate, 0, MAX_LAYERS, "Rate control: target bitrate for layer %d")
1008  ("KeepHierarchicalBit%d", cfg_RCKeepHierarchicalBit, false, MAX_LAYERS, "Rate control: keep hierarchical bit allocation for layer %d")
1009  ("LCULevelRateControl%d", cfg_RCLCULevelRC, true, MAX_LAYERS, "Rate control: LCU level RC")
1010  ("RCLCUSeparateModel%d", cfg_RCUseLCUSeparateModel, true, MAX_LAYERS, "Rate control: Use LCU level separate R-lambda model")
1011  ("InitialQP%d", cfg_RCInitialQP, 0, MAX_LAYERS, "Rate control: initial QP")
1012  ("RCForceIntraQP%d", cfg_RCForceIntraQP, false, MAX_LAYERS, "Rate control: force intra QP to be equal to initial QP")
1013#else
1014  ( "RateControl",         m_RCEnableRateControl,   false, "Rate control: enable rate control" )
1015  ( "TargetBitrate",       m_RCTargetBitrate,           0, "Rate control: target bitrate" )
1016  ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit,     0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
1017  ( "LCULevelRateControl", m_RCLCULevelRC,           true, "Rate control: true: LCU level RC; false: picture level RC" )
1018  ( "RCLCUSeparateModel",  m_RCUseLCUSeparateModel,  true, "Rate control: use LCU level separate R-lambda model" )
1019  ( "InitialQP",           m_RCInitialQP,               0, "Rate control: initial QP" )
1020  ( "RCForceIntraQP",      m_RCForceIntraQP,        false, "Rate control: force intra QP to be equal to initial QP" )
1021#endif
1022
1023  ("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
1024  ("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled")
1025  ("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
1026  ("StrongIntraSmoothing,-sis",      m_useStrongIntraSmoothing,           true, "Enable strong intra smoothing for 32x32 blocks")
1027  ("SEIActiveParameterSets",         m_activeParameterSetsSEIEnabled,          0, "Enable generation of active parameter sets SEI messages")
1028  ("VuiParametersPresent,-vui",      m_vuiParametersPresentFlag,           false, "Enable generation of vui_parameters()")
1029  ("AspectRatioInfoPresent",         m_aspectRatioInfoPresentFlag,         false, "Signals whether aspect_ratio_idc is present")
1030  ("AspectRatioIdc",                 m_aspectRatioIdc,                         0, "aspect_ratio_idc")
1031  ("SarWidth",                       m_sarWidth,                               0, "horizontal size of the sample aspect ratio")
1032  ("SarHeight",                      m_sarHeight,                              0, "vertical size of the sample aspect ratio")
1033  ("OverscanInfoPresent",            m_overscanInfoPresentFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
1034  ("OverscanAppropriate",            m_overscanAppropriateFlag,            false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
1035  ("VideoSignalTypePresent",         m_videoSignalTypePresentFlag,         false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
1036  ("VideoFormat",                    m_videoFormat,                            5, "Indicates representation of pictures")
1037  ("VideoFullRange",                 m_videoFullRangeFlag,                 false, "Indicates the black level and range of luma and chroma signals")
1038  ("ColourDescriptionPresent",       m_colourDescriptionPresentFlag,       false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
1039  ("ColourPrimaries",                m_colourPrimaries,                        2, "Indicates chromaticity coordinates of the source primaries")
1040  ("TransferCharacteristics",        m_transferCharacteristics,                2, "Indicates the opto-electronic transfer characteristics of the source")
1041  ("MatrixCoefficients",             m_matrixCoefficients,                     2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
1042  ("ChromaLocInfoPresent",           m_chromaLocInfoPresentFlag,           false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
1043  ("ChromaSampleLocTypeTopField",    m_chromaSampleLocTypeTopField,            0, "Specifies the location of chroma samples for top field")
1044  ("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField,         0, "Specifies the location of chroma samples for bottom field")
1045  ("NeutralChromaIndication",        m_neutralChromaIndicationFlag,        false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
1046  ("DefaultDisplayWindowFlag",       m_defaultDisplayWindowFlag,           false, "Indicates the presence of the Default Window parameters")
1047  ("DefDispWinLeftOffset",           m_defDispWinLeftOffset,                   0, "Specifies the left offset of the default display window from the conformance window")
1048  ("DefDispWinRightOffset",          m_defDispWinRightOffset,                  0, "Specifies the right offset of the default display window from the conformance window")
1049  ("DefDispWinTopOffset",            m_defDispWinTopOffset,                    0, "Specifies the top offset of the default display window from the conformance window")
1050  ("DefDispWinBottomOffset",         m_defDispWinBottomOffset,                 0, "Specifies the bottom offset of the default display window from the conformance window")
1051  ("FrameFieldInfoPresentFlag",      m_frameFieldInfoPresentFlag,               false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
1052  ("PocProportionalToTimingFlag",   m_pocProportionalToTimingFlag,         false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
1053  ("NumTicksPocDiffOneMinus1",      m_numTicksPocDiffOneMinus1,                0, "Number of ticks minus 1 that for a POC difference of one")
1054  ("BitstreamRestriction",           m_bitstreamRestrictionFlag,           false, "Signals whether bitstream restriction parameters are present")
1055  ("TilesFixedStructure",            m_tilesFixedStructureFlag,            false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
1056  ("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
1057  ("MaxBytesPerPicDenom",            m_maxBytesPerPicDenom,                    2, "Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture")
1058  ("MaxBitsPerMinCuDenom",           m_maxBitsPerMinCuDenom,                   1, "Indicates an upper bound for the number of bits of coding_unit() data")
1059  ("Log2MaxMvLengthHorizontal",      m_log2MaxMvLengthHorizontal,             15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
1060  ("Log2MaxMvLengthVertical",        m_log2MaxMvLengthVertical,               15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
1061  ("SEIRecoveryPoint",               m_recoveryPointSEIEnabled,                0, "Control generation of recovery point SEI messages")
1062  ("SEIBufferingPeriod",             m_bufferingPeriodSEIEnabled,              0, "Control generation of buffering period SEI messages")
1063  ("SEIPictureTiming",               m_pictureTimingSEIEnabled,                0, "Control generation of picture timing SEI messages")
1064  ("SEIToneMappingInfo",                       m_toneMappingInfoSEIEnabled,    false, "Control generation of Tone Mapping SEI messages")
1065  ("SEIToneMapId",                             m_toneMapId,                        0, "Specifies Id of Tone Mapping SEI message for a given session")
1066  ("SEIToneMapCancelFlag",                     m_toneMapCancelFlag,            false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
1067  ("SEIToneMapPersistenceFlag",                m_toneMapPersistenceFlag,        true, "Specifies the persistence of the Tone Mapping SEI message")
1068  ("SEIToneMapCodedDataBitDepth",              m_toneMapCodedDataBitDepth,         8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
1069  ("SEIToneMapTargetBitDepth",                 m_toneMapTargetBitDepth,            8, "Specifies Output BitDepth of Tome mapping function")
1070  ("SEIToneMapModelId",                        m_toneMapModelId,                   0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
1071                                                                                      "\t0:  linear mapping with clipping\n"
1072                                                                                      "\t1:  sigmoidal mapping\n"
1073                                                                                      "\t2:  user-defined table mapping\n"
1074                                                                                      "\t3:  piece-wise linear mapping\n"
1075                                                                                      "\t4:  luminance dynamic range information ")
1076  ("SEIToneMapMinValue",                              m_toneMapMinValue,                          0, "Specifies the minimum value in mode 0")
1077  ("SEIToneMapMaxValue",                              m_toneMapMaxValue,                       1023, "Specifies the maxmum value in mode 0")
1078  ("SEIToneMapSigmoidMidpoint",                       m_sigmoidMidpoint,                        512, "Specifies the centre point in mode 1")
1079  ("SEIToneMapSigmoidWidth",                          m_sigmoidWidth,                           960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
1080  ("SEIToneMapStartOfCodedInterval",                  cfg_startOfCodedInterval,          string(""), "Array of user-defined mapping table")
1081  ("SEIToneMapNumPivots",                             m_numPivots,                                0, "Specifies the number of pivot points in mode 3")
1082  ("SEIToneMapCodedPivotValue",                       cfg_codedPivotValue,               string(""), "Array of pivot point")
1083  ("SEIToneMapTargetPivotValue",                      cfg_targetPivotValue,              string(""), "Array of pivot point")
1084  ("SEIToneMapCameraIsoSpeedIdc",                     m_cameraIsoSpeedIdc,                        0, "Indicates the camera ISO speed for daylight illumination")
1085  ("SEIToneMapCameraIsoSpeedValue",                   m_cameraIsoSpeedValue,                    400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
1086  ("SEIToneMapExposureIndexIdc",                      m_exposureIndexIdc,                         0, "Indicates the exposure index setting of the camera")
1087  ("SEIToneMapExposureIndexValue",                    m_exposureIndexValue,                     400, "Specifies the exposure index setting of the cameran of Extended_ISO")
1088  ("SEIToneMapExposureCompensationValueSignFlag",     m_exposureCompensationValueSignFlag,        0, "Specifies the sign of ExposureCompensationValue")
1089  ("SEIToneMapExposureCompensationValueNumerator",    m_exposureCompensationValueNumerator,       0, "Specifies the numerator of ExposureCompensationValue")
1090  ("SEIToneMapExposureCompensationValueDenomIdc",     m_exposureCompensationValueDenomIdc,        2, "Specifies the denominator of ExposureCompensationValue")
1091  ("SEIToneMapRefScreenLuminanceWhite",               m_refScreenLuminanceWhite,                350, "Specifies reference screen brightness setting in units of candela per square metre")
1092  ("SEIToneMapExtendedRangeWhiteLevel",               m_extendedRangeWhiteLevel,                800, "Indicates the luminance dynamic range")
1093  ("SEIToneMapNominalBlackLevelLumaCodeValue",        m_nominalBlackLevelLumaCodeValue,          16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
1094  ("SEIToneMapNominalWhiteLevelLumaCodeValue",        m_nominalWhiteLevelLumaCodeValue,         235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
1095  ("SEIToneMapExtendedWhiteLevelLumaCodeValue",       m_extendedWhiteLevelLumaCodeValue,        300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
1096  ("SEIFramePacking",                m_framePackingSEIEnabled,                 0, "Control generation of frame packing SEI messages")
1097  ("SEIFramePackingType",            m_framePackingSEIType,                    0, "Define frame packing arrangement\n"
1098                                                                                  "\t0: checkerboard - pixels alternatively represent either frames\n"
1099                                                                                  "\t1: column alternation - frames are interlaced by column\n"
1100                                                                                  "\t2: row alternation - frames are interlaced by row\n"
1101                                                                                  "\t3: side by side - frames are displayed horizontally\n"
1102                                                                                  "\t4: top bottom - frames are displayed vertically\n"
1103                                                                                  "\t5: frame alternation - one frame is alternated with the other")
1104  ("SEIFramePackingId",              m_framePackingSEIId,                      0, "Id of frame packing SEI message for a given session")
1105  ("SEIFramePackingQuincunx",        m_framePackingSEIQuincunx,                0, "Indicate the presence of a Quincunx type video frame")
1106  ("SEIFramePackingInterpretation",  m_framePackingSEIInterpretation,          0, "Indicate the interpretation of the frame pair\n"
1107                                                                                  "\t0: unspecified\n"
1108                                                                                  "\t1: stereo pair, frame0 represents left view\n"
1109                                                                                  "\t2: stereo pair, frame0 represents right view")
1110  ("SEIDisplayOrientation",          m_displayOrientationSEIAngle,             0, "Control generation of display orientation SEI messages\n"
1111                                                              "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
1112                                                              "\t0: disable")
1113  ("SEITemporalLevel0Index",         m_temporalLevel0IndexSEIEnabled,          0, "Control generation of temporal level 0 index SEI messages")
1114  ("SEIGradualDecodingRefreshInfo",  m_gradualDecodingRefreshInfoEnabled,      0, "Control generation of gradual decoding refresh information SEI message")
1115  ("SEIDecodingUnitInfo",             m_decodingUnitInfoSEIEnabled,                       0, "Control generation of decoding unit information SEI message.")
1116#if LAYERS_NOT_PRESENT_SEI
1117  ("SEILayersNotPresent",            m_layersNotPresentSEIEnabled,             0, "Control generation of layers not present SEI message")
1118#endif
1119  ("SEISOPDescription",              m_SOPDescriptionSEIEnabled,              0, "Control generation of SOP description SEI messages")
1120  ("SEIScalableNesting",             m_scalableNestingSEIEnabled,              0, "Control generation of scalable nesting SEI messages")
1121#if P0050_KNEE_FUNCTION_SEI
1122  ("SEIKneeFunctionInfo",                 m_kneeSEIEnabled,               false, "Control generation of Knee function SEI messages")
1123  ("SEIKneeFunctionId",                   m_kneeSEIId,                        0, "Specifies Id of Knee function SEI message for a given session")
1124  ("SEIKneeFunctionCancelFlag",           m_kneeSEICancelFlag,            false, "Indicates that Knee function SEI message cancels the persistance or follows")
1125  ("SEIKneeFunctionPersistenceFlag",      m_kneeSEIPersistenceFlag,        true, "Specifies the persistence of the Knee function SEI message")
1126  ("SEIKneeFunctionMappingFlag",          m_kneeSEIMappingFlag,           false, "Specifies the mapping mode of the Knee function SEI message")
1127  ("SEIKneeFunctionInputDrange",          m_kneeSEIInputDrange,            1000, "Specifies the peak luminance level for the input picture of Knee function SEI messages")
1128  ("SEIKneeFunctionInputDispLuminance",   m_kneeSEIInputDispLuminance,      100, "Specifies the expected display brightness for the input picture of Knee function SEI messages")
1129  ("SEIKneeFunctionOutputDrange",         m_kneeSEIOutputDrange,           4000, "Specifies the peak luminance level for the output picture of Knee function SEI messages")
1130  ("SEIKneeFunctionOutputDispLuminance",  m_kneeSEIOutputDispLuminance,     800, "Specifies the expected display brightness for the output picture of Knee function SEI messages")
1131  ("SEIKneeFunctionNumKneePointsMinus1",  m_kneeSEINumKneePointsMinus1,       2, "Specifies the number of knee points - 1")
1132  ("SEIKneeFunctionInputKneePointValue",  cfg_kneeSEIInputKneePointValue,     string("600 800 900"), "Array of input knee point")
1133  ("SEIKneeFunctionOutputKneePointValue", cfg_kneeSEIOutputKneePointValue,    string("100 250 450"), "Array of output knee point")
1134#endif
1135#if Q0096_OVERLAY_SEI
1136  ("SEIOverlayInfo",                          m_overlaySEIEnabled,                      false, "Control generation of Selectable Overlays SEI messages")
1137  ("SEIOverlayCancelFlag",                    m_overlayInfoCancelFlag,                   true, "Indicates that Selectable Overlay SEI message cancels the persistance or follows (default: 1)")
1138  ("SEIOverlayContentAuxIdMinus128",          m_overlayContentAuxIdMinus128,          UInt(0), "Indicates the AuxId value of auxiliary pictures containing overlay content - 128")
1139  ("SEIOverlayLabelAuxIdMinus128",            m_overlayLabelAuxIdMinus128,            UInt(1), "Indicates the AuxId value of auxiliary pictures containing label content - 128")
1140  ("SEIOverlayAlphaAuxIdMinus128",            m_overlayAlphaAuxIdMinus128,            UInt(2), "Indicates the AuxId value of auxiliary pictures containing alpha content - 128")
1141  ("SEIOverlayElementLabelValueLengthMinus8", m_overlayElementLabelValueLengthMinus8, UInt(0), "Indicates the number of bits used for coding min and max label values - 8")
1142  ("SEIOverlayNumOverlaysMinus1",             m_numOverlaysMinus1,                    UInt(0), "Specifies the number of overlays described by this SEI message - 1")
1143  ("SEIOverlayIdx0",                          cfg_overlaySEIIdx[0],                   UInt(0), "Indicates the index of overlay 0")
1144  ("SEIOverlayIdx1",                          cfg_overlaySEIIdx[1],                   UInt(1), "Indicates the index of overlay 1")
1145  ("SEIOverlayIdx2",                          cfg_overlaySEIIdx[2],                   UInt(2), "Indicates the index of overlay 2")
1146  ("SEIOverlayLanguagePresentFlag0",          cfg_overlaySEILanguagePresentFlag[0],     false, "Indicates if the language for overlay 0 is specified")
1147  ("SEIOverlayLanguagePresentFlag1",          cfg_overlaySEILanguagePresentFlag[1],     false, "Indicates if the language for overlay 1 is specified")
1148  ("SEIOverlayLanguagePresentFlag2",          cfg_overlaySEILanguagePresentFlag[2],     false, "Indicates if the language for overlay 2 is specified")
1149  ("SEIOverlayContentLayerId0",               cfg_overlaySEIContentLayerId[0],        UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 0") 
1150  ("SEIOverlayContentLayerId1",               cfg_overlaySEIContentLayerId[1],        UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 1") 
1151  ("SEIOverlayContentLayerId2",               cfg_overlaySEIContentLayerId[2],        UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 2") 
1152  ("SEIOverlayLabelPresentFlag0",             cfg_overlaySEILabelPresentFlag[0],        false, "Specifies if label content 0 is present") 
1153  ("SEIOverlayLabelPresentFlag1",             cfg_overlaySEILabelPresentFlag[1],        false, "Specifies if label content 1 is present") 
1154  ("SEIOverlayLabelPresentFlag2",             cfg_overlaySEILabelPresentFlag[2],        false, "Specifies if label content 2 is present") 
1155  ("SEIOverlayLabelLayerId0",                 cfg_overlaySEILabelLayerId[0],          UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 0") 
1156  ("SEIOverlayLabelLayerId1",                 cfg_overlaySEILabelLayerId[1],          UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 1") 
1157  ("SEIOverlayLabelLayerId2",                 cfg_overlaySEILabelLayerId[2],          UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 2") 
1158  ("SEIOverlayAlphaPresentFlag0",             cfg_overlaySEIAlphaPresentFlag[0],        false, "Specifies if alpha content 0 is present") 
1159  ("SEIOverlayAlphaPresentFlag1",             cfg_overlaySEIAlphaPresentFlag[1],        false, "Specifies if alpha content 1 is present") 
1160  ("SEIOverlayAlphaPresentFlag2",             cfg_overlaySEIAlphaPresentFlag[2],        false, "Specifies if alpha content 2 is present") 
1161  ("SEIOverlayAlphaLayerId0",                 cfg_overlaySEIAlphaLayerId[0],          UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 0") 
1162  ("SEIOverlayAlphaLayerId1",                 cfg_overlaySEIAlphaLayerId[1],          UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 1") 
1163  ("SEIOverlayAlphaLayerId2",                 cfg_overlaySEIAlphaLayerId[2],          UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 2") 
1164  ("SEIOverlayNumElementsMinus1_0",           cfg_overlaySEINumElementsMinus1[0],     UInt(0), "Specifies the number of overlay elements in overlay 0") 
1165  ("SEIOverlayNumElementsMinus1_1",           cfg_overlaySEINumElementsMinus1[1],     UInt(0), "Specifies the number of overlay elements in overlay 1") 
1166  ("SEIOverlayNumElementsMinus1_2",           cfg_overlaySEINumElementsMinus1[2],     UInt(0), "Specifies the number of overlay elements in overlay 2") 
1167  ("SEIOverlayElementLabelRange0",            cfg_overlaySEIElementLabelRanges[0], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1168                                                                                               "indicating the range of sample values corresponding to overlay elements of overlay 0")   
1169  ("SEIOverlayElementLabelRange1",            cfg_overlaySEIElementLabelRanges[1], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1170                                                                                               "indicating the range of sample values corresponding to overlay elements of overlay 1")   
1171  ("SEIOverlayElementLabelRange2",            cfg_overlaySEIElementLabelRanges[2], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1172                                                                                               "indicating the range of sample values corresponding to overlay elements of overlay 2") 
1173  ("SEIOverlayLanguage0",                     cfg_overlaySEILanguage[0],           string(""), "Indicates the language of overlay 0 by a language tag according to RFC 5646")
1174  ("SEIOverlayLanguage1",                     cfg_overlaySEILanguage[1],           string(""), "Indicates the language of overlay 1 by a language tag according to RFC 5646")
1175  ("SEIOverlayLanguage2",                     cfg_overlaySEILanguage[2],           string(""), "Indicates the language of overlay 2 by a language tag according to RFC 5646")
1176  ("SEIOverlayName0",                         cfg_overlaySEIName[0],       string("Overlay0"), "Indicates the name of overlay 0")
1177  ("SEIOverlayName1",                         cfg_overlaySEIName[1],       string("Overlay1"), "Indicates the name of overlay 1")
1178  ("SEIOverlayName2",                         cfg_overlaySEIName[2],       string("Overlay2"), "Indicates the name of overlay 2")
1179  ("SEIOverlayElementNames0",                 cfg_overlaySEIElementNames[0],       string(""), "Indicates the names of all overlay elements of overlay 0 in the format name1|name2|name3|...")                                                                                       
1180  ("SEIOverlayElementNames1",                 cfg_overlaySEIElementNames[1],       string(""), "Indicates the names of all overlay elements of overlay 1 in the format name1|name2|name3|...")                                                                                       
1181  ("SEIOverlayElementNames2",                 cfg_overlaySEIElementNames[2],       string(""), "Indicates the names of all overlay elements of overlay 2 in the format name1|name2|name3|...")                                                                                       
1182  ("SEIOverlayPersistenceFlag",               m_overlayInfoPersistenceFlag,              true, "Indicates if the SEI message applies to the current picture only (0) or also to following pictures (1)")
1183#endif
1184#if Q0189_TMVP_CONSTRAINTS
1185  ("SEITemporalMotionVectorPredictionConstraints",             m_TMVPConstraintsSEIEnabled,              0, "Control generation of TMVP constrants SEI message")
1186#endif
1187#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1188  ("AdaptiveResolutionChange",     m_adaptiveResolutionChange, 0, "Adaptive resolution change frame number. Should coincide with EL RAP picture. (0: disable)")
1189#endif
1190#if HIGHER_LAYER_IRAP_SKIP_FLAG
1191  ("SkipPictureAtArcSwitch",     m_skipPictureAtArcSwitch, false, "Code the higher layer picture in ARC up-switching as a skip picture. (0: disable)")
1192#endif
1193#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
1194  ("SEIInterLayerConstrainedTileSets", m_interLayerConstrainedTileSetsSEIEnabled, false, "Control generation of inter layer constrained tile sets SEI message")
1195  ("IlNumSetsInMessage",               m_ilNumSetsInMessage,                         0u, "Number of inter layer constrained tile sets")
1196  ("TileSetsArray",                    cfg_tileSets,                         string(""), "Array containing tile sets params (TopLeftTileIndex, BottonRightTileIndex and ilcIdc for each set) ")
1197#endif
1198#if O0153_ALT_OUTPUT_LAYER_FLAG
1199  ("AltOutputLayerFlag",               m_altOutputLayerFlag,                      false, "Specifies the value of alt_output_layer_flag in VPS extension")
1200#endif
1201#if O0149_CROSS_LAYER_BLA_FLAG
1202  ("CrossLayerBLAFlag",                m_crossLayerBLAFlag,                       false, "Specifies the value of cross_layer_bla_flag in VPS")
1203#endif
1204#if Q0048_CGS_3D_ASYMLUT
1205  ("CGS",     m_nCGSFlag , 0, "whether CGS is enabled")
1206  ("CGSMaxOctantDepth", m_nCGSMaxOctantDepth , 1, "max octant depth")
1207  ("CGSMaxYPartNumLog",  m_nCGSMaxYPartNumLog2 , 2, "max Y part number ")
1208  ("CGSLUTBit",     m_nCGSLUTBit , 12, "bit depth of CGS LUT")
1209#if R0151_CGS_3D_ASYMLUT_IMPROVE
1210  ("CGSAdaptC",     m_nCGSAdaptiveChroma , 1, "adaptive chroma partition (only for the case of two chroma partitions)")
1211#endif
1212#if R0179_ENC_OPT_3DLUT_SIZE
1213  ("CGSSizeRDO",     m_nCGSLutSizeRDO , 0, "RDOpt selection of best table size (effective when large maximum table size such as 8x8x8 is used)")
1214#endif
1215#endif
1216#if Q0108_TSA_STSA
1217  ("InheritCodingStruct%d",m_inheritCodingStruct, 0, MAX_LAYERS, "Predicts the GOP structure of one layer for another layer")
1218#endif
1219  ;
1220 
1221  for(Int i=1; i<MAX_GOP+1; i++) {
1222    std::ostringstream cOSS;
1223    cOSS<<"Frame"<<i;
1224    opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
1225  }
1226
1227#if Q0108_TSA_STSA
1228  for (Int i=1; i<MAX_LAYERS; i++)
1229  {
1230    for(Int j=1; j<MAX_GOP+1; j++)
1231    { 
1232      std::ostringstream cOSS;
1233      cOSS<<"Layer"<<i<<"Frame"<<j;
1234      opts.addOptions()(cOSS.str(), m_EhGOPList[i][j-1], GOPEntry());
1235    }
1236  }
1237#endif
1238
1239  po::setDefaults(opts);
1240  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
1241
1242#if Q0108_TSA_STSA
1243  for (Int i=1; i<MAX_LAYERS; i++)
1244  {
1245    if(m_inheritCodingStruct[i] == 0)
1246    {
1247      for(Int j=1; j<MAX_GOP+1; j++)
1248      { 
1249        m_EhGOPList[i][j-1] = m_GOPList[j-1];
1250      }
1251    }
1252    else if( m_inheritCodingStruct[i] > 0)
1253    {
1254      for(Int j=1; j<MAX_GOP+1; j++)
1255      {
1256        m_EhGOPList[i][j-1] = m_EhGOPList[m_inheritCodingStruct[i]][j-1];
1257      }
1258    }
1259  }
1260#endif
1261
1262  if(m_isField)
1263  {
1264#if SVC_EXTENSION
1265    for(Int layer = 0; layer < MAX_LAYERS; layer++)
1266    {
1267      //Frame height
1268      m_acLayerCfg[layer].m_iSourceHeightOrg = m_acLayerCfg[layer].m_iSourceHeight;
1269      //Field height
1270      m_acLayerCfg[layer].m_iSourceHeight = m_acLayerCfg[layer].m_iSourceHeight >> 1;
1271    }
1272#else
1273    //Frame height
1274    m_iSourceHeightOrg = m_iSourceHeight;
1275    //Field height
1276    m_iSourceHeight = m_iSourceHeight >> 1;
1277#endif
1278    //number of fields to encode
1279    m_framesToBeEncoded *= 2;
1280  }
1281 
1282  for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
1283  {
1284    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
1285  }
1286 
1287  if (argc == 1 || do_help)
1288  {
1289    /* argc == 1: no options have been specified */
1290    po::doHelp(cout, opts);
1291    return false;
1292  }
1293 
1294  /*
1295   * Set any derived parameters
1296   */
1297  /* convert std::string to c string for compatability */
1298#if SVC_EXTENSION
1299#if AVC_BASE
1300#if VPS_AVC_BL_FLAG_REMOVAL
1301  if( m_nonHEVCBaseLayerFlag )
1302#else
1303  if( m_avcBaseLayerFlag )
1304#endif
1305  {
1306    *cfg_InputFile[0] = cfg_BLInputFile;
1307  }
1308#endif
1309  m_pBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
1310#else //SVC_EXTENSION
1311  m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
1312  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
1313  m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
1314  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
1315#if Q0074_COLOUR_REMAPPING_SEI
1316  m_colourRemapSEIFile = cfg_colourRemapSEIFile.empty() ? NULL : strdup(cfg_colourRemapSEIFile.c_str());
1317#endif
1318#endif //SVC_EXTENSION
1319
1320
1321  Char* pColumnWidth = cfgColumnWidth.empty() ? NULL: strdup(cfgColumnWidth.c_str());
1322  Char* pRowHeight = cfgRowHeight.empty() ? NULL : strdup(cfgRowHeight.c_str());
1323
1324  if( !m_tileUniformSpacingFlag && m_numTileColumnsMinus1 > 0 )
1325  {
1326    char *str;
1327    int  i=0;
1328    m_tileColumnWidth.resize( m_numTileColumnsMinus1 );
1329    str = strtok(pColumnWidth, " ,-");
1330    while(str!=NULL)
1331    {
1332      if( i >= m_numTileColumnsMinus1 )
1333      {
1334        printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
1335        exit( EXIT_FAILURE );
1336      }
1337      m_tileColumnWidth[i] = atoi( str );
1338      str = strtok(NULL, " ,-");
1339      i++;
1340    }
1341    if( i < m_numTileColumnsMinus1 )
1342    {
1343      printf( "The width of some columns is not defined.\n" );
1344      exit( EXIT_FAILURE );
1345    }
1346  }
1347  else
1348  {
1349    m_tileColumnWidth.clear();
1350  }
1351
1352  if( !m_tileUniformSpacingFlag && m_numTileRowsMinus1 > 0 )
1353  {
1354    char *str;
1355    int  i=0;
1356    m_tileRowHeight.resize(m_numTileRowsMinus1);
1357    str = strtok(pRowHeight, " ,-");
1358    while(str!=NULL)
1359    {
1360      if( i>=m_numTileRowsMinus1 )
1361      {
1362        printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
1363        exit( EXIT_FAILURE );
1364      }
1365      m_tileRowHeight[i] = atoi( str );
1366      str = strtok(NULL, " ,-");
1367      i++;
1368    }
1369    if( i < m_numTileRowsMinus1 )
1370    {
1371      printf( "The height of some rows is not defined.\n" );
1372      exit( EXIT_FAILURE );
1373   }
1374  }
1375  else
1376  {
1377    m_tileRowHeight.clear();
1378  }
1379#if SVC_EXTENSION
1380  if( pColumnWidth )
1381  {
1382    free( pColumnWidth );
1383    pColumnWidth = NULL;
1384  }
1385
1386  if( pRowHeight )
1387  {
1388    free( pRowHeight );
1389    pRowHeight = NULL;
1390  }
1391
1392  for(Int layer = 0; layer < MAX_LAYERS; layer++)
1393  {
1394    // If number of scaled ref. layer offsets is non-zero, at least one of the offsets should be specified
1395    if(m_acLayerCfg[layer].m_numScaledRefLayerOffsets)
1396    {
1397#if O0098_SCALED_REF_LAYER_ID
1398      assert( strcmp(cfg_scaledRefLayerId[layer].c_str(),  ""));
1399#endif
1400#if REF_REGION_OFFSET
1401      Bool srloFlag =
1402        strcmp(cfg_scaledRefLayerLeftOffset   [layer].c_str(), "") ||
1403        strcmp(cfg_scaledRefLayerRightOffset  [layer].c_str(), "") ||
1404        strcmp(cfg_scaledRefLayerTopOffset    [layer].c_str(), "") ||
1405        strcmp(cfg_scaledRefLayerBottomOffset [layer].c_str(), "");
1406      Bool rroFlag =
1407        strcmp(cfg_refRegionLeftOffset   [layer].c_str(), "") ||
1408        strcmp(cfg_refRegionRightOffset  [layer].c_str(), "") ||
1409        strcmp(cfg_refRegionTopOffset    [layer].c_str(), "") ||
1410        strcmp(cfg_refRegionBottomOffset [layer].c_str(), "");
1411#if R0209_GENERIC_PHASE
1412      Bool phaseSetFlag =
1413        strcmp(cfg_phaseHorLuma   [layer].c_str(), "") ||
1414        strcmp(cfg_phaseVerLuma  [layer].c_str(), "") ||
1415        strcmp(cfg_phaseHorChroma    [layer].c_str(), "") ||
1416        strcmp(cfg_phaseVerChroma [layer].c_str(), "");
1417      assert( srloFlag || rroFlag || phaseSetFlag);
1418#else
1419      assert( srloFlag || rroFlag );
1420#endif
1421#else
1422#if P0312_VERT_PHASE_ADJ
1423      assert( strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(),  "") ||
1424              strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(), "") ||
1425              strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(),   "") ||
1426              strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),"") ||
1427              strcmp(cfg_vertPhasePositionEnableFlag[layer].c_str(),"") ); 
1428#else
1429      assert( strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(),  "") ||
1430              strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(), "") ||
1431              strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(),   "") ||
1432              strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),"") ); 
1433#endif
1434#endif
1435    }
1436
1437    Int *tempArray = NULL;   // Contain the value
1438
1439#if O0098_SCALED_REF_LAYER_ID
1440    // ID //
1441    if(strcmp(cfg_scaledRefLayerId[layer].c_str(),  ""))
1442    {
1443      cfgStringToArray( &tempArray, cfg_scaledRefLayerId[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "ScaledRefLayerId");
1444      if(tempArray)
1445      {
1446        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1447        {
1448          m_acLayerCfg[layer].m_scaledRefLayerId[i] = tempArray[i];
1449        }
1450        delete [] tempArray; tempArray = NULL;
1451      }
1452    }
1453#endif
1454
1455#if REF_REGION_OFFSET
1456    // Presense Flag //
1457    if(strcmp(cfg_scaledRefLayerOffsetPresentFlag[layer].c_str(),  ""))
1458    {
1459      cfgStringToArray( &tempArray, cfg_scaledRefLayerOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "ScaledRefLayerOffsetPresentFlag");
1460      if(tempArray)
1461      {
1462        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1463        {
1464          m_acLayerCfg[layer].m_scaledRefLayerOffsetPresentFlag[i] = tempArray[i];
1465        }
1466        delete [] tempArray; tempArray = NULL;
1467      }
1468    }
1469#endif
1470
1471    // Left offset //
1472    if(strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(),  ""))
1473    {
1474      cfgStringToArray( &tempArray, cfg_scaledRefLayerLeftOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "LeftOffset");
1475      if(tempArray)
1476      {
1477        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1478        {
1479          m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i] = tempArray[i];
1480        }
1481        delete [] tempArray; tempArray = NULL;
1482      }
1483    }
1484
1485    // Top offset //
1486    if(strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(),  ""))
1487    {
1488      cfgStringToArray( &tempArray, cfg_scaledRefLayerTopOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "TopOffset");
1489      if(tempArray)
1490      {
1491        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1492        {
1493          m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i] = tempArray[i];
1494        }
1495        delete [] tempArray; tempArray = NULL;
1496      }
1497    }
1498
1499    // Right offset //
1500    if(strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(),  ""))
1501    {
1502      cfgStringToArray( &tempArray, cfg_scaledRefLayerRightOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RightOffset");
1503      if(tempArray)
1504      {
1505        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1506        {
1507          m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i] = tempArray[i];
1508        }
1509        delete [] tempArray; tempArray = NULL;
1510      }
1511    }
1512
1513    // Bottom offset //
1514    if(strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),  ""))
1515    {
1516      cfgStringToArray( &tempArray, cfg_scaledRefLayerBottomOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "BottomOffset");
1517      if(tempArray)
1518      {
1519        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1520        {
1521          m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i] = tempArray[i];
1522        }
1523        delete [] tempArray; tempArray = NULL;
1524      }
1525    }
1526#if P0312_VERT_PHASE_ADJ
1527   // VertPhasePositionEnableFlag //
1528    if(strcmp(cfg_vertPhasePositionEnableFlag[layer].c_str(),  ""))
1529    {
1530      cfgStringToArray( &tempArray, cfg_vertPhasePositionEnableFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "VertPhasePositionEnableFlag");
1531      if(tempArray)
1532      {
1533        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1534        {
1535          m_acLayerCfg[layer].m_vertPhasePositionEnableFlag[i] = tempArray[i];
1536        }
1537        delete [] tempArray; tempArray = NULL;
1538      }
1539    }
1540#endif
1541#if REF_REGION_OFFSET
1542    // Presense Flag //
1543    if(strcmp(cfg_refRegionOffsetPresentFlag[layer].c_str(),  ""))
1544    {
1545      cfgStringToArray( &tempArray, cfg_refRegionOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionOffsetPresentFlag");
1546      if(tempArray)
1547      {
1548        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1549        {
1550          m_acLayerCfg[layer].m_refRegionOffsetPresentFlag[i] = tempArray[i];
1551        }
1552        delete [] tempArray; tempArray = NULL;
1553      }
1554    }
1555
1556    // Left offset //
1557    if(strcmp(cfg_refRegionLeftOffset[layer].c_str(),  ""))
1558    {
1559      cfgStringToArray( &tempArray, cfg_refRegionLeftOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionLeftOffset");
1560      if(tempArray)
1561      {
1562        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1563        {
1564          m_acLayerCfg[layer].m_refRegionLeftOffset[i] = tempArray[i];
1565        }
1566        delete [] tempArray; tempArray = NULL;
1567      }
1568    }
1569
1570    // Top offset //
1571    if(strcmp(cfg_refRegionTopOffset[layer].c_str(),  ""))
1572    {
1573      cfgStringToArray( &tempArray, cfg_refRegionTopOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionTopOffset");
1574      if(tempArray)
1575      {
1576        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1577        {
1578          m_acLayerCfg[layer].m_refRegionTopOffset[i] = tempArray[i];
1579        }
1580        delete [] tempArray; tempArray = NULL;
1581      }
1582    }
1583
1584    // Right offset //
1585    if(strcmp(cfg_refRegionRightOffset[layer].c_str(),  ""))
1586    {
1587      cfgStringToArray( &tempArray, cfg_refRegionRightOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionRightOffset");
1588      if(tempArray)
1589      {
1590        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1591        {
1592          m_acLayerCfg[layer].m_refRegionRightOffset[i] = tempArray[i];
1593        }
1594        delete [] tempArray; tempArray = NULL;
1595      }
1596    }
1597
1598    // Bottom offset //
1599    if(strcmp(cfg_refRegionBottomOffset[layer].c_str(),  ""))
1600    {
1601      cfgStringToArray( &tempArray, cfg_refRegionBottomOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionBottomOffset");
1602      if(tempArray)
1603      {
1604        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1605        {
1606          m_acLayerCfg[layer].m_refRegionBottomOffset[i] = tempArray[i];
1607        }
1608        delete [] tempArray; tempArray = NULL;
1609      }
1610    }
1611#endif
1612#if R0209_GENERIC_PHASE
1613    Int numPhaseSet = m_acLayerCfg[layer].m_numScaledRefLayerOffsets;
1614
1615    // Presense Flag //
1616    if(strcmp(cfg_resamplePhaseSetPresentFlag[layer].c_str(),  ""))
1617    {
1618      cfgStringToArray( &tempArray, cfg_resamplePhaseSetPresentFlag[layer], numPhaseSet, "resamplePhaseSetPresentFlag");
1619      if(tempArray)
1620      {
1621        for(Int i = 0; i < numPhaseSet; i++)
1622        {
1623          m_acLayerCfg[layer].m_resamplePhaseSetPresentFlag[i] = tempArray[i];
1624        }
1625        delete [] tempArray; tempArray = NULL;
1626      }
1627    }
1628
1629    // Luma horizontal phase //
1630    if(strcmp(cfg_phaseHorLuma[layer].c_str(),  ""))
1631    {
1632      cfgStringToArray( &tempArray, cfg_phaseHorLuma[layer], numPhaseSet, "phaseHorLuma");
1633      if(tempArray)
1634      {
1635        for(Int i = 0; i < numPhaseSet; i++)
1636        {
1637          m_acLayerCfg[layer].m_phaseHorLuma[i] = tempArray[i];
1638        }
1639        delete [] tempArray; tempArray = NULL;
1640      }
1641    }
1642
1643    // Luma vertical phase //
1644    if(strcmp(cfg_phaseVerLuma[layer].c_str(),  ""))
1645    {
1646      cfgStringToArray( &tempArray, cfg_phaseVerLuma[layer], numPhaseSet, "phaseVerLuma");
1647      if(tempArray)
1648      {
1649        for(Int i = 0; i < numPhaseSet; i++)
1650        {
1651          m_acLayerCfg[layer].m_phaseVerLuma[i] = tempArray[i];
1652        }
1653        delete [] tempArray; tempArray = NULL;
1654      }
1655    }
1656
1657    // Chroma horizontal phase //
1658    if(strcmp(cfg_phaseHorChroma[layer].c_str(),  ""))
1659    {
1660      cfgStringToArray( &tempArray, cfg_phaseHorChroma[layer], numPhaseSet, "phaseHorChroma");
1661      if(tempArray)
1662      {
1663        for(Int i = 0; i < numPhaseSet; i++)
1664        {
1665          m_acLayerCfg[layer].m_phaseHorChroma[i] = tempArray[i];
1666        }
1667        delete [] tempArray; tempArray = NULL;
1668      }
1669    }
1670
1671    // Chroma vertical phase //
1672    if(strcmp(cfg_phaseVerChroma[layer].c_str(),  ""))
1673    {
1674      cfgStringToArray( &tempArray, cfg_phaseVerChroma[layer], numPhaseSet, "phaseVerChroma");
1675      if(tempArray)
1676      {
1677        for(Int i = 0; i < numPhaseSet; i++)
1678        {
1679          m_acLayerCfg[layer].m_phaseVerChroma[i] = tempArray[i];
1680        }
1681        delete [] tempArray; tempArray = NULL;
1682      }
1683    }
1684#endif
1685  }
1686
1687#if VPS_EXTN_DIRECT_REF_LAYERS
1688  for(Int layer = 0; layer < MAX_LAYERS; layer++)
1689  {
1690    Char* pSamplePredRefLayerIds = cfg_samplePredRefLayerIds[layer].empty() ? NULL: strdup(cfg_samplePredRefLayerIds[layer].c_str());
1691    if( m_acLayerCfg[layer].m_numSamplePredRefLayers > 0 )
1692    {
1693      char *samplePredRefLayerId;
1694      int  i=0;
1695      m_acLayerCfg[layer].m_samplePredRefLayerIds = new Int[m_acLayerCfg[layer].m_numSamplePredRefLayers];
1696      samplePredRefLayerId = strtok(pSamplePredRefLayerIds, " ,-");
1697      while(samplePredRefLayerId != NULL)
1698      {
1699        if( i >= m_acLayerCfg[layer].m_numSamplePredRefLayers )
1700        {
1701          printf( "NumSamplePredRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1702          exit( EXIT_FAILURE );
1703        }
1704        *( m_acLayerCfg[layer].m_samplePredRefLayerIds + i ) = atoi( samplePredRefLayerId );
1705        samplePredRefLayerId = strtok(NULL, " ,-");
1706        i++;
1707      }
1708      if( i < m_acLayerCfg[layer].m_numSamplePredRefLayers )
1709      {
1710        printf( "NumSamplePredRefLayers%d: The width of some columns is not defined.\n", layer );
1711        exit( EXIT_FAILURE );
1712      }
1713    }
1714    else
1715    {
1716      m_acLayerCfg[layer].m_samplePredRefLayerIds = NULL;
1717    }
1718
1719    if( pSamplePredRefLayerIds )
1720    {
1721      free( pSamplePredRefLayerIds );
1722      pSamplePredRefLayerIds = NULL;
1723    }
1724  }
1725  for(Int layer = 0; layer < MAX_LAYERS; layer++)
1726  {
1727    Char* pMotionPredRefLayerIds = cfg_motionPredRefLayerIds[layer].empty() ? NULL: strdup(cfg_motionPredRefLayerIds[layer].c_str());
1728    if( m_acLayerCfg[layer].m_numMotionPredRefLayers > 0 )
1729    {
1730      char *motionPredRefLayerId;
1731      int  i=0;
1732      m_acLayerCfg[layer].m_motionPredRefLayerIds = new Int[m_acLayerCfg[layer].m_numMotionPredRefLayers];
1733      motionPredRefLayerId = strtok(pMotionPredRefLayerIds, " ,-");
1734      while(motionPredRefLayerId != NULL)
1735      {
1736        if( i >= m_acLayerCfg[layer].m_numMotionPredRefLayers )
1737        {
1738          printf( "NumMotionPredRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1739          exit( EXIT_FAILURE );
1740        }
1741        *( m_acLayerCfg[layer].m_motionPredRefLayerIds + i ) = atoi( motionPredRefLayerId );
1742        motionPredRefLayerId = strtok(NULL, " ,-");
1743        i++;
1744      }
1745      if( i < m_acLayerCfg[layer].m_numMotionPredRefLayers )
1746      {
1747        printf( "NumMotionPredRefLayers%d: The width of some columns is not defined.\n", layer );
1748        exit( EXIT_FAILURE );
1749      }
1750    }
1751    else
1752    {
1753      m_acLayerCfg[layer].m_motionPredRefLayerIds = NULL;
1754    }
1755
1756    if( pMotionPredRefLayerIds )
1757    {
1758      free( pMotionPredRefLayerIds );
1759      pMotionPredRefLayerIds = NULL;
1760    }
1761  }
1762
1763#if AUXILIARY_PICTURES
1764  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
1765  {
1766    m_acLayerCfg[layer].m_InputChromaFormat =  numberToChromaFormat(cfg_tmpChromaFormatIDC[layer]);
1767    m_acLayerCfg[layer].m_chromaFormatIDC = ((cfg_tmpChromaFormatIDC[layer] == 0) ? (m_acLayerCfg[layer].m_InputChromaFormat ) : (numberToChromaFormat(cfg_tmpChromaFormatIDC[layer])));
1768  }
1769#endif
1770  for(Int layer = 0; layer < MAX_LAYERS; layer++)
1771  {
1772    Char* pPredLayerIds = cfg_predLayerIds[layer].empty() ? NULL: strdup(cfg_predLayerIds[layer].c_str());
1773    if( m_acLayerCfg[layer].m_numActiveRefLayers > 0 )
1774    {
1775      char *refLayerId;
1776      int  i=0;
1777      m_acLayerCfg[layer].m_predLayerIds = new Int[m_acLayerCfg[layer].m_numActiveRefLayers];
1778      refLayerId = strtok(pPredLayerIds, " ,-");
1779      while(refLayerId != NULL)
1780      {
1781        if( i >= m_acLayerCfg[layer].m_numActiveRefLayers )
1782        {
1783          printf( "NumActiveRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1784          exit( EXIT_FAILURE );
1785        }
1786        *( m_acLayerCfg[layer].m_predLayerIds + i ) = atoi( refLayerId );
1787        refLayerId = strtok(NULL, " ,-");
1788        i++;
1789      }
1790      if( i < m_acLayerCfg[layer].m_numActiveRefLayers )
1791      {
1792        printf( "NumActiveRefLayers%d: The width of some columns is not defined.\n", layer );
1793        exit( EXIT_FAILURE );
1794      }
1795    }
1796    else
1797    {
1798      m_acLayerCfg[layer].m_predLayerIds = NULL;
1799    }
1800
1801    if( pPredLayerIds )
1802    {
1803      free( pPredLayerIds );
1804      pPredLayerIds = NULL;
1805    }
1806  }
1807#endif
1808#if Q0078_ADD_LAYER_SETS
1809#if OUTPUT_LAYER_SETS_CONFIG
1810  for (Int layerSet = 1; layerSet < m_numLayerSets; layerSet++)
1811  {
1812    // Simplifying the code in the #else section, and allowing 0-th layer set t
1813    assert( scanStringToArray( cfg_layerSetLayerIdList[layerSet], m_numLayerInIdList[layerSet], "NumLayerInIdList", m_layerSetLayerIdList[layerSet] ) );
1814#else
1815  for (Int layerSet = 0; layerSet < m_numLayerSets; layerSet++)
1816  {
1817    if (m_numLayerInIdList[layerSet] > 0)
1818    {
1819      Char* layerSetLayerIdListDup = cfg_layerSetLayerIdList[layerSet].empty() ? NULL : strdup(cfg_layerSetLayerIdList[layerSet].c_str());
1820      Int  i = 0;
1821      char *layerId = strtok(layerSetLayerIdListDup, " ,-");
1822      while (layerId != NULL)
1823      {
1824        if (i >= m_numLayerInIdList[layerSet])
1825        {
1826          printf("NumLayerInIdList%d: The number of layers in the set is larger than the allowed number of layers.\n", layerSet);
1827          exit(EXIT_FAILURE);
1828        }
1829        m_layerSetLayerIdList[layerSet][i] = atoi(layerId);
1830        layerId = strtok(NULL, " ,-");
1831        i++;
1832      }
1833
1834      if( layerSetLayerIdListDup )
1835      {
1836        free( layerSetLayerIdListDup );
1837        layerSetLayerIdListDup = NULL;
1838      }
1839    }
1840#endif
1841  }
1842  for (Int addLayerSet = 0; addLayerSet < m_numAddLayerSets; addLayerSet++)
1843  {
1844#if OUTPUT_LAYER_SETS_CONFIG
1845    // Simplifying the code in the #else section
1846#if FIX_LAYER_ID_INIT
1847    assert( scanStringToArray( cfg_highestLayerIdx[addLayerSet], m_numHighestLayerIdx[addLayerSet], "HighestLayerIdx", m_highestLayerIdx[addLayerSet] ) );
1848#else
1849    assert( scanStringToArray( cfg_layerSetLayerIdList[addLayerSet], m_numLayerInIdList[addLayerSet], "NumLayerInIdList",  m_highestLayerIdx[addLayerSet] ) );
1850#endif
1851#else
1852    if (m_numHighestLayerIdx[addLayerSet] > 0)
1853    {
1854      Char* highestLayrIdxListDup = cfg_highestLayerIdx[addLayerSet].empty() ? NULL : strdup(cfg_highestLayerIdx[addLayerSet].c_str());
1855      Int  i = 0;
1856      char *layerIdx = strtok(highestLayrIdxListDup, " ,-");
1857      while (layerIdx != NULL)
1858      {
1859        if (i >= m_numLayerInIdList[addLayerSet])
1860        {
1861          printf("NumLayerInIdList%d: The number of layer idx's in the highest layer idx list is larger than the allowed number of idx's.\n", addLayerSet);
1862          exit(EXIT_FAILURE);
1863        }
1864        m_highestLayerIdx[addLayerSet][i] = atoi(layerIdx);
1865        layerIdx = strtok(NULL, " ,-");
1866        i++;
1867      }
1868
1869      if( highestLayrIdxListDup )
1870      {
1871        free( highestLayrIdxListDup );
1872        highestLayrIdxListDup = NULL;
1873      }
1874    }
1875#endif
1876  }
1877#endif
1878#if OUTPUT_LAYER_SETS_CONFIG
1879  if( m_defaultTargetOutputLayerIdc != -1 )
1880  {
1881    assert( m_defaultTargetOutputLayerIdc >= 0 && m_defaultTargetOutputLayerIdc <= 3 );
1882  }
1883  assert( m_numOutputLayerSets != 0 );
1884  assert( m_numOutputLayerSets >= m_numLayerSets + m_numAddLayerSets ); // Number of output layer sets must be at least as many as layer sets.
1885
1886  // If output layer Set Idx is specified, only specify it for the non-default output layer sets
1887  Int numNonDefaultOls = m_numOutputLayerSets - (m_numLayerSets + m_numAddLayerSets);
1888  if( numNonDefaultOls )
1889  {
1890    assert( scanStringToArray( *cfg_outputLayerSetIdx, numNonDefaultOls, "OutputLayerSetIdx", m_outputLayerSetIdx ) ); 
1891    for(Int i = 0; i < numNonDefaultOls; i++)
1892    {
1893      assert( m_outputLayerSetIdx[i] >= 0 && m_outputLayerSetIdx[i] < (m_numLayerSets + m_numAddLayerSets) );
1894    }
1895  }
1896
1897  // Number of output layers in output layer sets
1898  scanStringToArray( *cfg_numLayersInOutputLayerSet, m_numOutputLayerSets - 1, "NumLayersInOutputLayerSets", m_numLayersInOutputLayerSet );
1899  m_numLayersInOutputLayerSet.insert(m_numLayersInOutputLayerSet.begin(), 1);
1900  // Layers in the output layer set
1901  m_listOfOutputLayers.resize(m_numOutputLayerSets);
1902  Int startOlsCtr = 1;
1903  if( m_defaultTargetOutputLayerIdc == 0 || m_defaultTargetOutputLayerIdc == 1 )
1904  {
1905    // Default output layer sets defined
1906    startOlsCtr = m_numLayerSets + m_numAddLayerSets;
1907  }
1908  for( Int olsCtr = 1; olsCtr < m_numOutputLayerSets; olsCtr++ )
1909  {
1910    if( olsCtr < startOlsCtr )
1911    {
1912      if(scanStringToArray( cfg_listOfOutputLayers[olsCtr], m_numLayersInOutputLayerSet[olsCtr], "ListOfOutputLayers", m_listOfOutputLayers[olsCtr] ) )
1913      {
1914        std::cout << "Default OLS defined. Ignoring ListOfOutputLayers" << olsCtr << endl;
1915      }
1916    }
1917    else
1918    {
1919      assert( scanStringToArray( cfg_listOfOutputLayers[olsCtr], m_numLayersInOutputLayerSet[olsCtr], "ListOfOutputLayers", m_listOfOutputLayers[olsCtr] ) );
1920    }
1921  }
1922  delete cfg_numLayersInOutputLayerSet;
1923  delete [] cfg_listOfOutputLayers;
1924  delete cfg_outputLayerSetIdx;
1925#endif
1926#endif //SVC_EXTENSION
1927  m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
1928
1929  /* rules for input, output and internal bitdepths as per help text */
1930#if O0194_DIFFERENT_BITDEPTH_EL_BL
1931  for(Int layer = 0; layer < MAX_LAYERS; layer++)
1932  {
1933    if (!m_acLayerCfg[layer].m_internalBitDepthY) { m_acLayerCfg[layer].m_internalBitDepthY = m_acLayerCfg[layer].m_inputBitDepthY; }
1934    if (!m_acLayerCfg[layer].m_internalBitDepthC) { m_acLayerCfg[layer].m_internalBitDepthC = m_acLayerCfg[layer].m_internalBitDepthY; }
1935    if (!m_acLayerCfg[layer].m_inputBitDepthC) { m_acLayerCfg[layer].m_inputBitDepthC = m_acLayerCfg[layer].m_inputBitDepthY; }
1936    if (!m_acLayerCfg[layer].m_outputBitDepthY) { m_acLayerCfg[layer].m_outputBitDepthY = m_acLayerCfg[layer].m_internalBitDepthY; }
1937    if (!m_acLayerCfg[layer].m_outputBitDepthC) { m_acLayerCfg[layer].m_outputBitDepthC = m_acLayerCfg[layer].m_internalBitDepthC; }
1938  }
1939#else
1940  if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
1941  if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
1942  if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
1943  if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
1944  if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
1945#endif
1946
1947#if !SVC_EXTENSION
1948  // TODO:ChromaFmt assumes 4:2:0 below
1949  switch (m_conformanceWindowMode)
1950  {
1951  case 0:
1952    {
1953      // no conformance or padding
1954      m_confWinLeft = m_confWinRight = m_confWinTop = m_confWinBottom = 0;
1955      m_aiPad[1] = m_aiPad[0] = 0;
1956      break;
1957    }
1958  case 1:
1959    {
1960      // automatic padding to minimum CU size
1961      Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
1962      if (m_iSourceWidth % minCuSize)
1963      {
1964        m_aiPad[0] = m_confWinRight  = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
1965        m_iSourceWidth  += m_confWinRight;
1966      }
1967      if (m_iSourceHeight % minCuSize)
1968      {
1969        m_aiPad[1] = m_confWinBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
1970        m_iSourceHeight += m_confWinBottom;
1971        if ( m_isField )
1972        {
1973          m_iSourceHeightOrg += m_confWinBottom << 1;
1974          m_aiPad[1] = m_confWinBottom << 1;
1975        }
1976      }
1977      if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
1978      {
1979        fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
1980        exit(EXIT_FAILURE);
1981      }
1982      if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
1983      {
1984        fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
1985        exit(EXIT_FAILURE);
1986      }
1987      break;
1988    }
1989  case 2:
1990    {
1991      //padding
1992      m_iSourceWidth  += m_aiPad[0];
1993      m_iSourceHeight += m_aiPad[1];
1994      m_confWinRight  = m_aiPad[0];
1995      m_confWinBottom = m_aiPad[1];
1996      break;
1997    }
1998  case 3:
1999    {
2000      // conformance
2001      if ((m_confWinLeft == 0) && (m_confWinRight == 0) && (m_confWinTop == 0) && (m_confWinBottom == 0))
2002      {
2003        fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
2004      }
2005      if ((m_aiPad[1] != 0) || (m_aiPad[0]!=0))
2006      {
2007        fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
2008      }
2009      m_aiPad[1] = m_aiPad[0] = 0;
2010      break;
2011    }
2012  }
2013 
2014  // allocate slice-based dQP values
2015  m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
2016  ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
2017 
2018  // handling of floating-point QP values
2019  // if QP is not integer, sequence is split into two sections having QP and QP+1
2020  m_iQP = (Int)( m_fQP );
2021  if ( m_iQP < m_fQP )
2022  {
2023    Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
2024   
2025    iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
2026    for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
2027    {
2028      m_aidQP[i] = 1;
2029    }
2030  }
2031 
2032  // reading external dQP description from file
2033  if ( m_pchdQPFile )
2034  {
2035    FILE* fpt=fopen( m_pchdQPFile, "r" );
2036    if ( fpt )
2037    {
2038      Int iValue;
2039      Int iPOC = 0;
2040      while ( iPOC < m_framesToBeEncoded )
2041      {
2042        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
2043        m_aidQP[ iPOC ] = iValue;
2044        iPOC++;
2045      }
2046      fclose(fpt);
2047    }
2048  }
2049  m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
2050#endif
2051  if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
2052  {
2053    Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
2054    Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
2055    Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
2056    if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
2057    {
2058      char *startOfCodedInterval;
2059      UInt num = 1u<< m_toneMapTargetBitDepth;
2060      m_startOfCodedInterval = new Int[num];
2061      ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
2062      startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
2063      int i = 0;
2064      while( startOfCodedInterval && ( i < num ) )
2065      {
2066        m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
2067        startOfCodedInterval = strtok(NULL, " .");
2068        i++;
2069      }
2070    } 
2071    else
2072    {
2073      m_startOfCodedInterval = NULL;
2074    }
2075    if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
2076    {
2077      if( pcCodedPivotValue && pcTargetPivotValue )
2078      {
2079        char *codedPivotValue;
2080        char *targetPivotValue;
2081        m_codedPivotValue = new Int[m_numPivots];
2082        m_targetPivotValue = new Int[m_numPivots];
2083        ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
2084        ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
2085        codedPivotValue = strtok(pcCodedPivotValue, " .");
2086        int i=0;
2087        while(codedPivotValue&&i<m_numPivots)
2088        {
2089          m_codedPivotValue[i] = atoi( codedPivotValue );
2090          codedPivotValue = strtok(NULL, " .");
2091          i++;
2092        }
2093        i=0;
2094        targetPivotValue = strtok(pcTargetPivotValue, " .");
2095        while(targetPivotValue&&i<m_numPivots)
2096        {
2097          m_targetPivotValue[i]= atoi( targetPivotValue );
2098          targetPivotValue = strtok(NULL, " .");
2099          i++;
2100        }
2101      }
2102    }
2103    else
2104    {
2105      m_codedPivotValue = NULL;
2106      m_targetPivotValue = NULL;
2107    }
2108
2109    if( pcStartOfCodedInterval )
2110    {
2111      free( pcStartOfCodedInterval );
2112      pcStartOfCodedInterval = NULL;
2113    }
2114
2115    if( pcCodedPivotValue )
2116    {
2117      free( pcCodedPivotValue );
2118      pcCodedPivotValue = NULL;
2119    }
2120
2121    if( pcTargetPivotValue )
2122    {
2123      free( pcTargetPivotValue );
2124      pcTargetPivotValue = NULL;
2125    }
2126  }
2127#if P0050_KNEE_FUNCTION_SEI
2128  if( m_kneeSEIEnabled && !m_kneeSEICancelFlag )
2129  {
2130    Char* pcInputKneePointValue  = cfg_kneeSEIInputKneePointValue.empty()  ? NULL : strdup(cfg_kneeSEIInputKneePointValue.c_str());
2131    Char* pcOutputKneePointValue = cfg_kneeSEIOutputKneePointValue.empty() ? NULL : strdup(cfg_kneeSEIOutputKneePointValue.c_str());
2132    assert ( m_kneeSEINumKneePointsMinus1 >= 0 && m_kneeSEINumKneePointsMinus1 < 999 );
2133    m_kneeSEIInputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1];
2134    m_kneeSEIOutputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1];
2135    char *InputVal = strtok(pcInputKneePointValue, " .,");
2136    Int i=0;
2137    while( InputVal && i<(m_kneeSEINumKneePointsMinus1+1) )
2138    {
2139      m_kneeSEIInputKneePoint[i] = (UInt) atoi( InputVal );
2140      InputVal = strtok(NULL, " .,");
2141      i++;
2142    }
2143    char *OutputVal = strtok(pcOutputKneePointValue, " .,");
2144    i=0;
2145    while( OutputVal && i<(m_kneeSEINumKneePointsMinus1+1) )
2146    {
2147      m_kneeSEIOutputKneePoint[i] = (UInt) atoi( OutputVal );
2148      OutputVal = strtok(NULL, " .,");
2149      i++;
2150    }
2151
2152    if( pcInputKneePointValue )
2153    {
2154      free( pcInputKneePointValue );
2155      pcInputKneePointValue = NULL;
2156    }
2157
2158    if( pcOutputKneePointValue )
2159    {
2160      free( pcOutputKneePointValue );
2161      pcOutputKneePointValue = NULL;
2162    }
2163  }
2164#endif
2165#if Q0096_OVERLAY_SEI
2166  if( m_overlaySEIEnabled && !m_overlayInfoCancelFlag )
2167  {
2168    m_overlayIdx.resize                 ( m_numOverlaysMinus1+1 ); 
2169    m_overlayLanguagePresentFlag.resize ( m_numOverlaysMinus1+1 );
2170    m_overlayContentLayerId.resize      ( m_numOverlaysMinus1+1 );
2171    m_overlayLabelPresentFlag.resize    ( m_numOverlaysMinus1+1 );
2172    m_overlayLabelLayerId.resize        ( m_numOverlaysMinus1+1 );
2173    m_overlayAlphaPresentFlag.resize    ( m_numOverlaysMinus1+1 );
2174    m_overlayAlphaLayerId.resize        ( m_numOverlaysMinus1+1 );
2175    m_numOverlayElementsMinus1.resize   ( m_numOverlaysMinus1+1 );
2176    m_overlayElementLabelMin.resize     ( m_numOverlaysMinus1+1 );
2177    m_overlayElementLabelMax.resize     ( m_numOverlaysMinus1+1 ); 
2178    m_overlayLanguage.resize            ( m_numOverlaysMinus1+1 );     
2179    m_overlayName.resize                ( m_numOverlaysMinus1+1 );     
2180    m_overlayElementName.resize         ( m_numOverlaysMinus1+1 );     
2181    for (Int i=0 ; i<=m_numOverlaysMinus1 ; i++)
2182    {
2183      m_overlayIdx[i]                  = cfg_overlaySEIIdx[i];
2184      m_overlayLanguagePresentFlag[i]  = cfg_overlaySEILanguagePresentFlag[i];
2185      m_overlayContentLayerId[i]       = cfg_overlaySEIContentLayerId[i];
2186      m_overlayLabelPresentFlag[i]     = cfg_overlaySEILabelPresentFlag[i];
2187      m_overlayLabelLayerId[i]         = cfg_overlaySEILabelLayerId[i];
2188      m_overlayAlphaPresentFlag[i]     = cfg_overlaySEIAlphaPresentFlag[i];
2189      m_overlayAlphaLayerId[i]         = cfg_overlaySEIAlphaLayerId[i];
2190      m_numOverlayElementsMinus1[i]    = cfg_overlaySEINumElementsMinus1[i];
2191      m_overlayLanguage[i]             = cfg_overlaySEILanguage[i];
2192      m_overlayName[i]                 = cfg_overlaySEIName[i];
2193     
2194      //parse min and max values of label elements
2195      istringstream ranges(cfg_overlaySEIElementLabelRanges[i]);
2196      string range;         
2197      UInt val;       
2198      vector<UInt> vRanges;
2199      while ( getline(ranges, range, ' ') ) 
2200      {       
2201        istringstream(range) >> val;       
2202        vRanges.push_back(val);
2203      }     
2204      assert( vRanges.size()%2==0 );
2205      assert( vRanges.size()==2*(m_numOverlayElementsMinus1[i]+1) );
2206      m_overlayElementLabelMin[i].resize( m_numOverlayElementsMinus1[i]+1 );
2207      m_overlayElementLabelMax[i].resize( m_numOverlayElementsMinus1[i]+1 );
2208      for (Int j=0 ; j<=m_numOverlayElementsMinus1[i] ; j++)
2209      {
2210        m_overlayElementLabelMin[i][j] = vRanges[2*j];
2211        m_overlayElementLabelMax[i][j] = vRanges[2*j+1];
2212      }
2213     
2214      //parse overlay element names
2215      istringstream elementNames(cfg_overlaySEIElementNames[i]);
2216      string elementName;               
2217      vector<string> vElementName;               
2218      while ( getline(elementNames, elementName, '|') ) 
2219      {       
2220        vElementName.push_back(elementName);         
2221      }     
2222      if ( m_overlayLabelPresentFlag[i] )
2223      {
2224        m_overlayElementName[i].resize( m_numOverlayElementsMinus1[i]+1 );     
2225        for (Int j=0 ; j<=m_numOverlayElementsMinus1[i] ; j++)
2226        {
2227          if (j < vElementName.size())
2228          {
2229            m_overlayElementName[i][j] = vElementName[j];
2230          }
2231          else
2232          {
2233            m_overlayElementName[i][j] = string("NoElementName");
2234          }
2235        }
2236      }           
2237    }       
2238  }
2239#endif
2240#if Q0074_COLOUR_REMAPPING_SEI
2241#if !SVC_EXTENSION
2242  // reading external Colour Remapping Information SEI message parameters from file
2243  if( m_colourRemapSEIFile.size() > 0 )
2244  {
2245    FILE* fic;
2246    Int retval;
2247    if((fic = fopen(m_colourRemapSEIFile.c_str(),"r")) == (FILE*)NULL)
2248    {
2249      fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", m_colourRemapSEIFile.c_str());
2250      exit(EXIT_FAILURE);
2251    }
2252
2253    retval = fscanf( fic, "%d", &m_colourRemapSEIId );
2254    retval = fscanf( fic, "%d", &m_colourRemapSEICancelFlag );
2255    if( !m_colourRemapSEICancelFlag )
2256    {
2257      retval = fscanf( fic, "%d", &m_colourRemapSEIPersistenceFlag );
2258      retval = fscanf( fic, "%d", &m_colourRemapSEIVideoSignalInfoPresentFlag);
2259      if( m_colourRemapSEIVideoSignalInfoPresentFlag )
2260      {
2261        retval = fscanf( fic, "%d", &m_colourRemapSEIFullRangeFlag  );
2262        retval = fscanf( fic, "%d", &m_colourRemapSEIPrimaries );
2263        retval = fscanf( fic, "%d", &m_colourRemapSEITransferFunction );
2264        retval = fscanf( fic, "%d", &m_colourRemapSEIMatrixCoefficients );
2265      }
2266
2267      retval = fscanf( fic, "%d", &m_colourRemapSEIInputBitDepth );
2268      retval = fscanf( fic, "%d", &m_colourRemapSEIBitDepth );
2269 
2270      for( Int c=0 ; c<3 ; c++ )
2271      {
2272        retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutNumValMinus1[c] );
2273        if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
2274        {
2275          m_colourRemapSEIPreLutCodedValue[c]  = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
2276          m_colourRemapSEIPreLutTargetValue[c] = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
2277          for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
2278          {
2279            retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutCodedValue[c][i] );
2280            retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutTargetValue[c][i] );
2281          }
2282        }
2283      }
2284
2285      retval = fscanf( fic, "%d", &m_colourRemapSEIMatrixPresentFlag );
2286      if( m_colourRemapSEIMatrixPresentFlag )
2287      {
2288        retval = fscanf( fic, "%d", &m_colourRemapSEILog2MatrixDenom );
2289        for( Int c=0 ; c<3 ; c++ )
2290          for( Int i=0 ; i<3 ; i++ )
2291            retval = fscanf( fic, "%d", &m_colourRemapSEICoeffs[c][i] );
2292      }
2293
2294      for( Int c=0 ; c<3 ; c++ )
2295      {
2296        retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutNumValMinus1[c] );
2297        if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
2298        {
2299          m_colourRemapSEIPostLutCodedValue[c]  = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
2300          m_colourRemapSEIPostLutTargetValue[c] = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
2301          for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
2302          {
2303            retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutCodedValue[c][i] );
2304            retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutTargetValue[c][i] );
2305          }
2306        }
2307      }
2308    }
2309
2310    fclose( fic );
2311    if( retval != 1 )
2312    {
2313      fprintf(stderr, "Error while reading Colour Remapping Information SEI parameters file\n");
2314      exit(EXIT_FAILURE);
2315    }
2316  }
2317#else
2318   // Reading external Colour Remapping Information SEI message parameters from file
2319  // It seems that TAppEncLayerCfg::parseCfg is not used
2320  for(UInt layer = 0; layer < m_numLayers; layer++)
2321  {
2322    if( cfg_colourRemapSEIFile[layer]->length() )
2323    {
2324      FILE* fic;
2325      Int retval;
2326      if((fic = fopen(cfg_colourRemapSEIFile[layer]->c_str(),"r")) == (FILE*)NULL)
2327      {
2328        fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", cfg_colourRemapSEIFile[layer]->c_str());
2329        exit(EXIT_FAILURE);
2330      }
2331      Int tempCode;
2332      retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIId );
2333      retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEICancelFlag = tempCode ? 1 : 0;
2334      if( !m_acLayerCfg[layer].m_colourRemapSEICancelFlag )
2335      {
2336        retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIPersistenceFlag = tempCode ? 1 : 0;
2337        retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIVideoSignalInfoPresentFlag = tempCode ? 1 : 0;
2338        if( m_acLayerCfg[layer].m_colourRemapSEIVideoSignalInfoPresentFlag )
2339        {
2340          retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIFullRangeFlag = tempCode ? 1 : 0;
2341          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPrimaries );
2342          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEITransferFunction );
2343          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIMatrixCoefficients );
2344        }
2345
2346        retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIInputBitDepth );
2347        retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIBitDepth );
2348 
2349        for( Int c=0 ; c<3 ; c++ )
2350        {
2351          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c] );
2352          if( m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]>0 )
2353          {
2354            m_acLayerCfg[layer].m_colourRemapSEIPreLutCodedValue[c]  = new Int[m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]+1];
2355            m_acLayerCfg[layer].m_colourRemapSEIPreLutTargetValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]+1];
2356            for( Int i=0 ; i<=m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
2357            {
2358              retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutCodedValue[c][i] );
2359              retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutTargetValue[c][i] );
2360            }
2361          }
2362        }
2363
2364        retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIMatrixPresentFlag = tempCode ? 1 : 0;
2365        if( m_acLayerCfg[layer].m_colourRemapSEIMatrixPresentFlag )
2366        {
2367          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEILog2MatrixDenom );
2368          for( Int c=0 ; c<3 ; c++ )
2369            for( Int i=0 ; i<3 ; i++ )
2370              retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEICoeffs[c][i] );
2371        }
2372
2373        for( Int c=0 ; c<3 ; c++ )
2374        {
2375          retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c] );
2376          if( m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]>0 )
2377          {
2378            m_acLayerCfg[layer].m_colourRemapSEIPostLutCodedValue[c]  = new Int[m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]+1];
2379            m_acLayerCfg[layer].m_colourRemapSEIPostLutTargetValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]+1];
2380            for( Int i=0 ; i<=m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
2381            {
2382              retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutCodedValue[c][i] );
2383              retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutTargetValue[c][i] );
2384            }
2385          }
2386        }
2387      }
2388
2389      fclose( fic );
2390      if( retval != 1 )
2391      {
2392        fprintf(stderr, "Error while reading Colour Remapping Information SEI parameters file\n");
2393        exit(EXIT_FAILURE);
2394      }
2395    }
2396  }
2397#endif
2398#endif
2399#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
2400  if (m_interLayerConstrainedTileSetsSEIEnabled)
2401  {
2402    if (m_numTileColumnsMinus1 == 0 && m_numTileRowsMinus1 == 0)
2403    {
2404      printf( "Tiles are not defined (needed for inter-layer comnstrained tile sets SEI).\n" );
2405      exit( EXIT_FAILURE );
2406    }
2407    Char* pTileSets = cfg_tileSets.empty() ? NULL : strdup(cfg_tileSets.c_str());
2408    int i = 0;
2409    char *topLeftTileIndex = strtok(pTileSets, " ,");
2410    while(topLeftTileIndex != NULL)
2411    {
2412      if( i >= m_ilNumSetsInMessage )
2413      {
2414        printf( "The number of tile sets is larger than defined by IlNumSetsInMessage.\n" );
2415        exit( EXIT_FAILURE );
2416      }
2417      *( m_topLeftTileIndex + i ) = atoi( topLeftTileIndex );
2418      char *bottonRightTileIndex = strtok(NULL, " ,");
2419      if( bottonRightTileIndex == NULL )
2420      {
2421        printf( "BottonRightTileIndex is missing in the tile sets.\n" );
2422        exit( EXIT_FAILURE );
2423      }
2424      *( m_bottomRightTileIndex + i ) = atoi( bottonRightTileIndex );
2425      char *ilcIdc = strtok(NULL, " ,");
2426      if( ilcIdc == NULL )
2427      {
2428        printf( "IlcIdc is missing in the tile sets.\n" );
2429        exit( EXIT_FAILURE );
2430      }
2431      *( m_ilcIdc + i ) = atoi( ilcIdc );
2432      topLeftTileIndex = strtok(NULL, " ,");
2433      i++;
2434    }
2435    if( i < m_ilNumSetsInMessage )
2436    {
2437      printf( "The number of tile sets is smaller than defined by IlNumSetsInMessage.\n" );
2438      exit( EXIT_FAILURE );
2439    }
2440    m_skippedTileSetPresentFlag = false;
2441
2442    if( pTileSets )
2443    {
2444      free( pTileSets );
2445      pTileSets = NULL;
2446    }
2447  }
2448#endif
2449  // check validity of input parameters
2450  xCheckParameter();
2451 
2452  // set global varibles
2453#if LAYER_CTB
2454  for(Int layer = 0; layer < MAX_LAYERS; layer++)
2455  {
2456    xSetGlobal(layer);
2457  }
2458#else
2459  xSetGlobal();
2460#endif
2461 
2462  // print-out parameters
2463  xPrintParameter();
2464 
2465  return true;
2466}
2467// ====================================================================================================================
2468// Private member functions
2469// ====================================================================================================================
2470
2471Bool confirmPara(Bool bflag, const Char* message);
2472
2473Void TAppEncCfg::xCheckParameter()
2474{
2475  if (!m_decodedPictureHashSEIEnabled)
2476  {
2477    fprintf(stderr, "******************************************************************\n");
2478    fprintf(stderr, "** WARNING: --SEIDecodedPictureHash is now disabled by default. **\n");
2479    fprintf(stderr, "**          Automatic verification of decoded pictures by a     **\n");
2480    fprintf(stderr, "**          decoder requires this option to be enabled.         **\n");
2481    fprintf(stderr, "******************************************************************\n");
2482  }
2483  if( m_profile==Profile::NONE )
2484  {
2485    fprintf(stderr, "***************************************************************************\n");
2486    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Profile value must be set! **\n");
2487    fprintf(stderr, "***************************************************************************\n");
2488  }
2489  if( m_level==Level::NONE )
2490  {
2491    fprintf(stderr, "***************************************************************************\n");
2492    fprintf(stderr, "** WARNING: For conforming bitstreams a valid Level value must be set!   **\n");
2493    fprintf(stderr, "***************************************************************************\n");
2494  }
2495
2496  Bool check_failed = false; /* abort if there is a fatal configuration problem */
2497#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
2498  // check range of parameters
2499#if O0194_DIFFERENT_BITDEPTH_EL_BL
2500  for(UInt layer=0; layer<m_numLayers; layer++)
2501  {
2502    xConfirmPara( m_acLayerCfg[layer].m_inputBitDepthY < 8,                                                     "InputBitDepth must be at least 8" );
2503    xConfirmPara( m_acLayerCfg[layer].m_inputBitDepthC < 8,                                                     "InputBitDepthC must be at least 8" );
2504  }
2505#else
2506  xConfirmPara( m_inputBitDepthY < 8,                                                     "InputBitDepth must be at least 8" );
2507  xConfirmPara( m_inputBitDepthC < 8,                                                     "InputBitDepthC must be at least 8" );
2508#endif
2509#if !SVC_EXTENSION 
2510  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
2511#endif
2512  xConfirmPara( m_framesToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
2513  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
2514  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
2515#if !SVC_EXTENSION
2516  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
2517#endif
2518#if ALLOW_RECOVERY_POINT_AS_RAP
2519  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 3,                   "Decoding Refresh Type must be comprised between 0 and 3 included" );
2520  if(m_iDecodingRefreshType == 3)
2521  {
2522    xConfirmPara( !m_recoveryPointSEIEnabled,                                               "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
2523  }
2524#else
2525  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
2526#endif
2527#if !SVC_EXTENSION
2528  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
2529#endif
2530  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6,          "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
2531  xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6,              "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
2532  xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
2533  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
2534  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
2535  xConfirmPara( m_iMaxDeltaQP > 7,                                                          "Absolute Delta QP exceeds supported range (0 to 7)" );
2536#if LAYER_CTB
2537  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2538  {
2539    xConfirmPara( m_iMaxCuDQPDepth > m_acLayerCfg[layer].m_uiMaxCUDepth - 1,                "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
2540  }
2541#else
2542  xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1,                                          "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
2543#endif
2544
2545  xConfirmPara( m_cbQpOffset < -12,   "Min. Chroma Cb QP Offset is -12" );
2546  xConfirmPara( m_cbQpOffset >  12,   "Max. Chroma Cb QP Offset is  12" );
2547  xConfirmPara( m_crQpOffset < -12,   "Min. Chroma Cr QP Offset is -12" );
2548  xConfirmPara( m_crQpOffset >  12,   "Max. Chroma Cr QP Offset is  12" );
2549
2550  xConfirmPara( m_iQPAdaptationRange <= 0,                                                  "QP Adaptation Range must be more than 0" );
2551#if !SVC_EXTENSION
2552  if (m_iDecodingRefreshType == 2)
2553  {
2554    xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize ,                      "Intra period must be larger than GOP size for periodic IDR pictures");
2555  }
2556#endif
2557#if !LAYER_CTB
2558  xConfirmPara( (m_uiMaxCUWidth  >> m_uiMaxCUDepth) < 4,                                    "Minimum partition width size should be larger than or equal to 8");
2559  xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4,                                    "Minimum partition height size should be larger than or equal to 8");
2560  xConfirmPara( m_uiMaxCUWidth < 16,                                                        "Maximum partition width size should be larger than or equal to 16");
2561  xConfirmPara( m_uiMaxCUHeight < 16,                                                       "Maximum partition height size should be larger than or equal to 16");
2562#endif
2563#if !SVC_EXTENSION
2564  xConfirmPara( (m_iSourceWidth  % (m_uiMaxCUWidth  >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame width must be a multiple of the minimum CU size");
2565  xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0,             "Resulting coded frame height must be a multiple of the minimum CU size");
2566#endif
2567 
2568#if !LAYER_CTB
2569  xConfirmPara( m_uiQuadtreeTULog2MinSize < 2,                                        "QuadtreeTULog2MinSize must be 2 or greater.");
2570  xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5,                                        "QuadtreeTULog2MaxSize must be 5 or smaller.");
2571  xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth,                                        "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
2572 
2573  xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize,                "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
2574  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
2575  xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
2576  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth  >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
2577  xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
2578  xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1,                                                         "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
2579  xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthInter - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
2580  xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1,                                                         "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
2581  xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthIntra - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
2582#endif
2583 
2584  xConfirmPara(  m_maxNumMergeCand < 1,  "MaxNumMergeCand must be 1 or greater.");
2585  xConfirmPara(  m_maxNumMergeCand > 5,  "MaxNumMergeCand must be 5 or smaller.");
2586
2587#if !SVC_EXTENSION
2588#if ADAPTIVE_QP_SELECTION
2589  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
2590  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
2591#endif
2592#endif
2593
2594  if( m_usePCM)
2595  {
2596    xConfirmPara(  m_uiPCMLog2MinSize < 3,                                      "PCMLog2MinSize must be 3 or greater.");
2597    xConfirmPara(  m_uiPCMLog2MinSize > 5,                                      "PCMLog2MinSize must be 5 or smaller.");
2598    xConfirmPara(  m_pcmLog2MaxSize > 5,                                        "PCMLog2MaxSize must be 5 or smaller.");
2599    xConfirmPara(  m_pcmLog2MaxSize < m_uiPCMLog2MinSize,                       "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
2600  }
2601
2602  xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
2603  if (m_sliceMode!=0)
2604  {
2605    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
2606  }
2607  xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
2608  if (m_sliceSegmentMode!=0)
2609  {
2610    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
2611  }
2612 
2613#if !SVC_EXTENSION
2614  Bool tileFlag = (m_numTileColumnsMinus1 > 0 || m_numTileRowsMinus1 > 0 );
2615  xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
2616
2617  //TODO:ChromaFmt assumes 4:2:0 below
2618  xConfirmPara( m_iSourceWidth  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
2619  xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
2620
2621  xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
2622  xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
2623
2624  xConfirmPara( m_confWinLeft   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
2625  xConfirmPara( m_confWinRight  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
2626  xConfirmPara( m_confWinTop    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
2627  xConfirmPara( m_confWinBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
2628
2629  xConfirmPara( m_defaultDisplayWindowFlag && !m_vuiParametersPresentFlag, "VUI needs to be enabled for default display window");
2630
2631  if (m_defaultDisplayWindowFlag)
2632  {
2633    xConfirmPara( m_defDispWinLeftOffset   % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left default display window offset must be an integer multiple of the specified chroma subsampling");
2634    xConfirmPara( m_defDispWinRightOffset  % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right default display window offset must be an integer multiple of the specified chroma subsampling");
2635    xConfirmPara( m_defDispWinTopOffset    % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top default display window offset must be an integer multiple of the specified chroma subsampling");
2636    xConfirmPara( m_defDispWinBottomOffset % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom default display window offset must be an integer multiple of the specified chroma subsampling");
2637  }
2638#endif
2639
2640#if !LAYER_CTB
2641  // max CU width and height should be power of 2
2642  UInt ui = m_uiMaxCUWidth;
2643  while(ui)
2644  {
2645    ui >>= 1;
2646    if( (ui & 1) == 1)
2647      xConfirmPara( ui != 1 , "Width should be 2^n");
2648  }
2649  ui = m_uiMaxCUHeight;
2650  while(ui)
2651  {
2652    ui >>= 1;
2653    if( (ui & 1) == 1)
2654      xConfirmPara( ui != 1 , "Height should be 2^n");
2655  }
2656#endif
2657
2658  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
2659   * This permits the ability to omit a GOP structure specification */
2660#if SVC_EXTENSION
2661#if Q0108_TSA_STSA
2662  if( m_acLayerCfg[0].m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1 )
2663  {
2664    m_GOPList[0] = GOPEntry();
2665    m_GOPList[0].m_QPFactor = 1;
2666    m_GOPList[0].m_betaOffsetDiv2 = 0;
2667    m_GOPList[0].m_tcOffsetDiv2 = 0;
2668    m_GOPList[0].m_POC = 1;
2669    m_GOPList[0].m_numRefPicsActive = 4;
2670  }
2671
2672  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2673  {
2674    if (m_acLayerCfg[layer].m_iIntraPeriod == 1 && m_EhGOPList[layer][0].m_POC == -1) {
2675      m_EhGOPList[layer][0] = GOPEntry();
2676      m_EhGOPList[layer][0].m_QPFactor = 1;
2677      m_EhGOPList[layer][0].m_betaOffsetDiv2 = 0;
2678      m_EhGOPList[layer][0].m_tcOffsetDiv2 = 0;
2679      m_EhGOPList[layer][0].m_POC = 1;
2680      m_EhGOPList[layer][0].m_numRefPicsActive = 4;
2681    }
2682  }
2683#else
2684  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2685  {
2686    Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
2687    if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
2688      m_GOPList[0] = GOPEntry();
2689      m_GOPList[0].m_QPFactor = 1;
2690      m_GOPList[0].m_betaOffsetDiv2 = 0;
2691      m_GOPList[0].m_tcOffsetDiv2 = 0;
2692      m_GOPList[0].m_POC = 1;
2693      m_GOPList[0].m_numRefPicsActive = 4;
2694    }
2695  }
2696#endif
2697#else
2698  if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
2699    m_GOPList[0] = GOPEntry();
2700    m_GOPList[0].m_QPFactor = 1;
2701    m_GOPList[0].m_betaOffsetDiv2 = 0;
2702    m_GOPList[0].m_tcOffsetDiv2 = 0;
2703    m_GOPList[0].m_POC = 1;
2704    m_GOPList[0].m_numRefPicsActive = 4;
2705  }
2706#endif
2707
2708  Bool verifiedGOP=false;
2709  Bool errorGOP=false;
2710  Int checkGOP=1;
2711  Int numRefs = m_isField ? 2 : 1;
2712  Int refList[MAX_NUM_REF_PICS+1];
2713  refList[0]=0;
2714  if(m_isField)
2715  {
2716    refList[1] = 1;
2717  }
2718  Bool isOK[MAX_GOP];
2719  for(Int i=0; i<MAX_GOP; i++) 
2720  {
2721    isOK[i]=false;
2722  }
2723  Int numOK=0;
2724#if !SVC_EXTENSION
2725  xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
2726#endif
2727
2728  for(Int i=0; i<m_iGOPSize; i++)
2729  {
2730    if(m_GOPList[i].m_POC==m_iGOPSize)
2731    {
2732      xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
2733    }
2734  }
2735
2736#if SVC_EXTENSION
2737  xConfirmPara( m_numLayers > MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" );
2738  m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers;
2739 
2740  // it can be updated after AVC BL support will be added to the WD
2741#if VPS_AVC_BL_FLAG_REMOVAL
2742  if( m_nonHEVCBaseLayerFlag )
2743#else
2744  if( m_avcBaseLayerFlag )
2745#endif
2746  {
2747    m_crossLayerIrapAlignFlag = false;
2748    m_crossLayerPictureTypeAlignFlag = false;
2749    m_crossLayerAlignedIdrOnlyFlag = false;
2750  }
2751
2752  // verify layer configuration parameters
2753  for(UInt layer=0; layer<m_numLayers; layer++)
2754  {
2755    if(m_acLayerCfg[layer].xCheckParameter(m_isField))
2756    {
2757      printf("\nError: invalid configuration parameter found in layer %d \n", layer);
2758      check_failed = true;
2759    }
2760  }
2761
2762  // verify layer configuration parameters
2763  for(UInt layer=0; layer<m_numLayers; layer++)
2764  {
2765    Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
2766#endif
2767  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
2768  {
2769    for(Int i=0; i<m_iGOPSize; i++)
2770    {
2771      xConfirmPara( (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) < -6 || (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) > 6, "Loop Filter Beta Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
2772      xConfirmPara( (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) < -6 || (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) > 6, "Loop Filter Tc Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
2773    }
2774  }
2775#if SVC_EXTENSION
2776  }
2777#endif
2778
2779#if !Q0108_TSA_STSA
2780   m_extraRPSs = 0;                                     
2781#else
2782  memset( m_extraRPSs, 0, sizeof( m_extraRPSs ) );
2783#endif
2784  //start looping through frames in coding order until we can verify that the GOP structure is correct.
2785  while(!verifiedGOP&&!errorGOP) 
2786  {
2787    Int curGOP = (checkGOP-1)%m_iGOPSize;
2788    Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;   
2789    if(m_GOPList[curGOP].m_POC<0) 
2790    {
2791      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
2792      errorGOP=true;
2793    }
2794    else 
2795    {
2796      //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
2797      Bool beforeI = false;
2798      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
2799      {
2800        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2801        if(absPOC < 0)
2802        {
2803          beforeI=true;
2804        }
2805        else 
2806        {
2807          Bool found=false;
2808          for(Int j=0; j<numRefs; j++) 
2809          {
2810            if(refList[j]==absPOC) 
2811            {
2812              found=true;
2813              for(Int k=0; k<m_iGOPSize; k++)
2814              {
2815                if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
2816                {
2817                  if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
2818                  {
2819                    m_GOPList[k].m_refPic = true;
2820                  }
2821                  m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2822                }
2823              }
2824            }
2825          }
2826          if(!found)
2827          {
2828            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
2829            errorGOP=true;
2830          }
2831        }
2832      }
2833      if(!beforeI&&!errorGOP)
2834      {
2835        //all ref frames were present
2836        if(!isOK[curGOP]) 
2837        {
2838          numOK++;
2839          isOK[curGOP]=true;
2840          if(numOK==m_iGOPSize)
2841          {
2842            verifiedGOP=true;
2843          }
2844        }
2845      }
2846      else 
2847      {
2848        //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
2849#if !Q0108_TSA_STSA
2850        m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
2851#else
2852        m_GOPList[m_iGOPSize+m_extraRPSs[0]]=m_GOPList[curGOP];
2853#endif
2854        Int newRefs=0;
2855        for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
2856        {
2857          Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2858          if(absPOC>=0)
2859          {
2860#if !Q0108_TSA_STSA
2861            m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2862            m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2863#else
2864            m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2865            m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2866#endif
2867            newRefs++;
2868          }
2869        }
2870        Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
2871       
2872        for(Int offset = -1; offset>-checkGOP; offset--)
2873        {
2874          //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
2875          Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
2876          Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
2877          if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
2878          {
2879            Bool newRef=false;
2880            for(Int i=0; i<numRefs; i++)
2881            {
2882              if(refList[i]==offPOC)
2883              {
2884                newRef=true;
2885              }
2886            }
2887            for(Int i=0; i<newRefs; i++) 
2888            {
2889#if !Q0108_TSA_STSA
2890              if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
2891#else
2892              if(m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[i]==offPOC-curPOC)
2893#endif
2894              {
2895                newRef=false;
2896              }
2897            }
2898            if(newRef) 
2899            {
2900              Int insertPoint=newRefs;
2901              //this picture can be added, find appropriate place in list and insert it.
2902              if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
2903              {
2904                m_GOPList[offGOP].m_refPic = true;
2905              }
2906              for(Int j=0; j<newRefs; j++)
2907              {
2908#if !Q0108_TSA_STSA
2909                if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
2910#else
2911                if(m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]<offPOC-curPOC||m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]>0)
2912#endif
2913                {
2914                  insertPoint = j;
2915                  break;
2916                }
2917              }
2918              Int prev = offPOC-curPOC;
2919              Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2920              for(Int j=insertPoint; j<newRefs+1; j++)
2921              {
2922#if !Q0108_TSA_STSA
2923                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
2924                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
2925                m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
2926                m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
2927#else
2928                Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j];
2929                Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j];
2930                m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]=prev;
2931                m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j]=prevUsed;
2932#endif
2933
2934                prevUsed=newUsed;
2935                prev=newPrev;
2936              }
2937              newRefs++;
2938            }
2939          }
2940          if(newRefs>=numPrefRefs)
2941          {
2942            break;
2943          }
2944        }
2945#if !Q0108_TSA_STSA
2946        m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
2947        m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
2948#else
2949        m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefPics=newRefs;
2950        m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_POC = curPOC;
2951#endif
2952#if !Q0108_TSA_STSA
2953        if (m_extraRPSs == 0)
2954#else
2955        if (m_extraRPSs[0] == 0)
2956#endif
2957        {
2958#if !Q0108_TSA_STSA
2959          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
2960          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
2961#else
2962          m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_interRPSPrediction = 0;
2963          m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefIdc = 0;
2964#endif
2965        }
2966        else
2967        {
2968#if !Q0108_TSA_STSA
2969          Int rIdx =  m_iGOPSize + m_extraRPSs - 1;
2970#else
2971          Int rIdx =  m_iGOPSize + m_extraRPSs[0] - 1;
2972#endif
2973          Int refPOC = m_GOPList[rIdx].m_POC;
2974          Int refPics = m_GOPList[rIdx].m_numRefPics;
2975          Int newIdc=0;
2976          for(Int i = 0; i<= refPics; i++) 
2977          {
2978            Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
2979            Int absPOCref = refPOC+deltaPOC;
2980            Int refIdc = 0;
2981#if !Q0108_TSA_STSA
2982            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
2983            {
2984              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
2985              {
2986                if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
2987                {
2988                  refIdc = 1;
2989                }
2990                else
2991                {
2992                  refIdc = 2;
2993                }
2994              }
2995            }
2996            m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2997            newIdc++;
2998          }
2999          m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 
3000          m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
3001          m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 
3002        }
3003        curGOP=m_iGOPSize+m_extraRPSs;
3004        m_extraRPSs++;
3005      }
3006#else
3007            for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefPics; j++)
3008            {
3009              if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j])
3010              {
3011                if (m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j])
3012                {
3013                  refIdc = 1;
3014                }
3015                else
3016                {
3017                  refIdc = 2;
3018                }
3019              }
3020            }
3021            m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_refIdc[newIdc]=refIdc;
3022            newIdc++;
3023          }
3024          m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_interRPSPrediction = 1; 
3025          m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefIdc = newIdc;
3026          m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_POC; 
3027        }
3028        curGOP=m_iGOPSize+m_extraRPSs[0];
3029        m_extraRPSs[0]++;
3030      }
3031#endif
3032
3033      numRefs=0;
3034      for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 
3035      {
3036        Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
3037        if(absPOC >= 0) 
3038        {
3039          refList[numRefs]=absPOC;
3040          numRefs++;
3041        }
3042      }
3043      refList[numRefs]=curPOC;
3044      numRefs++;
3045    }
3046    checkGOP++;
3047  }
3048  xConfirmPara(errorGOP,"Invalid GOP structure given");
3049
3050#if SVC_EXTENSION && Q0108_TSA_STSA
3051  for ( Int layerId = 1; layerId < m_numLayers; layerId++ )
3052  {
3053    verifiedGOP=false;
3054    errorGOP=false;
3055    checkGOP=1;
3056    numRefs = m_isField ? 2 : 1;
3057    refList[0]=0;
3058
3059    if(m_isField)
3060    {
3061      refList[1] = 1;
3062    }
3063
3064    memset( isOK, 0, sizeof( isOK ) );
3065    numOK=0;
3066
3067    for(Int i=0; i<m_iGOPSize; i++)
3068    {
3069      if(m_EhGOPList[layerId][i].m_POC==m_iGOPSize)
3070      {
3071        xConfirmPara( m_EhGOPList[layerId][i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
3072      }
3073    }
3074
3075    xConfirmPara( m_numLayers > MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" );
3076    m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers;
3077
3078    // verify layer configuration parameters
3079    for(UInt layer=0; layer<m_numLayers; layer++)
3080    {
3081      Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
3082      if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
3083      {
3084        for(Int i=0; i<m_iGOPSize; i++)
3085        {
3086          xConfirmPara( (m_EhGOPList[layerId][i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) < -6 || (m_EhGOPList[layerId][i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) > 6, "Loop Filter Beta Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
3087          xConfirmPara( (m_EhGOPList[layerId][i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) < -6 || (m_EhGOPList[layerId][i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) > 6, "Loop Filter Tc Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
3088        }
3089      }
3090    }
3091
3092    //start looping through frames in coding order until we can verify that the GOP structure is correct.
3093    while(!verifiedGOP&&!errorGOP) 
3094    {
3095      Int curGOP = (checkGOP-1)%m_iGOPSize;
3096      Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_EhGOPList[layerId][curGOP].m_POC;   
3097      if(m_EhGOPList[layerId][curGOP].m_POC<0) 
3098      {
3099        printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
3100        errorGOP=true;
3101      }
3102      else 
3103      {
3104        //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
3105        Bool beforeI = false;
3106        for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++) 
3107        {
3108          Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3109          if(absPOC < 0)
3110          {
3111            beforeI=true;
3112          }
3113          else 
3114          {
3115            Bool found=false;
3116            for(Int j=0; j<numRefs; j++) 
3117            {
3118              if(refList[j]==absPOC) 
3119              {
3120                found=true;
3121                for(Int k=0; k<m_iGOPSize; k++)
3122                {
3123                  if(absPOC%m_iGOPSize == m_EhGOPList[layerId][k].m_POC%m_iGOPSize)
3124                  {
3125                    if(m_EhGOPList[layerId][k].m_temporalId==m_EhGOPList[layerId][curGOP].m_temporalId)
3126                    {
3127                      m_EhGOPList[layerId][k].m_refPic = true;
3128                    }
3129                    m_EhGOPList[layerId][curGOP].m_usedByCurrPic[i]=m_EhGOPList[layerId][k].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId;
3130                  }
3131                }
3132              }
3133            }
3134            if(!found)
3135            {
3136              printf("\nError: ref pic %d is not available for GOP frame %d\n",m_EhGOPList[layerId][curGOP].m_referencePics[i],curGOP+1);
3137              errorGOP=true;
3138            }
3139          }
3140        }
3141        if(!beforeI&&!errorGOP)
3142        {
3143          //all ref frames were present
3144          if(!isOK[curGOP]) 
3145          {
3146            numOK++;
3147            isOK[curGOP]=true;
3148            if(numOK==m_iGOPSize)
3149            {
3150              verifiedGOP=true;
3151            }
3152          }
3153        }
3154        else 
3155        {
3156          //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
3157
3158          m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]]=m_EhGOPList[layerId][curGOP];
3159          Int newRefs=0;
3160          for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++) 
3161          {
3162            Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3163            if(absPOC>=0)
3164            {
3165              m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[newRefs]=m_EhGOPList[layerId][curGOP].m_referencePics[i];
3166              m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[newRefs]=m_EhGOPList[layerId][curGOP].m_usedByCurrPic[i];
3167              newRefs++;
3168            }
3169          }
3170          Int numPrefRefs = m_EhGOPList[layerId][curGOP].m_numRefPicsActive;
3171
3172          for(Int offset = -1; offset>-checkGOP; offset--)
3173          {
3174            //step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
3175            Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
3176            Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_EhGOPList[layerId][offGOP].m_POC;
3177            if(offPOC>=0&&m_EhGOPList[layerId][offGOP].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId)
3178            {
3179              Bool newRef=false;
3180              for(Int i=0; i<numRefs; i++)
3181              {
3182                if(refList[i]==offPOC)
3183                {
3184                  newRef=true;
3185                }
3186              }
3187              for(Int i=0; i<newRefs; i++) 
3188              {
3189                if(m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[i]==offPOC-curPOC)
3190                {
3191                  newRef=false;
3192                }
3193              }
3194              if(newRef) 
3195              {
3196                Int insertPoint=newRefs;
3197                //this picture can be added, find appropriate place in list and insert it.
3198                if(m_EhGOPList[layerId][offGOP].m_temporalId==m_EhGOPList[layerId][curGOP].m_temporalId)
3199                {
3200                  m_EhGOPList[layerId][offGOP].m_refPic = true;
3201                }
3202                for(Int j=0; j<newRefs; j++)
3203                {
3204                  if(m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]<offPOC-curPOC||m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]>0)
3205                  {
3206                    insertPoint = j;
3207                    break;
3208                  }
3209                }
3210                Int prev = offPOC-curPOC;
3211                Int prevUsed = m_EhGOPList[layerId][offGOP].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId;
3212                for(Int j=insertPoint; j<newRefs+1; j++)
3213                {
3214                  Int newPrev = m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j];
3215                  Int newUsed = m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j];
3216                  m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]=prev;
3217                  m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j]=prevUsed;
3218                  prevUsed=newUsed;
3219                  prev=newPrev;
3220                }
3221                newRefs++;
3222              }
3223            }
3224            if(newRefs>=numPrefRefs)
3225            {
3226              break;
3227            }
3228          }
3229          m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefPics=newRefs;
3230          m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_POC = curPOC;
3231          if (m_extraRPSs[layerId] == 0)
3232          {
3233            m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_interRPSPrediction = 0;
3234            m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefIdc = 0;
3235          }
3236          else
3237          {
3238            Int rIdx =  m_iGOPSize + m_extraRPSs[layerId] - 1;
3239            Int refPOC = m_EhGOPList[layerId][rIdx].m_POC;
3240            Int refPics = m_EhGOPList[layerId][rIdx].m_numRefPics;
3241            Int newIdc=0;
3242            for(Int i = 0; i<= refPics; i++) 
3243            {
3244              Int deltaPOC = ((i != refPics)? m_EhGOPList[layerId][rIdx].m_referencePics[i] : 0);  // check if the reference abs POC is >= 0
3245              Int absPOCref = refPOC+deltaPOC;
3246              Int refIdc = 0;
3247              for (Int j = 0; j < m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefPics; j++)
3248              {
3249                if ( (absPOCref - curPOC) == m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j])
3250                {
3251                  if (m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j])
3252                  {
3253                    refIdc = 1;
3254                  }
3255                  else
3256                  {
3257                    refIdc = 2;
3258                  }
3259                }
3260              }
3261              m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_refIdc[newIdc]=refIdc;
3262              newIdc++;
3263            }
3264            m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_interRPSPrediction = 1; 
3265            m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefIdc = newIdc;
3266            m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_deltaRPS = refPOC - m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_POC; 
3267          }
3268          curGOP=m_iGOPSize+m_extraRPSs[layerId];
3269          m_extraRPSs[layerId]++;
3270        }
3271        numRefs=0;
3272        for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++) 
3273        {
3274          Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3275          if(absPOC >= 0) 
3276          {
3277            refList[numRefs]=absPOC;
3278            numRefs++;
3279          }
3280        }
3281        refList[numRefs]=curPOC;
3282        numRefs++;
3283      }
3284      checkGOP++;
3285    }
3286    xConfirmPara(errorGOP,"Invalid GOP structure given");
3287  }
3288#endif
3289
3290  m_maxTempLayer = 1;
3291  for(Int i=0; i<m_iGOPSize; i++) 
3292  {
3293    if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
3294    {
3295      m_maxTempLayer = m_GOPList[i].m_temporalId+1;
3296    }
3297    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
3298  }
3299
3300#if Q0108_TSA_STSA
3301  for ( Int layerId = 1; layerId < m_numLayers; layerId++)
3302  {
3303    m_EhMaxTempLayer[layerId] = 1;
3304    for(Int i=0; i<m_iGOPSize; i++) 
3305    {
3306      if(m_EhGOPList[layerId][i].m_temporalId >= m_EhMaxTempLayer[layerId] )
3307      {
3308        m_EhMaxTempLayer[layerId] = m_EhGOPList[layerId][i].m_temporalId;
3309      }
3310      xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
3311    }
3312  }
3313#endif
3314
3315  for(Int i=0; i<MAX_TLAYER; i++)
3316  {
3317    m_numReorderPics[i] = 0;
3318    m_maxDecPicBuffering[i] = 1;
3319  }
3320  for(Int i=0; i<m_iGOPSize; i++) 
3321  {
3322    if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
3323    {
3324      m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
3325    }
3326    Int highestDecodingNumberWithLowerPOC = 0; 
3327    for(Int j=0; j<m_iGOPSize; j++)
3328    {
3329      if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
3330      {
3331        highestDecodingNumberWithLowerPOC = j;
3332      }
3333    }
3334    Int numReorder = 0;
3335    for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
3336    {
3337      if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 
3338        m_GOPList[j].m_POC > m_GOPList[i].m_POC)
3339      {
3340        numReorder++;
3341      }
3342    }   
3343    if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
3344    {
3345      m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
3346    }
3347  }
3348  for(Int i=0; i<MAX_TLAYER-1; i++) 
3349  {
3350    // a lower layer can not have higher value of m_numReorderPics than a higher layer
3351    if(m_numReorderPics[i+1] < m_numReorderPics[i])
3352    {
3353      m_numReorderPics[i+1] = m_numReorderPics[i];
3354    }
3355    // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
3356    if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
3357    {
3358      m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
3359    }
3360    // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
3361    if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
3362    {
3363      m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
3364    }
3365  }
3366
3367
3368  // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] -  1, inclusive
3369  if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
3370  {
3371    m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
3372  }
3373
3374#if SVC_EXTENSION // ToDo: it should be checked for the case when parameters are different for the layers
3375  for(UInt layer = 0; layer < MAX_LAYERS; layer++)
3376  {
3377    Int m_iSourceWidth = m_acLayerCfg[layer].m_iSourceWidth;
3378    Int m_iSourceHeight = m_acLayerCfg[layer].m_iSourceHeight;
3379#if LAYER_CTB
3380    Int m_uiMaxCUWidth = m_acLayerCfg[layer].m_uiMaxCUWidth;
3381    Int m_uiMaxCUHeight = m_acLayerCfg[layer].m_uiMaxCUHeight;
3382#endif
3383
3384    Bool tileFlag = (m_numTileColumnsMinus1 > 0 || m_numTileRowsMinus1 > 0 );
3385    Int m_iWaveFrontSynchro = m_acLayerCfg[layer].m_waveFrontSynchro;
3386    xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together");
3387#endif
3388
3389  if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
3390  { 
3391    Int PicSizeInSamplesY =  m_iSourceWidth * m_iSourceHeight;
3392    if(tileFlag)
3393    {
3394      Int maxTileWidth = 0;
3395      Int maxTileHeight = 0;
3396      Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
3397      Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
3398      if(m_tileUniformSpacingFlag)
3399      {
3400        maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_numTileColumnsMinus1)/(m_numTileColumnsMinus1+1));
3401        maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_numTileRowsMinus1)/(m_numTileRowsMinus1+1));
3402        // if only the last tile-row is one treeblock higher than the others
3403        // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
3404        if(!((heightInCU-1)%(m_numTileRowsMinus1+1)))
3405        {
3406          maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
3407        }     
3408        // if only the last tile-column is one treeblock wider than the others
3409        // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others   
3410        if(!((widthInCU-1)%(m_numTileColumnsMinus1+1)))
3411        {
3412          maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
3413        }
3414      }
3415      else // not uniform spacing
3416      {
3417        if(m_numTileColumnsMinus1<1)
3418        {
3419          maxTileWidth = m_iSourceWidth;
3420        }
3421        else
3422        {
3423          Int accColumnWidth = 0;
3424          for(Int col=0; col<(m_numTileColumnsMinus1); col++)
3425          {
3426            maxTileWidth = m_tileColumnWidth[col]>maxTileWidth ? m_tileColumnWidth[col]:maxTileWidth;
3427            accColumnWidth += m_tileColumnWidth[col];
3428          }
3429          maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth*(widthInCU-accColumnWidth):m_uiMaxCUWidth*maxTileWidth;
3430        }
3431        if(m_numTileRowsMinus1<1)
3432        {
3433          maxTileHeight = m_iSourceHeight;
3434        }
3435        else
3436        {
3437          Int accRowHeight = 0;
3438          for(Int row=0; row<(m_numTileRowsMinus1); row++)
3439          {
3440            maxTileHeight = m_tileRowHeight[row]>maxTileHeight ? m_tileRowHeight[row]:maxTileHeight;
3441            accRowHeight += m_tileRowHeight[row];
3442          }
3443          maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight*(heightInCU-accRowHeight):m_uiMaxCUHeight*maxTileHeight;
3444        }
3445      }
3446      Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
3447      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
3448    }
3449    else if(m_iWaveFrontSynchro)
3450    {
3451      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
3452    }
3453    else if(m_sliceMode == 1)
3454    {
3455      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4;
3456    }
3457    else
3458    {
3459      m_minSpatialSegmentationIdc = 0;
3460    }
3461  }
3462#if SVC_EXTENSION
3463  }
3464#endif
3465#if !SVC_EXTENSION
3466  xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
3467  xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
3468  xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
3469#endif
3470
3471  xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
3472
3473  if (m_toneMappingInfoSEIEnabled)
3474  {
3475    xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
3476    xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
3477    xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
3478    xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
3479    xConfirmPara( m_exposureIndexValue  == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
3480    xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
3481    xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
3482    xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
3483  }
3484#if P0050_KNEE_FUNCTION_SEI
3485  if (m_kneeSEIEnabled && !m_kneeSEICancelFlag)
3486  {
3487    xConfirmPara( m_kneeSEINumKneePointsMinus1 < 0 || m_kneeSEINumKneePointsMinus1 > 998, "SEIKneeFunctionNumKneePointsMinus1 must be in the range of 0 to 998");
3488    for ( UInt i=0; i<=m_kneeSEINumKneePointsMinus1; i++ ){
3489      xConfirmPara( m_kneeSEIInputKneePoint[i] < 1 || m_kneeSEIInputKneePoint[i] > 999, "SEIKneeFunctionInputKneePointValue must be in the range of 1 to 999");
3490      xConfirmPara( m_kneeSEIOutputKneePoint[i] < 0 || m_kneeSEIOutputKneePoint[i] > 1000, "SEIKneeFunctionInputKneePointValue must be in the range of 0 to 1000");
3491      if ( i > 0 )
3492      {
3493        xConfirmPara( m_kneeSEIInputKneePoint[i-1] >= m_kneeSEIInputKneePoint[i],  "The i-th SEIKneeFunctionInputKneePointValue must be greather than the (i-1)-th value");
3494      }
3495    }
3496  }
3497#endif
3498#if Q0096_OVERLAY_SEI
3499  if( m_overlaySEIEnabled && !m_overlayInfoCancelFlag )
3500  {
3501    xConfirmPara( m_overlayContentAuxIdMinus128 < 0 || m_overlayContentAuxIdMinus128 > 31, "SEIOverlayContentAuxIdMinus128 must be in the range of 0 to 31");
3502    xConfirmPara( m_overlayLabelAuxIdMinus128 < 0 || m_overlayLabelAuxIdMinus128 > 31, "SEIOverlayLabelAuxIdMinus128 must be in the range of 0 to 31");
3503    xConfirmPara( m_overlayAlphaAuxIdMinus128 < 0 || m_overlayAlphaAuxIdMinus128 > 31, "SEIOverlayAlphaAuxIdMinus128 must be in the range of 0 to 31");
3504    xConfirmPara( m_numOverlaysMinus1 < 0 || m_numOverlaysMinus1 > 15, "SEIOverlayNumOverlaysMinus1 must be in the range of 0 to 15");
3505    for (Int i=0 ; i<=m_numOverlaysMinus1 ; i++ )
3506    {
3507      xConfirmPara( m_overlayIdx[i] < 0 || m_overlayIdx[i] > 255, "SEIOverlayIdx must be in the range of 0 to 255");
3508      xConfirmPara( m_numOverlayElementsMinus1[i] < 0 || m_numOverlayElementsMinus1[i] > 255, "SEIOverlayNumElementsMinus1 must be in the range of 0 to 255");
3509    }
3510  }
3511#endif
3512#if Q0074_COLOUR_REMAPPING_SEI
3513#if !SVC_EXTENSION
3514  if ( ( m_colourRemapSEIFile.size() > 0 ) && !m_colourRemapSEICancelFlag )
3515  {
3516    xConfirmPara( m_colourRemapSEIInputBitDepth < 8 || m_colourRemapSEIInputBitDepth > 16 , "colour_remap_input_bit_depth shall be in the range of 8 to 16, inclusive");
3517    xConfirmPara( m_colourRemapSEIBitDepth < 8 || m_colourRemapSEIBitDepth > 16, "colour_remap_bit_depth shall be in the range of 8 to 16, inclusive");
3518    for( Int c=0 ; c<3 ; c++)
3519    {
3520      xConfirmPara( m_colourRemapSEIPreLutNumValMinus1[c] < 0 || m_colourRemapSEIPreLutNumValMinus1[c] > 32, "pre_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
3521      if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
3522        for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++)
3523        {
3524          xConfirmPara( m_colourRemapSEIPreLutCodedValue[c][i] < 0 || m_colourRemapSEIPreLutCodedValue[c][i] > ((1<<m_colourRemapSEIInputBitDepth)-1), "pre_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_input_bit_depth)-1, inclusive");
3525          xConfirmPara( m_colourRemapSEIPreLutTargetValue[c][i] < 0 || m_colourRemapSEIPreLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "pre_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3526        }
3527      xConfirmPara( m_colourRemapSEIPostLutNumValMinus1[c] < 0 || m_colourRemapSEIPostLutNumValMinus1[c] > 32, "post_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
3528      if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
3529        for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++)
3530        {
3531          xConfirmPara( m_colourRemapSEIPostLutCodedValue[c][i] < 0 || m_colourRemapSEIPostLutCodedValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3532          xConfirmPara( m_colourRemapSEIPostLutTargetValue[c][i] < 0 || m_colourRemapSEIPostLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3533        }
3534    }
3535    if ( m_colourRemapSEIMatrixPresentFlag )
3536    {
3537      xConfirmPara( m_colourRemapSEILog2MatrixDenom < 0 || m_colourRemapSEILog2MatrixDenom > 15, "log2_matrix_denom shall be in the range of 0 to 15, inclusive");
3538      for( Int c=0 ; c<3 ; c++)
3539        for( Int i=0 ; i<3 ; i++)
3540          xConfirmPara( m_colourRemapSEICoeffs[c][i] < -32768 || m_colourRemapSEICoeffs[c][i] > 32767, "colour_remap_coeffs[c][i] shall be in the range of -32768 and 32767, inclusive");
3541    }
3542  }
3543#endif
3544#endif
3545
3546#if RC_SHVC_HARMONIZATION
3547  for ( Int layer=0; layer<m_numLayers; layer++ )
3548  {
3549    if ( m_acLayerCfg[layer].m_RCEnableRateControl )
3550    {
3551      if ( m_acLayerCfg[layer].m_RCForceIntraQP )
3552      {
3553        if ( m_acLayerCfg[layer].m_RCInitialQP == 0 )
3554        {
3555          printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
3556          m_acLayerCfg[layer].m_RCForceIntraQP = false;
3557        }
3558      }
3559    }
3560    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
3561  }
3562#else
3563  if ( m_RCEnableRateControl )
3564  {
3565    if ( m_RCForceIntraQP )
3566    {
3567      if ( m_RCInitialQP == 0 )
3568      {
3569        printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
3570        m_RCForceIntraQP = false;
3571      }
3572    }
3573    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
3574  }
3575#endif
3576
3577  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
3578
3579  xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
3580  if (m_framePackingSEIEnabled)
3581  {
3582    xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
3583  }
3584
3585#if SVC_EXTENSION
3586#if VPS_EXTN_DIRECT_REF_LAYERS
3587  xConfirmPara( (m_acLayerCfg[0].m_numSamplePredRefLayers != 0) && (m_acLayerCfg[0].m_numSamplePredRefLayers != -1), "Layer 0 cannot have any reference layers" );
3588  // NOTE: m_numSamplePredRefLayers  (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3589  for(Int layer = 1; layer < MAX_LAYERS; layer++)
3590  {
3591    xConfirmPara(m_acLayerCfg[layer].m_numSamplePredRefLayers > layer, "Cannot reference more layers than before current layer");
3592    for(Int i = 0; i < m_acLayerCfg[layer].m_numSamplePredRefLayers; i++)
3593    {
3594      xConfirmPara(m_acLayerCfg[layer].m_samplePredRefLayerIds[i] > layer, "Cannot reference higher layers");
3595      xConfirmPara(m_acLayerCfg[layer].m_samplePredRefLayerIds[i] == layer, "Cannot reference the current layer itself");
3596    }
3597  }
3598  xConfirmPara( (m_acLayerCfg[0].m_numMotionPredRefLayers != 0) && (m_acLayerCfg[0].m_numMotionPredRefLayers != -1), "Layer 0 cannot have any reference layers" );
3599  // NOTE: m_numMotionPredRefLayers  (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3600  for(Int layer = 1; layer < MAX_LAYERS; layer++)
3601  {
3602    xConfirmPara(m_acLayerCfg[layer].m_numMotionPredRefLayers > layer, "Cannot reference more layers than before current layer");
3603    for(Int i = 0; i < m_acLayerCfg[layer].m_numMotionPredRefLayers; i++)
3604    {
3605      xConfirmPara(m_acLayerCfg[layer].m_motionPredRefLayerIds[i] > layer, "Cannot reference higher layers");
3606      xConfirmPara(m_acLayerCfg[layer].m_motionPredRefLayerIds[i] == layer, "Cannot reference the current layer itself");
3607    }
3608  }
3609
3610  xConfirmPara( (m_acLayerCfg[0].m_numActiveRefLayers != 0) && (m_acLayerCfg[0].m_numActiveRefLayers != -1), "Layer 0 cannot have any active reference layers" );
3611  // NOTE: m_numActiveRefLayers  (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3612  for(Int layer = 1; layer < MAX_LAYERS; layer++)
3613  {
3614    Bool predEnabledFlag[MAX_LAYERS];
3615    for (Int refLayer = 0; refLayer < layer; refLayer++)
3616    {
3617      predEnabledFlag[refLayer] = false;
3618    }
3619    for(Int i = 0; i < m_acLayerCfg[layer].m_numSamplePredRefLayers; i++)
3620    {
3621      predEnabledFlag[m_acLayerCfg[layer].m_samplePredRefLayerIds[i]] = true;
3622    }
3623    for(Int i = 0; i < m_acLayerCfg[layer].m_numMotionPredRefLayers; i++)
3624    {
3625      predEnabledFlag[m_acLayerCfg[layer].m_motionPredRefLayerIds[i]] = true;
3626    }
3627    Int numDirectRefLayers = 0;
3628    for (Int refLayer = 0; refLayer < layer; refLayer++)
3629    {
3630      if (predEnabledFlag[refLayer] == true) numDirectRefLayers++;
3631    }
3632    xConfirmPara(m_acLayerCfg[layer].m_numActiveRefLayers > numDirectRefLayers, "Cannot reference more layers than NumDirectRefLayers");
3633    for(Int i = 0; i < m_acLayerCfg[layer].m_numActiveRefLayers; i++)
3634    {
3635      xConfirmPara(m_acLayerCfg[layer].m_predLayerIds[i] >= numDirectRefLayers, "Cannot reference higher layers");
3636    }
3637  }
3638#endif //VPS_EXTN_DIRECT_REF_LAYERS
3639#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3640  if (m_adaptiveResolutionChange > 0)
3641  {
3642    xConfirmPara(m_numLayers != 2, "Adaptive resolution change works with 2 layers only");
3643    xConfirmPara(m_acLayerCfg[1].m_iIntraPeriod == 0 || (m_adaptiveResolutionChange % m_acLayerCfg[1].m_iIntraPeriod) != 0, "Adaptive resolution change must happen at enhancement layer RAP picture");
3644  }
3645#endif
3646#if HIGHER_LAYER_IRAP_SKIP_FLAG
3647  if (m_adaptiveResolutionChange > 0)
3648  {
3649    xConfirmPara(m_crossLayerIrapAlignFlag != 0, "Cross layer IRAP alignment must be disabled when using adaptive resolution change.");
3650  }
3651  if (m_skipPictureAtArcSwitch)
3652  {
3653    xConfirmPara(m_adaptiveResolutionChange <= 0, "Skip picture at ARC switching only works when Adaptive Resolution Change is active (AdaptiveResolutionChange > 0)");
3654  }
3655#endif
3656  for (UInt layer=0; layer < MAX_LAYERS-1; layer++)
3657  {
3658    xConfirmPara(m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1 < 0 || m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1 > 7, "MaxTidIlRefPicsPlus1 must be in range 0 to 7");
3659  }
3660#if AUXILIARY_PICTURES
3661  for (UInt layer=0; layer < MAX_LAYERS-1; layer++)
3662  {
3663#if R0062_AUX_PSEUDO_MONOCHROME
3664    xConfirmPara(m_acLayerCfg[layer].m_auxId < 0 || m_acLayerCfg[layer].m_auxId > 2, "AuxId must be in range 0 to 2");
3665#else
3666    xConfirmPara(m_acLayerCfg[layer].m_auxId < 0 || m_acLayerCfg[layer].m_auxId > 4, "AuxId must be in range 0 to 4");
3667    xConfirmPara(m_acLayerCfg[layer].m_auxId > 0 && m_acLayerCfg[layer].m_chromaFormatIDC != CHROMA_400, "Auxiliary picture must be monochrome picture");
3668#endif
3669  }
3670#endif
3671#if Q0048_CGS_3D_ASYMLUT
3672  xConfirmPara( m_nCGSFlag < 0 || m_nCGSFlag > 1 , "0<=CGS<=1" );
3673#endif
3674#endif //SVC_EXTENSION
3675#undef xConfirmPara
3676  if (check_failed)
3677  {
3678    exit(EXIT_FAILURE);
3679  }
3680}
3681
3682/** \todo use of global variables should be removed later
3683 */
3684#if LAYER_CTB
3685Void TAppEncCfg::xSetGlobal(UInt layerId)
3686{
3687  // set max CU width & height
3688  g_auiLayerMaxCUWidth[layerId]  = m_acLayerCfg[layerId].m_uiMaxCUWidth;
3689  g_auiLayerMaxCUHeight[layerId] = m_acLayerCfg[layerId].m_uiMaxCUHeight;
3690 
3691  // compute actual CU depth with respect to config depth and max transform size
3692  g_auiLayerAddCUDepth[layerId]  = 0;
3693  while( (m_acLayerCfg[layerId].m_uiMaxCUWidth>>m_acLayerCfg[layerId].m_uiMaxCUDepth) > ( 1 << ( m_acLayerCfg[layerId].m_uiQuadtreeTULog2MinSize + g_auiLayerAddCUDepth[layerId] )  ) ) g_auiLayerAddCUDepth[layerId]++;
3694 
3695  m_acLayerCfg[layerId].m_uiMaxCUDepth += g_auiLayerAddCUDepth[layerId];
3696  g_auiLayerAddCUDepth[layerId]++;
3697  g_auiLayerMaxCUDepth[layerId] = m_acLayerCfg[layerId].m_uiMaxCUDepth;
3698 
3699#if O0194_DIFFERENT_BITDEPTH_EL_BL
3700  // set internal bit-depth to constant value to make sure to be updated later
3701  g_bitDepthY = -1;
3702  g_bitDepthC = -1;
3703 
3704  g_uiPCMBitDepthLuma = -1;
3705  g_uiPCMBitDepthChroma = -1;
3706#else
3707  // set internal bit-depth and constants
3708  g_bitDepthY = m_internalBitDepthY;
3709  g_bitDepthC = m_internalBitDepthC;
3710 
3711  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
3712  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
3713#endif
3714}
3715#else
3716Void TAppEncCfg::xSetGlobal()
3717{
3718  // set max CU width & height
3719  g_uiMaxCUWidth  = m_uiMaxCUWidth;
3720  g_uiMaxCUHeight = m_uiMaxCUHeight;
3721 
3722  // compute actual CU depth with respect to config depth and max transform size
3723  g_uiAddCUDepth  = 0;
3724  while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
3725 
3726  m_uiMaxCUDepth += g_uiAddCUDepth;
3727  g_uiAddCUDepth++;
3728  g_uiMaxCUDepth = m_uiMaxCUDepth;
3729 
3730#if O0194_DIFFERENT_BITDEPTH_EL_BL
3731  // set internal bit-depth to constant value to make sure to be updated later
3732  g_bitDepthY = -1;
3733  g_bitDepthC = -1;
3734 
3735  g_uiPCMBitDepthLuma = -1;
3736  g_uiPCMBitDepthChroma = -1;
3737#else
3738  g_bitDepthY = m_internalBitDepthY;
3739  g_bitDepthC = m_internalBitDepthC;
3740 
3741  g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
3742  g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
3743#endif
3744}
3745#endif
3746
3747Void TAppEncCfg::xPrintParameter()
3748{
3749  printf("\n");
3750#if SVC_EXTENSION 
3751  printf("Total number of layers        : %d\n", m_numLayers       );
3752  printf("Multiview                     : %d\n", m_scalabilityMask[VIEW_ORDER_INDEX] );
3753  printf("Scalable                      : %d\n", m_scalabilityMask[SCALABILITY_ID] );
3754#if AVC_BASE
3755#if VPS_AVC_BL_FLAG_REMOVAL
3756  printf("Base layer                    : %s\n", m_nonHEVCBaseLayerFlag ? "Non-HEVC" : "HEVC");
3757#else
3758  printf("Base layer                    : %s\n", m_avcBaseLayerFlag ? "AVC" : "HEVC");
3759#endif
3760#endif
3761#if AUXILIARY_PICTURES
3762  printf("Auxiliary pictures            : %d\n", m_scalabilityMask[AUX_ID] );
3763#endif
3764#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3765  printf("Adaptive Resolution Change    : %d\n", m_adaptiveResolutionChange );
3766#endif
3767#if HIGHER_LAYER_IRAP_SKIP_FLAG
3768  printf("Skip picture at ARC switch    : %d\n", m_skipPictureAtArcSwitch );
3769#endif
3770#if O0223_PICTURE_TYPES_ALIGN_FLAG
3771  printf("Align picture type            : %d\n", m_crossLayerPictureTypeAlignFlag );
3772#endif
3773  printf("Cross layer IRAP alignment    : %d\n", m_crossLayerIrapAlignFlag );
3774#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
3775  printf("IDR only for IRAP             : %d\n", m_crossLayerAlignedIdrOnlyFlag );
3776#endif
3777#if O0194_WEIGHTED_PREDICTION_CGS
3778  printf("InterLayerWeightedPred        : %d\n", m_useInterLayerWeightedPred );
3779#endif
3780  for(UInt layer=0; layer<m_numLayers; layer++)
3781  {
3782    printf("=== Layer %d settings === \n", layer);
3783    m_acLayerCfg[layer].xPrintParameter();
3784    printf("\n");
3785  }
3786  printf("=== Common configuration settings === \n");
3787  printf("Bitstream      File          : %s\n", m_pBitstreamFile      );
3788#else //SVC_EXTENSION
3789  printf("Input          File          : %s\n", m_pchInputFile          );
3790  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
3791  printf("Reconstruction File          : %s\n", m_pchReconFile          );
3792  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confWinLeft - m_confWinRight, m_iSourceHeight - m_confWinTop - m_confWinBottom, m_iFrameRate );
3793  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
3794#endif //SVC_EXTENSION
3795  if (m_isField)
3796  {
3797    printf("Frame/Field          : Field based coding\n");
3798    printf("Field index          : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
3799    if (m_isTopFieldFirst)
3800    {
3801      printf("Field Order            : Top field first\n");
3802    }
3803    else
3804    {
3805      printf("Field Order            : Bottom field first\n");
3806    }
3807  }
3808  else
3809  {
3810    printf("Frame/Field                  : Frame based coding\n");
3811    printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
3812  }
3813#if !LAYER_CTB
3814  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
3815  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
3816  printf("Max RQT depth inter          : %d\n", m_uiQuadtreeTUMaxDepthInter);
3817  printf("Max RQT depth intra          : %d\n", m_uiQuadtreeTUMaxDepthIntra);
3818#endif
3819  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
3820  printf("Motion search range          : %d\n", m_iSearchRange );
3821#if !SVC_EXTENSION
3822  printf("Intra period                 : %d\n", m_iIntraPeriod );
3823#endif
3824  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
3825#if !SVC_EXTENSION
3826  printf("QP                           : %5.2f\n", m_fQP );
3827#endif
3828  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
3829
3830  printf("Cb QP Offset                 : %d\n", m_cbQpOffset   );
3831  printf("Cr QP Offset                 : %d\n", m_crQpOffset);
3832
3833  printf("QP adaptation                : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
3834  printf("GOP size                     : %d\n", m_iGOPSize );
3835#if !O0194_DIFFERENT_BITDEPTH_EL_BL
3836  printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
3837  printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
3838#endif
3839#if O0215_PHASE_ALIGNMENT
3840  printf("Cross-layer sample alignment : %d\n", m_phaseAlignFlag);
3841#endif
3842#if !RC_SHVC_HARMONIZATION
3843  printf("RateControl                  : %d\n", m_RCEnableRateControl );
3844  if(m_RCEnableRateControl)
3845  {
3846    printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
3847    printf("KeepHierarchicalBit          : %d\n", m_RCKeepHierarchicalBit );
3848    printf("LCULevelRC                   : %d\n", m_RCLCULevelRC );
3849    printf("UseLCUSeparateModel          : %d\n", m_RCUseLCUSeparateModel );
3850    printf("InitialQP                    : %d\n", m_RCInitialQP );
3851    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
3852  }
3853#endif
3854
3855  printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
3856  printf("\n");
3857 
3858  printf("TOOL CFG: ");
3859#if !O0194_DIFFERENT_BITDEPTH_EL_BL
3860  printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);
3861#endif
3862  printf("HAD:%d ", m_bUseHADME           );
3863  printf("RDQ:%d ", m_useRDOQ            );
3864  printf("RDQTS:%d ", m_useRDOQTS        );
3865  printf("RDpenalty:%d ", m_rdPenalty  );
3866  printf("SQP:%d ", m_uiDeltaQpRD         );
3867  printf("ASR:%d ", m_bUseASR             );
3868  printf("FEN:%d ", m_bUseFastEnc         );
3869  printf("ECU:%d ", m_bUseEarlyCU         );
3870  printf("FDM:%d ", m_useFastDecisionForMerge );
3871  printf("CFM:%d ", m_bUseCbfFastMode         );
3872  printf("ESD:%d ", m_useEarlySkipDetection  );
3873#if FAST_INTRA_SHVC
3874  printf("FIS:%d ", m_useFastIntraScalable  );
3875#endif
3876  printf("RQT:%d ", 1     );
3877  printf("TransformSkip:%d ",     m_useTransformSkip              );
3878  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
3879  printf("Slice: M=%d ", m_sliceMode);
3880  if (m_sliceMode!=0)
3881  {
3882    printf("A=%d ", m_sliceArgument);
3883  }
3884  printf("SliceSegment: M=%d ",m_sliceSegmentMode);
3885  if (m_sliceSegmentMode!=0)
3886  {
3887    printf("A=%d ", m_sliceSegmentArgument);
3888  }
3889  printf("CIP:%d ", m_bUseConstrainedIntraPred);
3890  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
3891#if !LAYER_CTB
3892  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
3893#endif
3894  if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
3895  {
3896    printf("TransQuantBypassEnabled: =1 ");
3897  }
3898  else
3899  {
3900    printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
3901  }
3902  printf("WPP:%d ", (Int)m_useWeightedPred);
3903  printf("WPB:%d ", (Int)m_useWeightedBiPred);
3904  printf("PME:%d ", m_log2ParallelMergeLevel);
3905#if !SVC_EXTENSION
3906  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
3907          m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
3908#endif
3909  printf(" ScalingList:%d ", m_useScalingListId );
3910  printf("TMVPMode:%d ", m_TMVPModeId     );
3911#if ADAPTIVE_QP_SELECTION
3912  printf("AQpS:%d", m_bUseAdaptQpSelect   );
3913#endif
3914
3915  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
3916#if SVC_EXTENSION
3917  printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
3918  printf("EL_RAP_SliceType: %d ", m_elRapSliceBEnabled);
3919  printf("REF_IDX_ME_ZEROMV: %d ", REF_IDX_ME_ZEROMV);
3920  printf("ENCODER_FAST_MODE: %d ", ENCODER_FAST_MODE);
3921  printf("REF_IDX_MFM: %d ", REF_IDX_MFM);
3922  printf("O0194_DIFFERENT_BITDEPTH_EL_BL: %d ", O0194_DIFFERENT_BITDEPTH_EL_BL);
3923  printf("O0194_JOINT_US_BITSHIFT: %d ", O0194_JOINT_US_BITSHIFT);
3924#else
3925  printf("RecalQP:%d", m_recalculateQPAccordingToLambda ? 1 : 0 );
3926#endif
3927#if Q0048_CGS_3D_ASYMLUT
3928  printf("CGS: %d CGSMaxOctantDepth: %d CGSMaxYPartNumLog2: %d CGSLUTBit:%d " , m_nCGSFlag , m_nCGSMaxOctantDepth , m_nCGSMaxYPartNumLog2 , m_nCGSLUTBit );
3929#endif
3930#if R0151_CGS_3D_ASYMLUT_IMPROVE
3931  printf("CGSAdaptC:%d " , m_nCGSAdaptiveChroma );
3932#endif
3933#if R0179_ENC_OPT_3DLUT_SIZE
3934  printf("CGSSizeRDO:%d " , m_nCGSLutSizeRDO );
3935#endif
3936
3937  printf("\n\n");
3938 
3939  fflush(stdout);
3940}
3941
3942Bool confirmPara(Bool bflag, const Char* message)
3943{
3944  if (!bflag)
3945    return false;
3946 
3947  printf("Error: %s\n",message);
3948  return true;
3949}
3950
3951#if SVC_EXTENSION
3952#if OUTPUT_LAYER_SETS_CONFIG
3953Void TAppEncCfg::cfgStringToArray(Int **arr, string const cfgString, Int const numEntries, const char* logString)
3954#else
3955Void TAppEncCfg::cfgStringToArray(Int **arr, string cfgString, Int numEntries, const char* logString)
3956#endif
3957{
3958  Char *tempChar = cfgString.empty() ? NULL : strdup(cfgString.c_str());
3959  if( numEntries > 0 )
3960  {
3961    Char *arrayEntry;
3962    Int i = 0;
3963    *arr = new Int[numEntries];
3964
3965#if OUTPUT_LAYER_SETS_CONFIG
3966    if( tempChar == NULL )
3967    {
3968      arrayEntry = NULL;
3969    }
3970    else
3971    {
3972      arrayEntry = strtok( tempChar, " ,");
3973    }
3974#else
3975    arrayEntry = strtok( tempChar, " ,");
3976#endif
3977    while(arrayEntry != NULL)
3978    {
3979      if( i >= numEntries )
3980      {
3981        printf( "%s: The number of entries specified is larger than the allowed number.\n", logString );
3982        exit( EXIT_FAILURE );
3983      }
3984      *( *arr + i ) = atoi( arrayEntry );
3985      arrayEntry = strtok(NULL, " ,");
3986      i++;
3987    }
3988    if( i < numEntries )
3989    {
3990      printf( "%s: Some entries are not specified.\n", logString );
3991      exit( EXIT_FAILURE );
3992    }
3993  }
3994  else
3995  {
3996    *arr = NULL;
3997  }
3998
3999  if( tempChar )
4000  {
4001    free( tempChar );
4002    tempChar = NULL;
4003  }
4004}
4005
4006#if OUTPUT_LAYER_SETS_CONFIG
4007Bool TAppEncCfg::scanStringToArray(string const cfgString, Int const numEntries, const char* logString, Int * const returnArray)
4008{
4009  Int *tempArray = NULL;
4010  // For all layer sets
4011  cfgStringToArray( &tempArray, cfgString, numEntries, logString );
4012  if(tempArray)
4013  {
4014    for(Int i = 0; i < numEntries; i++)
4015    {
4016      returnArray[i] = tempArray[i];
4017    }
4018    delete [] tempArray; tempArray = NULL;
4019    return true;
4020  }
4021  return false;
4022}
4023Bool TAppEncCfg::scanStringToArray(string const cfgString, Int const numEntries, const char* logString, std::vector<Int> & returnVector)
4024{
4025  Int *tempArray = NULL;
4026  // For all layer sets
4027  cfgStringToArray( &tempArray, cfgString, numEntries, logString );
4028  if(tempArray)
4029  {
4030    returnVector.empty();
4031    for(Int i = 0; i < numEntries; i++)
4032    {
4033      returnVector.push_back(tempArray[i]);
4034    }
4035    delete [] tempArray; tempArray = NULL;
4036    return true;
4037  }
4038  return false;
4039}
4040#endif
4041#endif //SVC_EXTENSION
4042//! \}
Note: See TracBrowser for help on using the repository browser.