source: SHVCSoftware/branches/SHM-5.1-dev/source/App/TAppEncoder/TAppEncTop.cpp @ 644

Last change on this file since 644 was 635, checked in by seregin, 11 years ago

fix compiler warnings, reported by J. Chen
  • Property svn:eol-style set to native
File size: 88.6 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     TAppEncTop.cpp
35    \brief    Encoder application class
36*/
37
38#include <list>
39#include <fstream>
40#include <stdlib.h>
41#include <stdio.h>
42#include <fcntl.h>
43#include <assert.h>
44
45#include "TAppEncTop.h"
46#include "TLibEncoder/AnnexBwrite.h"
47
48using namespace std;
49
50//! \ingroup TAppEncoder
51//! \{
52
53// ====================================================================================================================
54// Constructor / destructor / initialization / destroy
55// ====================================================================================================================
56
57TAppEncTop::TAppEncTop()
58{
59  m_iFrameRcvd = 0;
60  m_totalBytes = 0;
61  m_essentialBytes = 0;
62#if SVC_EXTENSION
63  for(UInt layer=0; layer < MAX_LAYERS; layer++)
64  {
65    m_apcTEncTop[layer] = &m_acTEncTop[layer];
66  }
67#endif
68}
69
70TAppEncTop::~TAppEncTop()
71{
72}
73
74#if SVC_EXTENSION
75Void TAppEncTop::xInitLibCfg()
76{
77  TComVPS* vps = m_acTEncTop[0].getVPS();
78
79  vps->setMaxTLayers                       ( m_maxTempLayer );
80  if (m_maxTempLayer == 1)
81  {
82    vps->setTemporalNestingFlag(true);
83  }
84#if !VPS_RENAME
85  vps.setMaxLayers                        ( 1 );
86#endif
87  for(Int i = 0; i < MAX_TLAYER; i++)
88  {
89    vps->setNumReorderPics                 ( m_numReorderPics[i], i );
90    vps->setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
91  }
92
93#if REPN_FORMAT_IN_VPS
94  vps->setRepFormatIdxPresentFlag( true );   // Could be disabled to optimize in some cases.
95  Int maxRepFormatIdx = -1;
96  Int formatIdx = -1;
97  for(UInt layer=0; layer < m_numLayers; layer++)
98  {
99    // Auto generation of the format index
100    if( m_acLayerCfg[layer].getRepFormatIdx() == -1 )
101    {     
102      Bool found = false;
103      for( UInt idx = 0; idx < layer; idx++ )
104      {
105        if( m_acLayerCfg[layer].getSourceWidth() == m_acLayerCfg[idx].getSourceWidth() && m_acLayerCfg[layer].getSourceHeight() == m_acLayerCfg[idx].getSourceHeight()
106#if AUXILIARY_PICTURES
107          && m_acLayerCfg[layer].getChromaFormatIDC() == m_acLayerCfg[idx].getChromaFormatIDC()
108#endif
109#if O0194_DIFFERENT_BITDEPTH_EL_BL
110          && m_acLayerCfg[layer].m_internalBitDepthY == m_acLayerCfg[idx].m_internalBitDepthY && m_acLayerCfg[layer].m_internalBitDepthC == m_acLayerCfg[idx].m_internalBitDepthC
111#endif
112          )
113        {
114          found = true;
115          break;
116        }
117      }
118      if( !found )
119      {
120        formatIdx++;
121      }
122
123      m_acLayerCfg[layer].setRepFormatIdx( formatIdx );
124    }
125
126    assert( m_acLayerCfg[layer].getRepFormatIdx() != -1 && "RepFormatIdx not assigned for a layer" );
127    vps->setVpsRepFormatIdx( layer, m_acLayerCfg[layer].getRepFormatIdx() );
128    maxRepFormatIdx = std::max( m_acLayerCfg[layer].getRepFormatIdx(), maxRepFormatIdx );
129  }
130  assert( vps->getVpsRepFormatIdx( 0 ) == 0 );  // Base layer should point to the first one.
131  Int* mapIdxToLayer = new Int[maxRepFormatIdx + 1];
132  // Check that all the indices from 0 to maxRepFormatIdx are used in the VPS
133  for(Int i = 0; i <= maxRepFormatIdx; i++)
134  {
135    mapIdxToLayer[i] = -1;
136    UInt layer;
137    for(layer=0; layer < m_numLayers; layer++)
138    {
139      if( vps->getVpsRepFormatIdx(layer) == i )
140      {
141        mapIdxToLayer[i] = layer;
142        break;
143      }
144    }
145    assert( layer != m_numLayers );   // One of the VPS Rep format indices not set
146  }
147  vps->setVpsNumRepFormats( maxRepFormatIdx + 1 );
148  for(UInt idx=0; idx < vps->getVpsNumRepFormats(); idx++)
149  {
150    RepFormat *repFormat = vps->getVpsRepFormat( idx );
151#if REPN_FORMAT_CONTROL_FLAG
152    repFormat->setChromaAndBitDepthVpsPresentFlag( true ); 
153    if (idx==0)
154    {
155      assert(repFormat->getChromaAndBitDepthVpsPresentFlag() == true); 
156    }
157#endif
158    repFormat->setPicWidthVpsInLumaSamples  ( m_acLayerCfg[mapIdxToLayer[idx]].getSourceWidth()   );
159    repFormat->setPicHeightVpsInLumaSamples ( m_acLayerCfg[mapIdxToLayer[idx]].getSourceHeight()  );
160#if AUXILIARY_PICTURES
161    repFormat->setChromaFormatVpsIdc        ( m_acLayerCfg[mapIdxToLayer[idx]].getChromaFormatIDC() );
162#else
163    repFormat->setChromaFormatVpsIdc        ( 1                                             );  // Need modification to change for each layer - corresponds to 420
164#endif
165    repFormat->setSeparateColourPlaneVpsFlag( 0                                             );  // Need modification to change for each layer
166#if O0194_DIFFERENT_BITDEPTH_EL_BL
167    repFormat->setBitDepthVpsLuma           ( getInternalBitDepthY(mapIdxToLayer[idx])      );  // Need modification to change for each layer
168    repFormat->setBitDepthVpsChroma         ( getInternalBitDepthC(mapIdxToLayer[idx])      );  // Need modification to change for each layer
169#else
170    repFormat->setBitDepthVpsLuma           ( getInternalBitDepthY()                        );  // Need modification to change for each layer
171    repFormat->setBitDepthVpsChroma         ( getInternalBitDepthC()                        );  // Need modification to change for each layer
172#endif
173#if HIGHER_LAYER_IRAP_SKIP_FLAG
174    m_acTEncTop[mapIdxToLayer[idx]].setSkipPictureAtArcSwitch( m_skipPictureAtArcSwitch );
175#endif
176  }
177  delete [] mapIdxToLayer;
178#endif
179
180  for(UInt layer=0; layer<m_numLayers; layer++)
181  {
182#if O0194_DIFFERENT_BITDEPTH_EL_BL
183    //1
184    g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
185    g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
186
187    g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
188    g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
189
190    // Set this to be used in Upsampling filter in function "TComUpsampleFilter::upsampleBasePic"
191    g_bitDepthYLayer[layer] = g_bitDepthY;
192    g_bitDepthCLayer[layer] = g_bitDepthC;
193
194#if O0194_WEIGHTED_PREDICTION_CGS
195    m_acTEncTop[layer].setInterLayerWeightedPredFlag( m_useInterLayerWeightedPred );
196#endif
197#endif
198    //m_acTEncTop[layer].setVPS(&vps);
199    m_acTEncTop[layer].setFrameRate                    ( m_acLayerCfg[layer].getFrameRate() );
200    m_acTEncTop[layer].setFrameSkip                    ( m_FrameSkip );
201    m_acTEncTop[layer].setSourceWidth                  ( m_acLayerCfg[layer].getSourceWidth() );
202    m_acTEncTop[layer].setSourceHeight                 ( m_acLayerCfg[layer].getSourceHeight() );
203    m_acTEncTop[layer].setConformanceMode              ( m_acLayerCfg[layer].getConformanceMode() );
204    m_acTEncTop[layer].setConformanceWindow            ( m_acLayerCfg[layer].m_confLeft, m_acLayerCfg[layer].m_confRight, m_acLayerCfg[layer].m_confTop, m_acLayerCfg[layer].m_confBottom );
205    m_acTEncTop[layer].setFramesToBeEncoded            ( m_framesToBeEncoded );
206
207    m_acTEncTop[layer].setProfile(m_profile);
208    m_acTEncTop[layer].setLevel(m_levelTier, m_level);
209    m_acTEncTop[layer].setProgressiveSourceFlag(m_progressiveSourceFlag);
210    m_acTEncTop[layer].setInterlacedSourceFlag(m_interlacedSourceFlag);
211    m_acTEncTop[layer].setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
212    m_acTEncTop[layer].setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
213
214#if REF_IDX_MFM
215#if AVC_BASE
216    m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : ( m_avcBaseLayerFlag ? AVC_SYNTAX : true ) && m_acLayerCfg[layer].getNumMotionPredRefLayers());
217#else
218    m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : ( m_acLayerCfg[layer].getNumMotionPredRefLayers() > 0 ) );
219#endif
220#endif
221    // set layer ID
222    m_acTEncTop[layer].setLayerId ( layer );
223    m_acTEncTop[layer].setNumLayer ( m_numLayers );
224    m_acTEncTop[layer].setLayerEnc(m_apcTEncTop);
225
226    //====== Coding Structure ========
227    m_acTEncTop[layer].setIntraPeriod                  ( m_acLayerCfg[layer].m_iIntraPeriod );
228    m_acTEncTop[layer].setDecodingRefreshType          ( m_iDecodingRefreshType );
229    m_acTEncTop[layer].setGOPSize                      ( m_iGOPSize );
230    m_acTEncTop[layer].setGopList                      ( m_GOPList );
231
232    m_acTEncTop[layer].setExtraRPSs                    ( m_extraRPSs );
233    for(Int i = 0; i < MAX_TLAYER; i++)
234    {
235      m_acTEncTop[layer].setNumReorderPics             ( m_numReorderPics[i], i );
236      m_acTEncTop[layer].setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
237    }
238    for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
239    {
240      m_acTEncTop[layer].setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
241    }
242    m_acTEncTop[layer].setQP                           ( m_acLayerCfg[layer].getIntQP() );
243
244    m_acTEncTop[layer].setPad                          ( m_acLayerCfg[layer].getPad() );
245
246    m_acTEncTop[layer].setMaxTempLayer                 ( m_maxTempLayer );
247    m_acTEncTop[layer].setUseAMP( m_enableAMP );
248#if N0120_MAX_TID_REF_CFG
249    if (layer<m_numLayers-1)
250    {
251       m_acTEncTop[layer].setMaxTidIlRefPicsPlus1 ( m_acLayerCfg[layer].getMaxTidIlRefPicsPlus1());
252    }
253#endif
254#if VPS_EXTN_DIRECT_REF_LAYERS
255    if(layer)
256    {
257      for(Int i = 0; i < MAX_VPS_LAYER_ID_PLUS1; i++)
258      {
259        m_acTEncTop[layer].setSamplePredEnabledFlag(i, false);
260        m_acTEncTop[layer].setMotionPredEnabledFlag(i, false);
261      }
262      if(m_acLayerCfg[layer].getNumSamplePredRefLayers() == -1)
263      {
264        // Not included in the configuration file; assume that each layer depends on previous layer
265        m_acTEncTop[layer].setNumSamplePredRefLayers   (1);      // One sample pred ref. layer
266        m_acTEncTop[layer].setSamplePredRefLayerId     (0, layer - 1);   // Previous layer
267        m_acTEncTop[layer].setSamplePredEnabledFlag    (layer - 1, true);
268      }
269      else
270      {
271        m_acTEncTop[layer].setNumSamplePredRefLayers   ( m_acLayerCfg[layer].getNumSamplePredRefLayers() );
272        for(Int i = 0; i < m_acTEncTop[layer].getNumSamplePredRefLayers(); i++)
273        {
274          m_acTEncTop[layer].setSamplePredRefLayerId   ( i, m_acLayerCfg[layer].getSamplePredRefLayerId(i));
275          m_acTEncTop[layer].setSamplePredEnabledFlag  (m_acLayerCfg[layer].getSamplePredRefLayerId(i), true);
276        }
277      }
278      if(m_acLayerCfg[layer].getNumMotionPredRefLayers() == -1)
279      {
280        // Not included in the configuration file; assume that each layer depends on previous layer
281        m_acTEncTop[layer].setNumMotionPredRefLayers   (1);      // One motion pred ref. layer
282        m_acTEncTop[layer].setMotionPredRefLayerId     (0, layer - 1);   // Previous layer
283        m_acTEncTop[layer].setMotionPredEnabledFlag    (layer - 1, true);
284      }
285      else
286      {
287        m_acTEncTop[layer].setNumMotionPredRefLayers   ( m_acLayerCfg[layer].getNumMotionPredRefLayers() );
288        for(Int i = 0; i < m_acTEncTop[layer].getNumMotionPredRefLayers(); i++)
289        {
290          m_acTEncTop[layer].setMotionPredRefLayerId   ( i, m_acLayerCfg[layer].getMotionPredRefLayerId(i));
291          m_acTEncTop[layer].setMotionPredEnabledFlag  (m_acLayerCfg[layer].getMotionPredRefLayerId(i), true);
292        }
293      }
294      Int numDirectRefLayers = 0;
295      for (Int i = 0; i < layer; i++)
296      {
297        if (m_acTEncTop[layer].getSamplePredEnabledFlag(i) || m_acTEncTop[layer].getMotionPredEnabledFlag(i))
298        {
299          m_acTEncTop[layer].setRefLayerId(numDirectRefLayers, i);
300          numDirectRefLayers++;
301        }
302      }
303      m_acTEncTop[layer].setNumDirectRefLayers(numDirectRefLayers);
304
305      if(m_acLayerCfg[layer].getNumActiveRefLayers() == -1)
306      {
307        m_acTEncTop[layer].setNumActiveRefLayers( m_acTEncTop[layer].getNumDirectRefLayers() );
308        for( Int i = 0; i < m_acTEncTop[layer].getNumActiveRefLayers(); i++ )
309        {
310          m_acTEncTop[layer].setPredLayerId(i, i);
311        }
312      }
313      else
314      {
315        m_acTEncTop[layer].setNumActiveRefLayers       ( m_acLayerCfg[layer].getNumActiveRefLayers() );
316        for(Int i = 0; i < m_acTEncTop[layer].getNumActiveRefLayers(); i++)
317        {
318          m_acTEncTop[layer].setPredLayerId             ( i, m_acLayerCfg[layer].getPredLayerId(i));
319        }
320      }
321    }
322#endif //VPS_EXTN_DIRECT_REF_LAYERS
323    //===== Slice ========
324
325    //====== Loop/Deblock Filter ========
326    m_acTEncTop[layer].setLoopFilterDisable            ( m_bLoopFilterDisable       );
327    m_acTEncTop[layer].setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
328    m_acTEncTop[layer].setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
329    m_acTEncTop[layer].setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
330    m_acTEncTop[layer].setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
331    m_acTEncTop[layer].setDeblockingFilterMetric       ( m_DeblockingFilterMetric );
332
333    //====== Motion search ========
334    m_acTEncTop[layer].setFastSearch                   ( m_iFastSearch  );
335    m_acTEncTop[layer].setSearchRange                  ( m_iSearchRange );
336    m_acTEncTop[layer].setBipredSearchRange            ( m_bipredSearchRange );
337
338    //====== Quality control ========
339    m_acTEncTop[layer].setMaxDeltaQP                   ( m_iMaxDeltaQP  );
340    m_acTEncTop[layer].setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
341
342    m_acTEncTop[layer].setChromaCbQpOffset             ( m_cbQpOffset     );
343    m_acTEncTop[layer].setChromaCrQpOffset             ( m_crQpOffset  );
344
345#if ADAPTIVE_QP_SELECTION
346    m_acTEncTop[layer].setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
347#endif
348   
349    m_acTEncTop[layer].setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
350    m_acTEncTop[layer].setQPAdaptationRange            ( m_iQPAdaptationRange );
351
352    //====== Tool list ========   
353    m_acTEncTop[layer].setDeltaQpRD                    ( m_uiDeltaQpRD  );
354    m_acTEncTop[layer].setUseASR                       ( m_bUseASR      );
355    m_acTEncTop[layer].setUseHADME                     ( m_bUseHADME    );   
356    m_acTEncTop[layer].setdQPs                         ( m_acLayerCfg[layer].getdQPs() );
357    m_acTEncTop[layer].setUseRDOQ                      ( m_useRDOQ     );
358    m_acTEncTop[layer].setUseRDOQTS                    ( m_useRDOQTS   );
359    m_acTEncTop[layer].setRDpenalty                    ( m_rdPenalty );
360#if LAYER_CTB
361    m_acTEncTop[layer].setQuadtreeTULog2MaxSize        ( m_acLayerCfg[layer].m_uiQuadtreeTULog2MaxSize );
362    m_acTEncTop[layer].setQuadtreeTULog2MinSize        ( m_acLayerCfg[layer].m_uiQuadtreeTULog2MinSize );
363    m_acTEncTop[layer].setQuadtreeTUMaxDepthInter      ( m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthInter );
364    m_acTEncTop[layer].setQuadtreeTUMaxDepthIntra      ( m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthIntra );
365#else
366    m_acTEncTop[layer].setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
367    m_acTEncTop[layer].setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
368    m_acTEncTop[layer].setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
369    m_acTEncTop[layer].setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
370#endif
371    m_acTEncTop[layer].setUseFastEnc                   ( m_bUseFastEnc  );
372    m_acTEncTop[layer].setUseEarlyCU                   ( m_bUseEarlyCU  );
373    m_acTEncTop[layer].setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
374    m_acTEncTop[layer].setUseCbfFastMode               ( m_bUseCbfFastMode  );
375    m_acTEncTop[layer].setUseEarlySkipDetection        ( m_useEarlySkipDetection );
376#if FAST_INTRA_SHVC
377    m_acTEncTop[layer].setUseFastIntraScalable         ( m_useFastIntraScalable );
378#endif
379
380    m_acTEncTop[layer].setUseTransformSkip             ( m_useTransformSkip      );
381    m_acTEncTop[layer].setUseTransformSkipFast         ( m_useTransformSkipFast  );
382    m_acTEncTop[layer].setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
383    m_acTEncTop[layer].setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
384    m_acTEncTop[layer].setUsePCM                       ( m_usePCM );
385    m_acTEncTop[layer].setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
386    m_acTEncTop[layer].setMaxNumMergeCand              ( m_maxNumMergeCand );
387
388
389    //====== Weighted Prediction ========
390    m_acTEncTop[layer].setUseWP                   ( m_useWeightedPred      );
391    m_acTEncTop[layer].setWPBiPred                ( m_useWeightedBiPred   );
392#if O0194_WEIGHTED_PREDICTION_CGS
393    if( layer != 0 && m_useInterLayerWeightedPred )
394    {
395      // Enable weighted prediction for enhancement layer
396      m_acTEncTop[layer].setUseWP                 ( true   );
397      m_acTEncTop[layer].setWPBiPred              ( true   );
398    }
399#endif
400    //====== Parallel Merge Estimation ========
401    m_acTEncTop[layer].setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
402
403    //====== Slice ========
404    m_acTEncTop[layer].setSliceMode               ( m_sliceMode                );
405    m_acTEncTop[layer].setSliceArgument           ( m_sliceArgument            );
406
407    //====== Dependent Slice ========
408    m_acTEncTop[layer].setSliceSegmentMode        ( m_sliceSegmentMode         );
409    m_acTEncTop[layer].setSliceSegmentArgument    ( m_sliceSegmentArgument     );
410#if LAYER_CTB
411    Int iNumPartInCU = 1<<(m_acLayerCfg[layer].m_uiMaxCUDepth<<1);
412#else
413    Int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
414#endif
415    if(m_sliceSegmentMode==FIXED_NUMBER_OF_LCU)
416    {
417      m_acTEncTop[layer].setSliceSegmentArgument ( m_sliceSegmentArgument * iNumPartInCU );
418    }
419    if(m_sliceMode==FIXED_NUMBER_OF_LCU)
420    {
421      m_acTEncTop[layer].setSliceArgument ( m_sliceArgument * iNumPartInCU );
422    }
423    if(m_sliceMode==FIXED_NUMBER_OF_TILES)
424    {
425      m_acTEncTop[layer].setSliceArgument ( m_sliceArgument );
426    }
427
428    if(m_sliceMode == 0 )
429    {
430      m_bLFCrossSliceBoundaryFlag = true;
431    }
432    m_acTEncTop[layer].setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
433    m_acTEncTop[layer].setUseSAO ( m_bUseSAO );
434    m_acTEncTop[layer].setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
435
436    m_acTEncTop[layer].setSaoLcuBoundary (m_saoLcuBoundary);
437    m_acTEncTop[layer].setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
438    m_acTEncTop[layer].setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
439
440    m_acTEncTop[layer].setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
441    m_acTEncTop[layer].setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
442    m_acTEncTop[layer].setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
443    m_acTEncTop[layer].setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
444    m_acTEncTop[layer].setToneMappingInfoSEIEnabled                 ( m_toneMappingInfoSEIEnabled );
445    m_acTEncTop[layer].setTMISEIToneMapId                           ( m_toneMapId );
446    m_acTEncTop[layer].setTMISEIToneMapCancelFlag                   ( m_toneMapCancelFlag );
447    m_acTEncTop[layer].setTMISEIToneMapPersistenceFlag              ( m_toneMapPersistenceFlag );
448    m_acTEncTop[layer].setTMISEICodedDataBitDepth                   ( m_toneMapCodedDataBitDepth );
449    m_acTEncTop[layer].setTMISEITargetBitDepth                      ( m_toneMapTargetBitDepth );
450    m_acTEncTop[layer].setTMISEIModelID                             ( m_toneMapModelId );
451    m_acTEncTop[layer].setTMISEIMinValue                            ( m_toneMapMinValue );
452    m_acTEncTop[layer].setTMISEIMaxValue                            ( m_toneMapMaxValue );
453    m_acTEncTop[layer].setTMISEISigmoidMidpoint                     ( m_sigmoidMidpoint );
454    m_acTEncTop[layer].setTMISEISigmoidWidth                        ( m_sigmoidWidth );
455    m_acTEncTop[layer].setTMISEIStartOfCodedInterva                 ( m_startOfCodedInterval );
456    m_acTEncTop[layer].setTMISEINumPivots                           ( m_numPivots );
457    m_acTEncTop[layer].setTMISEICodedPivotValue                     ( m_codedPivotValue );
458    m_acTEncTop[layer].setTMISEITargetPivotValue                    ( m_targetPivotValue );
459    m_acTEncTop[layer].setTMISEICameraIsoSpeedIdc                   ( m_cameraIsoSpeedIdc );
460    m_acTEncTop[layer].setTMISEICameraIsoSpeedValue                 ( m_cameraIsoSpeedValue );
461    m_acTEncTop[layer].setTMISEIExposureCompensationValueSignFlag   ( m_exposureCompensationValueSignFlag );
462    m_acTEncTop[layer].setTMISEIExposureCompensationValueNumerator  ( m_exposureCompensationValueNumerator );
463    m_acTEncTop[layer].setTMISEIExposureCompensationValueDenomIdc   ( m_exposureCompensationValueDenomIdc );
464    m_acTEncTop[layer].setTMISEIRefScreenLuminanceWhite             ( m_refScreenLuminanceWhite );
465    m_acTEncTop[layer].setTMISEIExtendedRangeWhiteLevel             ( m_extendedRangeWhiteLevel );
466    m_acTEncTop[layer].setTMISEINominalBlackLevelLumaCodeValue      ( m_nominalBlackLevelLumaCodeValue );
467    m_acTEncTop[layer].setTMISEINominalWhiteLevelLumaCodeValue      ( m_nominalWhiteLevelLumaCodeValue );
468    m_acTEncTop[layer].setTMISEIExtendedWhiteLevelLumaCodeValue     ( m_extendedWhiteLevelLumaCodeValue );
469    m_acTEncTop[layer].setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled );
470    m_acTEncTop[layer].setFramePackingArrangementSEIType( m_framePackingSEIType );
471    m_acTEncTop[layer].setFramePackingArrangementSEIId( m_framePackingSEIId );
472    m_acTEncTop[layer].setFramePackingArrangementSEIQuincunx( m_framePackingSEIQuincunx );
473    m_acTEncTop[layer].setFramePackingArrangementSEIInterpretation( m_framePackingSEIInterpretation );
474    m_acTEncTop[layer].setDisplayOrientationSEIAngle( m_displayOrientationSEIAngle );
475    m_acTEncTop[layer].setTemporalLevel0IndexSEIEnabled( m_temporalLevel0IndexSEIEnabled );
476    m_acTEncTop[layer].setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled );
477    m_acTEncTop[layer].setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled );
478#if LAYERS_NOT_PRESENT_SEI
479    m_acTEncTop[layer].setLayersNotPresentSEIEnabled( m_layersNotPresentSEIEnabled );
480#endif
481    m_acTEncTop[layer].setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled );
482    m_acTEncTop[layer].setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled );
483#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
484    m_acTEncTop[layer].setInterLayerConstrainedTileSetsSEIEnabled( m_interLayerConstrainedTileSetsSEIEnabled );
485    m_acTEncTop[layer].setIlNumSetsInMessage( m_ilNumSetsInMessage );
486    m_acTEncTop[layer].setSkippedTileSetPresentFlag( m_skippedTileSetPresentFlag );
487    m_acTEncTop[layer].setTopLeftTileIndex( m_topLeftTileIndex );
488    m_acTEncTop[layer].setBottomRightTileIndex( m_bottomRightTileIndex );
489    m_acTEncTop[layer].setIlcIdc( m_ilcIdc );
490#endif
491    m_acTEncTop[layer].setUniformSpacingIdr          ( m_iUniformSpacingIdr );
492    m_acTEncTop[layer].setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
493    m_acTEncTop[layer].setNumRowsMinus1              ( m_iNumRowsMinus1 );
494    if(m_iUniformSpacingIdr==0)
495    {
496      m_acTEncTop[layer].setColumnWidth              ( m_pColumnWidth );
497      m_acTEncTop[layer].setRowHeight                ( m_pRowHeight );
498    }
499    m_acTEncTop[layer].xCheckGSParameters();
500    Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
501    if(uiTilesCount == 1)
502    {
503      m_bLFCrossTileBoundaryFlag = true;
504    }
505    m_acTEncTop[layer].setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
506    m_acTEncTop[layer].setWaveFrontSynchro           ( m_iWaveFrontSynchro );
507    m_acTEncTop[layer].setWaveFrontSubstreams        ( m_acLayerCfg[layer].m_iWaveFrontSubstreams );
508    m_acTEncTop[layer].setTMVPModeId ( m_TMVPModeId );
509    m_acTEncTop[layer].setUseScalingListId           ( m_useScalingListId  );
510    m_acTEncTop[layer].setScalingListFile            ( m_scalingListFile   );
511    m_acTEncTop[layer].setSignHideFlag(m_signHideFlag);
512#if RC_SHVC_HARMONIZATION
513    m_acTEncTop[layer].setUseRateCtrl     (m_acLayerCfg[layer].getRCEnableRateControl());
514    m_acTEncTop[layer].setTargetBitrate   (m_acLayerCfg[layer].getRCTargetBitrate());
515    m_acTEncTop[layer].setKeepHierBit     (m_acLayerCfg[layer].getRCKeepHierarchicalBit());
516    m_acTEncTop[layer].setLCULevelRC      (m_acLayerCfg[layer].getRCLCULevelRC());
517    m_acTEncTop[layer].setUseLCUSeparateModel (m_acLayerCfg[layer].getRCUseLCUSeparateModel());
518    m_acTEncTop[layer].setInitialQP           (m_acLayerCfg[layer].getRCInitialQP());
519    m_acTEncTop[layer].setForceIntraQP        (m_acLayerCfg[layer].getRCForceIntraQP());
520#else
521    m_acTEncTop[layer].setUseRateCtrl         ( m_RCEnableRateControl );
522    m_acTEncTop[layer].setTargetBitrate       ( m_RCTargetBitrate );
523    m_acTEncTop[layer].setKeepHierBit         ( m_RCKeepHierarchicalBit );
524    m_acTEncTop[layer].setLCULevelRC          ( m_RCLCULevelRC );
525    m_acTEncTop[layer].setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
526    m_acTEncTop[layer].setInitialQP           ( m_RCInitialQP );
527    m_acTEncTop[layer].setForceIntraQP        ( m_RCForceIntraQP );
528#endif
529    m_acTEncTop[layer].setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
530    m_acTEncTop[layer].setCUTransquantBypassFlagForceValue(m_CUTransquantBypassFlagForce);
531    m_acTEncTop[layer].setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
532    m_acTEncTop[layer].setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
533    m_acTEncTop[layer].setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
534    m_acTEncTop[layer].setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
535    m_acTEncTop[layer].setAspectRatioIdc( m_aspectRatioIdc );
536    m_acTEncTop[layer].setSarWidth( m_sarWidth );
537    m_acTEncTop[layer].setSarHeight( m_sarHeight );
538    m_acTEncTop[layer].setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
539    m_acTEncTop[layer].setOverscanAppropriateFlag( m_overscanAppropriateFlag );
540    m_acTEncTop[layer].setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
541    m_acTEncTop[layer].setVideoFormat( m_videoFormat );
542    m_acTEncTop[layer].setVideoFullRangeFlag( m_videoFullRangeFlag );
543    m_acTEncTop[layer].setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
544    m_acTEncTop[layer].setColourPrimaries( m_colourPrimaries );
545    m_acTEncTop[layer].setTransferCharacteristics( m_transferCharacteristics );
546    m_acTEncTop[layer].setMatrixCoefficients( m_matrixCoefficients );
547    m_acTEncTop[layer].setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
548    m_acTEncTop[layer].setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
549    m_acTEncTop[layer].setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
550    m_acTEncTop[layer].setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
551    m_acTEncTop[layer].setDefaultDisplayWindow( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
552    m_acTEncTop[layer].setFrameFieldInfoPresentFlag( m_frameFieldInfoPresentFlag );
553    m_acTEncTop[layer].setPocProportionalToTimingFlag( m_pocProportionalToTimingFlag );
554    m_acTEncTop[layer].setNumTicksPocDiffOneMinus1   ( m_numTicksPocDiffOneMinus1    );
555    m_acTEncTop[layer].setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
556    m_acTEncTop[layer].setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
557    m_acTEncTop[layer].setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
558    m_acTEncTop[layer].setMinSpatialSegmentationIdc( m_minSpatialSegmentationIdc );
559    m_acTEncTop[layer].setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
560    m_acTEncTop[layer].setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
561    m_acTEncTop[layer].setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
562    m_acTEncTop[layer].setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
563    m_acTEncTop[layer].setElRapSliceTypeB(layer == 0? 0 : m_elRapSliceBEnabled);
564    if( layer > 0 )
565    {
566      m_acTEncTop[layer].setNumScaledRefLayerOffsets( m_acLayerCfg[layer].m_numScaledRefLayerOffsets );
567      for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
568      {
569#if O0098_SCALED_REF_LAYER_ID
570        m_acTEncTop[layer].setScaledRefLayerId(i, m_acLayerCfg[layer].m_scaledRefLayerId[i]);
571#endif
572#if P0312_VERT_PHASE_ADJ
573        m_acTEncTop[layer].setVertPhasePositionEnableFlag( i, m_acLayerCfg[layer].m_vertPhasePositionEnableFlag[i] );
574        m_acTEncTop[layer].getScaledRefLayerWindow(i).setWindow( 2*m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i],
575                                                  2*m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i], m_acLayerCfg[layer].m_vertPhasePositionEnableFlag[i] );
576#else
577        m_acTEncTop[layer].getScaledRefLayerWindow(i).setWindow( 2*m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i],
578                                                  2*m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i]);
579#endif
580      }
581    }
582#if M0040_ADAPTIVE_RESOLUTION_CHANGE
583    m_acTEncTop[layer].setAdaptiveResolutionChange( m_adaptiveResolutionChange );
584#endif
585#if AUXILIARY_PICTURES
586    m_acTEncTop[layer].setChromaFormatIDC( m_acLayerCfg[layer].m_chromaFormatIDC );
587#endif
588#if O0153_ALT_OUTPUT_LAYER_FLAG
589    m_acTEncTop[layer].setAltOuputLayerFlag( m_altOutputLayerFlag );
590#endif
591#if O0149_CROSS_LAYER_BLA_FLAG
592    m_acTEncTop[layer].setCrossLayerBLAFlag( m_crossLayerBLAFlag );
593#endif
594  }
595}
596#else //SVC_EXTENSION
597Void TAppEncTop::xInitLibCfg()
598{
599  TComVPS vps;
600
601  vps.setMaxTLayers                       ( m_maxTempLayer );
602  if (m_maxTempLayer == 1)
603  {
604    vps.setTemporalNestingFlag(true);
605  }
606  vps.setMaxLayers                        ( 1 );
607  for(Int i = 0; i < MAX_TLAYER; i++)
608  {
609    vps.setNumReorderPics                 ( m_numReorderPics[i], i );
610    vps.setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
611  }
612  m_cTEncTop.setVPS(&vps);
613
614  m_cTEncTop.setProfile(m_profile);
615  m_cTEncTop.setLevel(m_levelTier, m_level);
616  m_cTEncTop.setProgressiveSourceFlag(m_progressiveSourceFlag);
617  m_cTEncTop.setInterlacedSourceFlag(m_interlacedSourceFlag);
618  m_cTEncTop.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
619  m_cTEncTop.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
620
621  m_cTEncTop.setFrameRate                    ( m_iFrameRate );
622  m_cTEncTop.setFrameSkip                    ( m_FrameSkip );
623  m_cTEncTop.setSourceWidth                  ( m_iSourceWidth );
624  m_cTEncTop.setSourceHeight                 ( m_iSourceHeight );
625  m_cTEncTop.setConformanceWindow            ( m_confLeft, m_confRight, m_confTop, m_confBottom );
626  m_cTEncTop.setFramesToBeEncoded            ( m_framesToBeEncoded );
627
628  //====== Coding Structure ========
629  m_cTEncTop.setIntraPeriod                  ( m_iIntraPeriod );
630  m_cTEncTop.setDecodingRefreshType          ( m_iDecodingRefreshType );
631  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
632  m_cTEncTop.setGopList                      ( m_GOPList );
633  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
634  for(Int i = 0; i < MAX_TLAYER; i++)
635  {
636    m_cTEncTop.setNumReorderPics             ( m_numReorderPics[i], i );
637    m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
638  }
639  for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
640  {
641    m_cTEncTop.setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
642  }
643  m_cTEncTop.setQP                           ( m_iQP );
644
645  m_cTEncTop.setPad                          ( m_aiPad );
646
647  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
648  m_cTEncTop.setUseAMP( m_enableAMP );
649
650  //===== Slice ========
651
652  //====== Loop/Deblock Filter ========
653  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
654  m_cTEncTop.setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
655  m_cTEncTop.setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
656  m_cTEncTop.setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
657  m_cTEncTop.setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
658  m_cTEncTop.setDeblockingFilterMetric       ( m_DeblockingFilterMetric );
659
660  //====== Motion search ========
661  m_cTEncTop.setFastSearch                   ( m_iFastSearch  );
662  m_cTEncTop.setSearchRange                  ( m_iSearchRange );
663  m_cTEncTop.setBipredSearchRange            ( m_bipredSearchRange );
664
665  //====== Quality control ========
666  m_cTEncTop.setMaxDeltaQP                   ( m_iMaxDeltaQP  );
667  m_cTEncTop.setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
668
669  m_cTEncTop.setChromaCbQpOffset               ( m_cbQpOffset     );
670  m_cTEncTop.setChromaCrQpOffset            ( m_crQpOffset  );
671
672#if ADAPTIVE_QP_SELECTION
673  m_cTEncTop.setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
674#endif
675
676  m_cTEncTop.setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
677  m_cTEncTop.setQPAdaptationRange            ( m_iQPAdaptationRange );
678
679  //====== Tool list ========
680  m_cTEncTop.setDeltaQpRD                    ( m_uiDeltaQpRD  );
681  m_cTEncTop.setUseASR                       ( m_bUseASR      );
682  m_cTEncTop.setUseHADME                     ( m_bUseHADME    );
683  m_cTEncTop.setdQPs                         ( m_aidQP        );
684  m_cTEncTop.setUseRDOQ                      ( m_useRDOQ     );
685  m_cTEncTop.setUseRDOQTS                    ( m_useRDOQTS   );
686  m_cTEncTop.setRDpenalty                 ( m_rdPenalty );
687  m_cTEncTop.setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
688  m_cTEncTop.setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
689  m_cTEncTop.setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
690  m_cTEncTop.setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
691  m_cTEncTop.setUseFastEnc                   ( m_bUseFastEnc  );
692  m_cTEncTop.setUseEarlyCU                   ( m_bUseEarlyCU  );
693  m_cTEncTop.setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
694  m_cTEncTop.setUseCbfFastMode            ( m_bUseCbfFastMode  );
695  m_cTEncTop.setUseEarlySkipDetection            ( m_useEarlySkipDetection );
696#if FAST_INTRA_SHVC
697  m_cTEncTop.setUseFastIntraScalable            ( m_useFastIntraScalable );
698#endif
699
700  m_cTEncTop.setUseTransformSkip             ( m_useTransformSkip      );
701  m_cTEncTop.setUseTransformSkipFast         ( m_useTransformSkipFast  );
702  m_cTEncTop.setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
703  m_cTEncTop.setPCMLog2MinSize          ( m_uiPCMLog2MinSize);
704  m_cTEncTop.setUsePCM                       ( m_usePCM );
705  m_cTEncTop.setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
706  m_cTEncTop.setMaxNumMergeCand              ( m_maxNumMergeCand );
707
708
709  //====== Weighted Prediction ========
710  m_cTEncTop.setUseWP                   ( m_useWeightedPred      );
711  m_cTEncTop.setWPBiPred                ( m_useWeightedBiPred   );
712  //====== Parallel Merge Estimation ========
713  m_cTEncTop.setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
714
715  //====== Slice ========
716  m_cTEncTop.setSliceMode               ( m_sliceMode                );
717  m_cTEncTop.setSliceArgument           ( m_sliceArgument            );
718
719  //====== Dependent Slice ========
720  m_cTEncTop.setSliceSegmentMode        ( m_sliceSegmentMode         );
721  m_cTEncTop.setSliceSegmentArgument    ( m_sliceSegmentArgument     );
722  Int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
723  if(m_sliceSegmentMode==FIXED_NUMBER_OF_LCU)
724  {
725    m_cTEncTop.setSliceSegmentArgument ( m_sliceSegmentArgument * iNumPartInCU );
726  }
727  if(m_sliceMode==FIXED_NUMBER_OF_LCU)
728  {
729    m_cTEncTop.setSliceArgument ( m_sliceArgument * iNumPartInCU );
730  }
731  if(m_sliceMode==FIXED_NUMBER_OF_TILES)
732  {
733    m_cTEncTop.setSliceArgument ( m_sliceArgument );
734  }
735
736  if(m_sliceMode == 0 )
737  {
738    m_bLFCrossSliceBoundaryFlag = true;
739  }
740  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
741  m_cTEncTop.setUseSAO ( m_bUseSAO );
742  m_cTEncTop.setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
743
744  m_cTEncTop.setSaoLcuBoundary (m_saoLcuBoundary);
745  m_cTEncTop.setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
746  m_cTEncTop.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
747
748  m_cTEncTop.setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
749  m_cTEncTop.setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
750  m_cTEncTop.setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
751  m_cTEncTop.setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
752  m_cTEncTop.setToneMappingInfoSEIEnabled                 ( m_toneMappingInfoSEIEnabled );
753  m_cTEncTop.setTMISEIToneMapId                           ( m_toneMapId );
754  m_cTEncTop.setTMISEIToneMapCancelFlag                   ( m_toneMapCancelFlag );
755  m_cTEncTop.setTMISEIToneMapPersistenceFlag              ( m_toneMapPersistenceFlag );
756  m_cTEncTop.setTMISEICodedDataBitDepth                   ( m_toneMapCodedDataBitDepth );
757  m_cTEncTop.setTMISEITargetBitDepth                      ( m_toneMapTargetBitDepth );
758  m_cTEncTop.setTMISEIModelID                             ( m_toneMapModelId );
759  m_cTEncTop.setTMISEIMinValue                            ( m_toneMapMinValue );
760  m_cTEncTop.setTMISEIMaxValue                            ( m_toneMapMaxValue );
761  m_cTEncTop.setTMISEISigmoidMidpoint                     ( m_sigmoidMidpoint );
762  m_cTEncTop.setTMISEISigmoidWidth                        ( m_sigmoidWidth );
763  m_cTEncTop.setTMISEIStartOfCodedInterva                 ( m_startOfCodedInterval );
764  m_cTEncTop.setTMISEINumPivots                           ( m_numPivots );
765  m_cTEncTop.setTMISEICodedPivotValue                     ( m_codedPivotValue );
766  m_cTEncTop.setTMISEITargetPivotValue                    ( m_targetPivotValue );
767  m_cTEncTop.setTMISEICameraIsoSpeedIdc                   ( m_cameraIsoSpeedIdc );
768  m_cTEncTop.setTMISEICameraIsoSpeedValue                 ( m_cameraIsoSpeedValue );
769  m_cTEncTop.setTMISEIExposureCompensationValueSignFlag   ( m_exposureCompensationValueSignFlag );
770  m_cTEncTop.setTMISEIExposureCompensationValueNumerator  ( m_exposureCompensationValueNumerator );
771  m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc   ( m_exposureCompensationValueDenomIdc );
772  m_cTEncTop.setTMISEIRefScreenLuminanceWhite             ( m_refScreenLuminanceWhite );
773  m_cTEncTop.setTMISEIExtendedRangeWhiteLevel             ( m_extendedRangeWhiteLevel );
774  m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue      ( m_nominalBlackLevelLumaCodeValue );
775  m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue      ( m_nominalWhiteLevelLumaCodeValue );
776  m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue     ( m_extendedWhiteLevelLumaCodeValue );
777  m_cTEncTop.setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled );
778  m_cTEncTop.setFramePackingArrangementSEIType( m_framePackingSEIType );
779  m_cTEncTop.setFramePackingArrangementSEIId( m_framePackingSEIId );
780  m_cTEncTop.setFramePackingArrangementSEIQuincunx( m_framePackingSEIQuincunx );
781  m_cTEncTop.setFramePackingArrangementSEIInterpretation( m_framePackingSEIInterpretation );
782  m_cTEncTop.setDisplayOrientationSEIAngle( m_displayOrientationSEIAngle );
783  m_cTEncTop.setTemporalLevel0IndexSEIEnabled( m_temporalLevel0IndexSEIEnabled );
784  m_cTEncTop.setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled );
785  m_cTEncTop.setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled );
786#if LAYERS_NOT_PRESENT_SEI
787  m_cTEncTop.setLayersNotPresentSEIEnabled( m_layersNotPresentSEIEnabled );
788#endif
789  m_cTEncTop.setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled );
790  m_cTEncTop.setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled );
791  m_cTEncTop.setUniformSpacingIdr          ( m_iUniformSpacingIdr );
792  m_cTEncTop.setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
793  m_cTEncTop.setNumRowsMinus1              ( m_iNumRowsMinus1 );
794  if(m_iUniformSpacingIdr==0)
795  {
796    m_cTEncTop.setColumnWidth              ( m_pColumnWidth );
797    m_cTEncTop.setRowHeight                ( m_pRowHeight );
798  }
799  m_cTEncTop.xCheckGSParameters();
800  Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
801  if(uiTilesCount == 1)
802  {
803    m_bLFCrossTileBoundaryFlag = true;
804  }
805  m_cTEncTop.setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
806  m_cTEncTop.setWaveFrontSynchro           ( m_iWaveFrontSynchro );
807  m_cTEncTop.setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
808  m_cTEncTop.setTMVPModeId ( m_TMVPModeId );
809  m_cTEncTop.setUseScalingListId           ( m_useScalingListId  );
810  m_cTEncTop.setScalingListFile            ( m_scalingListFile   );
811  m_cTEncTop.setSignHideFlag(m_signHideFlag);
812  m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
813  m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
814  m_cTEncTop.setKeepHierBit         ( m_RCKeepHierarchicalBit );
815  m_cTEncTop.setLCULevelRC          ( m_RCLCULevelRC );
816  m_cTEncTop.setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
817  m_cTEncTop.setInitialQP           ( m_RCInitialQP );
818  m_cTEncTop.setForceIntraQP        ( m_RCForceIntraQP );
819  m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
820  m_cTEncTop.setCUTransquantBypassFlagForceValue(m_CUTransquantBypassFlagForce);
821  m_cTEncTop.setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
822  m_cTEncTop.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
823  m_cTEncTop.setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
824  m_cTEncTop.setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
825  m_cTEncTop.setAspectRatioIdc( m_aspectRatioIdc );
826  m_cTEncTop.setSarWidth( m_sarWidth );
827  m_cTEncTop.setSarHeight( m_sarHeight );
828  m_cTEncTop.setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
829  m_cTEncTop.setOverscanAppropriateFlag( m_overscanAppropriateFlag );
830  m_cTEncTop.setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
831  m_cTEncTop.setVideoFormat( m_videoFormat );
832  m_cTEncTop.setVideoFullRangeFlag( m_videoFullRangeFlag );
833  m_cTEncTop.setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
834  m_cTEncTop.setColourPrimaries( m_colourPrimaries );
835  m_cTEncTop.setTransferCharacteristics( m_transferCharacteristics );
836  m_cTEncTop.setMatrixCoefficients( m_matrixCoefficients );
837  m_cTEncTop.setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
838  m_cTEncTop.setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
839  m_cTEncTop.setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
840  m_cTEncTop.setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
841  m_cTEncTop.setDefaultDisplayWindow( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
842  m_cTEncTop.setFrameFieldInfoPresentFlag( m_frameFieldInfoPresentFlag );
843  m_cTEncTop.setPocProportionalToTimingFlag( m_pocProportionalToTimingFlag );
844  m_cTEncTop.setNumTicksPocDiffOneMinus1   ( m_numTicksPocDiffOneMinus1    );
845  m_cTEncTop.setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
846  m_cTEncTop.setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
847  m_cTEncTop.setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
848  m_cTEncTop.setMinSpatialSegmentationIdc( m_minSpatialSegmentationIdc );
849  m_cTEncTop.setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
850  m_cTEncTop.setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
851  m_cTEncTop.setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
852  m_cTEncTop.setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
853}
854#endif //SVC_EXTENSION
855
856Void TAppEncTop::xCreateLib()
857{
858  // Video I/O
859#if SVC_EXTENSION
860  // initialize global variables
861  initROM();
862
863  for(UInt layer=0; layer<m_numLayers; layer++)
864  {
865#if O0194_DIFFERENT_BITDEPTH_EL_BL
866    //2
867    g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
868    g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
869
870    g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
871    g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
872#endif
873#if LAYER_CTB
874    g_uiMaxCUWidth  = g_auiLayerMaxCUWidth[layer];
875    g_uiMaxCUHeight = g_auiLayerMaxCUHeight[layer];
876    g_uiMaxCUDepth  = g_auiLayerMaxCUDepth[layer];
877    g_uiAddCUDepth  = g_auiLayerAddCUDepth[layer];
878#endif
879#if O0194_DIFFERENT_BITDEPTH_EL_BL
880    m_acTVideoIOYuvInputFile[layer].open( (Char *)m_acLayerCfg[layer].getInputFile().c_str(),  false, m_acLayerCfg[layer].m_inputBitDepthY, m_acLayerCfg[layer].m_inputBitDepthC, m_acLayerCfg[layer].m_internalBitDepthY, m_acLayerCfg[layer].m_internalBitDepthC );  // read  mode
881#else
882    m_acTVideoIOYuvInputFile[layer].open( (Char *)m_acLayerCfg[layer].getInputFile().c_str(),  false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
883#endif
884    m_acTVideoIOYuvInputFile[layer].skipFrames(m_FrameSkip, m_acLayerCfg[layer].getSourceWidth() - m_acLayerCfg[layer].getPad()[0], m_acLayerCfg[layer].getSourceHeight() - m_acLayerCfg[layer].getPad()[1]);
885
886    if (!m_acLayerCfg[layer].getReconFile().empty())
887    {
888#if O0194_DIFFERENT_BITDEPTH_EL_BL
889      m_acTVideoIOYuvReconFile[layer].open((Char *)m_acLayerCfg[layer].getReconFile().c_str(), true, m_acLayerCfg[layer].m_outputBitDepthY, m_acLayerCfg[layer].m_outputBitDepthC, m_acLayerCfg[layer].m_internalBitDepthY, m_acLayerCfg[layer].m_internalBitDepthC );  // write mode
890#else
891      m_acTVideoIOYuvReconFile[layer].open((Char *)m_acLayerCfg[layer].getReconFile().c_str(), true, m_outputBitDepthY, m_outputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // write mode
892#endif
893    }
894
895    m_acTEncTop[layer].create();
896  }
897#else //SVC_EXTENSION
898  m_cTVideoIOYuvInputFile.open( m_pchInputFile,     false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
899  m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
900
901  if (m_pchReconFile)
902    m_cTVideoIOYuvReconFile.open(m_pchReconFile, true, m_outputBitDepthY, m_outputBitDepthC, m_internalBitDepthY, m_internalBitDepthC);  // write mode
903
904  // Neo Decoder
905  m_cTEncTop.create();
906#endif //SVC_EXTENSION
907}
908
909Void TAppEncTop::xDestroyLib()
910{
911  // Video I/O
912#if SVC_EXTENSION
913  // destroy ROM
914  destroyROM();
915
916  for(UInt layer=0; layer<m_numLayers; layer++)
917  {
918#if LAYER_CTB
919    g_uiMaxCUWidth  = g_auiLayerMaxCUWidth[layer];
920    g_uiMaxCUHeight = g_auiLayerMaxCUHeight[layer];
921    g_uiMaxCUDepth  = g_auiLayerMaxCUDepth[layer];
922    g_uiAddCUDepth  = g_auiLayerAddCUDepth[layer];
923#endif
924
925    m_acTVideoIOYuvInputFile[layer].close();
926    m_acTVideoIOYuvReconFile[layer].close();
927
928    m_acTEncTop[layer].destroy();
929  }
930#else //SVC_EXTENSION
931  m_cTVideoIOYuvInputFile.close();
932  m_cTVideoIOYuvReconFile.close();
933
934  // Neo Decoder
935  m_cTEncTop.destroy();
936#endif //SVC_EXTENSION
937}
938
939Void TAppEncTop::xInitLib(Bool isFieldCoding)
940{
941#if SVC_EXTENSION
942  for(UInt layer=0; layer<m_numLayers; layer++)
943  {
944#if O0194_DIFFERENT_BITDEPTH_EL_BL
945    //3
946    g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
947    g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
948
949    g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
950    g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
951#endif
952#if LAYER_CTB
953    g_uiMaxCUWidth  = g_auiLayerMaxCUWidth[layer];
954    g_uiMaxCUHeight = g_auiLayerMaxCUHeight[layer];
955    g_uiMaxCUDepth  = g_auiLayerMaxCUDepth[layer];
956    g_uiAddCUDepth  = g_auiLayerAddCUDepth[layer];
957
958    memcpy( g_auiZscanToRaster, g_auiLayerZscanToRaster[layer], sizeof( g_auiZscanToRaster ) );
959    memcpy( g_auiRasterToZscan, g_auiLayerRasterToZscan[layer], sizeof( g_auiRasterToZscan ) );
960    memcpy( g_auiRasterToPelX,  g_auiLayerRasterToPelX[layer],  sizeof( g_auiRasterToPelX ) );
961    memcpy( g_auiRasterToPelY,  g_auiLayerRasterToPelY[layer],  sizeof( g_auiRasterToPelY ) );
962#endif
963    m_acTEncTop[layer].init(isFieldCoding);
964#if P0182_VPS_VUI_PS_FLAG
965    m_acTEncTop[layer].getVPS()->setSPSId(layer, m_acTEncTop[layer].getSPS()->getSPSId());
966    m_acTEncTop[layer].getVPS()->setPPSId(layer, m_acTEncTop[layer].getPPS()->getPPSId());
967#endif
968  }
969#if VPS_RENAME
970  m_acTEncTop[0].getVPS()->setMaxLayers( m_numLayers );
971#endif
972#if VPS_EXTN_OP_LAYER_SETS
973  TComVPS* vps = m_acTEncTop[0].getVPS();
974  vps->setMaxLayerId(m_numLayers - 1);    // Set max-layer ID
975
976  vps->setNumLayerSets(m_numLayers);
977  for(Int setId = 1; setId < vps->getNumLayerSets(); setId++)
978  {
979    for(Int layerId = 0; layerId <= vps->getMaxLayerId(); layerId++)
980    {
981#if O0194_DIFFERENT_BITDEPTH_EL_BL
982      //4
983      g_bitDepthY = m_acLayerCfg[layerId].m_internalBitDepthY;
984      g_bitDepthC = m_acLayerCfg[layerId].m_internalBitDepthC;
985
986      g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layerId].m_inputBitDepthY : m_acLayerCfg[layerId].m_internalBitDepthY;
987      g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layerId].m_inputBitDepthC : m_acLayerCfg[layerId].m_internalBitDepthC;
988#endif
989      if( layerId <= setId )
990      {
991        vps->setLayerIdIncludedFlag(true, setId, layerId);
992      }
993      else
994      {
995        vps->setLayerIdIncludedFlag(false, setId, layerId);
996      }
997    }
998  }
999#if VPS_EXTN_MASK_AND_DIM_INFO
1000  UInt i = 0, dimIdLen = 0;
1001#if AVC_BASE
1002  vps->setAvcBaseLayerFlag(m_avcBaseLayerFlag);
1003#else
1004  vps->setAvcBaseLayerFlag(false);
1005#endif
1006  vps->setSplittingFlag(false);
1007  for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
1008  {
1009    vps->setScalabilityMask(i, false);
1010  }
1011  if(m_numLayers > 1)
1012  {
1013    Int scalabilityTypes = 0;
1014    for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
1015    {
1016      vps->setScalabilityMask(i, m_scalabilityMask[i]);
1017      scalabilityTypes += m_scalabilityMask[i];
1018    }
1019#if AUXILIARY_PICTURES
1020    assert( scalabilityTypes <= 2 );
1021#else
1022    assert( scalabilityTypes == 1 );
1023#endif
1024    vps->setNumScalabilityTypes(scalabilityTypes);
1025  }
1026  else
1027  {
1028    vps->setNumScalabilityTypes(0);
1029  }
1030  while((1 << dimIdLen) < m_numLayers)
1031  {
1032    dimIdLen++;
1033  }
1034  vps->setDimensionIdLen(0, dimIdLen);
1035  vps->setNuhLayerIdPresentFlag(false);
1036  vps->setLayerIdInNuh(0, 0);
1037  vps->setLayerIdInVps(0, 0);
1038  for(i = 1; i < vps->getMaxLayers(); i++)
1039  {
1040    vps->setLayerIdInNuh(i, i);
1041    vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
1042    vps->setDimensionId(i, 0, i);
1043  }
1044#if AUXILIARY_PICTURES
1045  if (m_scalabilityMask[3])
1046  {
1047    UInt maxAuxId = 0;
1048    UInt auxDimIdLen = 1;
1049    for(i = 1; i < vps->getMaxLayers(); i++)
1050    {
1051      if (m_acLayerCfg[i].getAuxId() > maxAuxId)
1052      {
1053        maxAuxId = m_acLayerCfg[i].getAuxId();
1054      }
1055    }
1056    while((1 << auxDimIdLen) < (maxAuxId + 1))
1057    {
1058      auxDimIdLen++;
1059    }
1060    vps->setDimensionIdLen(1, auxDimIdLen);
1061    for(i = 1; i < vps->getMaxLayers(); i++)
1062    {
1063      vps->setDimensionId(i, 1, m_acLayerCfg[i].getAuxId());
1064    }
1065  }
1066#endif
1067#endif
1068#if VPS_TSLAYERS
1069    vps->setMaxTSLayersPresentFlag(true);
1070    for( i = 0; i < MAX_VPS_LAYER_ID_PLUS1 - 1; i++ )
1071    {
1072        vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
1073    }
1074#endif
1075#if N0120_MAX_TID_REF_PRESENT_FLAG
1076#if N0120_MAX_TID_REF_CFG
1077  vps->setMaxTidRefPresentFlag(m_maxTidRefPresentFlag);
1078#else
1079  vps->setMaxTidRefPresentFlag(true);
1080#endif
1081  if (vps->getMaxTidRefPresentFlag())
1082  {
1083    for( i = 0; i < MAX_VPS_LAYER_ID_PLUS1 - 1; i++ )
1084    {
1085#if N0120_MAX_TID_REF_CFG
1086#if O0225_MAX_TID_FOR_REF_LAYERS
1087      for( Int j = i+1; j <= MAX_VPS_LAYER_ID_PLUS1 - 1; j++)
1088      {
1089        vps->setMaxTidIlRefPicsPlus1(i, j, m_acTEncTop[i].getMaxTidIlRefPicsPlus1());
1090      }
1091#else
1092      vps->setMaxTidIlRefPicsPlus1(i, m_acTEncTop[i].getMaxTidIlRefPicsPlus1());
1093#endif
1094#else
1095#if O0225_MAX_TID_FOR_REF_LAYERS
1096      for( Int j = i+1; j <= MAX_VPS_LAYER_ID_PLUS1 - 1; j++)
1097      {
1098        vps->setMaxTidIlRefPicsPlus1(i, j, vps->getMaxTLayers()+1);
1099      }
1100#else
1101      vps->setMaxTidIlRefPicsPlus1(i, vps->getMaxTLayers()+1);
1102#endif
1103#endif
1104    }
1105  }
1106  else
1107  {
1108    for( i = 0; i < MAX_VPS_LAYER_ID_PLUS1 - 1; i++ )
1109    {
1110#if O0225_MAX_TID_FOR_REF_LAYERS
1111      for( Int j = i+1; j <= MAX_VPS_LAYER_ID_PLUS1 - 1; j++)
1112      {
1113        vps->setMaxTidIlRefPicsPlus1(i, j, 7);
1114      }
1115#else
1116      vps->setMaxTidIlRefPicsPlus1(i, 7);
1117#endif
1118    }
1119  }
1120#endif
1121#if ILP_SSH_SIG
1122#if ILP_SSH_SIG_FIX
1123    vps->setIlpSshSignalingEnabledFlag(false);
1124#else
1125    vps->setIlpSshSignalingEnabledFlag(true);
1126#endif
1127#endif
1128#if VPS_EXTN_PROFILE_INFO
1129  vps->getPTLForExtnPtr()->resize(vps->getNumLayerSets());
1130  for(Int setId = 1; setId < vps->getNumLayerSets(); setId++)
1131  {
1132    vps->setProfilePresentFlag(setId, true);
1133    // Note - may need to be changed for other layer structures.
1134    *(vps->getPTLForExtn(setId)) = *(m_acTEncTop[setId].getSPS()->getPTL());
1135  }
1136#endif
1137  // Target output layer
1138  vps->setNumOutputLayerSets(vps->getNumLayerSets());
1139  vps->setNumProfileTierLevel(vps->getNumLayerSets());
1140#if P0295_DEFAULT_OUT_LAYER_IDC
1141  vps->setDefaultTargetOutputLayerIdc(1);
1142#else
1143#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
1144  vps->setDefaultOneTargetOutputLayerIdc(1);
1145#else
1146  vps->setDefaultOneTargetOutputLayerFlag(true);
1147#endif
1148#endif
1149  for(i = 1; i < vps->getNumLayerSets(); i++)
1150  {
1151    vps->setProfileLevelTierIdx(i, i);
1152    vps->setOutputLayerSetIdx(i, i);
1153  }
1154
1155  for(Int lsIdx = 1; lsIdx < vps->getNumLayerSets(); lsIdx++)
1156  {
1157    // Include the highest layer as output layer
1158    for(UInt layer=0; layer <= vps->getMaxLayerId() ; layer++)
1159    {
1160      if(vps->getLayerIdIncludedFlag(lsIdx, layer))
1161      {
1162        vps->setOutputLayerFlag(lsIdx, layer, layer == (vps->getMaxLayerId()));
1163      }
1164    }
1165  }
1166#endif
1167 #if VPS_DPB_SIZE_TABLE
1168  // The Layer ID List variables can be derived here. 
1169#if DERIVE_LAYER_ID_LIST_VARIABLES
1170  vps->deriveLayerIdListVariables();
1171#endif
1172#if RESOLUTION_BASED_DPB
1173  vps->assignSubDpbIndices();
1174#else
1175  vps->deriveNumberOfSubDpbs();
1176#endif
1177  // Initialize dpb_size_table() for all ouput layer sets in the VPS extension
1178  for(i = 1; i < vps->getNumOutputLayerSets(); i++)
1179  {
1180#if CHANGE_NUMSUBDPB_IDX
1181    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
1182#endif
1183    Int layerSetId = vps->getOutputLayerSetIdx(i);
1184
1185    for(Int j = 0; j < vps->getMaxTLayers(); j++)
1186    {
1187
1188      Int maxNumReorderPics = -1;
1189#if CHANGE_NUMSUBDPB_IDX
1190#if RESOLUTION_BASED_DPB
1191      for(Int k = 0; k < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); k++)
1192#else
1193      for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
1194#endif
1195#else
1196      for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
1197#endif
1198      {
1199        Int layerId = vps->getLayerSetLayerIdList(layerSetId, k); // k-th layer in the output layer set
1200#if RESOLUTION_BASED_DPB
1201        vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, m_acTEncTop[layerId].getMaxDecPicBuffering(j) - 1 );
1202        // Add sub-DPB sizes of layers belonging to a sub-DPB. If a different sub-DPB size is calculated
1203        // at the encoder, modify below
1204        Int oldValue = vps->getMaxVpsDecPicBufferingMinus1( i, vps->getSubDpbAssigned( layerSetIdxForOutputLayerSet, k ), j );
1205        oldValue += vps->getMaxVpsLayerDecPicBuffMinus1( i, k, j ) + 1;
1206        vps->setMaxVpsDecPicBufferingMinus1( i, vps->getSubDpbAssigned( layerSetIdxForOutputLayerSet, k ), j, oldValue );
1207#else
1208        vps->setMaxVpsDecPicBufferingMinus1( i, k, j,  m_acTEncTop[layerId].getMaxDecPicBuffering(j) - 1 );
1209#endif
1210        maxNumReorderPics       = std::max( maxNumReorderPics, m_acTEncTop[layerId].getNumReorderPics(j));
1211      }
1212#if RESOLUTION_BASED_DPB
1213      for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
1214      {
1215        // Decrement m_maxVpsDecPicBufferingMinus1
1216        Int oldValue = vps->getMaxVpsDecPicBufferingMinus1( i, vps->getSubDpbAssigned( layerSetIdxForOutputLayerSet, k ), j );
1217        vps->setMaxVpsDecPicBufferingMinus1( i, vps->getSubDpbAssigned( layerSetIdxForOutputLayerSet, k ), j, oldValue - 1 );
1218      }
1219#endif
1220      vps->setMaxVpsNumReorderPics(i, j, maxNumReorderPics);
1221      vps->determineSubDpbInfoFlags();
1222    }
1223  }
1224#endif
1225#if VPS_EXTN_DIRECT_REF_LAYERS
1226  // Direct reference layers
1227  UInt maxDirectRefLayers = 0;
1228#if O0096_DEFAULT_DEPENDENCY_TYPE
1229  Bool isDefaultDirectDependencyTypeSet = false;
1230#endif
1231  for(UInt layerCtr = 1;layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
1232  {
1233    vps->setNumDirectRefLayers( layerCtr, m_acTEncTop[layerCtr].getNumDirectRefLayers() );
1234    maxDirectRefLayers = max<UInt>( maxDirectRefLayers, vps->getNumDirectRefLayers( layerCtr ) );
1235
1236    for(i = 0; i < vps->getNumDirectRefLayers(layerCtr); i++)
1237    {
1238      vps->setRefLayerId( layerCtr, i, m_acTEncTop[layerCtr].getRefLayerId(i) );
1239    }
1240    // Set direct dependency flag
1241    // Initialize flag to 0
1242    for(Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1243    {
1244      vps->setDirectDependencyFlag( layerCtr, refLayerCtr, false );
1245    }
1246    for(i = 0; i < vps->getNumDirectRefLayers(layerCtr); i++)
1247    {
1248      vps->setDirectDependencyFlag( layerCtr, vps->getLayerIdInVps(m_acTEncTop[layerCtr].getRefLayerId(i)), true);
1249    }
1250    // prediction indications
1251    vps->setDirectDepTypeLen(2); // sample and motion types are encoded
1252    for(Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1253    {
1254      if (vps->getDirectDependencyFlag( layerCtr, refLayerCtr))
1255      {
1256        assert(m_acTEncTop[layerCtr].getSamplePredEnabledFlag(refLayerCtr) || m_acTEncTop[layerCtr].getMotionPredEnabledFlag(refLayerCtr));
1257        vps->setDirectDependencyType( layerCtr, refLayerCtr, ((m_acTEncTop[layerCtr].getSamplePredEnabledFlag(refLayerCtr) ? 1 : 0) |
1258                                                              (m_acTEncTop[layerCtr].getMotionPredEnabledFlag(refLayerCtr) ? 2 : 0)) - 1);
1259#if O0096_DEFAULT_DEPENDENCY_TYPE
1260        if (!isDefaultDirectDependencyTypeSet)
1261        {
1262          vps->setDefaultDirectDependecyTypeFlag(1);
1263          vps->setDefaultDirectDependecyType(vps->getDirectDependencyType(layerCtr, refLayerCtr));
1264          isDefaultDirectDependencyTypeSet = true;
1265        }
1266        else if (vps->getDirectDependencyType(layerCtr, refLayerCtr) != vps->getDefaultDirectDependencyType())
1267        {
1268          vps->setDefaultDirectDependecyTypeFlag(0);
1269        }
1270#endif
1271      }
1272      else
1273      {
1274        vps->setDirectDependencyType( layerCtr, refLayerCtr, 0 );
1275      }
1276    }
1277  }
1278
1279#if O0092_0094_DEPENDENCY_CONSTRAINT
1280  for(UInt layerCtr = 1;layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
1281  {
1282    vps->setNumRefLayers(vps->getLayerIdInNuh(layerCtr));   // identify the number of direct and indirect reference layers of current layer and set recursiveRefLayersFlags
1283  }
1284  if(vps->getMaxLayers() > MAX_REF_LAYERS)
1285  {
1286    for(UInt layerCtr = 1;layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
1287    {
1288      assert( vps->getNumRefLayers(vps->getLayerIdInNuh(layerCtr)) <= MAX_REF_LAYERS);
1289    }
1290  }
1291#endif
1292#endif
1293    vps->setMaxOneActiveRefLayerFlag(maxDirectRefLayers > 1 ? false : true);
1294#if O0062_POC_LSB_NOT_PRESENT_FLAG
1295    for(i = 1; i< vps->getMaxLayers(); i++)
1296    {
1297      if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0  )
1298      {
1299        vps->setPocLsbNotPresentFlag(i, false);
1300      }
1301    }
1302#endif
1303#if O0223_PICTURE_TYPES_ALIGN_FLAG
1304    vps->setCrossLayerPictureTypeAlignFlag( m_crossLayerPictureTypeAlignFlag );
1305#endif
1306#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
1307    vps->setCrossLayerAlignedIdrOnlyFlag( m_crossLayerAlignedIdrOnlyFlag );
1308#endif
1309#if N0147_IRAP_ALIGN_FLAG
1310    vps->setCrossLayerIrapAlignFlag( m_crossLayerIrapAlignFlag );
1311    for(UInt layerCtr = 1;layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
1312    {
1313      for(Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1314      {
1315        if (vps->getDirectDependencyFlag( layerCtr, refLayerCtr))
1316        {
1317          if(m_acTEncTop[layerCtr].getIntraPeriod() !=  m_acTEncTop[refLayerCtr].getIntraPeriod())
1318          {
1319            vps->setCrossLayerIrapAlignFlag(false);
1320            break;
1321          }
1322        }
1323      }
1324    }
1325
1326    if( vps->getAvcBaseLayerFlag() )
1327    {
1328      vps->setCrossLayerIrapAlignFlag(false);
1329    }
1330#endif
1331#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1332  vps->setSingleLayerForNonIrapFlag(m_adaptiveResolutionChange > 0 ? true : false);
1333#endif
1334#if HIGHER_LAYER_IRAP_SKIP_FLAG
1335  vps->setHigherLayerIrapSkipFlag(m_skipPictureAtArcSwitch);
1336#endif
1337#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
1338#if !VPS_EXTN_OFFSET_CALC
1339#if VPS_EXTN_OFFSET
1340  // to be updated according to the current semantics
1341  vps->setExtensionOffset( 0xffff );
1342#endif
1343#endif
1344#endif
1345
1346#if O0215_PHASE_ALIGNMENT
1347  vps->setPhaseAlignFlag( m_phaseAlignFlag );
1348#endif
1349
1350#if P0300_ALT_OUTPUT_LAYER_FLAG
1351  for (Int k = 0; k < MAX_VPS_LAYER_SETS_PLUS1; k++)
1352  {
1353    vps->setAltOuputLayerFlag( k, m_altOutputLayerFlag );
1354  }
1355#else
1356#if O0153_ALT_OUTPUT_LAYER_FLAG
1357  vps->setAltOuputLayerFlag( m_altOutputLayerFlag );
1358#endif
1359#endif
1360
1361#if P0312_VERT_PHASE_ADJ
1362  Bool vpsVuiVertPhaseInUseFlag = false;
1363  for( UInt layerId = 1; layerId < m_numLayers; layerId++ )
1364  {
1365    for( i = 0; i < m_acLayerCfg[layerId].m_numScaledRefLayerOffsets; i++ )
1366    {
1367      if( m_acTEncTop[layerId].getVertPhasePositionEnableFlag(i) )
1368      {
1369        vpsVuiVertPhaseInUseFlag = true;
1370        break;
1371      }
1372    }
1373  }
1374  vps->setVpsVuiVertPhaseInUseFlag( vpsVuiVertPhaseInUseFlag );
1375#endif
1376
1377#if O0164_MULTI_LAYER_HRD
1378  vps->setVpsVuiBspHrdPresentFlag(false);
1379  TEncTop *pcCfg = &m_acTEncTop[0];
1380  if( pcCfg->getBufferingPeriodSEIEnabled() )
1381  {
1382    vps->setVpsVuiBspHrdPresentFlag(true);
1383    vps->setVpsNumBspHrdParametersMinus1(vps->getNumLayerSets() - 2); 
1384    vps->createBspHrdParamBuffer(vps->getVpsNumBspHrdParametersMinus1() + 1);
1385    for ( i = 0; i <= vps->getVpsNumBspHrdParametersMinus1(); i++ )
1386    {
1387      vps->setBspCprmsPresentFlag(i, true);
1388
1389      UInt layerId = i + 1;
1390      TEncTop *pcCfgLayer = &m_acTEncTop[layerId];
1391
1392      Int iPicWidth         = pcCfgLayer->getSourceWidth();
1393      Int iPicHeight        = pcCfgLayer->getSourceHeight();
1394      UInt uiWidthInCU       = ( iPicWidth %m_uiMaxCUWidth  ) ? iPicWidth /m_uiMaxCUWidth  + 1 : iPicWidth /m_uiMaxCUWidth;
1395      UInt uiHeightInCU      = ( iPicHeight%m_uiMaxCUHeight ) ? iPicHeight/m_uiMaxCUHeight + 1 : iPicHeight/m_uiMaxCUHeight;
1396      UInt uiNumCUsInFrame   = uiWidthInCU * uiHeightInCU;
1397
1398      UInt maxCU = pcCfgLayer->getSliceArgument() >> ( m_uiMaxCUDepth << 1);
1399      UInt numDU = ( pcCfgLayer->getSliceMode() == 1 ) ? ( uiNumCUsInFrame / maxCU ) : ( 0 );
1400      if( uiNumCUsInFrame % maxCU != 0 || numDU == 0 )
1401      {
1402        numDU ++;
1403      }
1404      vps->getBspHrd(i)->setNumDU( numDU );
1405      vps->setBspHrdParameters( i, pcCfgLayer->getFrameRate(), numDU, pcCfgLayer->getTargetBitrate(), ( pcCfgLayer->getIntraPeriod() > 0 ) );
1406    }
1407    for(UInt h = 1; h <= (vps->getNumLayerSets()-1); h++)
1408    {
1409      vps->setNumBitstreamPartitions(h, 1);
1410      for( i = 0; i < vps->getNumBitstreamPartitions(h); i++ )
1411      {
1412        for( UInt j = 0; j <= (vps->getMaxLayers()-1); j++ )
1413        {
1414          if (vps->getLayerIdIncludedFlag(h, j) && h == j)
1415          {
1416            vps->setLayerInBspFlag(h, i, j, true);
1417          }
1418        }
1419      }
1420      vps->setNumBspSchedCombinations(h, 1);
1421      for( i = 0; i < vps->getNumBspSchedCombinations(h); i++ )
1422      {
1423        for( UInt j = 0; j < vps->getNumBitstreamPartitions(h); j++ )
1424        {
1425          vps->setBspCombHrdIdx(h, i, j, 0);
1426          vps->setBspCombSchedIdx(h, i, j, 0);
1427        }
1428      }
1429    }
1430  }
1431#endif
1432
1433#else //SVC_EXTENSION
1434  m_cTEncTop.init(isFieldCoding);
1435#endif //SVC_EXTENSION
1436}
1437
1438// ====================================================================================================================
1439// Public member functions
1440// ====================================================================================================================
1441
1442/**
1443 - create internal class
1444 - initialize internal variable
1445 - until the end of input YUV file, call encoding function in TEncTop class
1446 - delete allocated buffers
1447 - destroy internal class
1448 .
1449 */
1450#if SVC_EXTENSION
1451Void TAppEncTop::encode()
1452{
1453  fstream bitstreamFile(m_pBitstreamFile, fstream::binary | fstream::out);
1454  if (!bitstreamFile)
1455  {
1456    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pBitstreamFile);
1457    exit(EXIT_FAILURE);
1458  }
1459
1460  TComPicYuv*       pcPicYuvOrg [MAX_LAYERS];
1461  TComPicYuv*       pcPicYuvRec = NULL;
1462
1463  // initialize internal class & member variables
1464  xInitLibCfg();
1465  xCreateLib();
1466  xInitLib(m_isField);
1467
1468  // main encoder loop
1469  Int   iNumEncoded = 0, iTotalNumEncoded = 0;
1470  Bool  bEos = false;
1471
1472  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
1473
1474  for(UInt layer=0; layer<m_numLayers; layer++)
1475  {
1476#if O0194_DIFFERENT_BITDEPTH_EL_BL
1477    //5
1478    g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
1479    g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
1480
1481    g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
1482    g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
1483#endif
1484    // allocate original YUV buffer
1485    pcPicYuvOrg[layer] = new TComPicYuv;
1486    if( m_isField )
1487    {
1488#if SVC_UPSAMPLING
1489#if LAYER_CTB
1490#if AUXILIARY_PICTURES
1491      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeightOrg(), m_acLayerCfg[layer].getChromaFormatIDC(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1492#else
1493      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeightOrg(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1494#endif
1495#else
1496#if AUXILIARY_PICTURES
1497      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeightOrg(), m_acLayerCfg[layer].getChromaFormatIDC(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1498#else
1499      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeightOrg(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1500#endif
1501#endif
1502#else
1503      pcPicYuvOrg->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeightOrg(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1504#endif
1505    }
1506    else
1507    {
1508#if SVC_UPSAMPLING
1509#if LAYER_CTB
1510#if AUXILIARY_PICTURES
1511      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].getChromaFormatIDC(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1512#else
1513      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1514#endif
1515#else
1516#if AUXILIARY_PICTURES
1517      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].getChromaFormatIDC(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1518#else
1519      pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1520#endif
1521#endif
1522#else
1523      pcPicYuvOrg->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1524#endif
1525    }
1526  }
1527
1528#if AVC_SYNTAX
1529  fstream streamSyntaxFile;
1530  if( m_acTEncTop[0].getVPS()->getAvcBaseLayerFlag() )
1531  {
1532    if( !m_BLSyntaxFile )
1533    {
1534      printf( "Wrong base layer syntax input file\n" );
1535      exit(EXIT_FAILURE);
1536    }
1537    streamSyntaxFile.open( m_BLSyntaxFile, fstream::in | fstream::binary );
1538    if( !streamSyntaxFile.good() )
1539    {
1540      printf( "Base layer syntax input reading error\n" );
1541      exit(EXIT_FAILURE);
1542    }
1543    m_acTEncTop[0].setBLSyntaxFile( &streamSyntaxFile );
1544  }
1545#endif
1546
1547  Bool bFirstFrame = true;
1548  while ( !bEos )
1549  {
1550    // Read enough frames
1551    Bool bFramesReadyToCode = false;
1552    while(!bFramesReadyToCode)
1553    {
1554      for(UInt layer=0; layer<m_numLayers; layer++)
1555      {
1556#if O0194_DIFFERENT_BITDEPTH_EL_BL
1557        //6
1558        g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
1559        g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
1560
1561        g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
1562        g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
1563#endif
1564#if LAYER_CTB
1565        g_uiMaxCUWidth  = g_auiLayerMaxCUWidth[layer];
1566        g_uiMaxCUHeight = g_auiLayerMaxCUHeight[layer];
1567        g_uiMaxCUDepth  = g_auiLayerMaxCUDepth[layer];
1568        g_uiAddCUDepth  = g_auiLayerAddCUDepth[layer];
1569#endif
1570
1571        // get buffers
1572        xGetBuffer(pcPicYuvRec, layer);
1573
1574        // read input YUV file
1575        m_acTVideoIOYuvInputFile[layer].read( pcPicYuvOrg[layer], m_acLayerCfg[layer].getPad() );
1576
1577#if AUXILIARY_PICTURES
1578        if (m_acLayerCfg[layer].getChromaFormatIDC() == CHROMA_400)
1579        {
1580          pcPicYuvOrg[layer]->convertToMonochrome();
1581        }
1582#endif
1583
1584        if(layer == m_numLayers-1)
1585        {
1586          // increase number of received frames
1587          m_iFrameRcvd++;
1588          // check end of file
1589          bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
1590        }
1591
1592        if ( m_isField )
1593        {
1594          m_acTEncTop[layer].encodePrep( pcPicYuvOrg[layer], m_isTopFieldFirst );
1595        }
1596        else
1597        {
1598          m_acTEncTop[layer].encodePrep( pcPicYuvOrg[layer] );
1599        }
1600      }
1601
1602      bFramesReadyToCode = !(!bFirstFrame && ( m_acTEncTop[m_numLayers-1].getNumPicRcvd() != m_iGOPSize && m_iGOPSize ) && !bEos );
1603    }
1604    Bool flush = 0;
1605    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1606    if (m_acTVideoIOYuvInputFile[m_numLayers-1].isEof())
1607    {
1608      flush = true;
1609      bEos = true;
1610      m_iFrameRcvd--;
1611      m_acTEncTop[m_numLayers-1].setFramesToBeEncoded(m_iFrameRcvd);
1612    }
1613
1614#if RC_SHVC_HARMONIZATION
1615    for(UInt layer=0; layer<m_numLayers; layer++)
1616    {
1617      if ( m_acTEncTop[layer].getUseRateCtrl() )
1618      {
1619        (m_acTEncTop[layer].getRateCtrl())->initRCGOP(m_acTEncTop[layer].getNumPicRcvd());
1620      }
1621    }
1622#endif
1623
1624#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1625    if (m_adaptiveResolutionChange)
1626    {
1627      for(UInt layer = 0; layer < m_numLayers; layer++)
1628      {
1629        TComList<TComPicYuv*>::iterator iterPicYuvRec;
1630        for (iterPicYuvRec = m_acListPicYuvRec[layer].begin(); iterPicYuvRec != m_acListPicYuvRec[layer].end(); iterPicYuvRec++)
1631        {
1632          TComPicYuv* recPic = *(iterPicYuvRec);
1633          recPic->setReconstructed(false);
1634        }
1635      }
1636    }
1637#endif
1638
1639    // loop through frames in one GOP
1640    for ( UInt iPicIdInGOP=0; iPicIdInGOP < (bFirstFrame? 1:m_iGOPSize); iPicIdInGOP++ )
1641    {
1642      // layer by layer for each frame
1643      for(UInt layer=0; layer<m_numLayers; layer++)
1644      {
1645#if O0194_DIFFERENT_BITDEPTH_EL_BL
1646        //7
1647        g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
1648        g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
1649
1650        g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
1651        g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
1652#endif
1653#if LAYER_CTB
1654        g_uiMaxCUWidth  = g_auiLayerMaxCUWidth[layer];
1655        g_uiMaxCUHeight = g_auiLayerMaxCUHeight[layer];
1656        g_uiMaxCUDepth  = g_auiLayerMaxCUDepth[layer];
1657        g_uiAddCUDepth  = g_auiLayerAddCUDepth[layer];
1658
1659        memcpy( g_auiZscanToRaster, g_auiLayerZscanToRaster[layer], sizeof( g_auiZscanToRaster ) );
1660        memcpy( g_auiRasterToZscan, g_auiLayerRasterToZscan[layer], sizeof( g_auiRasterToZscan ) );
1661        memcpy( g_auiRasterToPelX,  g_auiLayerRasterToPelX[layer],  sizeof( g_auiRasterToPelX ) );
1662        memcpy( g_auiRasterToPelY,  g_auiLayerRasterToPelY[layer],  sizeof( g_auiRasterToPelY ) );
1663#endif
1664        // call encoding function for one frame
1665        if ( m_isField )
1666        {
1667          m_acTEncTop[layer].encode( flush ? 0 : pcPicYuvOrg[layer], m_acListPicYuvRec[layer], outputAccessUnits, iPicIdInGOP, m_isTopFieldFirst );
1668        }
1669        else
1670        {
1671          m_acTEncTop[layer].encode( flush ? 0 : pcPicYuvOrg[layer], m_acListPicYuvRec[layer], outputAccessUnits, iPicIdInGOP );
1672        }
1673      }
1674    }
1675
1676#if RC_SHVC_HARMONIZATION
1677    for(UInt layer=0; layer<m_numLayers; layer++)
1678    {
1679      if ( m_acTEncTop[layer].getUseRateCtrl() )
1680      {
1681        (m_acTEncTop[layer].getRateCtrl())->destroyRCGOP();
1682      }
1683    }
1684#endif
1685
1686    iTotalNumEncoded = 0;
1687    for(UInt layer=0; layer<m_numLayers; layer++)
1688    {
1689#if O0194_DIFFERENT_BITDEPTH_EL_BL
1690      //8
1691      g_bitDepthY = m_acLayerCfg[layer].m_internalBitDepthY;
1692      g_bitDepthC = m_acLayerCfg[layer].m_internalBitDepthC;
1693
1694      g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthY : m_acLayerCfg[layer].m_internalBitDepthY;
1695      g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_acLayerCfg[layer].m_inputBitDepthC : m_acLayerCfg[layer].m_internalBitDepthC;
1696#endif
1697      // write bistream to file if necessary
1698      iNumEncoded = m_acTEncTop[layer].getNumPicRcvd();
1699      if ( iNumEncoded > 0 )
1700      {
1701        xWriteRecon(layer, iNumEncoded);
1702        iTotalNumEncoded += iNumEncoded;
1703      }
1704      m_acTEncTop[layer].setNumPicRcvd( 0 );
1705    }
1706
1707    // write bitstream out
1708    if(iTotalNumEncoded)
1709    {
1710#if P0130_EOB
1711      if( bEos )
1712      {
1713        OutputNALUnit nalu(NAL_UNIT_EOB);
1714        nalu.m_layerId = 0;
1715
1716        AccessUnit& accessUnit = outputAccessUnits.back();
1717        nalu.m_temporalId = accessUnit.front()->m_temporalId;
1718        accessUnit.push_back(new NALUnitEBSP(nalu));
1719      }
1720#endif
1721      xWriteStream(bitstreamFile, iTotalNumEncoded, outputAccessUnits);
1722      outputAccessUnits.clear();
1723    }
1724
1725    // print out summary
1726    if (bEos)
1727    {
1728      printOutSummary(m_isTopFieldFirst);
1729    }
1730
1731    bFirstFrame = false;
1732  }
1733  // delete original YUV buffer
1734  for(UInt layer=0; layer<m_numLayers; layer++)
1735  {
1736    pcPicYuvOrg[layer]->destroy();
1737    delete pcPicYuvOrg[layer];
1738    pcPicYuvOrg[layer] = NULL;
1739
1740    // delete used buffers in encoder class
1741    m_acTEncTop[layer].deletePicBuffer();
1742  }
1743
1744#if AVC_SYNTAX
1745  if( streamSyntaxFile.is_open() )
1746  {
1747    streamSyntaxFile.close();
1748  }
1749#endif
1750
1751  // delete buffers & classes
1752  xDeleteBuffer();
1753  xDestroyLib();
1754
1755  printRateSummary();
1756
1757  return;
1758}
1759
1760Void TAppEncTop::printOutSummary(Bool isField)
1761{
1762  UInt layer;
1763
1764  // set frame rate
1765  for(layer = 0; layer < m_numLayers; layer++)
1766  {
1767    if(isField)
1768    {
1769      m_gcAnalyzeAll[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() * 2);
1770      m_gcAnalyzeI[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() * 2 );
1771      m_gcAnalyzeP[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() * 2 );
1772      m_gcAnalyzeB[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() * 2 );
1773    }
1774    else
1775    {
1776      m_gcAnalyzeAll[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate());
1777      m_gcAnalyzeI[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1778      m_gcAnalyzeP[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1779      m_gcAnalyzeB[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1780    }
1781  }
1782
1783  //-- all
1784  printf( "\n\nSUMMARY --------------------------------------------------------\n" );
1785  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1786  for(layer = 0; layer < m_numLayers; layer++)
1787  {
1788    m_gcAnalyzeAll[layer].printOut('a', layer);
1789  }
1790
1791  printf( "\n\nI Slices--------------------------------------------------------\n" );
1792  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1793  for(layer = 0; layer < m_numLayers; layer++)
1794  {
1795    m_gcAnalyzeI[layer].printOut('i', layer);
1796  }
1797
1798  printf( "\n\nP Slices--------------------------------------------------------\n" );
1799  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1800  for(layer = 0; layer < m_numLayers; layer++)
1801  {
1802    m_gcAnalyzeP[layer].printOut('p', layer);
1803  }
1804
1805  printf( "\n\nB Slices--------------------------------------------------------\n" );
1806  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1807  for(layer = 0; layer < m_numLayers; layer++)
1808  {
1809    m_gcAnalyzeB[layer].printOut('b', layer);
1810  }
1811
1812  if(isField)
1813  {
1814    for(layer = 0; layer < m_numLayers; layer++)
1815    {
1816      //-- interlaced summary
1817      m_gcAnalyzeAll_in.setFrmRate( m_acLayerCfg[layer].getFrameRate());
1818      printf( "\n\nSUMMARY INTERLACED ---------------------------------------------\n" );
1819      m_gcAnalyzeAll_in.printOutInterlaced('a',  m_gcAnalyzeAll[layer].getBits());
1820
1821#if _SUMMARY_OUT_
1822      m_gcAnalyzeAll_in.printSummaryOutInterlaced();
1823#endif
1824    }
1825  }
1826}
1827
1828#else
1829Void TAppEncTop::encode()
1830{
1831  fstream bitstreamFile(m_pchBitstreamFile, fstream::binary | fstream::out);
1832  if (!bitstreamFile)
1833  {
1834    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
1835    exit(EXIT_FAILURE);
1836  }
1837
1838  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
1839  TComPicYuv*       pcPicYuvRec = NULL;
1840
1841  // initialize internal class & member variables
1842  xInitLibCfg();
1843  xCreateLib();
1844  xInitLib(m_isField);
1845
1846  // main encoder loop
1847  Int   iNumEncoded = 0;
1848  Bool  bEos = false;
1849
1850  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
1851
1852  // allocate original YUV buffer
1853  if( m_isField )
1854  {
1855    pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeightOrg, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1856  }
1857  else
1858  {
1859    pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1860  }
1861
1862  while ( !bEos )
1863  {
1864    // get buffers
1865    xGetBuffer(pcPicYuvRec);
1866
1867    // read input YUV file
1868    m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, m_aiPad );
1869
1870    // increase number of received frames
1871    m_iFrameRcvd++;
1872
1873    bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
1874    Bool flush = 0;
1875    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1876    if (m_cTVideoIOYuvInputFile.isEof())
1877    {
1878      flush = true;
1879      bEos = true;
1880      m_iFrameRcvd--;
1881      m_cTEncTop.setFramesToBeEncoded(m_iFrameRcvd);
1882    }
1883
1884    // call encoding function for one frame
1885    if ( m_isField )
1886    {
1887      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded, m_isTopFieldFirst);
1888    }
1889    else
1890    {
1891    m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
1892    }
1893
1894    // write bistream to file if necessary
1895    if ( iNumEncoded > 0 )
1896    {
1897      xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
1898      outputAccessUnits.clear();
1899    }
1900  }
1901
1902  m_cTEncTop.printSummary(m_isField);
1903
1904  // delete original YUV buffer
1905  pcPicYuvOrg->destroy();
1906  delete pcPicYuvOrg;
1907  pcPicYuvOrg = NULL;
1908
1909  // delete used buffers in encoder class
1910  m_cTEncTop.deletePicBuffer();
1911
1912  // delete buffers & classes
1913  xDeleteBuffer();
1914  xDestroyLib();
1915
1916  printRateSummary();
1917
1918  return;
1919}
1920#endif
1921
1922// ====================================================================================================================
1923// Protected member functions
1924// ====================================================================================================================
1925
1926/**
1927 - application has picture buffer list with size of GOP
1928 - picture buffer list acts as ring buffer
1929 - end of the list has the latest picture
1930 .
1931 */
1932#if SVC_EXTENSION
1933Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
1934{
1935  assert( m_iGOPSize > 0 );
1936
1937  // org. buffer
1938  if ( m_acListPicYuvRec[layer].size() == (UInt)m_iGOPSize )
1939  {
1940    rpcPicYuvRec = m_acListPicYuvRec[layer].popFront();
1941
1942  }
1943  else
1944  {
1945    rpcPicYuvRec = new TComPicYuv;
1946
1947#if SVC_UPSAMPLING
1948#if LAYER_CTB
1949#if AUXILIARY_PICTURES
1950    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].getChromaFormatIDC(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1951#else
1952    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].m_uiMaxCUWidth, m_acLayerCfg[layer].m_uiMaxCUHeight, m_acLayerCfg[layer].m_uiMaxCUDepth, NULL );
1953#endif
1954#else
1955#if AUXILIARY_PICTURES
1956    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_acLayerCfg[layer].getChromaFormatIDC(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1957#else
1958    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1959#endif
1960#endif
1961#else
1962    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1963#endif
1964
1965  }
1966  m_acListPicYuvRec[layer].pushBack( rpcPicYuvRec );
1967}
1968
1969Void TAppEncTop::xDeleteBuffer( )
1970{
1971  for(UInt layer=0; layer<m_numLayers; layer++)
1972  {
1973    TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_acListPicYuvRec[layer].begin();
1974
1975    Int iSize = Int( m_acListPicYuvRec[layer].size() );
1976
1977    for ( Int i = 0; i < iSize; i++ )
1978    {
1979      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1980      pcPicYuvRec->destroy();
1981      delete pcPicYuvRec; pcPicYuvRec = NULL;
1982    }
1983  }
1984}
1985
1986Void TAppEncTop::xWriteRecon(UInt layer, Int iNumEncoded)
1987{
1988  if (m_isField)
1989  {
1990    //Reinterlace fields
1991    Int i;
1992    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
1993
1994    for ( i = 0; i < iNumEncoded; i++ )
1995    {
1996      --iterPicYuvRec;
1997    }
1998
1999    for ( i = 0; i < iNumEncoded/2; i++ )
2000    {
2001      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
2002      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);
2003
2004#if M0040_ADAPTIVE_RESOLUTION_CHANGE
2005      if (!m_acLayerCfg[layer].getReconFile().empty() && pcPicYuvRecTop->isReconstructed() && pcPicYuvRecBottom->isReconstructed())
2006#else
2007      if (!m_acLayerCfg[layer].getReconFile().empty())
2008#endif
2009      {
2010        m_acTVideoIOYuvReconFile[layer].write( pcPicYuvRecTop, pcPicYuvRecBottom, m_acLayerCfg[layer].getConfLeft(), m_acLayerCfg[layer].getConfRight(), m_acLayerCfg[layer].getConfTop(), m_acLayerCfg[layer].getConfBottom(), m_isTopFieldFirst );
2011      }
2012    }
2013  }
2014  else
2015  {
2016    Int i;
2017
2018    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
2019
2020    for ( i = 0; i < iNumEncoded; i++ )
2021    {
2022      --iterPicYuvRec;
2023    }
2024
2025    for ( i = 0; i < iNumEncoded; i++ )
2026    {
2027      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
2028#if M0040_ADAPTIVE_RESOLUTION_CHANGE
2029      if (!m_acLayerCfg[layer].getReconFile().empty() && pcPicYuvRec->isReconstructed())
2030#else
2031      if (!m_acLayerCfg[layer].getReconFile().empty())
2032#endif
2033      {
2034        m_acTVideoIOYuvReconFile[layer].write( pcPicYuvRec, m_acLayerCfg[layer].getConfLeft(), m_acLayerCfg[layer].getConfRight(),
2035          m_acLayerCfg[layer].getConfTop(), m_acLayerCfg[layer].getConfBottom() );
2036      }
2037    }
2038  }
2039}
2040
2041Void TAppEncTop::xWriteStream(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
2042{
2043  if (m_isField)
2044  {
2045    //Reinterlace fields
2046    Int i;
2047    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2048
2049#if M0040_ADAPTIVE_RESOLUTION_CHANGE
2050    for ( i = 0; i < iNumEncoded/2 && iterBitstream != accessUnits.end(); i++ )
2051#else
2052    for ( i = 0; i < iNumEncoded/2; i++ )
2053#endif
2054    {
2055      const AccessUnit& auTop = *(iterBitstream++);
2056      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
2057      rateStatsAccum(auTop, statsTop);
2058
2059      const AccessUnit& auBottom = *(iterBitstream++);
2060      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
2061      rateStatsAccum(auBottom, statsBottom);
2062    }
2063  }
2064  else
2065  {
2066    Int i;
2067
2068    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2069
2070#if M0040_ADAPTIVE_RESOLUTION_CHANGE
2071    for ( i = 0; i < iNumEncoded && iterBitstream != accessUnits.end(); i++ )
2072#else
2073    for ( i = 0; i < iNumEncoded; i++ )
2074#endif
2075    {
2076      const AccessUnit& au = *(iterBitstream++);
2077      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
2078      rateStatsAccum(au, stats);
2079    }
2080  }
2081}
2082
2083#else // SVC_EXTENSION
2084Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
2085{
2086  assert( m_iGOPSize > 0 );
2087
2088  // org. buffer
2089  if ( m_cListPicYuvRec.size() == (UInt)m_iGOPSize )
2090  {
2091    rpcPicYuvRec = m_cListPicYuvRec.popFront();
2092
2093  }
2094  else
2095  {
2096    rpcPicYuvRec = new TComPicYuv;
2097
2098    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
2099
2100  }
2101  m_cListPicYuvRec.pushBack( rpcPicYuvRec );
2102}
2103
2104Void TAppEncTop::xDeleteBuffer( )
2105{
2106  TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_cListPicYuvRec.begin();
2107
2108  Int iSize = Int( m_cListPicYuvRec.size() );
2109
2110  for ( Int i = 0; i < iSize; i++ )
2111  {
2112    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
2113    pcPicYuvRec->destroy();
2114    delete pcPicYuvRec; pcPicYuvRec = NULL;
2115  }
2116
2117}
2118
2119/** \param iNumEncoded  number of encoded frames
2120 */
2121Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
2122{
2123  if (m_isField)
2124  {
2125    //Reinterlace fields
2126    Int i;
2127    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
2128    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2129
2130    for ( i = 0; i < iNumEncoded; i++ )
2131    {
2132      --iterPicYuvRec;
2133    }
2134
2135    for ( i = 0; i < iNumEncoded/2; i++ )
2136    {
2137      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
2138      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);
2139
2140      if (m_pchReconFile)
2141      {
2142        m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, m_confLeft, m_confRight, m_confTop, m_confBottom, m_isTopFieldFirst );
2143      }
2144
2145      const AccessUnit& auTop = *(iterBitstream++);
2146      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
2147      rateStatsAccum(auTop, statsTop);
2148
2149      const AccessUnit& auBottom = *(iterBitstream++);
2150      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
2151      rateStatsAccum(auBottom, statsBottom);
2152    }
2153  }
2154  else
2155  {
2156    Int i;
2157
2158    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
2159    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2160
2161    for ( i = 0; i < iNumEncoded; i++ )
2162    {
2163      --iterPicYuvRec;
2164    }
2165
2166    for ( i = 0; i < iNumEncoded; i++ )
2167    {
2168      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
2169      if (m_pchReconFile)
2170      {
2171#if SYNTAX_OUTPUT
2172        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
2173#endif
2174      }
2175
2176      const AccessUnit& au = *(iterBitstream++);
2177      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
2178      rateStatsAccum(au, stats);
2179    }
2180  }
2181}
2182#endif
2183
2184/**
2185 *
2186 */
2187void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& annexBsizes)
2188{
2189  AccessUnit::const_iterator it_au = au.begin();
2190  vector<UInt>::const_iterator it_stats = annexBsizes.begin();
2191
2192  for (; it_au != au.end(); it_au++, it_stats++)
2193  {
2194    switch ((*it_au)->m_nalUnitType)
2195    {
2196    case NAL_UNIT_CODED_SLICE_TRAIL_R:
2197    case NAL_UNIT_CODED_SLICE_TRAIL_N:
2198    case NAL_UNIT_CODED_SLICE_TSA_R:
2199    case NAL_UNIT_CODED_SLICE_TSA_N:
2200    case NAL_UNIT_CODED_SLICE_STSA_R:
2201    case NAL_UNIT_CODED_SLICE_STSA_N:
2202    case NAL_UNIT_CODED_SLICE_BLA_W_LP:
2203    case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
2204    case NAL_UNIT_CODED_SLICE_BLA_N_LP:
2205    case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
2206    case NAL_UNIT_CODED_SLICE_IDR_N_LP:
2207    case NAL_UNIT_CODED_SLICE_CRA:
2208    case NAL_UNIT_CODED_SLICE_RADL_N:
2209    case NAL_UNIT_CODED_SLICE_RADL_R:
2210    case NAL_UNIT_CODED_SLICE_RASL_N:
2211    case NAL_UNIT_CODED_SLICE_RASL_R:
2212    case NAL_UNIT_VPS:
2213    case NAL_UNIT_SPS:
2214    case NAL_UNIT_PPS:
2215      m_essentialBytes += *it_stats;
2216      break;
2217    default:
2218      break;
2219    }
2220
2221    m_totalBytes += *it_stats;
2222  }
2223}
2224
2225void TAppEncTop::printRateSummary()
2226{
2227#if SVC_EXTENSION
2228  Double time = (Double) m_iFrameRcvd / m_acLayerCfg[m_numLayers-1].getFrameRate();
2229#else
2230  Double time = (Double) m_iFrameRcvd / m_iFrameRate;
2231#endif
2232  printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
2233#if VERBOSE_RATE
2234  printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
2235#endif
2236}
2237
2238//! \}
Note: See TracBrowser for help on using the repository browser.